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