gdb/python/py-inferior.c

   1 /* Python interface to inferiors.
   2
   3    Copyright (C) 2009-2019 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 "common/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 (inferior_ptid == null_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 gdbpy_ref<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   /* We are returning a new reference.  */
 233   gdb_assert (inf_obj != nullptr);
 234   return gdbpy_ref<inferior_object>::new_reference (inf_obj);
 235 }
 236
 237 /* Called when a new inferior is created.  Notifies any Python event
 238    listeners.  */
 239 static void
 240 python_new_inferior (struct inferior *inf)
 241 {
 242   if (!gdb_python_initialized)
 243     return;
 244
 245   gdbpy_enter enter_py (python_gdbarch, python_language);
 246
 247   if (evregpy_no_listeners_p (gdb_py_events.new_inferior))
 248     return;
 249
 250   gdbpy_ref<inferior_object> inf_obj = inferior_to_inferior_object (inf);
 251   if (inf_obj == NULL)
 252     {
 253       gdbpy_print_stack ();
 254       return;
 255     }
 256
 257   gdbpy_ref<> event = create_event_object (&new_inferior_event_object_type);
 258   if (event == NULL
 259       || evpy_add_attribute (event.get (), "inferior",
 260                              (PyObject *) inf_obj.get ()) < 0
 261       || evpy_emit_event (event.get (), gdb_py_events.new_inferior) < 0)
 262     gdbpy_print_stack ();
 263 }
 264
 265 /* Called when an inferior is removed.  Notifies any Python event
 266    listeners.  */
 267 static void
 268 python_inferior_deleted (struct inferior *inf)
 269 {
 270   if (!gdb_python_initialized)
 271     return;
 272
 273   gdbpy_enter enter_py (python_gdbarch, python_language);
 274
 275   if (evregpy_no_listeners_p (gdb_py_events.inferior_deleted))
 276     return;
 277
 278   gdbpy_ref<inferior_object> inf_obj = inferior_to_inferior_object (inf);
 279   if (inf_obj == NULL)
 280     {
 281       gdbpy_print_stack ();
 282       return;
 283     }
 284
 285   gdbpy_ref<> event = create_event_object (&inferior_deleted_event_object_type);
 286   if (event == NULL
 287       || evpy_add_attribute (event.get (), "inferior",
 288                              (PyObject *) inf_obj.get ()) < 0
 289       || evpy_emit_event (event.get (), gdb_py_events.inferior_deleted) < 0)
 290     gdbpy_print_stack ();
 291 }
 292
 293 gdbpy_ref<>
 294 thread_to_thread_object (thread_info *thr)
 295 {
 296   gdbpy_ref<inferior_object> inf_obj = inferior_to_inferior_object (thr->inf);
 297   if (inf_obj == NULL)
 298     return NULL;
 299
 300   for (threadlist_entry *thread = inf_obj->threads;
 301        thread != NULL;
 302        thread = thread->next)
 303     if (thread->thread_obj->thread == thr)
 304       return gdbpy_ref<>::new_reference ((PyObject *) thread->thread_obj);
 305
 306   PyErr_SetString (PyExc_SystemError,
 307                    _("could not find gdb thread object"));
 308   return NULL;
 309 }
 310
 311 static void
 312 add_thread_object (struct thread_info *tp)
 313 {
 314   thread_object *thread_obj;
 315   inferior_object *inf_obj;
 316   struct threadlist_entry *entry;
 317
 318   if (!gdb_python_initialized)
 319     return;
 320
 321   gdbpy_enter enter_py (python_gdbarch, python_language);
 322
 323   thread_obj = create_thread_object (tp);
 324   if (!thread_obj)
 325     {
 326       gdbpy_print_stack ();
 327       return;
 328     }
 329
 330   inf_obj = (inferior_object *) thread_obj->inf_obj;
 331
 332   entry = XNEW (struct threadlist_entry);
 333   entry->thread_obj = thread_obj;
 334   entry->next = inf_obj->threads;
 335
 336   inf_obj->threads = entry;
 337   inf_obj->nthreads++;
 338
 339   if (evregpy_no_listeners_p (gdb_py_events.new_thread))
 340     return;
 341
 342   gdbpy_ref<> event = create_thread_event_object (&new_thread_event_object_type,
 343                                                   (PyObject *) thread_obj);
 344   if (event == NULL
 345       || evpy_emit_event (event.get (), gdb_py_events.new_thread) < 0)
 346     gdbpy_print_stack ();
 347 }
 348
 349 static void
 350 delete_thread_object (struct thread_info *tp, int ignore)
 351 {
 352   struct threadlist_entry **entry, *tmp;
 353
 354   if (!gdb_python_initialized)
 355     return;
 356
 357   gdbpy_enter enter_py (python_gdbarch, python_language);
 358
 359   gdbpy_ref<inferior_object> inf_obj = inferior_to_inferior_object (tp->inf);
 360   if (inf_obj == NULL)
 361     return;
 362
 363   /* Find thread entry in its inferior's thread_list.  */
 364   for (entry = &inf_obj->threads; *entry != NULL; entry =
 365          &(*entry)->next)
 366     if ((*entry)->thread_obj->thread == tp)
 367       break;
 368
 369   if (!*entry)
 370     return;
 371
 372   tmp = *entry;
 373   tmp->thread_obj->thread = NULL;
 374
 375   *entry = (*entry)->next;
 376   inf_obj->nthreads--;
 377
 378   Py_DECREF (tmp->thread_obj);
 379   xfree (tmp);
 380 }
 381
 382 static PyObject *
 383 infpy_threads (PyObject *self, PyObject *args)
 384 {
 385   int i;
 386   struct threadlist_entry *entry;
 387   inferior_object *inf_obj = (inferior_object *) self;
 388   PyObject *tuple;
 389
 390   INFPY_REQUIRE_VALID (inf_obj);
 391
 392   TRY
 393     {
 394       update_thread_list ();
 395     }
 396   CATCH (except, RETURN_MASK_ALL)
 397     {
 398       GDB_PY_HANDLE_EXCEPTION (except);
 399     }
 400   END_CATCH
 401
 402   tuple = PyTuple_New (inf_obj->nthreads);
 403   if (!tuple)
 404     return NULL;
 405
 406   for (i = 0, entry = inf_obj->threads; i < inf_obj->nthreads;
 407        i++, entry = entry->next)
 408     {
 409       Py_INCREF (entry->thread_obj);
 410       PyTuple_SET_ITEM (tuple, i, (PyObject *) entry->thread_obj);
 411     }
 412
 413   return tuple;
 414 }
 415
 416 static PyObject *
 417 infpy_get_num (PyObject *self, void *closure)
 418 {
 419   inferior_object *inf = (inferior_object *) self;
 420
 421   INFPY_REQUIRE_VALID (inf);
 422
 423   return PyLong_FromLong (inf->inferior->num);
 424 }
 425
 426 static PyObject *
 427 infpy_get_pid (PyObject *self, void *closure)
 428 {
 429   inferior_object *inf = (inferior_object *) self;
 430
 431   INFPY_REQUIRE_VALID (inf);
 432
 433   return PyLong_FromLong (inf->inferior->pid);
 434 }
 435
 436 static PyObject *
 437 infpy_get_was_attached (PyObject *self, void *closure)
 438 {
 439   inferior_object *inf = (inferior_object *) self;
 440
 441   INFPY_REQUIRE_VALID (inf);
 442   if (inf->inferior->attach_flag)
 443     Py_RETURN_TRUE;
 444   Py_RETURN_FALSE;
 445 }
 446
 447 /* Getter of gdb.Inferior.progspace.  */
 448
 449 static PyObject *
 450 infpy_get_progspace (PyObject *self, void *closure)
 451 {
 452   inferior_object *inf = (inferior_object *) self;
 453
 454   INFPY_REQUIRE_VALID (inf);
 455
 456   program_space *pspace = inf->inferior->pspace;
 457   gdb_assert (pspace != nullptr);
 458
 459   return pspace_to_pspace_object (pspace).release ();
 460 }
 461
 462 static int
 463 build_inferior_list (struct inferior *inf, void *arg)
 464 {
 465   PyObject *list = (PyObject *) arg;
 466   gdbpy_ref<inferior_object> inferior = inferior_to_inferior_object (inf);
 467
 468   if (inferior == NULL)
 469     return 0;
 470
 471   return PyList_Append (list, (PyObject *) inferior.get ()) ? 1 : 0;
 472 }
 473
 474 /* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
 475    Returns a tuple of all inferiors.  */
 476 PyObject *
 477 gdbpy_inferiors (PyObject *unused, PyObject *unused2)
 478 {
 479   gdbpy_ref<> list (PyList_New (0));
 480   if (list == NULL)
 481     return NULL;
 482
 483   if (iterate_over_inferiors (build_inferior_list, list.get ()))
 484     return NULL;
 485
 486   return PyList_AsTuple (list.get ());
 487 }
 488
 489 /* Membuf and memory manipulation.  */
 490
 491 /* Implementation of Inferior.read_memory (address, length).
 492    Returns a Python buffer object with LENGTH bytes of the inferior's
 493    memory at ADDRESS.  Both arguments are integers.  Returns NULL on error,
 494    with a python exception set.  */
 495 static PyObject *
 496 infpy_read_memory (PyObject *self, PyObject *args, PyObject *kw)
 497 {
 498   CORE_ADDR addr, length;
 499   gdb::unique_xmalloc_ptr<gdb_byte> buffer;
 500   PyObject *addr_obj, *length_obj, *result;
 501   static const char *keywords[] = { "address", "length", NULL };
 502
 503   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "OO", keywords,
 504                                         &addr_obj, &length_obj))
 505     return NULL;
 506
 507   if (get_addr_from_python (addr_obj, &addr) < 0
 508       || get_addr_from_python (length_obj, &length) < 0)
 509     return NULL;
 510
 511   TRY
 512     {
 513       buffer.reset ((gdb_byte *) xmalloc (length));
 514
 515       read_memory (addr, buffer.get (), length);
 516     }
 517   CATCH (except, RETURN_MASK_ALL)
 518     {
 519       GDB_PY_HANDLE_EXCEPTION (except);
 520     }
 521   END_CATCH
 522
 523   gdbpy_ref<membuf_object> membuf_obj (PyObject_New (membuf_object,
 524                                                      &membuf_object_type));
 525   if (membuf_obj == NULL)
 526     return NULL;
 527
 528   membuf_obj->buffer = buffer.release ();
 529   membuf_obj->addr = addr;
 530   membuf_obj->length = length;
 531
 532 #ifdef IS_PY3K
 533   result = PyMemoryView_FromObject ((PyObject *) membuf_obj.get ());
 534 #else
 535   result = PyBuffer_FromReadWriteObject ((PyObject *) membuf_obj.get (), 0,
 536                                          Py_END_OF_BUFFER);
 537 #endif
 538
 539   return result;
 540 }
 541
 542 /* Implementation of Inferior.write_memory (address, buffer [, length]).
 543    Writes the contents of BUFFER (a Python object supporting the read
 544    buffer protocol) at ADDRESS in the inferior's memory.  Write LENGTH
 545    bytes from BUFFER, or its entire contents if the argument is not
 546    provided.  The function returns nothing.  Returns NULL on error, with
 547    a python exception set.  */
 548 static PyObject *
 549 infpy_write_memory (PyObject *self, PyObject *args, PyObject *kw)
 550 {
 551   struct gdb_exception except = exception_none;
 552   Py_ssize_t buf_len;
 553   const gdb_byte *buffer;
 554   CORE_ADDR addr, length;
 555   PyObject *addr_obj, *length_obj = NULL;
 556   static const char *keywords[] = { "address", "buffer", "length", NULL };
 557 #ifdef IS_PY3K
 558   Py_buffer pybuf;
 559
 560   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "Os*|O", keywords,
 561                                         &addr_obj, &pybuf, &length_obj))
 562     return NULL;
 563
 564   buffer = (const gdb_byte *) pybuf.buf;
 565   buf_len = pybuf.len;
 566 #else
 567   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "Os#|O", keywords,
 568                                         &addr_obj, &buffer, &buf_len,
 569                                         &length_obj))
 570     return NULL;
 571
 572   buffer = (const gdb_byte *) buffer;
 573 #endif
 574
 575   if (get_addr_from_python (addr_obj, &addr) < 0)
 576     goto fail;
 577
 578   if (!length_obj)
 579     length = buf_len;
 580   else if (get_addr_from_python (length_obj, &length) < 0)
 581     goto fail;
 582
 583   TRY
 584     {
 585       write_memory_with_notification (addr, buffer, length);
 586     }
 587   CATCH (ex, RETURN_MASK_ALL)
 588     {
 589       except = ex;
 590     }
 591   END_CATCH
 592
 593 #ifdef IS_PY3K
 594   PyBuffer_Release (&pybuf);
 595 #endif
 596   GDB_PY_HANDLE_EXCEPTION (except);
 597
 598   Py_RETURN_NONE;
 599
 600  fail:
 601 #ifdef IS_PY3K
 602   PyBuffer_Release (&pybuf);
 603 #endif
 604   return NULL;
 605 }
 606
 607 /* Destructor of Membuf objects.  */
 608 static void
 609 mbpy_dealloc (PyObject *self)
 610 {
 611   xfree (((membuf_object *) self)->buffer);
 612   Py_TYPE (self)->tp_free (self);
 613 }
 614
 615 /* Return a description of the Membuf object.  */
 616 static PyObject *
 617 mbpy_str (PyObject *self)
 618 {
 619   membuf_object *membuf_obj = (membuf_object *) self;
 620
 621   return PyString_FromFormat (_("Memory buffer for address %s, \
 622 which is %s bytes long."),
 623                               paddress (python_gdbarch, membuf_obj->addr),
 624                               pulongest (membuf_obj->length));
 625 }
 626
 627 #ifdef IS_PY3K
 628
 629 static int
 630 get_buffer (PyObject *self, Py_buffer *buf, int flags)
 631 {
 632   membuf_object *membuf_obj = (membuf_object *) self;
 633   int ret;
 634
 635   ret = PyBuffer_FillInfo (buf, self, membuf_obj->buffer,
 636                            membuf_obj->length, 0,
 637                            PyBUF_CONTIG);
 638
 639   /* Despite the documentation saying this field is a "const char *",
 640      in Python 3.4 at least, it's really a "char *".  */
 641   buf->format = (char *) "c";
 642
 643   return ret;
 644 }
 645
 646 #else
 647
 648 static Py_ssize_t
 649 get_read_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
 650 {
 651   membuf_object *membuf_obj = (membuf_object *) self;
 652
 653   if (segment)
 654     {
 655       PyErr_SetString (PyExc_SystemError,
 656                        _("The memory buffer supports only one segment."));
 657       return -1;
 658     }
 659
 660   *ptrptr = membuf_obj->buffer;
 661
 662   return membuf_obj->length;
 663 }
 664
 665 static Py_ssize_t
 666 get_write_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
 667 {
 668   return get_read_buffer (self, segment, ptrptr);
 669 }
 670
 671 static Py_ssize_t
 672 get_seg_count (PyObject *self, Py_ssize_t *lenp)
 673 {
 674   if (lenp)
 675     *lenp = ((membuf_object *) self)->length;
 676
 677   return 1;
 678 }
 679
 680 static Py_ssize_t
 681 get_char_buffer (PyObject *self, Py_ssize_t segment, char **ptrptr)
 682 {
 683   void *ptr = NULL;
 684   Py_ssize_t ret;
 685
 686   ret = get_read_buffer (self, segment, &ptr);
 687   *ptrptr = (char *) ptr;
 688
 689   return ret;
 690 }
 691
 692 #endif  /* IS_PY3K */
 693
 694 /* Implementation of
 695    gdb.search_memory (address, length, pattern).  ADDRESS is the
 696    address to start the search.  LENGTH specifies the scope of the
 697    search from ADDRESS.  PATTERN is the pattern to search for (and
 698    must be a Python object supporting the buffer protocol).
 699    Returns a Python Long object holding the address where the pattern
 700    was located, or if the pattern was not found, returns None.  Returns NULL
 701    on error, with a python exception set.  */
 702 static PyObject *
 703 infpy_search_memory (PyObject *self, PyObject *args, PyObject *kw)
 704 {
 705   struct gdb_exception except = exception_none;
 706   CORE_ADDR start_addr, length;
 707   static const char *keywords[] = { "address", "length", "pattern", NULL };
 708   PyObject *start_addr_obj, *length_obj;
 709   Py_ssize_t pattern_size;
 710   const gdb_byte *buffer;
 711   CORE_ADDR found_addr;
 712   int found = 0;
 713 #ifdef IS_PY3K
 714   Py_buffer pybuf;
 715
 716   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "OOs*", keywords,
 717                                         &start_addr_obj, &length_obj,
 718                                         &pybuf))
 719     return NULL;
 720
 721   buffer = (const gdb_byte *) pybuf.buf;
 722   pattern_size = pybuf.len;
 723 #else
 724   PyObject *pattern;
 725   const void *vbuffer;
 726
 727   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "OOO", keywords,
 728                                         &start_addr_obj, &length_obj,
 729                                         &pattern))
 730      return NULL;
 731
 732   if (!PyObject_CheckReadBuffer (pattern))
 733     {
 734       PyErr_SetString (PyExc_RuntimeError,
 735                        _("The pattern is not a Python buffer."));
 736
 737       return NULL;
 738     }
 739
 740   if (PyObject_AsReadBuffer (pattern, &vbuffer, &pattern_size) == -1)
 741     return NULL;
 742
 743   buffer = (const gdb_byte *) vbuffer;
 744 #endif
 745
 746   if (get_addr_from_python (start_addr_obj, &start_addr) < 0)
 747     goto fail;
 748
 749   if (get_addr_from_python (length_obj, &length) < 0)
 750     goto fail;
 751
 752   if (!length)
 753     {
 754       PyErr_SetString (PyExc_ValueError,
 755                        _("Search range is empty."));
 756       goto fail;
 757     }
 758   /* Watch for overflows.  */
 759   else if (length > CORE_ADDR_MAX
 760            || (start_addr + length - 1) < start_addr)
 761     {
 762       PyErr_SetString (PyExc_ValueError,
 763                        _("The search range is too large."));
 764       goto fail;
 765     }
 766
 767   TRY
 768     {
 769       found = target_search_memory (start_addr, length,
 770                                     buffer, pattern_size,
 771                                     &found_addr);
 772     }
 773   CATCH (ex, RETURN_MASK_ALL)
 774     {
 775       except = ex;
 776     }
 777   END_CATCH
 778
 779 #ifdef IS_PY3K
 780   PyBuffer_Release (&pybuf);
 781 #endif
 782   GDB_PY_HANDLE_EXCEPTION (except);
 783
 784   if (found)
 785     return PyLong_FromLong (found_addr);
 786   else
 787     Py_RETURN_NONE;
 788
 789  fail:
 790 #ifdef IS_PY3K
 791   PyBuffer_Release (&pybuf);
 792 #endif
 793   return NULL;
 794 }
 795
 796 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
 797    Returns True if this inferior object still exists in GDB.  */
 798
 799 static PyObject *
 800 infpy_is_valid (PyObject *self, PyObject *args)
 801 {
 802   inferior_object *inf = (inferior_object *) self;
 803
 804   if (! inf->inferior)
 805     Py_RETURN_FALSE;
 806
 807   Py_RETURN_TRUE;
 808 }
 809
 810 /* Implementation of gdb.Inferior.thread_from_thread_handle (self, handle)
 811                         ->  gdb.InferiorThread.  */
 812
 813 static PyObject *
 814 infpy_thread_from_thread_handle (PyObject *self, PyObject *args, PyObject *kw)
 815 {
 816   PyObject *handle_obj;
 817   inferior_object *inf_obj = (inferior_object *) self;
 818   static const char *keywords[] = { "thread_handle", NULL };
 819
 820   INFPY_REQUIRE_VALID (inf_obj);
 821
 822   if (! gdb_PyArg_ParseTupleAndKeywords (args, kw, "O", keywords, &handle_obj))
 823     return NULL;
 824
 825   if (!gdbpy_is_value_object (handle_obj))
 826     {
 827       PyErr_SetString (PyExc_TypeError,
 828                        _("Argument 'handle_obj' must be a thread handle object."));
 829
 830       return NULL;
 831     }
 832
 833   TRY
 834     {
 835       struct thread_info *thread_info;
 836       struct value *val = value_object_to_value (handle_obj);
 837
 838       thread_info = find_thread_by_handle (val, inf_obj->inferior);
 839       if (thread_info != NULL)
 840         return thread_to_thread_object (thread_info).release ();
 841     }
 842   CATCH (except, RETURN_MASK_ALL)
 843     {
 844       GDB_PY_HANDLE_EXCEPTION (except);
 845     }
 846   END_CATCH
 847
 848   Py_RETURN_NONE;
 849 }
 850
 851 /* Implementation of gdb.Inferior.architecture.  */
 852
 853 static PyObject *
 854 infpy_architecture (PyObject *self, PyObject *args)
 855 {
 856   inferior_object *inf = (inferior_object *) self;
 857
 858   INFPY_REQUIRE_VALID (inf);
 859
 860   return gdbarch_to_arch_object (inf->inferior->gdbarch);
 861 }
 862
 863 /* Implement repr() for gdb.Inferior.  */
 864
 865 static PyObject *
 866 infpy_repr (PyObject *obj)
 867 {
 868   inferior_object *self = (inferior_object *) obj;
 869   inferior *inf = self->inferior;
 870
 871   if (inf == nullptr)
 872     return PyString_FromString ("<gdb.Inferior (invalid)>");
 873
 874   return PyString_FromFormat ("<gdb.Inferior num=%d, pid=%d>",
 875                               inf->num, inf->pid);
 876 }
 877
 878
 879 static void
 880 infpy_dealloc (PyObject *obj)
 881 {
 882   inferior_object *inf_obj = (inferior_object *) obj;
 883   struct inferior *inf = inf_obj->inferior;
 884
 885   if (! inf)
 886     return;
 887
 888   set_inferior_data (inf, infpy_inf_data_key, NULL);
 889 }
 890
 891 /* Clear the INFERIOR pointer in an Inferior object and clear the
 892    thread list.  */
 893 static void
 894 py_free_inferior (struct inferior *inf, void *datum)
 895 {
 896   gdbpy_ref<inferior_object> inf_obj ((inferior_object *) datum);
 897   struct threadlist_entry *th_entry, *th_tmp;
 898
 899   if (!gdb_python_initialized)
 900     return;
 901
 902   gdbpy_enter enter_py (python_gdbarch, python_language);
 903
 904   inf_obj->inferior = NULL;
 905
 906   /* Deallocate threads list.  */
 907   for (th_entry = inf_obj->threads; th_entry != NULL;)
 908     {
 909       Py_DECREF (th_entry->thread_obj);
 910
 911       th_tmp = th_entry;
 912       th_entry = th_entry->next;
 913       xfree (th_tmp);
 914     }
 915
 916   inf_obj->nthreads = 0;
 917 }
 918
 919 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
 920    Returns the current inferior object.  */
 921
 922 PyObject *
 923 gdbpy_selected_inferior (PyObject *self, PyObject *args)
 924 {
 925   return ((PyObject *)
 926           inferior_to_inferior_object (current_inferior ()).release ());
 927 }
 928
 929 int
 930 gdbpy_initialize_inferior (void)
 931 {
 932   if (PyType_Ready (&inferior_object_type) < 0)
 933     return -1;
 934
 935   if (gdb_pymodule_addobject (gdb_module, "Inferior",
 936                               (PyObject *) &inferior_object_type) < 0)
 937     return -1;
 938
 939   infpy_inf_data_key =
 940     register_inferior_data_with_cleanup (NULL, py_free_inferior);
 941
 942   gdb::observers::new_thread.attach (add_thread_object);
 943   gdb::observers::thread_exit.attach (delete_thread_object);
 944   gdb::observers::normal_stop.attach (python_on_normal_stop);
 945   gdb::observers::target_resumed.attach (python_on_resume);
 946   gdb::observers::inferior_call_pre.attach (python_on_inferior_call_pre);
 947   gdb::observers::inferior_call_post.attach (python_on_inferior_call_post);
 948   gdb::observers::memory_changed.attach (python_on_memory_change);
 949   gdb::observers::register_changed.attach (python_on_register_change);
 950   gdb::observers::inferior_exit.attach (python_inferior_exit);
 951   gdb::observers::new_objfile.attach (python_new_objfile);
 952   gdb::observers::inferior_added.attach (python_new_inferior);
 953   gdb::observers::inferior_removed.attach (python_inferior_deleted);
 954
 955   membuf_object_type.tp_new = PyType_GenericNew;
 956   if (PyType_Ready (&membuf_object_type) < 0)
 957     return -1;
 958
 959   return gdb_pymodule_addobject (gdb_module, "Membuf",
 960                                  (PyObject *) &membuf_object_type);
 961 }
 962
 963 static gdb_PyGetSetDef inferior_object_getset[] =
 964 {
 965   { "num", infpy_get_num, NULL, "ID of inferior, as assigned by GDB.", NULL },
 966   { "pid", infpy_get_pid, NULL, "PID of inferior, as assigned by the OS.",
 967     NULL },
 968   { "was_attached", infpy_get_was_attached, NULL,
 969     "True if the inferior was created using 'attach'.", NULL },
 970   { "progspace", infpy_get_progspace, NULL, "Program space of this inferior" },
 971   { NULL }
 972 };
 973
 974 static PyMethodDef inferior_object_methods[] =
 975 {
 976   { "is_valid", infpy_is_valid, METH_NOARGS,
 977     "is_valid () -> Boolean.\n\
 978 Return true if this inferior is valid, false if not." },
 979   { "threads", infpy_threads, METH_NOARGS,
 980     "Return all the threads of this inferior." },
 981   { "read_memory", (PyCFunction) infpy_read_memory,
 982     METH_VARARGS | METH_KEYWORDS,
 983     "read_memory (address, length) -> buffer\n\
 984 Return a buffer object for reading from the inferior's memory." },
 985   { "write_memory", (PyCFunction) infpy_write_memory,
 986     METH_VARARGS | METH_KEYWORDS,
 987     "write_memory (address, buffer [, length])\n\
 988 Write the given buffer object to the inferior's memory." },
 989   { "search_memory", (PyCFunction) infpy_search_memory,
 990     METH_VARARGS | METH_KEYWORDS,
 991     "search_memory (address, length, pattern) -> long\n\
 992 Return a long with the address of a match, or None." },
 993   { "thread_from_thread_handle", (PyCFunction) infpy_thread_from_thread_handle,
 994     METH_VARARGS | METH_KEYWORDS,
 995     "thread_from_thread_handle (handle) -> gdb.InferiorThread.\n\
 996 Return thread object corresponding to thread handle." },
 997   { "architecture", (PyCFunction) infpy_architecture, METH_NOARGS,
 998     "architecture () -> gdb.Architecture\n\
 999 Return architecture of this inferior." },
1000   { NULL }
1001 };
1002
1003 PyTypeObject inferior_object_type =
1004 {
1005   PyVarObject_HEAD_INIT (NULL, 0)
1006   "gdb.Inferior",                 /* tp_name */
1007   sizeof (inferior_object),       /* tp_basicsize */
1008   0,                              /* tp_itemsize */
1009   infpy_dealloc,                  /* tp_dealloc */
1010   0,                              /* tp_print */
1011   0,                              /* tp_getattr */
1012   0,                              /* tp_setattr */
1013   0,                              /* tp_compare */
1014   infpy_repr,                     /* tp_repr */
1015   0,                              /* tp_as_number */
1016   0,                              /* tp_as_sequence */
1017   0,                              /* tp_as_mapping */
1018   0,                              /* tp_hash  */
1019   0,                              /* tp_call */
1020   0,                              /* tp_str */
1021   0,                              /* tp_getattro */
1022   0,                              /* tp_setattro */
1023   0,                              /* tp_as_buffer */
1024   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /* tp_flags */
1025   "GDB inferior object",          /* tp_doc */
1026   0,                              /* tp_traverse */
1027   0,                              /* tp_clear */
1028   0,                              /* tp_richcompare */
1029   0,                              /* tp_weaklistoffset */
1030   0,                              /* tp_iter */
1031   0,                              /* tp_iternext */
1032   inferior_object_methods,        /* tp_methods */
1033   0,                              /* tp_members */
1034   inferior_object_getset,         /* tp_getset */
1035   0,                              /* tp_base */
1036   0,                              /* tp_dict */
1037   0,                              /* tp_descr_get */
1038   0,                              /* tp_descr_set */
1039   0,                              /* tp_dictoffset */
1040   0,                              /* tp_init */
1041   0                               /* tp_alloc */
1042 };
1043
1044 #ifdef IS_PY3K
1045
1046 static PyBufferProcs buffer_procs =
1047 {
1048   get_buffer
1049 };
1050
1051 #else
1052
1053 /* Python doesn't provide a decent way to get compatibility here.  */
1054 #if HAVE_LIBPYTHON2_4
1055 #define CHARBUFFERPROC_NAME getcharbufferproc
1056 #else
1057 #define CHARBUFFERPROC_NAME charbufferproc
1058 #endif
1059
1060 static PyBufferProcs buffer_procs = {
1061   get_read_buffer,
1062   get_write_buffer,
1063   get_seg_count,
1064   /* The cast here works around a difference between Python 2.4 and
1065      Python 2.5.  */
1066   (CHARBUFFERPROC_NAME) get_char_buffer
1067 };
1068 #endif  /* IS_PY3K */
1069
1070 PyTypeObject membuf_object_type = {
1071   PyVarObject_HEAD_INIT (NULL, 0)
1072   "gdb.Membuf",                   /*tp_name*/
1073   sizeof (membuf_object),         /*tp_basicsize*/
1074   0,                              /*tp_itemsize*/
1075   mbpy_dealloc,                   /*tp_dealloc*/
1076   0,                              /*tp_print*/
1077   0,                              /*tp_getattr*/
1078   0,                              /*tp_setattr*/
1079   0,                              /*tp_compare*/
1080   0,                              /*tp_repr*/
1081   0,                              /*tp_as_number*/
1082   0,                              /*tp_as_sequence*/
1083   0,                              /*tp_as_mapping*/
1084   0,                              /*tp_hash */
1085   0,                              /*tp_call*/
1086   mbpy_str,                       /*tp_str*/
1087   0,                              /*tp_getattro*/
1088   0,                              /*tp_setattro*/
1089   &buffer_procs,                  /*tp_as_buffer*/
1090   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
1091   "GDB memory buffer object",     /*tp_doc*/
1092   0,                              /* tp_traverse */
1093   0,                              /* tp_clear */
1094   0,                              /* tp_richcompare */
1095   0,                              /* tp_weaklistoffset */
1096   0,                              /* tp_iter */
1097   0,                              /* tp_iternext */
1098   0,                              /* tp_methods */
1099   0,                              /* tp_members */
1100   0,                              /* tp_getset */
1101   0,                              /* tp_base */
1102   0,                              /* tp_dict */
1103   0,                              /* tp_descr_get */
1104   0,                              /* tp_descr_set */
1105   0,                              /* tp_dictoffset */
1106   0,                              /* tp_init */
1107   0,                              /* tp_alloc */
1108 };