gdb/python/py-inferior.c

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