gdb/python/py-inferior.c

   1 /* Python interface to inferiors.
   2
   3    Copyright (C) 2009-2012 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 "exceptions.h"
  22 #include "gdbcore.h"
  23 #include "gdbthread.h"
  24 #include "inferior.h"
  25 #include "objfiles.h"
  26 #include "observer.h"
  27 #include "python-internal.h"
  28 #include "arch-utils.h"
  29 #include "language.h"
  30 #include "gdb_signals.h"
  31 #include "py-event.h"
  32 #include "py-stopevent.h"
  33
  34 struct threadlist_entry {
  35   thread_object *thread_obj;
  36   struct threadlist_entry *next;
  37 };
  38
  39 typedef struct
  40 {
  41   PyObject_HEAD
  42
  43   /* The inferior we represent.  */
  44   struct inferior *inferior;
  45
  46   /* thread_object instances under this inferior.  This list owns a
  47      reference to each object it contains.  */
  48   struct threadlist_entry *threads;
  49
  50   /* Number of threads in the list.  */
  51   int nthreads;
  52 } inferior_object;
  53
  54 static PyTypeObject inferior_object_type;
  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 static PyTypeObject membuf_object_type;
  68
  69 /* Require that INFERIOR be a valid inferior ID.  */
  70 #define INFPY_REQUIRE_VALID(Inferior)                           \
  71   do {                                                          \
  72     if (!Inferior->inferior)                                    \
  73       {                                                         \
  74         PyErr_SetString (PyExc_RuntimeError,                    \
  75                          _("Inferior no longer exists."));      \
  76         return NULL;                                            \
  77       }                                                         \
  78   } while (0)
  79
  80 static void
  81 python_on_normal_stop (struct bpstats *bs, int print_frame)
  82 {
  83   struct cleanup *cleanup;
  84   enum gdb_signal stop_signal;
  85
  86   if (!find_thread_ptid (inferior_ptid))
  87       return;
  88
  89   stop_signal = inferior_thread ()->suspend.stop_signal;
  90
  91   cleanup = ensure_python_env (get_current_arch (), current_language);
  92
  93   if (emit_stop_event (bs, stop_signal) < 0)
  94     gdbpy_print_stack ();
  95
  96   do_cleanups (cleanup);
  97 }
  98
  99 static void
 100 python_on_resume (ptid_t ptid)
 101 {
 102   struct cleanup *cleanup;
 103
 104   cleanup = ensure_python_env (target_gdbarch (), current_language);
 105
 106   if (emit_continue_event (ptid) < 0)
 107     gdbpy_print_stack ();
 108
 109   do_cleanups (cleanup);
 110 }
 111
 112 static void
 113 python_inferior_exit (struct inferior *inf)
 114 {
 115   struct cleanup *cleanup;
 116   const LONGEST *exit_code = NULL;
 117
 118   cleanup = ensure_python_env (target_gdbarch (), current_language);
 119
 120   if (inf->has_exit_code)
 121     exit_code = &inf->exit_code;
 122
 123   if (emit_exited_event (exit_code, inf) < 0)
 124     gdbpy_print_stack ();
 125
 126   do_cleanups (cleanup);
 127 }
 128
 129 /* Callback used to notify Python listeners about new objfiles loaded in the
 130    inferior.  */
 131
 132 static void
 133 python_new_objfile (struct objfile *objfile)
 134 {
 135   struct cleanup *cleanup;
 136
 137   if (objfile == NULL)
 138     return;
 139
 140   cleanup = ensure_python_env (get_objfile_arch (objfile), current_language);
 141
 142   if (emit_new_objfile_event (objfile) < 0)
 143     gdbpy_print_stack ();
 144
 145   do_cleanups (cleanup);
 146 }
 147
 148 /* Return a reference to the Python object of type Inferior
 149    representing INFERIOR.  If the object has already been created,
 150    return it and increment the reference count,  otherwise, create it.
 151    Return NULL on failure.  */
 152 PyObject *
 153 inferior_to_inferior_object (struct inferior *inferior)
 154 {
 155   inferior_object *inf_obj;
 156
 157   inf_obj = inferior_data (inferior, infpy_inf_data_key);
 158   if (!inf_obj)
 159     {
 160       inf_obj = PyObject_New (inferior_object, &inferior_object_type);
 161       if (!inf_obj)
 162           return NULL;
 163
 164       inf_obj->inferior = inferior;
 165       inf_obj->threads = NULL;
 166       inf_obj->nthreads = 0;
 167
 168       set_inferior_data (inferior, infpy_inf_data_key, inf_obj);
 169
 170     }
 171   else
 172     Py_INCREF ((PyObject *)inf_obj);
 173
 174   return (PyObject *) inf_obj;
 175 }
 176
 177 /* Finds the Python Inferior object for the given PID.  Returns a
 178    reference, or NULL if PID does not match any inferior object. */
 179
 180 PyObject *
 181 find_inferior_object (int pid)
 182 {
 183   struct inferior *inf = find_inferior_pid (pid);
 184
 185   if (inf)
 186     return inferior_to_inferior_object (inf);
 187
 188   return NULL;
 189 }
 190
 191 thread_object *
 192 find_thread_object (ptid_t ptid)
 193 {
 194   int pid;
 195   struct threadlist_entry *thread;
 196   PyObject *inf_obj;
 197   thread_object *found = NULL;
 198
 199   pid = PIDGET (ptid);
 200   if (pid == 0)
 201     return NULL;
 202
 203   inf_obj = find_inferior_object (pid);
 204
 205   if (! inf_obj)
 206     return NULL;
 207
 208   for (thread = ((inferior_object *)inf_obj)->threads; thread;
 209        thread = thread->next)
 210     if (ptid_equal (thread->thread_obj->thread->ptid, ptid))
 211       {
 212         found = thread->thread_obj;
 213         break;
 214       }
 215
 216   Py_DECREF (inf_obj);
 217
 218   if (found)
 219     return found;
 220
 221   return NULL;
 222 }
 223
 224 static void
 225 add_thread_object (struct thread_info *tp)
 226 {
 227   struct cleanup *cleanup;
 228   thread_object *thread_obj;
 229   inferior_object *inf_obj;
 230   struct threadlist_entry *entry;
 231
 232   cleanup = ensure_python_env (python_gdbarch, python_language);
 233
 234   thread_obj = create_thread_object (tp);
 235   if (!thread_obj)
 236     {
 237       gdbpy_print_stack ();
 238       do_cleanups (cleanup);
 239       return;
 240     }
 241
 242   inf_obj = (inferior_object *) thread_obj->inf_obj;
 243
 244   entry = xmalloc (sizeof (struct threadlist_entry));
 245   entry->thread_obj = thread_obj;
 246   entry->next = inf_obj->threads;
 247
 248   inf_obj->threads = entry;
 249   inf_obj->nthreads++;
 250
 251   do_cleanups (cleanup);
 252 }
 253
 254 static void
 255 delete_thread_object (struct thread_info *tp, int ignore)
 256 {
 257   struct cleanup *cleanup;
 258   inferior_object *inf_obj;
 259   struct threadlist_entry **entry, *tmp;
 260
 261   cleanup = ensure_python_env (python_gdbarch, python_language);
 262
 263   inf_obj = (inferior_object *) find_inferior_object (PIDGET(tp->ptid));
 264   if (!inf_obj)
 265     {
 266       do_cleanups (cleanup);
 267       return;
 268     }
 269
 270   /* Find thread entry in its inferior's thread_list.  */
 271   for (entry = &inf_obj->threads; *entry != NULL; entry =
 272          &(*entry)->next)
 273     if ((*entry)->thread_obj->thread == tp)
 274       break;
 275
 276   if (!*entry)
 277     {
 278       Py_DECREF (inf_obj);
 279       do_cleanups (cleanup);
 280       return;
 281     }
 282
 283   tmp = *entry;
 284   tmp->thread_obj->thread = NULL;
 285
 286   *entry = (*entry)->next;
 287   inf_obj->nthreads--;
 288
 289   Py_DECREF (tmp->thread_obj);
 290   Py_DECREF (inf_obj);
 291   xfree (tmp);
 292
 293   do_cleanups (cleanup);
 294 }
 295
 296 static PyObject *
 297 infpy_threads (PyObject *self, PyObject *args)
 298 {
 299   int i;
 300   struct threadlist_entry *entry;
 301   inferior_object *inf_obj = (inferior_object *) self;
 302   PyObject *tuple;
 303   volatile struct gdb_exception except;
 304
 305   INFPY_REQUIRE_VALID (inf_obj);
 306
 307   TRY_CATCH (except, RETURN_MASK_ALL)
 308     update_thread_list ();
 309   GDB_PY_HANDLE_EXCEPTION (except);
 310
 311   tuple = PyTuple_New (inf_obj->nthreads);
 312   if (!tuple)
 313     return NULL;
 314
 315   for (i = 0, entry = inf_obj->threads; i < inf_obj->nthreads;
 316        i++, entry = entry->next)
 317     {
 318       Py_INCREF (entry->thread_obj);
 319       PyTuple_SET_ITEM (tuple, i, (PyObject *) entry->thread_obj);
 320     }
 321
 322   return tuple;
 323 }
 324
 325 static PyObject *
 326 infpy_get_num (PyObject *self, void *closure)
 327 {
 328   inferior_object *inf = (inferior_object *) self;
 329
 330   INFPY_REQUIRE_VALID (inf);
 331
 332   return PyLong_FromLong (inf->inferior->num);
 333 }
 334
 335 static PyObject *
 336 infpy_get_pid (PyObject *self, void *closure)
 337 {
 338   inferior_object *inf = (inferior_object *) self;
 339
 340   INFPY_REQUIRE_VALID (inf);
 341
 342   return PyLong_FromLong (inf->inferior->pid);
 343 }
 344
 345 static PyObject *
 346 infpy_get_was_attached (PyObject *self, void *closure)
 347 {
 348   inferior_object *inf = (inferior_object *) self;
 349
 350   INFPY_REQUIRE_VALID (inf);
 351   if (inf->inferior->attach_flag)
 352     Py_RETURN_TRUE;
 353   Py_RETURN_FALSE;
 354 }
 355
 356 static int
 357 build_inferior_list (struct inferior *inf, void *arg)
 358 {
 359   PyObject *list = arg;
 360   PyObject *inferior = inferior_to_inferior_object (inf);
 361   int success = 0;
 362
 363   if (! inferior)
 364     return 0;
 365
 366   success = PyList_Append (list, inferior);
 367   Py_DECREF (inferior);
 368
 369   if (success)
 370     return 1;
 371
 372   return 0;
 373 }
 374
 375 /* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
 376    Returns a tuple of all inferiors.  */
 377 PyObject *
 378 gdbpy_inferiors (PyObject *unused, PyObject *unused2)
 379 {
 380   PyObject *list, *tuple;
 381
 382   list = PyList_New (0);
 383   if (!list)
 384     return NULL;
 385
 386   if (iterate_over_inferiors (build_inferior_list, list))
 387     {
 388       Py_DECREF (list);
 389       return NULL;
 390     }
 391
 392   tuple = PyList_AsTuple (list);
 393   Py_DECREF (list);
 394
 395   return tuple;
 396 }
 397
 398 /* Membuf and memory manipulation.  */
 399
 400 /* Implementation of Inferior.read_memory (address, length).
 401    Returns a Python buffer object with LENGTH bytes of the inferior's
 402    memory at ADDRESS.  Both arguments are integers.  Returns NULL on error,
 403    with a python exception set.  */
 404 static PyObject *
 405 infpy_read_memory (PyObject *self, PyObject *args, PyObject *kw)
 406 {
 407   int error = 0;
 408   CORE_ADDR addr, length;
 409   void *buffer = NULL;
 410   membuf_object *membuf_obj;
 411   PyObject *addr_obj, *length_obj, *result;
 412   volatile struct gdb_exception except;
 413   static char *keywords[] = { "address", "length", NULL };
 414
 415   if (! PyArg_ParseTupleAndKeywords (args, kw, "OO", keywords,
 416                                      &addr_obj, &length_obj))
 417     return NULL;
 418
 419   TRY_CATCH (except, RETURN_MASK_ALL)
 420     {
 421       if (!get_addr_from_python (addr_obj, &addr)
 422           || !get_addr_from_python (length_obj, &length))
 423         {
 424           error = 1;
 425           break;
 426         }
 427
 428       buffer = xmalloc (length);
 429
 430       read_memory (addr, buffer, length);
 431     }
 432   if (except.reason < 0)
 433     {
 434       xfree (buffer);
 435       GDB_PY_HANDLE_EXCEPTION (except);
 436     }
 437
 438   if (error)
 439     {
 440       xfree (buffer);
 441       return NULL;
 442     }
 443
 444   membuf_obj = PyObject_New (membuf_object, &membuf_object_type);
 445   if (membuf_obj == NULL)
 446     {
 447       xfree (buffer);
 448       PyErr_SetString (PyExc_MemoryError,
 449                        _("Could not allocate memory buffer object."));
 450       return NULL;
 451     }
 452
 453   membuf_obj->buffer = buffer;
 454   membuf_obj->addr = addr;
 455   membuf_obj->length = length;
 456
 457 #ifdef IS_PY3K
 458   result = PyMemoryView_FromObject ((PyObject *) membuf_obj);
 459 #else
 460   result = PyBuffer_FromReadWriteObject ((PyObject *) membuf_obj, 0,
 461                                          Py_END_OF_BUFFER);
 462 #endif
 463   Py_DECREF (membuf_obj);
 464
 465   return result;
 466 }
 467
 468 /* Implementation of Inferior.write_memory (address, buffer [, length]).
 469    Writes the contents of BUFFER (a Python object supporting the read
 470    buffer protocol) at ADDRESS in the inferior's memory.  Write LENGTH
 471    bytes from BUFFER, or its entire contents if the argument is not
 472    provided.  The function returns nothing.  Returns NULL on error, with
 473    a python exception set.  */
 474 static PyObject *
 475 infpy_write_memory (PyObject *self, PyObject *args, PyObject *kw)
 476 {
 477   Py_ssize_t buf_len;
 478   int error = 0;
 479   const char *buffer;
 480   CORE_ADDR addr, length;
 481   PyObject *addr_obj, *length_obj = NULL;
 482   volatile struct gdb_exception except;
 483   static char *keywords[] = { "address", "buffer", "length", NULL };
 484 #ifdef IS_PY3K
 485   Py_buffer pybuf;
 486
 487   if (! PyArg_ParseTupleAndKeywords (args, kw, "Os*|O", keywords,
 488                                      &addr_obj, &pybuf,
 489                                      &length_obj))
 490     return NULL;
 491
 492   buffer = pybuf.buf;
 493   buf_len = pybuf.len;
 494 #else
 495   if (! PyArg_ParseTupleAndKeywords (args, kw, "Os#|O", keywords,
 496                                      &addr_obj, &buffer, &buf_len,
 497                                      &length_obj))
 498     return NULL;
 499 #endif
 500
 501   TRY_CATCH (except, RETURN_MASK_ALL)
 502     {
 503       if (!get_addr_from_python (addr_obj, &addr))
 504         {
 505           error = 1;
 506           break;
 507         }
 508
 509       if (!length_obj)
 510         length = buf_len;
 511       else if (!get_addr_from_python (length_obj, &length))
 512         {
 513           error = 1;
 514           break;
 515         }
 516       write_memory_with_notification (addr, buffer, length);
 517     }
 518 #ifdef IS_PY3K
 519   PyBuffer_Release (&pybuf);
 520 #endif
 521   GDB_PY_HANDLE_EXCEPTION (except);
 522
 523
 524   if (error)
 525     return NULL;
 526
 527   Py_RETURN_NONE;
 528 }
 529
 530 /* Destructor of Membuf objects.  */
 531 static void
 532 mbpy_dealloc (PyObject *self)
 533 {
 534   xfree (((membuf_object *) self)->buffer);
 535   Py_TYPE (self)->tp_free (self);
 536 }
 537
 538 /* Return a description of the Membuf object.  */
 539 static PyObject *
 540 mbpy_str (PyObject *self)
 541 {
 542   membuf_object *membuf_obj = (membuf_object *) self;
 543
 544   return PyString_FromFormat (_("Memory buffer for address %s, \
 545 which is %s bytes long."),
 546                               paddress (python_gdbarch, membuf_obj->addr),
 547                               pulongest (membuf_obj->length));
 548 }
 549
 550 #ifdef IS_PY3K
 551
 552 static int
 553 get_buffer (PyObject *self, Py_buffer *buf, int flags)
 554 {
 555   membuf_object *membuf_obj = (membuf_object *) self;
 556   int ret;
 557
 558   ret = PyBuffer_FillInfo (buf, self, membuf_obj->buffer,
 559                            membuf_obj->length, 0,
 560                            PyBUF_CONTIG);
 561   buf->format = "c";
 562
 563   return ret;
 564 }
 565
 566 #else
 567
 568 static Py_ssize_t
 569 get_read_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
 570 {
 571   membuf_object *membuf_obj = (membuf_object *) self;
 572
 573   if (segment)
 574     {
 575       PyErr_SetString (PyExc_SystemError,
 576                        _("The memory buffer supports only one segment."));
 577       return -1;
 578     }
 579
 580   *ptrptr = membuf_obj->buffer;
 581
 582   return membuf_obj->length;
 583 }
 584
 585 static Py_ssize_t
 586 get_write_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
 587 {
 588   return get_read_buffer (self, segment, ptrptr);
 589 }
 590
 591 static Py_ssize_t
 592 get_seg_count (PyObject *self, Py_ssize_t *lenp)
 593 {
 594   if (lenp)
 595     *lenp = ((membuf_object *) self)->length;
 596
 597   return 1;
 598 }
 599
 600 static Py_ssize_t
 601 get_char_buffer (PyObject *self, Py_ssize_t segment, char **ptrptr)
 602 {
 603   void *ptr = NULL;
 604   Py_ssize_t ret;
 605
 606   ret = get_read_buffer (self, segment, &ptr);
 607   *ptrptr = (char *) ptr;
 608
 609   return ret;
 610 }
 611
 612 #endif  /* IS_PY3K */
 613
 614 /* Implementation of
 615    gdb.search_memory (address, length, pattern).  ADDRESS is the
 616    address to start the search.  LENGTH specifies the scope of the
 617    search from ADDRESS.  PATTERN is the pattern to search for (and
 618    must be a Python object supporting the buffer protocol).
 619    Returns a Python Long object holding the address where the pattern
 620    was located, or if the pattern was not found, returns None.  Returns NULL
 621    on error, with a python exception set.  */
 622 static PyObject *
 623 infpy_search_memory (PyObject *self, PyObject *args, PyObject *kw)
 624 {
 625   CORE_ADDR start_addr, length;
 626   static char *keywords[] = { "address", "length", "pattern", NULL };
 627   PyObject *start_addr_obj, *length_obj;
 628   volatile struct gdb_exception except;
 629   Py_ssize_t pattern_size;
 630   const void *buffer;
 631   CORE_ADDR found_addr;
 632   int found = 0;
 633 #ifdef IS_PY3K
 634   Py_buffer pybuf;
 635
 636   if (! PyArg_ParseTupleAndKeywords (args, kw, "OOs*", keywords,
 637                                      &start_addr_obj, &length_obj,
 638                                      &pybuf))
 639     return NULL;
 640
 641   buffer = pybuf.buf;
 642   pattern_size = pybuf.len;
 643 #else
 644   PyObject *pattern;
 645
 646   if (! PyArg_ParseTupleAndKeywords (args, kw, "OOO", keywords,
 647                                      &start_addr_obj, &length_obj,
 648                                      &pattern))
 649      return NULL;
 650
 651   if (!PyObject_CheckReadBuffer (pattern))
 652     {
 653       PyErr_SetString (PyExc_RuntimeError,
 654                        _("The pattern is not a Python buffer."));
 655
 656       return NULL;
 657     }
 658
 659   if (PyObject_AsReadBuffer (pattern, &buffer, &pattern_size) == -1)
 660     return NULL;
 661 #endif
 662
 663   if (get_addr_from_python (start_addr_obj, &start_addr)
 664       && get_addr_from_python (length_obj, &length))
 665     {
 666       if (!length)
 667         {
 668           PyErr_SetString (PyExc_ValueError,
 669                            _("Search range is empty."));
 670
 671 #ifdef IS_PY3K
 672           PyBuffer_Release (&pybuf);
 673 #endif
 674           return NULL;
 675         }
 676       /* Watch for overflows.  */
 677       else if (length > CORE_ADDR_MAX
 678                || (start_addr + length - 1) < start_addr)
 679         {
 680           PyErr_SetString (PyExc_ValueError,
 681                            _("The search range is too large."));
 682
 683 #ifdef IS_PY3K
 684           PyBuffer_Release (&pybuf);
 685 #endif
 686           return NULL;
 687         }
 688     }
 689   else
 690     return NULL;
 691
 692   TRY_CATCH (except, RETURN_MASK_ALL)
 693     {
 694       found = target_search_memory (start_addr, length,
 695                                     buffer, pattern_size,
 696                                     &found_addr);
 697     }
 698   GDB_PY_HANDLE_EXCEPTION (except);
 699
 700 #ifdef IS_PY3K
 701   PyBuffer_Release (&pybuf);
 702 #endif
 703
 704   if (found)
 705     return PyLong_FromLong (found_addr);
 706   else
 707     Py_RETURN_NONE;
 708 }
 709
 710 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
 711    Returns True if this inferior object still exists in GDB.  */
 712
 713 static PyObject *
 714 infpy_is_valid (PyObject *self, PyObject *args)
 715 {
 716   inferior_object *inf = (inferior_object *) self;
 717
 718   if (! inf->inferior)
 719     Py_RETURN_FALSE;
 720
 721   Py_RETURN_TRUE;
 722 }
 723
 724 static void
 725 infpy_dealloc (PyObject *obj)
 726 {
 727   inferior_object *inf_obj = (inferior_object *) obj;
 728   struct inferior *inf = inf_obj->inferior;
 729
 730   if (! inf)
 731     return;
 732
 733   set_inferior_data (inf, infpy_inf_data_key, NULL);
 734 }
 735
 736 /* Clear the INFERIOR pointer in an Inferior object and clear the
 737    thread list.  */
 738 static void
 739 py_free_inferior (struct inferior *inf, void *datum)
 740 {
 741
 742   struct cleanup *cleanup;
 743   inferior_object *inf_obj = datum;
 744   struct threadlist_entry *th_entry, *th_tmp;
 745
 746   cleanup = ensure_python_env (python_gdbarch, python_language);
 747
 748   inf_obj->inferior = NULL;
 749
 750   /* Deallocate threads list.  */
 751   for (th_entry = inf_obj->threads; th_entry != NULL;)
 752     {
 753       Py_DECREF (th_entry->thread_obj);
 754
 755       th_tmp = th_entry;
 756       th_entry = th_entry->next;
 757       xfree (th_tmp);
 758     }
 759
 760   inf_obj->nthreads = 0;
 761
 762   Py_DECREF ((PyObject *) inf_obj);
 763   do_cleanups (cleanup);
 764 }
 765
 766 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
 767    Returns the current inferior object.  */
 768
 769 PyObject *
 770 gdbpy_selected_inferior (PyObject *self, PyObject *args)
 771 {
 772   PyObject *inf_obj;
 773
 774   inf_obj = inferior_to_inferior_object (current_inferior ());
 775   Py_INCREF (inf_obj);
 776
 777   return inf_obj;
 778 }
 779
 780 void
 781 gdbpy_initialize_inferior (void)
 782 {
 783   if (PyType_Ready (&inferior_object_type) < 0)
 784     return;
 785
 786   Py_INCREF (&inferior_object_type);
 787   PyModule_AddObject (gdb_module, "Inferior",
 788                       (PyObject *) &inferior_object_type);
 789
 790   infpy_inf_data_key =
 791     register_inferior_data_with_cleanup (NULL, py_free_inferior);
 792
 793   observer_attach_new_thread (add_thread_object);
 794   observer_attach_thread_exit (delete_thread_object);
 795   observer_attach_normal_stop (python_on_normal_stop);
 796   observer_attach_target_resumed (python_on_resume);
 797   observer_attach_inferior_exit (python_inferior_exit);
 798   observer_attach_new_objfile (python_new_objfile);
 799
 800   membuf_object_type.tp_new = PyType_GenericNew;
 801   if (PyType_Ready (&membuf_object_type) < 0)
 802     return;
 803
 804   Py_INCREF (&membuf_object_type);
 805   PyModule_AddObject (gdb_module, "Membuf", (PyObject *)
 806                       &membuf_object_type);
 807 }
 808
 809 static PyGetSetDef inferior_object_getset[] =
 810 {
 811   { "num", infpy_get_num, NULL, "ID of inferior, as assigned by GDB.", NULL },
 812   { "pid", infpy_get_pid, NULL, "PID of inferior, as assigned by the OS.",
 813     NULL },
 814   { "was_attached", infpy_get_was_attached, NULL,
 815     "True if the inferior was created using 'attach'.", NULL },
 816   { NULL }
 817 };
 818
 819 static PyMethodDef inferior_object_methods[] =
 820 {
 821   { "is_valid", infpy_is_valid, METH_NOARGS,
 822     "is_valid () -> Boolean.\n\
 823 Return true if this inferior is valid, false if not." },
 824   { "threads", infpy_threads, METH_NOARGS,
 825     "Return all the threads of this inferior." },
 826   { "read_memory", (PyCFunction) infpy_read_memory,
 827     METH_VARARGS | METH_KEYWORDS,
 828     "read_memory (address, length) -> buffer\n\
 829 Return a buffer object for reading from the inferior's memory." },
 830   { "write_memory", (PyCFunction) infpy_write_memory,
 831     METH_VARARGS | METH_KEYWORDS,
 832     "write_memory (address, buffer [, length])\n\
 833 Write the given buffer object to the inferior's memory." },
 834   { "search_memory", (PyCFunction) infpy_search_memory,
 835     METH_VARARGS | METH_KEYWORDS,
 836     "search_memory (address, length, pattern) -> long\n\
 837 Return a long with the address of a match, or None." },
 838   { NULL }
 839 };
 840
 841 static PyTypeObject inferior_object_type =
 842 {
 843   PyVarObject_HEAD_INIT (NULL, 0)
 844   "gdb.Inferior",                 /* tp_name */
 845   sizeof (inferior_object),       /* tp_basicsize */
 846   0,                              /* tp_itemsize */
 847   infpy_dealloc,                  /* tp_dealloc */
 848   0,                              /* tp_print */
 849   0,                              /* tp_getattr */
 850   0,                              /* tp_setattr */
 851   0,                              /* tp_compare */
 852   0,                              /* tp_repr */
 853   0,                              /* tp_as_number */
 854   0,                              /* tp_as_sequence */
 855   0,                              /* tp_as_mapping */
 856   0,                              /* tp_hash  */
 857   0,                              /* tp_call */
 858   0,                              /* tp_str */
 859   0,                              /* tp_getattro */
 860   0,                              /* tp_setattro */
 861   0,                              /* tp_as_buffer */
 862   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /* tp_flags */
 863   "GDB inferior object",          /* tp_doc */
 864   0,                              /* tp_traverse */
 865   0,                              /* tp_clear */
 866   0,                              /* tp_richcompare */
 867   0,                              /* tp_weaklistoffset */
 868   0,                              /* tp_iter */
 869   0,                              /* tp_iternext */
 870   inferior_object_methods,        /* tp_methods */
 871   0,                              /* tp_members */
 872   inferior_object_getset,         /* tp_getset */
 873   0,                              /* tp_base */
 874   0,                              /* tp_dict */
 875   0,                              /* tp_descr_get */
 876   0,                              /* tp_descr_set */
 877   0,                              /* tp_dictoffset */
 878   0,                              /* tp_init */
 879   0                               /* tp_alloc */
 880 };
 881
 882 #ifdef IS_PY3K
 883
 884 static PyBufferProcs buffer_procs =
 885 {
 886   get_buffer
 887 };
 888
 889 #else
 890
 891 /* Python doesn't provide a decent way to get compatibility here.  */
 892 #if HAVE_LIBPYTHON2_4
 893 #define CHARBUFFERPROC_NAME getcharbufferproc
 894 #else
 895 #define CHARBUFFERPROC_NAME charbufferproc
 896 #endif
 897
 898 static PyBufferProcs buffer_procs = {
 899   get_read_buffer,
 900   get_write_buffer,
 901   get_seg_count,
 902   /* The cast here works around a difference between Python 2.4 and
 903      Python 2.5.  */
 904   (CHARBUFFERPROC_NAME) get_char_buffer
 905 };
 906 #endif  /* IS_PY3K */
 907
 908 static PyTypeObject membuf_object_type = {
 909   PyVarObject_HEAD_INIT (NULL, 0)
 910   "gdb.Membuf",                   /*tp_name*/
 911   sizeof (membuf_object),         /*tp_basicsize*/
 912   0,                              /*tp_itemsize*/
 913   mbpy_dealloc,                   /*tp_dealloc*/
 914   0,                              /*tp_print*/
 915   0,                              /*tp_getattr*/
 916   0,                              /*tp_setattr*/
 917   0,                              /*tp_compare*/
 918   0,                              /*tp_repr*/
 919   0,                              /*tp_as_number*/
 920   0,                              /*tp_as_sequence*/
 921   0,                              /*tp_as_mapping*/
 922   0,                              /*tp_hash */
 923   0,                              /*tp_call*/
 924   mbpy_str,                       /*tp_str*/
 925   0,                              /*tp_getattro*/
 926   0,                              /*tp_setattro*/
 927   &buffer_procs,                  /*tp_as_buffer*/
 928   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 929   "GDB memory buffer object",     /*tp_doc*/
 930   0,                              /* tp_traverse */
 931   0,                              /* tp_clear */
 932   0,                              /* tp_richcompare */
 933   0,                              /* tp_weaklistoffset */
 934   0,                              /* tp_iter */
 935   0,                              /* tp_iternext */
 936   0,                              /* tp_methods */
 937   0,                              /* tp_members */
 938   0,                              /* tp_getset */
 939   0,                              /* tp_base */
 940   0,                              /* tp_dict */
 941   0,                              /* tp_descr_get */
 942   0,                              /* tp_descr_set */
 943   0,                              /* tp_dictoffset */
 944   0,                              /* tp_init */
 945   0,                              /* tp_alloc */
 946 };