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 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_byte *buffer = NULL;
 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 = (gdb_byte *) xmalloc (length);
 514
 515       read_memory (addr, buffer, length);
 516     }
 517   CATCH (except, RETURN_MASK_ALL)
 518     {
 519       xfree (buffer);
 520       GDB_PY_HANDLE_EXCEPTION (except);
 521     }
 522   END_CATCH
 523
 524   gdbpy_ref<membuf_object> membuf_obj (PyObject_New (membuf_object,
 525                                                      &membuf_object_type));
 526   if (membuf_obj == NULL)
 527     {
 528       xfree (buffer);
 529       return NULL;
 530     }
 531
 532   membuf_obj->buffer = buffer;
 533   membuf_obj->addr = addr;
 534   membuf_obj->length = length;
 535
 536 #ifdef IS_PY3K
 537   result = PyMemoryView_FromObject ((PyObject *) membuf_obj.get ());
 538 #else
 539   result = PyBuffer_FromReadWriteObject ((PyObject *) membuf_obj.get (), 0,
 540                                          Py_END_OF_BUFFER);
 541 #endif
 542
 543   return result;
 544 }
 545
 546 /* Implementation of Inferior.write_memory (address, buffer [, length]).
 547    Writes the contents of BUFFER (a Python object supporting the read
 548    buffer protocol) at ADDRESS in the inferior's memory.  Write LENGTH
 549    bytes from BUFFER, or its entire contents if the argument is not
 550    provided.  The function returns nothing.  Returns NULL on error, with
 551    a python exception set.  */
 552 static PyObject *
 553 infpy_write_memory (PyObject *self, PyObject *args, PyObject *kw)
 554 {
 555   struct gdb_exception except = exception_none;
 556   Py_ssize_t buf_len;
 557   const gdb_byte *buffer;
 558   CORE_ADDR addr, length;
 559   PyObject *addr_obj, *length_obj = NULL;
 560   static const char *keywords[] = { "address", "buffer", "length", NULL };
 561 #ifdef IS_PY3K
 562   Py_buffer pybuf;
 563
 564   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "Os*|O", keywords,
 565                                         &addr_obj, &pybuf, &length_obj))
 566     return NULL;
 567
 568   buffer = (const gdb_byte *) pybuf.buf;
 569   buf_len = pybuf.len;
 570 #else
 571   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "Os#|O", keywords,
 572                                         &addr_obj, &buffer, &buf_len,
 573                                         &length_obj))
 574     return NULL;
 575
 576   buffer = (const gdb_byte *) buffer;
 577 #endif
 578
 579   if (get_addr_from_python (addr_obj, &addr) < 0)
 580     goto fail;
 581
 582   if (!length_obj)
 583     length = buf_len;
 584   else if (get_addr_from_python (length_obj, &length) < 0)
 585     goto fail;
 586
 587   TRY
 588     {
 589       write_memory_with_notification (addr, buffer, length);
 590     }
 591   CATCH (ex, RETURN_MASK_ALL)
 592     {
 593       except = ex;
 594     }
 595   END_CATCH
 596
 597 #ifdef IS_PY3K
 598   PyBuffer_Release (&pybuf);
 599 #endif
 600   GDB_PY_HANDLE_EXCEPTION (except);
 601
 602   Py_RETURN_NONE;
 603
 604  fail:
 605 #ifdef IS_PY3K
 606   PyBuffer_Release (&pybuf);
 607 #endif
 608   return NULL;
 609 }
 610
 611 /* Destructor of Membuf objects.  */
 612 static void
 613 mbpy_dealloc (PyObject *self)
 614 {
 615   xfree (((membuf_object *) self)->buffer);
 616   Py_TYPE (self)->tp_free (self);
 617 }
 618
 619 /* Return a description of the Membuf object.  */
 620 static PyObject *
 621 mbpy_str (PyObject *self)
 622 {
 623   membuf_object *membuf_obj = (membuf_object *) self;
 624
 625   return PyString_FromFormat (_("Memory buffer for address %s, \
 626 which is %s bytes long."),
 627                               paddress (python_gdbarch, membuf_obj->addr),
 628                               pulongest (membuf_obj->length));
 629 }
 630
 631 #ifdef IS_PY3K
 632
 633 static int
 634 get_buffer (PyObject *self, Py_buffer *buf, int flags)
 635 {
 636   membuf_object *membuf_obj = (membuf_object *) self;
 637   int ret;
 638
 639   ret = PyBuffer_FillInfo (buf, self, membuf_obj->buffer,
 640                            membuf_obj->length, 0,
 641                            PyBUF_CONTIG);
 642
 643   /* Despite the documentation saying this field is a "const char *",
 644      in Python 3.4 at least, it's really a "char *".  */
 645   buf->format = (char *) "c";
 646
 647   return ret;
 648 }
 649
 650 #else
 651
 652 static Py_ssize_t
 653 get_read_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
 654 {
 655   membuf_object *membuf_obj = (membuf_object *) self;
 656
 657   if (segment)
 658     {
 659       PyErr_SetString (PyExc_SystemError,
 660                        _("The memory buffer supports only one segment."));
 661       return -1;
 662     }
 663
 664   *ptrptr = membuf_obj->buffer;
 665
 666   return membuf_obj->length;
 667 }
 668
 669 static Py_ssize_t
 670 get_write_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
 671 {
 672   return get_read_buffer (self, segment, ptrptr);
 673 }
 674
 675 static Py_ssize_t
 676 get_seg_count (PyObject *self, Py_ssize_t *lenp)
 677 {
 678   if (lenp)
 679     *lenp = ((membuf_object *) self)->length;
 680
 681   return 1;
 682 }
 683
 684 static Py_ssize_t
 685 get_char_buffer (PyObject *self, Py_ssize_t segment, char **ptrptr)
 686 {
 687   void *ptr = NULL;
 688   Py_ssize_t ret;
 689
 690   ret = get_read_buffer (self, segment, &ptr);
 691   *ptrptr = (char *) ptr;
 692
 693   return ret;
 694 }
 695
 696 #endif  /* IS_PY3K */
 697
 698 /* Implementation of
 699    gdb.search_memory (address, length, pattern).  ADDRESS is the
 700    address to start the search.  LENGTH specifies the scope of the
 701    search from ADDRESS.  PATTERN is the pattern to search for (and
 702    must be a Python object supporting the buffer protocol).
 703    Returns a Python Long object holding the address where the pattern
 704    was located, or if the pattern was not found, returns None.  Returns NULL
 705    on error, with a python exception set.  */
 706 static PyObject *
 707 infpy_search_memory (PyObject *self, PyObject *args, PyObject *kw)
 708 {
 709   struct gdb_exception except = exception_none;
 710   CORE_ADDR start_addr, length;
 711   static const char *keywords[] = { "address", "length", "pattern", NULL };
 712   PyObject *start_addr_obj, *length_obj;
 713   Py_ssize_t pattern_size;
 714   const gdb_byte *buffer;
 715   CORE_ADDR found_addr;
 716   int found = 0;
 717 #ifdef IS_PY3K
 718   Py_buffer pybuf;
 719
 720   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "OOs*", keywords,
 721                                         &start_addr_obj, &length_obj,
 722                                         &pybuf))
 723     return NULL;
 724
 725   buffer = (const gdb_byte *) pybuf.buf;
 726   pattern_size = pybuf.len;
 727 #else
 728   PyObject *pattern;
 729   const void *vbuffer;
 730
 731   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "OOO", keywords,
 732                                         &start_addr_obj, &length_obj,
 733                                         &pattern))
 734      return NULL;
 735
 736   if (!PyObject_CheckReadBuffer (pattern))
 737     {
 738       PyErr_SetString (PyExc_RuntimeError,
 739                        _("The pattern is not a Python buffer."));
 740
 741       return NULL;
 742     }
 743
 744   if (PyObject_AsReadBuffer (pattern, &vbuffer, &pattern_size) == -1)
 745     return NULL;
 746
 747   buffer = (const gdb_byte *) vbuffer;
 748 #endif
 749
 750   if (get_addr_from_python (start_addr_obj, &start_addr) < 0)
 751     goto fail;
 752
 753   if (get_addr_from_python (length_obj, &length) < 0)
 754     goto fail;
 755
 756   if (!length)
 757     {
 758       PyErr_SetString (PyExc_ValueError,
 759                        _("Search range is empty."));
 760       goto fail;
 761     }
 762   /* Watch for overflows.  */
 763   else if (length > CORE_ADDR_MAX
 764            || (start_addr + length - 1) < start_addr)
 765     {
 766       PyErr_SetString (PyExc_ValueError,
 767                        _("The search range is too large."));
 768       goto fail;
 769     }
 770
 771   TRY
 772     {
 773       found = target_search_memory (start_addr, length,
 774                                     buffer, pattern_size,
 775                                     &found_addr);
 776     }
 777   CATCH (ex, RETURN_MASK_ALL)
 778     {
 779       except = ex;
 780     }
 781   END_CATCH
 782
 783 #ifdef IS_PY3K
 784   PyBuffer_Release (&pybuf);
 785 #endif
 786   GDB_PY_HANDLE_EXCEPTION (except);
 787
 788   if (found)
 789     return PyLong_FromLong (found_addr);
 790   else
 791     Py_RETURN_NONE;
 792
 793  fail:
 794 #ifdef IS_PY3K
 795   PyBuffer_Release (&pybuf);
 796 #endif
 797   return NULL;
 798 }
 799
 800 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
 801    Returns True if this inferior object still exists in GDB.  */
 802
 803 static PyObject *
 804 infpy_is_valid (PyObject *self, PyObject *args)
 805 {
 806   inferior_object *inf = (inferior_object *) self;
 807
 808   if (! inf->inferior)
 809     Py_RETURN_FALSE;
 810
 811   Py_RETURN_TRUE;
 812 }
 813
 814 /* Implementation of gdb.Inferior.thread_from_thread_handle (self, handle)
 815                         ->  gdb.InferiorThread.  */
 816
 817 PyObject *
 818 infpy_thread_from_thread_handle (PyObject *self, PyObject *args, PyObject *kw)
 819 {
 820   PyObject *handle_obj, *result;
 821   inferior_object *inf_obj = (inferior_object *) self;
 822   static const char *keywords[] = { "thread_handle", NULL };
 823
 824   INFPY_REQUIRE_VALID (inf_obj);
 825
 826   if (! gdb_PyArg_ParseTupleAndKeywords (args, kw, "O", keywords, &handle_obj))
 827     return NULL;
 828
 829   result = Py_None;
 830
 831   if (!gdbpy_is_value_object (handle_obj))
 832     {
 833       PyErr_SetString (PyExc_TypeError,
 834                        _("Argument 'handle_obj' must be a thread handle object."));
 835
 836       return NULL;
 837     }
 838   else
 839     {
 840       TRY
 841         {
 842           struct thread_info *thread_info;
 843           struct value *val = value_object_to_value (handle_obj);
 844
 845           thread_info = find_thread_by_handle (val, inf_obj->inferior);
 846           if (thread_info != NULL)
 847             {
 848               result = (PyObject *) thread_to_thread_object (thread_info);
 849               if (result != NULL)
 850                 Py_INCREF (result);
 851             }
 852         }
 853       CATCH (except, RETURN_MASK_ALL)
 854         {
 855           GDB_PY_HANDLE_EXCEPTION (except);
 856         }
 857       END_CATCH
 858     }
 859
 860   return result;
 861 }
 862
 863
 864 static void
 865 infpy_dealloc (PyObject *obj)
 866 {
 867   inferior_object *inf_obj = (inferior_object *) obj;
 868   struct inferior *inf = inf_obj->inferior;
 869
 870   if (! inf)
 871     return;
 872
 873   set_inferior_data (inf, infpy_inf_data_key, NULL);
 874 }
 875
 876 /* Clear the INFERIOR pointer in an Inferior object and clear the
 877    thread list.  */
 878 static void
 879 py_free_inferior (struct inferior *inf, void *datum)
 880 {
 881   gdbpy_ref<inferior_object> inf_obj ((inferior_object *) datum);
 882   struct threadlist_entry *th_entry, *th_tmp;
 883
 884   if (!gdb_python_initialized)
 885     return;
 886
 887   gdbpy_enter enter_py (python_gdbarch, python_language);
 888
 889   inf_obj->inferior = NULL;
 890
 891   /* Deallocate threads list.  */
 892   for (th_entry = inf_obj->threads; th_entry != NULL;)
 893     {
 894       Py_DECREF (th_entry->thread_obj);
 895
 896       th_tmp = th_entry;
 897       th_entry = th_entry->next;
 898       xfree (th_tmp);
 899     }
 900
 901   inf_obj->nthreads = 0;
 902 }
 903
 904 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
 905    Returns the current inferior object.  */
 906
 907 PyObject *
 908 gdbpy_selected_inferior (PyObject *self, PyObject *args)
 909 {
 910   return (PyObject *) inferior_to_inferior_object (current_inferior ());
 911 }
 912
 913 int
 914 gdbpy_initialize_inferior (void)
 915 {
 916   if (PyType_Ready (&inferior_object_type) < 0)
 917     return -1;
 918
 919   if (gdb_pymodule_addobject (gdb_module, "Inferior",
 920                               (PyObject *) &inferior_object_type) < 0)
 921     return -1;
 922
 923   infpy_inf_data_key =
 924     register_inferior_data_with_cleanup (NULL, py_free_inferior);
 925
 926   gdb::observers::new_thread.attach (add_thread_object);
 927   gdb::observers::thread_exit.attach (delete_thread_object);
 928   gdb::observers::normal_stop.attach (python_on_normal_stop);
 929   gdb::observers::target_resumed.attach (python_on_resume);
 930   gdb::observers::inferior_call_pre.attach (python_on_inferior_call_pre);
 931   gdb::observers::inferior_call_post.attach (python_on_inferior_call_post);
 932   gdb::observers::memory_changed.attach (python_on_memory_change);
 933   gdb::observers::register_changed.attach (python_on_register_change);
 934   gdb::observers::inferior_exit.attach (python_inferior_exit);
 935   gdb::observers::new_objfile.attach (python_new_objfile);
 936   gdb::observers::inferior_added.attach (python_new_inferior);
 937   gdb::observers::inferior_removed.attach (python_inferior_deleted);
 938
 939   membuf_object_type.tp_new = PyType_GenericNew;
 940   if (PyType_Ready (&membuf_object_type) < 0)
 941     return -1;
 942
 943   return gdb_pymodule_addobject (gdb_module, "Membuf", (PyObject *)
 944                                  &membuf_object_type);
 945 }
 946
 947 static gdb_PyGetSetDef inferior_object_getset[] =
 948 {
 949   { "num", infpy_get_num, NULL, "ID of inferior, as assigned by GDB.", NULL },
 950   { "pid", infpy_get_pid, NULL, "PID of inferior, as assigned by the OS.",
 951     NULL },
 952   { "was_attached", infpy_get_was_attached, NULL,
 953     "True if the inferior was created using 'attach'.", NULL },
 954   { NULL }
 955 };
 956
 957 static PyMethodDef inferior_object_methods[] =
 958 {
 959   { "is_valid", infpy_is_valid, METH_NOARGS,
 960     "is_valid () -> Boolean.\n\
 961 Return true if this inferior is valid, false if not." },
 962   { "threads", infpy_threads, METH_NOARGS,
 963     "Return all the threads of this inferior." },
 964   { "read_memory", (PyCFunction) infpy_read_memory,
 965     METH_VARARGS | METH_KEYWORDS,
 966     "read_memory (address, length) -> buffer\n\
 967 Return a buffer object for reading from the inferior's memory." },
 968   { "write_memory", (PyCFunction) infpy_write_memory,
 969     METH_VARARGS | METH_KEYWORDS,
 970     "write_memory (address, buffer [, length])\n\
 971 Write the given buffer object to the inferior's memory." },
 972   { "search_memory", (PyCFunction) infpy_search_memory,
 973     METH_VARARGS | METH_KEYWORDS,
 974     "search_memory (address, length, pattern) -> long\n\
 975 Return a long with the address of a match, or None." },
 976   { "thread_from_thread_handle", (PyCFunction) infpy_thread_from_thread_handle,
 977     METH_VARARGS | METH_KEYWORDS,
 978     "thread_from_thread_handle (handle) -> gdb.InferiorThread.\n\
 979 Return thread object corresponding to thread handle." },
 980   { NULL }
 981 };
 982
 983 PyTypeObject inferior_object_type =
 984 {
 985   PyVarObject_HEAD_INIT (NULL, 0)
 986   "gdb.Inferior",                 /* tp_name */
 987   sizeof (inferior_object),       /* tp_basicsize */
 988   0,                              /* tp_itemsize */
 989   infpy_dealloc,                  /* tp_dealloc */
 990   0,                              /* tp_print */
 991   0,                              /* tp_getattr */
 992   0,                              /* tp_setattr */
 993   0,                              /* tp_compare */
 994   0,                              /* tp_repr */
 995   0,                              /* tp_as_number */
 996   0,                              /* tp_as_sequence */
 997   0,                              /* tp_as_mapping */
 998   0,                              /* tp_hash  */
 999   0,                              /* tp_call */
1000   0,                              /* tp_str */
1001   0,                              /* tp_getattro */
1002   0,                              /* tp_setattro */
1003   0,                              /* tp_as_buffer */
1004   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /* tp_flags */
1005   "GDB inferior object",          /* tp_doc */
1006   0,                              /* tp_traverse */
1007   0,                              /* tp_clear */
1008   0,                              /* tp_richcompare */
1009   0,                              /* tp_weaklistoffset */
1010   0,                              /* tp_iter */
1011   0,                              /* tp_iternext */
1012   inferior_object_methods,        /* tp_methods */
1013   0,                              /* tp_members */
1014   inferior_object_getset,         /* tp_getset */
1015   0,                              /* tp_base */
1016   0,                              /* tp_dict */
1017   0,                              /* tp_descr_get */
1018   0,                              /* tp_descr_set */
1019   0,                              /* tp_dictoffset */
1020   0,                              /* tp_init */
1021   0                               /* tp_alloc */
1022 };
1023
1024 #ifdef IS_PY3K
1025
1026 static PyBufferProcs buffer_procs =
1027 {
1028   get_buffer
1029 };
1030
1031 #else
1032
1033 /* Python doesn't provide a decent way to get compatibility here.  */
1034 #if HAVE_LIBPYTHON2_4
1035 #define CHARBUFFERPROC_NAME getcharbufferproc
1036 #else
1037 #define CHARBUFFERPROC_NAME charbufferproc
1038 #endif
1039
1040 static PyBufferProcs buffer_procs = {
1041   get_read_buffer,
1042   get_write_buffer,
1043   get_seg_count,
1044   /* The cast here works around a difference between Python 2.4 and
1045      Python 2.5.  */
1046   (CHARBUFFERPROC_NAME) get_char_buffer
1047 };
1048 #endif  /* IS_PY3K */
1049
1050 PyTypeObject membuf_object_type = {
1051   PyVarObject_HEAD_INIT (NULL, 0)
1052   "gdb.Membuf",                   /*tp_name*/
1053   sizeof (membuf_object),         /*tp_basicsize*/
1054   0,                              /*tp_itemsize*/
1055   mbpy_dealloc,                   /*tp_dealloc*/
1056   0,                              /*tp_print*/
1057   0,                              /*tp_getattr*/
1058   0,                              /*tp_setattr*/
1059   0,                              /*tp_compare*/
1060   0,                              /*tp_repr*/
1061   0,                              /*tp_as_number*/
1062   0,                              /*tp_as_sequence*/
1063   0,                              /*tp_as_mapping*/
1064   0,                              /*tp_hash */
1065   0,                              /*tp_call*/
1066   mbpy_str,                       /*tp_str*/
1067   0,                              /*tp_getattro*/
1068   0,                              /*tp_setattro*/
1069   &buffer_procs,                  /*tp_as_buffer*/
1070   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
1071   "GDB memory buffer object",     /*tp_doc*/
1072   0,                              /* tp_traverse */
1073   0,                              /* tp_clear */
1074   0,                              /* tp_richcompare */
1075   0,                              /* tp_weaklistoffset */
1076   0,                              /* tp_iter */
1077   0,                              /* tp_iternext */
1078   0,                              /* tp_methods */
1079   0,                              /* tp_members */
1080   0,                              /* tp_getset */
1081   0,                              /* tp_base */
1082   0,                              /* tp_dict */
1083   0,                              /* tp_descr_get */
1084   0,                              /* tp_descr_set */
1085   0,                              /* tp_dictoffset */
1086   0,                              /* tp_init */
1087   0,                              /* tp_alloc */
1088 };