gdb/python/py-inferior.c

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