gdb/python/py-inferior.c

   1 /* Python interface to inferiors.
   2
   3    Copyright (C) 2009-2018 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "gdbcore.h"
  22 #include "gdbthread.h"
  23 #include "inferior.h"
  24 #include "objfiles.h"
  25 #include "observable.h"
  26 #include "python-internal.h"
  27 #include "arch-utils.h"
  28 #include "language.h"
  29 #include "gdb_signals.h"
  30 #include "py-event.h"
  31 #include "py-stopevent.h"
  32
  33 struct threadlist_entry {
  34   thread_object *thread_obj;
  35   struct threadlist_entry *next;
  36 };
  37
  38 struct inferior_object
  39 {
  40   PyObject_HEAD
  41
  42   /* The inferior we represent.  */
  43   struct inferior *inferior;
  44
  45   /* thread_object instances under this inferior.  This list owns a
  46      reference to each object it contains.  */
  47   struct threadlist_entry *threads;
  48
  49   /* Number of threads in the list.  */
  50   int nthreads;
  51 };
  52
  53 extern PyTypeObject inferior_object_type
  54     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("inferior_object");
  55
  56 static const struct inferior_data *infpy_inf_data_key;
  57
  58 typedef struct {
  59   PyObject_HEAD
  60   void *buffer;
  61
  62   /* These are kept just for mbpy_str.  */
  63   CORE_ADDR addr;
  64   CORE_ADDR length;
  65 } membuf_object;
  66
  67 extern PyTypeObject membuf_object_type
  68     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("membuf_object");
  69
  70 /* Require that INFERIOR be a valid inferior ID.  */
  71 #define INFPY_REQUIRE_VALID(Inferior)                           \
  72   do {                                                          \
  73     if (!Inferior->inferior)                                    \
  74       {                                                         \
  75         PyErr_SetString (PyExc_RuntimeError,                    \
  76                          _("Inferior no longer exists."));      \
  77         return NULL;                                            \
  78       }                                                         \
  79   } while (0)
  80
  81 static void
  82 python_on_normal_stop (struct bpstats *bs, int print_frame)
  83 {
  84   enum gdb_signal stop_signal;
  85
  86   if (!gdb_python_initialized)
  87     return;
  88
  89   if (!find_thread_ptid (inferior_ptid))
  90       return;
  91
  92   stop_signal = inferior_thread ()->suspend.stop_signal;
  93
  94   gdbpy_enter enter_py (get_current_arch (), current_language);
  95
  96   if (emit_stop_event (bs, stop_signal) < 0)
  97     gdbpy_print_stack ();
  98 }
  99
 100 static void
 101 python_on_resume (ptid_t ptid)
 102 {
 103   if (!gdb_python_initialized)
 104     return;
 105
 106   gdbpy_enter enter_py (target_gdbarch (), current_language);
 107
 108   if (emit_continue_event (ptid) < 0)
 109     gdbpy_print_stack ();
 110 }
 111
 112 /* Callback, registered as an observer, that notifies Python listeners
 113    when an inferior function call is about to be made. */
 114
 115 static void
 116 python_on_inferior_call_pre (ptid_t thread, CORE_ADDR address)
 117 {
 118   gdbpy_enter enter_py (target_gdbarch (), current_language);
 119
 120   if (emit_inferior_call_event (INFERIOR_CALL_PRE, thread, address) < 0)
 121     gdbpy_print_stack ();
 122 }
 123
 124 /* Callback, registered as an observer, that notifies Python listeners
 125    when an inferior function call has completed. */
 126
 127 static void
 128 python_on_inferior_call_post (ptid_t thread, CORE_ADDR address)
 129 {
 130   gdbpy_enter enter_py (target_gdbarch (), current_language);
 131
 132   if (emit_inferior_call_event (INFERIOR_CALL_POST, thread, address) < 0)
 133     gdbpy_print_stack ();
 134 }
 135
 136 /* Callback, registered as an observer, that notifies Python listeners
 137    when a part of memory has been modified by user action (eg via a
 138    'set' command). */
 139
 140 static void
 141 python_on_memory_change (struct inferior *inferior, CORE_ADDR addr, ssize_t len, const bfd_byte *data)
 142 {
 143   gdbpy_enter enter_py (target_gdbarch (), current_language);
 144
 145   if (emit_memory_changed_event (addr, len) < 0)
 146     gdbpy_print_stack ();
 147 }
 148
 149 /* Callback, registered as an observer, that notifies Python listeners
 150    when a register has been modified by user action (eg via a 'set'
 151    command). */
 152
 153 static void
 154 python_on_register_change (struct frame_info *frame, int regnum)
 155 {
 156   gdbpy_enter enter_py (target_gdbarch (), current_language);
 157
 158   if (emit_register_changed_event (frame, regnum) < 0)
 159     gdbpy_print_stack ();
 160 }
 161
 162 static void
 163 python_inferior_exit (struct inferior *inf)
 164 {
 165   const LONGEST *exit_code = NULL;
 166
 167   if (!gdb_python_initialized)
 168     return;
 169
 170   gdbpy_enter enter_py (target_gdbarch (), current_language);
 171
 172   if (inf->has_exit_code)
 173     exit_code = &inf->exit_code;
 174
 175   if (emit_exited_event (exit_code, inf) < 0)
 176     gdbpy_print_stack ();
 177 }
 178
 179 /* Callback used to notify Python listeners about new objfiles loaded in the
 180    inferior.  OBJFILE may be NULL which means that the objfile list has been
 181    cleared (emptied).  */
 182
 183 static void
 184 python_new_objfile (struct objfile *objfile)
 185 {
 186   if (!gdb_python_initialized)
 187     return;
 188
 189   gdbpy_enter enter_py (objfile != NULL
 190                         ? get_objfile_arch (objfile)
 191                         : target_gdbarch (),
 192                         current_language);
 193
 194   if (objfile == NULL)
 195     {
 196       if (emit_clear_objfiles_event () < 0)
 197         gdbpy_print_stack ();
 198     }
 199   else
 200     {
 201       if (emit_new_objfile_event (objfile) < 0)
 202         gdbpy_print_stack ();
 203     }
 204 }
 205
 206 /* Return a reference to the Python object of type Inferior
 207    representing INFERIOR.  If the object has already been created,
 208    return it and increment the reference count,  otherwise, create it.
 209    Return NULL on failure.  */
 210
 211 inferior_object *
 212 inferior_to_inferior_object (struct inferior *inferior)
 213 {
 214   inferior_object *inf_obj;
 215
 216   inf_obj = (inferior_object *) inferior_data (inferior, infpy_inf_data_key);
 217   if (!inf_obj)
 218     {
 219       inf_obj = PyObject_New (inferior_object, &inferior_object_type);
 220       if (!inf_obj)
 221           return NULL;
 222
 223       inf_obj->inferior = inferior;
 224       inf_obj->threads = NULL;
 225       inf_obj->nthreads = 0;
 226
 227       /* PyObject_New initializes the new object with a refcount of 1.  This
 228          counts for the reference we are keeping in the inferior data.  */
 229       set_inferior_data (inferior, infpy_inf_data_key, inf_obj);
 230
 231     }
 232
 233   /* We are returning a new reference.  */
 234   Py_INCREF ((PyObject *)inf_obj);
 235
 236   return inf_obj;
 237 }
 238
 239 /* Called when a new inferior is created.  Notifies any Python event
 240    listeners.  */
 241 static void
 242 python_new_inferior (struct inferior *inf)
 243 {
 244   if (!gdb_python_initialized)
 245     return;
 246
 247   gdbpy_enter enter_py (python_gdbarch, python_language);
 248
 249   if (evregpy_no_listeners_p (gdb_py_events.new_inferior))
 250     return;
 251
 252   gdbpy_ref<inferior_object> inf_obj (inferior_to_inferior_object (inf));
 253   if (inf_obj == NULL)
 254     {
 255       gdbpy_print_stack ();
 256       return;
 257     }
 258
 259   gdbpy_ref<> event = create_event_object (&new_inferior_event_object_type);
 260   if (event == NULL
 261       || evpy_add_attribute (event.get (), "inferior",
 262                              (PyObject *) inf_obj.get ()) < 0
 263       || evpy_emit_event (event.get (), gdb_py_events.new_inferior) < 0)
 264     gdbpy_print_stack ();
 265 }
 266
 267 /* Called when an inferior is removed.  Notifies any Python event
 268    listeners.  */
 269 static void
 270 python_inferior_deleted (struct inferior *inf)
 271 {
 272   if (!gdb_python_initialized)
 273     return;
 274
 275   gdbpy_enter enter_py (python_gdbarch, python_language);
 276
 277   if (evregpy_no_listeners_p (gdb_py_events.inferior_deleted))
 278     return;
 279
 280   gdbpy_ref<inferior_object> inf_obj (inferior_to_inferior_object (inf));
 281   if (inf_obj == NULL)
 282     {
 283       gdbpy_print_stack ();
 284       return;
 285     }
 286
 287   gdbpy_ref<> event = create_event_object (&inferior_deleted_event_object_type);
 288   if (event == NULL
 289       || evpy_add_attribute (event.get (), "inferior",
 290                              (PyObject *) inf_obj.get ()) < 0
 291       || evpy_emit_event (event.get (), gdb_py_events.inferior_deleted) < 0)
 292     gdbpy_print_stack ();
 293 }
 294
 295 gdbpy_ref<>
 296 thread_to_thread_object (thread_info *thr)
 297 {
 298   gdbpy_ref<inferior_object> inf_obj (inferior_to_inferior_object (thr->inf));
 299   if (inf_obj == NULL)
 300     return NULL;
 301
 302   for (threadlist_entry *thread = inf_obj->threads;
 303        thread != NULL;
 304        thread = thread->next)
 305     if (thread->thread_obj->thread == thr)
 306       return gdbpy_ref<>::new_reference ((PyObject *) thread->thread_obj);
 307
 308   PyErr_SetString (PyExc_SystemError,
 309                    _("could not find gdb thread object"));
 310   return NULL;
 311 }
 312
 313 static void
 314 add_thread_object (struct thread_info *tp)
 315 {
 316   thread_object *thread_obj;
 317   inferior_object *inf_obj;
 318   struct threadlist_entry *entry;
 319
 320   if (!gdb_python_initialized)
 321     return;
 322
 323   gdbpy_enter enter_py (python_gdbarch, python_language);
 324
 325   thread_obj = create_thread_object (tp);
 326   if (!thread_obj)
 327     {
 328       gdbpy_print_stack ();
 329       return;
 330     }
 331
 332   inf_obj = (inferior_object *) thread_obj->inf_obj;
 333
 334   entry = XNEW (struct threadlist_entry);
 335   entry->thread_obj = thread_obj;
 336   entry->next = inf_obj->threads;
 337
 338   inf_obj->threads = entry;
 339   inf_obj->nthreads++;
 340
 341   if (evregpy_no_listeners_p (gdb_py_events.new_thread))
 342     return;
 343
 344   gdbpy_ref<> event = create_thread_event_object (&new_thread_event_object_type,
 345                                                   (PyObject *) thread_obj);
 346   if (event == NULL
 347       || evpy_emit_event (event.get (), gdb_py_events.new_thread) < 0)
 348     gdbpy_print_stack ();
 349 }
 350
 351 static void
 352 delete_thread_object (struct thread_info *tp, int ignore)
 353 {
 354   struct threadlist_entry **entry, *tmp;
 355
 356   if (!gdb_python_initialized)
 357     return;
 358
 359   gdbpy_enter enter_py (python_gdbarch, python_language);
 360
 361   gdbpy_ref<inferior_object> inf_obj
 362     ((inferior_object *) inferior_to_inferior_object (tp->inf));
 363   if (inf_obj == NULL)
 364     return;
 365
 366   /* Find thread entry in its inferior's thread_list.  */
 367   for (entry = &inf_obj->threads; *entry != NULL; entry =
 368          &(*entry)->next)
 369     if ((*entry)->thread_obj->thread == tp)
 370       break;
 371
 372   if (!*entry)
 373     return;
 374
 375   tmp = *entry;
 376   tmp->thread_obj->thread = NULL;
 377
 378   *entry = (*entry)->next;
 379   inf_obj->nthreads--;
 380
 381   Py_DECREF (tmp->thread_obj);
 382   xfree (tmp);
 383 }
 384
 385 static PyObject *
 386 infpy_threads (PyObject *self, PyObject *args)
 387 {
 388   int i;
 389   struct threadlist_entry *entry;
 390   inferior_object *inf_obj = (inferior_object *) self;
 391   PyObject *tuple;
 392
 393   INFPY_REQUIRE_VALID (inf_obj);
 394
 395   TRY
 396     {
 397       update_thread_list ();
 398     }
 399   CATCH (except, RETURN_MASK_ALL)
 400     {
 401       GDB_PY_HANDLE_EXCEPTION (except);
 402     }
 403   END_CATCH
 404
 405   tuple = PyTuple_New (inf_obj->nthreads);
 406   if (!tuple)
 407     return NULL;
 408
 409   for (i = 0, entry = inf_obj->threads; i < inf_obj->nthreads;
 410        i++, entry = entry->next)
 411     {
 412       Py_INCREF (entry->thread_obj);
 413       PyTuple_SET_ITEM (tuple, i, (PyObject *) entry->thread_obj);
 414     }
 415
 416   return tuple;
 417 }
 418
 419 static PyObject *
 420 infpy_get_num (PyObject *self, void *closure)
 421 {
 422   inferior_object *inf = (inferior_object *) self;
 423
 424   INFPY_REQUIRE_VALID (inf);
 425
 426   return PyLong_FromLong (inf->inferior->num);
 427 }
 428
 429 static PyObject *
 430 infpy_get_pid (PyObject *self, void *closure)
 431 {
 432   inferior_object *inf = (inferior_object *) self;
 433
 434   INFPY_REQUIRE_VALID (inf);
 435
 436   return PyLong_FromLong (inf->inferior->pid);
 437 }
 438
 439 static PyObject *
 440 infpy_get_was_attached (PyObject *self, void *closure)
 441 {
 442   inferior_object *inf = (inferior_object *) self;
 443
 444   INFPY_REQUIRE_VALID (inf);
 445   if (inf->inferior->attach_flag)
 446     Py_RETURN_TRUE;
 447   Py_RETURN_FALSE;
 448 }
 449
 450 /* Getter of gdb.Inferior.progspace.  */
 451
 452 static PyObject *
 453 infpy_get_progspace (PyObject *self, void *closure)
 454 {
 455   inferior_object *inf = (inferior_object *) self;
 456
 457   INFPY_REQUIRE_VALID (inf);
 458
 459   program_space *pspace = inf->inferior->pspace;
 460   gdb_assert (pspace != nullptr);
 461
 462   return pspace_to_pspace_object (pspace).release ();
 463 }
 464
 465 static int
 466 build_inferior_list (struct inferior *inf, void *arg)
 467 {
 468   PyObject *list = (PyObject *) arg;
 469   gdbpy_ref<inferior_object> inferior (inferior_to_inferior_object (inf));
 470
 471   if (inferior == NULL)
 472     return 0;
 473
 474   return PyList_Append (list, (PyObject *) inferior.get ()) ? 1 : 0;
 475 }
 476
 477 /* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
 478    Returns a tuple of all inferiors.  */
 479 PyObject *
 480 gdbpy_inferiors (PyObject *unused, PyObject *unused2)
 481 {
 482   gdbpy_ref<> list (PyList_New (0));
 483   if (list == NULL)
 484     return NULL;
 485
 486   if (iterate_over_inferiors (build_inferior_list, list.get ()))
 487     return NULL;
 488
 489   return PyList_AsTuple (list.get ());
 490 }
 491
 492 /* Membuf and memory manipulation.  */
 493
 494 /* Implementation of Inferior.read_memory (address, length).
 495    Returns a Python buffer object with LENGTH bytes of the inferior's
 496    memory at ADDRESS.  Both arguments are integers.  Returns NULL on error,
 497    with a python exception set.  */
 498 static PyObject *
 499 infpy_read_memory (PyObject *self, PyObject *args, PyObject *kw)
 500 {
 501   CORE_ADDR addr, length;
 502   gdb_byte *buffer = NULL;
 503   PyObject *addr_obj, *length_obj, *result;
 504   static const char *keywords[] = { "address", "length", NULL };
 505
 506   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "OO", keywords,
 507                                         &addr_obj, &length_obj))
 508     return NULL;
 509
 510   if (get_addr_from_python (addr_obj, &addr) < 0
 511       || get_addr_from_python (length_obj, &length) < 0)
 512     return NULL;
 513
 514   TRY
 515     {
 516       buffer = (gdb_byte *) xmalloc (length);
 517
 518       read_memory (addr, buffer, length);
 519     }
 520   CATCH (except, RETURN_MASK_ALL)
 521     {
 522       xfree (buffer);
 523       GDB_PY_HANDLE_EXCEPTION (except);
 524     }
 525   END_CATCH
 526
 527   gdbpy_ref<membuf_object> membuf_obj (PyObject_New (membuf_object,
 528                                                      &membuf_object_type));
 529   if (membuf_obj == NULL)
 530     {
 531       xfree (buffer);
 532       return NULL;
 533     }
 534
 535   membuf_obj->buffer = buffer;
 536   membuf_obj->addr = addr;
 537   membuf_obj->length = length;
 538
 539 #ifdef IS_PY3K
 540   result = PyMemoryView_FromObject ((PyObject *) membuf_obj.get ());
 541 #else
 542   result = PyBuffer_FromReadWriteObject ((PyObject *) membuf_obj.get (), 0,
 543                                          Py_END_OF_BUFFER);
 544 #endif
 545
 546   return result;
 547 }
 548
 549 /* Implementation of Inferior.write_memory (address, buffer [, length]).
 550    Writes the contents of BUFFER (a Python object supporting the read
 551    buffer protocol) at ADDRESS in the inferior's memory.  Write LENGTH
 552    bytes from BUFFER, or its entire contents if the argument is not
 553    provided.  The function returns nothing.  Returns NULL on error, with
 554    a python exception set.  */
 555 static PyObject *
 556 infpy_write_memory (PyObject *self, PyObject *args, PyObject *kw)
 557 {
 558   struct gdb_exception except = exception_none;
 559   Py_ssize_t buf_len;
 560   const gdb_byte *buffer;
 561   CORE_ADDR addr, length;
 562   PyObject *addr_obj, *length_obj = NULL;
 563   static const char *keywords[] = { "address", "buffer", "length", NULL };
 564 #ifdef IS_PY3K
 565   Py_buffer pybuf;
 566
 567   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "Os*|O", keywords,
 568                                         &addr_obj, &pybuf, &length_obj))
 569     return NULL;
 570
 571   buffer = (const gdb_byte *) pybuf.buf;
 572   buf_len = pybuf.len;
 573 #else
 574   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "Os#|O", keywords,
 575                                         &addr_obj, &buffer, &buf_len,
 576                                         &length_obj))
 577     return NULL;
 578
 579   buffer = (const gdb_byte *) buffer;
 580 #endif
 581
 582   if (get_addr_from_python (addr_obj, &addr) < 0)
 583     goto fail;
 584
 585   if (!length_obj)
 586     length = buf_len;
 587   else if (get_addr_from_python (length_obj, &length) < 0)
 588     goto fail;
 589
 590   TRY
 591     {
 592       write_memory_with_notification (addr, buffer, length);
 593     }
 594   CATCH (ex, RETURN_MASK_ALL)
 595     {
 596       except = ex;
 597     }
 598   END_CATCH
 599
 600 #ifdef IS_PY3K
 601   PyBuffer_Release (&pybuf);
 602 #endif
 603   GDB_PY_HANDLE_EXCEPTION (except);
 604
 605   Py_RETURN_NONE;
 606
 607  fail:
 608 #ifdef IS_PY3K
 609   PyBuffer_Release (&pybuf);
 610 #endif
 611   return NULL;
 612 }
 613
 614 /* Destructor of Membuf objects.  */
 615 static void
 616 mbpy_dealloc (PyObject *self)
 617 {
 618   xfree (((membuf_object *) self)->buffer);
 619   Py_TYPE (self)->tp_free (self);
 620 }
 621
 622 /* Return a description of the Membuf object.  */
 623 static PyObject *
 624 mbpy_str (PyObject *self)
 625 {
 626   membuf_object *membuf_obj = (membuf_object *) self;
 627
 628   return PyString_FromFormat (_("Memory buffer for address %s, \
 629 which is %s bytes long."),
 630                               paddress (python_gdbarch, membuf_obj->addr),
 631                               pulongest (membuf_obj->length));
 632 }
 633
 634 #ifdef IS_PY3K
 635
 636 static int
 637 get_buffer (PyObject *self, Py_buffer *buf, int flags)
 638 {
 639   membuf_object *membuf_obj = (membuf_object *) self;
 640   int ret;
 641
 642   ret = PyBuffer_FillInfo (buf, self, membuf_obj->buffer,
 643                            membuf_obj->length, 0,
 644                            PyBUF_CONTIG);
 645
 646   /* Despite the documentation saying this field is a "const char *",
 647      in Python 3.4 at least, it's really a "char *".  */
 648   buf->format = (char *) "c";
 649
 650   return ret;
 651 }
 652
 653 #else
 654
 655 static Py_ssize_t
 656 get_read_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
 657 {
 658   membuf_object *membuf_obj = (membuf_object *) self;
 659
 660   if (segment)
 661     {
 662       PyErr_SetString (PyExc_SystemError,
 663                        _("The memory buffer supports only one segment."));
 664       return -1;
 665     }
 666
 667   *ptrptr = membuf_obj->buffer;
 668
 669   return membuf_obj->length;
 670 }
 671
 672 static Py_ssize_t
 673 get_write_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
 674 {
 675   return get_read_buffer (self, segment, ptrptr);
 676 }
 677
 678 static Py_ssize_t
 679 get_seg_count (PyObject *self, Py_ssize_t *lenp)
 680 {
 681   if (lenp)
 682     *lenp = ((membuf_object *) self)->length;
 683
 684   return 1;
 685 }
 686
 687 static Py_ssize_t
 688 get_char_buffer (PyObject *self, Py_ssize_t segment, char **ptrptr)
 689 {
 690   void *ptr = NULL;
 691   Py_ssize_t ret;
 692
 693   ret = get_read_buffer (self, segment, &ptr);
 694   *ptrptr = (char *) ptr;
 695
 696   return ret;
 697 }
 698
 699 #endif  /* IS_PY3K */
 700
 701 /* Implementation of
 702    gdb.search_memory (address, length, pattern).  ADDRESS is the
 703    address to start the search.  LENGTH specifies the scope of the
 704    search from ADDRESS.  PATTERN is the pattern to search for (and
 705    must be a Python object supporting the buffer protocol).
 706    Returns a Python Long object holding the address where the pattern
 707    was located, or if the pattern was not found, returns None.  Returns NULL
 708    on error, with a python exception set.  */
 709 static PyObject *
 710 infpy_search_memory (PyObject *self, PyObject *args, PyObject *kw)
 711 {
 712   struct gdb_exception except = exception_none;
 713   CORE_ADDR start_addr, length;
 714   static const char *keywords[] = { "address", "length", "pattern", NULL };
 715   PyObject *start_addr_obj, *length_obj;
 716   Py_ssize_t pattern_size;
 717   const gdb_byte *buffer;
 718   CORE_ADDR found_addr;
 719   int found = 0;
 720 #ifdef IS_PY3K
 721   Py_buffer pybuf;
 722
 723   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "OOs*", keywords,
 724                                         &start_addr_obj, &length_obj,
 725                                         &pybuf))
 726     return NULL;
 727
 728   buffer = (const gdb_byte *) pybuf.buf;
 729   pattern_size = pybuf.len;
 730 #else
 731   PyObject *pattern;
 732   const void *vbuffer;
 733
 734   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "OOO", keywords,
 735                                         &start_addr_obj, &length_obj,
 736                                         &pattern))
 737      return NULL;
 738
 739   if (!PyObject_CheckReadBuffer (pattern))
 740     {
 741       PyErr_SetString (PyExc_RuntimeError,
 742                        _("The pattern is not a Python buffer."));
 743
 744       return NULL;
 745     }
 746
 747   if (PyObject_AsReadBuffer (pattern, &vbuffer, &pattern_size) == -1)
 748     return NULL;
 749
 750   buffer = (const gdb_byte *) vbuffer;
 751 #endif
 752
 753   if (get_addr_from_python (start_addr_obj, &start_addr) < 0)
 754     goto fail;
 755
 756   if (get_addr_from_python (length_obj, &length) < 0)
 757     goto fail;
 758
 759   if (!length)
 760     {
 761       PyErr_SetString (PyExc_ValueError,
 762                        _("Search range is empty."));
 763       goto fail;
 764     }
 765   /* Watch for overflows.  */
 766   else if (length > CORE_ADDR_MAX
 767            || (start_addr + length - 1) < start_addr)
 768     {
 769       PyErr_SetString (PyExc_ValueError,
 770                        _("The search range is too large."));
 771       goto fail;
 772     }
 773
 774   TRY
 775     {
 776       found = target_search_memory (start_addr, length,
 777                                     buffer, pattern_size,
 778                                     &found_addr);
 779     }
 780   CATCH (ex, RETURN_MASK_ALL)
 781     {
 782       except = ex;
 783     }
 784   END_CATCH
 785
 786 #ifdef IS_PY3K
 787   PyBuffer_Release (&pybuf);
 788 #endif
 789   GDB_PY_HANDLE_EXCEPTION (except);
 790
 791   if (found)
 792     return PyLong_FromLong (found_addr);
 793   else
 794     Py_RETURN_NONE;
 795
 796  fail:
 797 #ifdef IS_PY3K
 798   PyBuffer_Release (&pybuf);
 799 #endif
 800   return NULL;
 801 }
 802
 803 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
 804    Returns True if this inferior object still exists in GDB.  */
 805
 806 static PyObject *
 807 infpy_is_valid (PyObject *self, PyObject *args)
 808 {
 809   inferior_object *inf = (inferior_object *) self;
 810
 811   if (! inf->inferior)
 812     Py_RETURN_FALSE;
 813
 814   Py_RETURN_TRUE;
 815 }
 816
 817 /* Implementation of gdb.Inferior.thread_from_thread_handle (self, handle)
 818                         ->  gdb.InferiorThread.  */
 819
 820 static PyObject *
 821 infpy_thread_from_thread_handle (PyObject *self, PyObject *args, PyObject *kw)
 822 {
 823   PyObject *handle_obj;
 824   inferior_object *inf_obj = (inferior_object *) self;
 825   static const char *keywords[] = { "thread_handle", NULL };
 826
 827   INFPY_REQUIRE_VALID (inf_obj);
 828
 829   if (! gdb_PyArg_ParseTupleAndKeywords (args, kw, "O", keywords, &handle_obj))
 830     return NULL;
 831
 832   if (!gdbpy_is_value_object (handle_obj))
 833     {
 834       PyErr_SetString (PyExc_TypeError,
 835                        _("Argument 'handle_obj' must be a thread handle object."));
 836
 837       return NULL;
 838     }
 839
 840   TRY
 841     {
 842       struct thread_info *thread_info;
 843       struct value *val = value_object_to_value (handle_obj);
 844
 845       thread_info = find_thread_by_handle (val, inf_obj->inferior);
 846       if (thread_info != NULL)
 847         return thread_to_thread_object (thread_info).release ();
 848     }
 849   CATCH (except, RETURN_MASK_ALL)
 850     {
 851       GDB_PY_HANDLE_EXCEPTION (except);
 852     }
 853   END_CATCH
 854
 855   Py_RETURN_NONE;
 856 }
 857
 858 /* Implementation of gdb.Inferior.architecture.  */
 859
 860 static PyObject *
 861 infpy_architecture (PyObject *self, PyObject *args)
 862 {
 863   inferior_object *inf = (inferior_object *) self;
 864
 865   INFPY_REQUIRE_VALID (inf);
 866
 867   return gdbarch_to_arch_object (inf->inferior->gdbarch);
 868 }
 869
 870 /* Implement repr() for gdb.Inferior.  */
 871
 872 static PyObject *
 873 infpy_repr (PyObject *obj)
 874 {
 875   inferior_object *self = (inferior_object *) obj;
 876   inferior *inf = self->inferior;
 877
 878   if (inf == nullptr)
 879     return PyString_FromString ("<gdb.Inferior (invalid)>");
 880
 881   return PyString_FromFormat ("<gdb.Inferior num=%d, pid=%d>",
 882                               inf->num, inf->pid);
 883 }
 884
 885
 886 static void
 887 infpy_dealloc (PyObject *obj)
 888 {
 889   inferior_object *inf_obj = (inferior_object *) obj;
 890   struct inferior *inf = inf_obj->inferior;
 891
 892   if (! inf)
 893     return;
 894
 895   set_inferior_data (inf, infpy_inf_data_key, NULL);
 896 }
 897
 898 /* Clear the INFERIOR pointer in an Inferior object and clear the
 899    thread list.  */
 900 static void
 901 py_free_inferior (struct inferior *inf, void *datum)
 902 {
 903   gdbpy_ref<inferior_object> inf_obj ((inferior_object *) datum);
 904   struct threadlist_entry *th_entry, *th_tmp;
 905
 906   if (!gdb_python_initialized)
 907     return;
 908
 909   gdbpy_enter enter_py (python_gdbarch, python_language);
 910
 911   inf_obj->inferior = NULL;
 912
 913   /* Deallocate threads list.  */
 914   for (th_entry = inf_obj->threads; th_entry != NULL;)
 915     {
 916       Py_DECREF (th_entry->thread_obj);
 917
 918       th_tmp = th_entry;
 919       th_entry = th_entry->next;
 920       xfree (th_tmp);
 921     }
 922
 923   inf_obj->nthreads = 0;
 924 }
 925
 926 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
 927    Returns the current inferior object.  */
 928
 929 PyObject *
 930 gdbpy_selected_inferior (PyObject *self, PyObject *args)
 931 {
 932   return (PyObject *) inferior_to_inferior_object (current_inferior ());
 933 }
 934
 935 int
 936 gdbpy_initialize_inferior (void)
 937 {
 938   if (PyType_Ready (&inferior_object_type) < 0)
 939     return -1;
 940
 941   if (gdb_pymodule_addobject (gdb_module, "Inferior",
 942                               (PyObject *) &inferior_object_type) < 0)
 943     return -1;
 944
 945   infpy_inf_data_key =
 946     register_inferior_data_with_cleanup (NULL, py_free_inferior);
 947
 948   gdb::observers::new_thread.attach (add_thread_object);
 949   gdb::observers::thread_exit.attach (delete_thread_object);
 950   gdb::observers::normal_stop.attach (python_on_normal_stop);
 951   gdb::observers::target_resumed.attach (python_on_resume);
 952   gdb::observers::inferior_call_pre.attach (python_on_inferior_call_pre);
 953   gdb::observers::inferior_call_post.attach (python_on_inferior_call_post);
 954   gdb::observers::memory_changed.attach (python_on_memory_change);
 955   gdb::observers::register_changed.attach (python_on_register_change);
 956   gdb::observers::inferior_exit.attach (python_inferior_exit);
 957   gdb::observers::new_objfile.attach (python_new_objfile);
 958   gdb::observers::inferior_added.attach (python_new_inferior);
 959   gdb::observers::inferior_removed.attach (python_inferior_deleted);
 960
 961   membuf_object_type.tp_new = PyType_GenericNew;
 962   if (PyType_Ready (&membuf_object_type) < 0)
 963     return -1;
 964
 965   return gdb_pymodule_addobject (gdb_module, "Membuf", (PyObject *)
 966                                  &membuf_object_type);
 967 }
 968
 969 static gdb_PyGetSetDef inferior_object_getset[] =
 970 {
 971   { "num", infpy_get_num, NULL, "ID of inferior, as assigned by GDB.", NULL },
 972   { "pid", infpy_get_pid, NULL, "PID of inferior, as assigned by the OS.",
 973     NULL },
 974   { "was_attached", infpy_get_was_attached, NULL,
 975     "True if the inferior was created using 'attach'.", NULL },
 976   { "progspace", infpy_get_progspace, NULL, "Program space of this inferior" },
 977   { NULL }
 978 };
 979
 980 static PyMethodDef inferior_object_methods[] =
 981 {
 982   { "is_valid", infpy_is_valid, METH_NOARGS,
 983     "is_valid () -> Boolean.\n\
 984 Return true if this inferior is valid, false if not." },
 985   { "threads", infpy_threads, METH_NOARGS,
 986     "Return all the threads of this inferior." },
 987   { "read_memory", (PyCFunction) infpy_read_memory,
 988     METH_VARARGS | METH_KEYWORDS,
 989     "read_memory (address, length) -> buffer\n\
 990 Return a buffer object for reading from the inferior's memory." },
 991   { "write_memory", (PyCFunction) infpy_write_memory,
 992     METH_VARARGS | METH_KEYWORDS,
 993     "write_memory (address, buffer [, length])\n\
 994 Write the given buffer object to the inferior's memory." },
 995   { "search_memory", (PyCFunction) infpy_search_memory,
 996     METH_VARARGS | METH_KEYWORDS,
 997     "search_memory (address, length, pattern) -> long\n\
 998 Return a long with the address of a match, or None." },
 999   { "thread_from_thread_handle", (PyCFunction) infpy_thread_from_thread_handle,
1000     METH_VARARGS | METH_KEYWORDS,
1001     "thread_from_thread_handle (handle) -> gdb.InferiorThread.\n\
1002 Return thread object corresponding to thread handle." },
1003   { "architecture", (PyCFunction) infpy_architecture, METH_NOARGS,
1004     "architecture () -> gdb.Architecture\n\
1005 Return architecture of this inferior." },
1006   { NULL }
1007 };
1008
1009 PyTypeObject inferior_object_type =
1010 {
1011   PyVarObject_HEAD_INIT (NULL, 0)
1012   "gdb.Inferior",                 /* tp_name */
1013   sizeof (inferior_object),       /* tp_basicsize */
1014   0,                              /* tp_itemsize */
1015   infpy_dealloc,                  /* tp_dealloc */
1016   0,                              /* tp_print */
1017   0,                              /* tp_getattr */
1018   0,                              /* tp_setattr */
1019   0,                              /* tp_compare */
1020   infpy_repr,                     /* tp_repr */
1021   0,                              /* tp_as_number */
1022   0,                              /* tp_as_sequence */
1023   0,                              /* tp_as_mapping */
1024   0,                              /* tp_hash  */
1025   0,                              /* tp_call */
1026   0,                              /* tp_str */
1027   0,                              /* tp_getattro */
1028   0,                              /* tp_setattro */
1029   0,                              /* tp_as_buffer */
1030   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /* tp_flags */
1031   "GDB inferior object",          /* tp_doc */
1032   0,                              /* tp_traverse */
1033   0,                              /* tp_clear */
1034   0,                              /* tp_richcompare */
1035   0,                              /* tp_weaklistoffset */
1036   0,                              /* tp_iter */
1037   0,                              /* tp_iternext */
1038   inferior_object_methods,        /* tp_methods */
1039   0,                              /* tp_members */
1040   inferior_object_getset,         /* tp_getset */
1041   0,                              /* tp_base */
1042   0,                              /* tp_dict */
1043   0,                              /* tp_descr_get */
1044   0,                              /* tp_descr_set */
1045   0,                              /* tp_dictoffset */
1046   0,                              /* tp_init */
1047   0                               /* tp_alloc */
1048 };
1049
1050 #ifdef IS_PY3K
1051
1052 static PyBufferProcs buffer_procs =
1053 {
1054   get_buffer
1055 };
1056
1057 #else
1058
1059 /* Python doesn't provide a decent way to get compatibility here.  */
1060 #if HAVE_LIBPYTHON2_4
1061 #define CHARBUFFERPROC_NAME getcharbufferproc
1062 #else
1063 #define CHARBUFFERPROC_NAME charbufferproc
1064 #endif
1065
1066 static PyBufferProcs buffer_procs = {
1067   get_read_buffer,
1068   get_write_buffer,
1069   get_seg_count,
1070   /* The cast here works around a difference between Python 2.4 and
1071      Python 2.5.  */
1072   (CHARBUFFERPROC_NAME) get_char_buffer
1073 };
1074 #endif  /* IS_PY3K */
1075
1076 PyTypeObject membuf_object_type = {
1077   PyVarObject_HEAD_INIT (NULL, 0)
1078   "gdb.Membuf",                   /*tp_name*/
1079   sizeof (membuf_object),         /*tp_basicsize*/
1080   0,                              /*tp_itemsize*/
1081   mbpy_dealloc,                   /*tp_dealloc*/
1082   0,                              /*tp_print*/
1083   0,                              /*tp_getattr*/
1084   0,                              /*tp_setattr*/
1085   0,                              /*tp_compare*/
1086   0,                              /*tp_repr*/
1087   0,                              /*tp_as_number*/
1088   0,                              /*tp_as_sequence*/
1089   0,                              /*tp_as_mapping*/
1090   0,                              /*tp_hash */
1091   0,                              /*tp_call*/
1092   mbpy_str,                       /*tp_str*/
1093   0,                              /*tp_getattro*/
1094   0,                              /*tp_setattro*/
1095   &buffer_procs,                  /*tp_as_buffer*/
1096   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
1097   "GDB memory buffer object",     /*tp_doc*/
1098   0,                              /* tp_traverse */
1099   0,                              /* tp_clear */
1100   0,                              /* tp_richcompare */
1101   0,                              /* tp_weaklistoffset */
1102   0,                              /* tp_iter */
1103   0,                              /* tp_iternext */
1104   0,                              /* tp_methods */
1105   0,                              /* tp_members */
1106   0,                              /* tp_getset */
1107   0,                              /* tp_base */
1108   0,                              /* tp_dict */
1109   0,                              /* tp_descr_get */
1110   0,                              /* tp_descr_set */
1111   0,                              /* tp_dictoffset */
1112   0,                              /* tp_init */
1113   0,                              /* tp_alloc */
1114 };