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 typedef struct
  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 } inferior_object;
  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 PyObject *
 211 inferior_to_inferior_object (struct inferior *inferior)
 212 {
 213   inferior_object *inf_obj;
 214
 215   inf_obj = (inferior_object *) inferior_data (inferior, infpy_inf_data_key);
 216   if (!inf_obj)
 217     {
 218       inf_obj = PyObject_New (inferior_object, &inferior_object_type);
 219       if (!inf_obj)
 220           return NULL;
 221
 222       inf_obj->inferior = inferior;
 223       inf_obj->threads = NULL;
 224       inf_obj->nthreads = 0;
 225
 226       /* PyObject_New initializes the new object with a refcount of 1.  This
 227          counts for the reference we are keeping in the inferior data.  */
 228       set_inferior_data (inferior, infpy_inf_data_key, inf_obj);
 229
 230     }
 231
 232   /* We are returning a new reference.  */
 233   Py_INCREF ((PyObject *)inf_obj);
 234
 235   return (PyObject *) inf_obj;
 236 }
 237
 238 /* Called when a new inferior is created.  Notifies any Python event
 239    listeners.  */
 240 static void
 241 python_new_inferior (struct inferior *inf)
 242 {
 243   if (!gdb_python_initialized)
 244     return;
 245
 246   gdbpy_enter enter_py (python_gdbarch, python_language);
 247
 248   if (evregpy_no_listeners_p (gdb_py_events.new_inferior))
 249     return;
 250
 251   gdbpy_ref<> inf_obj (inferior_to_inferior_object (inf));
 252   if (inf_obj == NULL)
 253     {
 254       gdbpy_print_stack ();
 255       return;
 256     }
 257
 258   gdbpy_ref<> event (create_event_object (&new_inferior_event_object_type));
 259   if (event == NULL
 260       || evpy_add_attribute (event.get (), "inferior", 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<> 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", inf_obj.get ()) < 0
 288       || evpy_emit_event (event.get (), gdb_py_events.inferior_deleted) < 0)
 289     gdbpy_print_stack ();
 290 }
 291
 292 /* Finds the Python Inferior object for the given PID.  Returns a
 293    reference, or NULL if PID does not match any inferior object. */
 294
 295 PyObject *
 296 find_inferior_object (int pid)
 297 {
 298   struct inferior *inf = find_inferior_pid (pid);
 299
 300   if (inf)
 301     return inferior_to_inferior_object (inf);
 302
 303   return NULL;
 304 }
 305
 306 thread_object *
 307 find_thread_object (ptid_t ptid)
 308 {
 309   int pid;
 310   struct threadlist_entry *thread;
 311
 312   pid = ptid_get_pid (ptid);
 313   if (pid == 0)
 314     return NULL;
 315
 316   gdbpy_ref<> inf_obj (find_inferior_object (pid));
 317   if (inf_obj == NULL)
 318     return NULL;
 319
 320   for (thread = ((inferior_object *)(inf_obj.get ()))->threads; thread;
 321        thread = thread->next)
 322     if (ptid_equal (thread->thread_obj->thread->ptid, ptid))
 323       return thread->thread_obj;
 324
 325   return NULL;
 326 }
 327
 328 static void
 329 add_thread_object (struct thread_info *tp)
 330 {
 331   thread_object *thread_obj;
 332   inferior_object *inf_obj;
 333   struct threadlist_entry *entry;
 334
 335   if (!gdb_python_initialized)
 336     return;
 337
 338   gdbpy_enter enter_py (python_gdbarch, python_language);
 339
 340   thread_obj = create_thread_object (tp);
 341   if (!thread_obj)
 342     {
 343       gdbpy_print_stack ();
 344       return;
 345     }
 346
 347   inf_obj = (inferior_object *) thread_obj->inf_obj;
 348
 349   entry = XNEW (struct threadlist_entry);
 350   entry->thread_obj = thread_obj;
 351   entry->next = inf_obj->threads;
 352
 353   inf_obj->threads = entry;
 354   inf_obj->nthreads++;
 355
 356   if (evregpy_no_listeners_p (gdb_py_events.new_thread))
 357     return;
 358
 359   gdbpy_ref<> event (create_thread_event_object (&new_thread_event_object_type,
 360                                                  (PyObject *) thread_obj));
 361   if (event == NULL
 362       || evpy_emit_event (event.get (), gdb_py_events.new_thread) < 0)
 363     gdbpy_print_stack ();
 364 }
 365
 366 static void
 367 delete_thread_object (struct thread_info *tp, int ignore)
 368 {
 369   struct threadlist_entry **entry, *tmp;
 370
 371   if (!gdb_python_initialized)
 372     return;
 373
 374   gdbpy_enter enter_py (python_gdbarch, python_language);
 375
 376   gdbpy_ref<inferior_object> inf_obj
 377     ((inferior_object *) find_inferior_object (ptid_get_pid (tp->ptid)));
 378   if (inf_obj == NULL)
 379     return;
 380
 381   /* Find thread entry in its inferior's thread_list.  */
 382   for (entry = &inf_obj->threads; *entry != NULL; entry =
 383          &(*entry)->next)
 384     if ((*entry)->thread_obj->thread == tp)
 385       break;
 386
 387   if (!*entry)
 388     return;
 389
 390   tmp = *entry;
 391   tmp->thread_obj->thread = NULL;
 392
 393   *entry = (*entry)->next;
 394   inf_obj->nthreads--;
 395
 396   Py_DECREF (tmp->thread_obj);
 397   xfree (tmp);
 398 }
 399
 400 static PyObject *
 401 infpy_threads (PyObject *self, PyObject *args)
 402 {
 403   int i;
 404   struct threadlist_entry *entry;
 405   inferior_object *inf_obj = (inferior_object *) self;
 406   PyObject *tuple;
 407
 408   INFPY_REQUIRE_VALID (inf_obj);
 409
 410   TRY
 411     {
 412       update_thread_list ();
 413     }
 414   CATCH (except, RETURN_MASK_ALL)
 415     {
 416       GDB_PY_HANDLE_EXCEPTION (except);
 417     }
 418   END_CATCH
 419
 420   tuple = PyTuple_New (inf_obj->nthreads);
 421   if (!tuple)
 422     return NULL;
 423
 424   for (i = 0, entry = inf_obj->threads; i < inf_obj->nthreads;
 425        i++, entry = entry->next)
 426     {
 427       Py_INCREF (entry->thread_obj);
 428       PyTuple_SET_ITEM (tuple, i, (PyObject *) entry->thread_obj);
 429     }
 430
 431   return tuple;
 432 }
 433
 434 static PyObject *
 435 infpy_get_num (PyObject *self, void *closure)
 436 {
 437   inferior_object *inf = (inferior_object *) self;
 438
 439   INFPY_REQUIRE_VALID (inf);
 440
 441   return PyLong_FromLong (inf->inferior->num);
 442 }
 443
 444 static PyObject *
 445 infpy_get_pid (PyObject *self, void *closure)
 446 {
 447   inferior_object *inf = (inferior_object *) self;
 448
 449   INFPY_REQUIRE_VALID (inf);
 450
 451   return PyLong_FromLong (inf->inferior->pid);
 452 }
 453
 454 static PyObject *
 455 infpy_get_was_attached (PyObject *self, void *closure)
 456 {
 457   inferior_object *inf = (inferior_object *) self;
 458
 459   INFPY_REQUIRE_VALID (inf);
 460   if (inf->inferior->attach_flag)
 461     Py_RETURN_TRUE;
 462   Py_RETURN_FALSE;
 463 }
 464
 465 static int
 466 build_inferior_list (struct inferior *inf, void *arg)
 467 {
 468   PyObject *list = (PyObject *) arg;
 469   gdbpy_ref<> inferior (inferior_to_inferior_object (inf));
 470
 471   if (inferior  == NULL)
 472     return 0;
 473
 474   return PyList_Append (list, 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 PyObject *
 821 infpy_thread_from_thread_handle (PyObject *self, PyObject *args, PyObject *kw)
 822 {
 823   PyObject *handle_obj, *result;
 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   result = Py_None;
 833
 834   if (!gdbpy_is_value_object (handle_obj))
 835     {
 836       PyErr_SetString (PyExc_TypeError,
 837                        _("Argument 'handle_obj' must be a thread handle object."));
 838
 839       return NULL;
 840     }
 841   else
 842     {
 843       TRY
 844         {
 845           struct thread_info *thread_info;
 846           struct value *val = value_object_to_value (handle_obj);
 847
 848           thread_info = find_thread_by_handle (val, inf_obj->inferior);
 849           if (thread_info != NULL)
 850             {
 851               result = (PyObject *) find_thread_object (thread_info->ptid);
 852               if (result != NULL)
 853                 Py_INCREF (result);
 854             }
 855         }
 856       CATCH (except, RETURN_MASK_ALL)
 857         {
 858           GDB_PY_HANDLE_EXCEPTION (except);
 859         }
 860       END_CATCH
 861     }
 862
 863   return result;
 864 }
 865
 866
 867 static void
 868 infpy_dealloc (PyObject *obj)
 869 {
 870   inferior_object *inf_obj = (inferior_object *) obj;
 871   struct inferior *inf = inf_obj->inferior;
 872
 873   if (! inf)
 874     return;
 875
 876   set_inferior_data (inf, infpy_inf_data_key, NULL);
 877 }
 878
 879 /* Clear the INFERIOR pointer in an Inferior object and clear the
 880    thread list.  */
 881 static void
 882 py_free_inferior (struct inferior *inf, void *datum)
 883 {
 884   gdbpy_ref<inferior_object> inf_obj ((inferior_object *) datum);
 885   struct threadlist_entry *th_entry, *th_tmp;
 886
 887   if (!gdb_python_initialized)
 888     return;
 889
 890   gdbpy_enter enter_py (python_gdbarch, python_language);
 891
 892   inf_obj->inferior = NULL;
 893
 894   /* Deallocate threads list.  */
 895   for (th_entry = inf_obj->threads; th_entry != NULL;)
 896     {
 897       Py_DECREF (th_entry->thread_obj);
 898
 899       th_tmp = th_entry;
 900       th_entry = th_entry->next;
 901       xfree (th_tmp);
 902     }
 903
 904   inf_obj->nthreads = 0;
 905 }
 906
 907 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
 908    Returns the current inferior object.  */
 909
 910 PyObject *
 911 gdbpy_selected_inferior (PyObject *self, PyObject *args)
 912 {
 913   return inferior_to_inferior_object (current_inferior ());
 914 }
 915
 916 int
 917 gdbpy_initialize_inferior (void)
 918 {
 919   if (PyType_Ready (&inferior_object_type) < 0)
 920     return -1;
 921
 922   if (gdb_pymodule_addobject (gdb_module, "Inferior",
 923                               (PyObject *) &inferior_object_type) < 0)
 924     return -1;
 925
 926   infpy_inf_data_key =
 927     register_inferior_data_with_cleanup (NULL, py_free_inferior);
 928
 929   gdb::observers::new_thread.attach (add_thread_object);
 930   gdb::observers::thread_exit.attach (delete_thread_object);
 931   gdb::observers::normal_stop.attach (python_on_normal_stop);
 932   gdb::observers::target_resumed.attach (python_on_resume);
 933   gdb::observers::inferior_call_pre.attach (python_on_inferior_call_pre);
 934   gdb::observers::inferior_call_post.attach (python_on_inferior_call_post);
 935   gdb::observers::memory_changed.attach (python_on_memory_change);
 936   gdb::observers::register_changed.attach (python_on_register_change);
 937   gdb::observers::inferior_exit.attach (python_inferior_exit);
 938   gdb::observers::new_objfile.attach (python_new_objfile);
 939   gdb::observers::inferior_added.attach (python_new_inferior);
 940   gdb::observers::inferior_removed.attach (python_inferior_deleted);
 941
 942   membuf_object_type.tp_new = PyType_GenericNew;
 943   if (PyType_Ready (&membuf_object_type) < 0)
 944     return -1;
 945
 946   return gdb_pymodule_addobject (gdb_module, "Membuf", (PyObject *)
 947                                  &membuf_object_type);
 948 }
 949
 950 static gdb_PyGetSetDef inferior_object_getset[] =
 951 {
 952   { "num", infpy_get_num, NULL, "ID of inferior, as assigned by GDB.", NULL },
 953   { "pid", infpy_get_pid, NULL, "PID of inferior, as assigned by the OS.",
 954     NULL },
 955   { "was_attached", infpy_get_was_attached, NULL,
 956     "True if the inferior was created using 'attach'.", NULL },
 957   { NULL }
 958 };
 959
 960 static PyMethodDef inferior_object_methods[] =
 961 {
 962   { "is_valid", infpy_is_valid, METH_NOARGS,
 963     "is_valid () -> Boolean.\n\
 964 Return true if this inferior is valid, false if not." },
 965   { "threads", infpy_threads, METH_NOARGS,
 966     "Return all the threads of this inferior." },
 967   { "read_memory", (PyCFunction) infpy_read_memory,
 968     METH_VARARGS | METH_KEYWORDS,
 969     "read_memory (address, length) -> buffer\n\
 970 Return a buffer object for reading from the inferior's memory." },
 971   { "write_memory", (PyCFunction) infpy_write_memory,
 972     METH_VARARGS | METH_KEYWORDS,
 973     "write_memory (address, buffer [, length])\n\
 974 Write the given buffer object to the inferior's memory." },
 975   { "search_memory", (PyCFunction) infpy_search_memory,
 976     METH_VARARGS | METH_KEYWORDS,
 977     "search_memory (address, length, pattern) -> long\n\
 978 Return a long with the address of a match, or None." },
 979   { "thread_from_thread_handle", (PyCFunction) infpy_thread_from_thread_handle,
 980     METH_VARARGS | METH_KEYWORDS,
 981     "thread_from_thread_handle (handle) -> gdb.InferiorThread.\n\
 982 Return thread object corresponding to thread handle." },
 983   { NULL }
 984 };
 985
 986 PyTypeObject inferior_object_type =
 987 {
 988   PyVarObject_HEAD_INIT (NULL, 0)
 989   "gdb.Inferior",                 /* tp_name */
 990   sizeof (inferior_object),       /* tp_basicsize */
 991   0,                              /* tp_itemsize */
 992   infpy_dealloc,                  /* tp_dealloc */
 993   0,                              /* tp_print */
 994   0,                              /* tp_getattr */
 995   0,                              /* tp_setattr */
 996   0,                              /* tp_compare */
 997   0,                              /* tp_repr */
 998   0,                              /* tp_as_number */
 999   0,                              /* tp_as_sequence */
1000   0,                              /* tp_as_mapping */
1001   0,                              /* tp_hash  */
1002   0,                              /* tp_call */
1003   0,                              /* tp_str */
1004   0,                              /* tp_getattro */
1005   0,                              /* tp_setattro */
1006   0,                              /* tp_as_buffer */
1007   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /* tp_flags */
1008   "GDB inferior object",          /* tp_doc */
1009   0,                              /* tp_traverse */
1010   0,                              /* tp_clear */
1011   0,                              /* tp_richcompare */
1012   0,                              /* tp_weaklistoffset */
1013   0,                              /* tp_iter */
1014   0,                              /* tp_iternext */
1015   inferior_object_methods,        /* tp_methods */
1016   0,                              /* tp_members */
1017   inferior_object_getset,         /* tp_getset */
1018   0,                              /* tp_base */
1019   0,                              /* tp_dict */
1020   0,                              /* tp_descr_get */
1021   0,                              /* tp_descr_set */
1022   0,                              /* tp_dictoffset */
1023   0,                              /* tp_init */
1024   0                               /* tp_alloc */
1025 };
1026
1027 #ifdef IS_PY3K
1028
1029 static PyBufferProcs buffer_procs =
1030 {
1031   get_buffer
1032 };
1033
1034 #else
1035
1036 /* Python doesn't provide a decent way to get compatibility here.  */
1037 #if HAVE_LIBPYTHON2_4
1038 #define CHARBUFFERPROC_NAME getcharbufferproc
1039 #else
1040 #define CHARBUFFERPROC_NAME charbufferproc
1041 #endif
1042
1043 static PyBufferProcs buffer_procs = {
1044   get_read_buffer,
1045   get_write_buffer,
1046   get_seg_count,
1047   /* The cast here works around a difference between Python 2.4 and
1048      Python 2.5.  */
1049   (CHARBUFFERPROC_NAME) get_char_buffer
1050 };
1051 #endif  /* IS_PY3K */
1052
1053 PyTypeObject membuf_object_type = {
1054   PyVarObject_HEAD_INIT (NULL, 0)
1055   "gdb.Membuf",                   /*tp_name*/
1056   sizeof (membuf_object),         /*tp_basicsize*/
1057   0,                              /*tp_itemsize*/
1058   mbpy_dealloc,                   /*tp_dealloc*/
1059   0,                              /*tp_print*/
1060   0,                              /*tp_getattr*/
1061   0,                              /*tp_setattr*/
1062   0,                              /*tp_compare*/
1063   0,                              /*tp_repr*/
1064   0,                              /*tp_as_number*/
1065   0,                              /*tp_as_sequence*/
1066   0,                              /*tp_as_mapping*/
1067   0,                              /*tp_hash */
1068   0,                              /*tp_call*/
1069   mbpy_str,                       /*tp_str*/
1070   0,                              /*tp_getattro*/
1071   0,                              /*tp_setattro*/
1072   &buffer_procs,                  /*tp_as_buffer*/
1073   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
1074   "GDB memory buffer object",     /*tp_doc*/
1075   0,                              /* tp_traverse */
1076   0,                              /* tp_clear */
1077   0,                              /* tp_richcompare */
1078   0,                              /* tp_weaklistoffset */
1079   0,                              /* tp_iter */
1080   0,                              /* tp_iternext */
1081   0,                              /* tp_methods */
1082   0,                              /* tp_members */
1083   0,                              /* tp_getset */
1084   0,                              /* tp_base */
1085   0,                              /* tp_dict */
1086   0,                              /* tp_descr_get */
1087   0,                              /* tp_descr_set */
1088   0,                              /* tp_dictoffset */
1089   0,                              /* tp_init */
1090   0,                              /* tp_alloc */
1091 };