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   thread_object *found = NULL;
 255
 256   pid = ptid_get_pid (ptid);
 257   if (pid == 0)
 258     return NULL;
 259
 260   gdbpy_ref inf_obj (find_inferior_object (pid));
 261   if (inf_obj == NULL)
 262     return NULL;
 263
 264   for (thread = ((inferior_object *)(inf_obj.get ()))->threads; thread;
 265        thread = thread->next)
 266     if (ptid_equal (thread->thread_obj->thread->ptid, ptid))
 267       {
 268         found = thread->thread_obj;
 269         break;
 270       }
 271
 272   if (found)
 273     return found;
 274
 275   return NULL;
 276 }
 277
 278 static void
 279 add_thread_object (struct thread_info *tp)
 280 {
 281   thread_object *thread_obj;
 282   inferior_object *inf_obj;
 283   struct threadlist_entry *entry;
 284
 285   if (!gdb_python_initialized)
 286     return;
 287
 288   gdbpy_enter enter_py (python_gdbarch, python_language);
 289
 290   thread_obj = create_thread_object (tp);
 291   if (!thread_obj)
 292     {
 293       gdbpy_print_stack ();
 294       return;
 295     }
 296
 297   inf_obj = (inferior_object *) thread_obj->inf_obj;
 298
 299   entry = XNEW (struct threadlist_entry);
 300   entry->thread_obj = thread_obj;
 301   entry->next = inf_obj->threads;
 302
 303   inf_obj->threads = entry;
 304   inf_obj->nthreads++;
 305 }
 306
 307 static void
 308 delete_thread_object (struct thread_info *tp, int ignore)
 309 {
 310   inferior_object *inf_obj;
 311   struct threadlist_entry **entry, *tmp;
 312
 313   if (!gdb_python_initialized)
 314     return;
 315
 316   gdbpy_enter enter_py (python_gdbarch, python_language);
 317
 318   inf_obj
 319     = (inferior_object *) find_inferior_object (ptid_get_pid (tp->ptid));
 320   if (!inf_obj)
 321     return;
 322
 323   /* Find thread entry in its inferior's thread_list.  */
 324   for (entry = &inf_obj->threads; *entry != NULL; entry =
 325          &(*entry)->next)
 326     if ((*entry)->thread_obj->thread == tp)
 327       break;
 328
 329   if (!*entry)
 330     {
 331       Py_DECREF (inf_obj);
 332       return;
 333     }
 334
 335   tmp = *entry;
 336   tmp->thread_obj->thread = NULL;
 337
 338   *entry = (*entry)->next;
 339   inf_obj->nthreads--;
 340
 341   Py_DECREF (tmp->thread_obj);
 342   Py_DECREF (inf_obj);
 343   xfree (tmp);
 344 }
 345
 346 static PyObject *
 347 infpy_threads (PyObject *self, PyObject *args)
 348 {
 349   int i;
 350   struct threadlist_entry *entry;
 351   inferior_object *inf_obj = (inferior_object *) self;
 352   PyObject *tuple;
 353
 354   INFPY_REQUIRE_VALID (inf_obj);
 355
 356   TRY
 357     {
 358       update_thread_list ();
 359     }
 360   CATCH (except, RETURN_MASK_ALL)
 361     {
 362       GDB_PY_HANDLE_EXCEPTION (except);
 363     }
 364   END_CATCH
 365
 366   tuple = PyTuple_New (inf_obj->nthreads);
 367   if (!tuple)
 368     return NULL;
 369
 370   for (i = 0, entry = inf_obj->threads; i < inf_obj->nthreads;
 371        i++, entry = entry->next)
 372     {
 373       Py_INCREF (entry->thread_obj);
 374       PyTuple_SET_ITEM (tuple, i, (PyObject *) entry->thread_obj);
 375     }
 376
 377   return tuple;
 378 }
 379
 380 static PyObject *
 381 infpy_get_num (PyObject *self, void *closure)
 382 {
 383   inferior_object *inf = (inferior_object *) self;
 384
 385   INFPY_REQUIRE_VALID (inf);
 386
 387   return PyLong_FromLong (inf->inferior->num);
 388 }
 389
 390 static PyObject *
 391 infpy_get_pid (PyObject *self, void *closure)
 392 {
 393   inferior_object *inf = (inferior_object *) self;
 394
 395   INFPY_REQUIRE_VALID (inf);
 396
 397   return PyLong_FromLong (inf->inferior->pid);
 398 }
 399
 400 static PyObject *
 401 infpy_get_was_attached (PyObject *self, void *closure)
 402 {
 403   inferior_object *inf = (inferior_object *) self;
 404
 405   INFPY_REQUIRE_VALID (inf);
 406   if (inf->inferior->attach_flag)
 407     Py_RETURN_TRUE;
 408   Py_RETURN_FALSE;
 409 }
 410
 411 static int
 412 build_inferior_list (struct inferior *inf, void *arg)
 413 {
 414   PyObject *list = (PyObject *) arg;
 415   gdbpy_ref inferior (inferior_to_inferior_object (inf));
 416
 417   if (inferior  == NULL)
 418     return 0;
 419
 420   return PyList_Append (list, inferior.get ()) ? 1 : 0;
 421 }
 422
 423 /* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
 424    Returns a tuple of all inferiors.  */
 425 PyObject *
 426 gdbpy_inferiors (PyObject *unused, PyObject *unused2)
 427 {
 428   gdbpy_ref list (PyList_New (0));
 429   if (list == NULL)
 430     return NULL;
 431
 432   if (iterate_over_inferiors (build_inferior_list, list.get ()))
 433     return NULL;
 434
 435   return PyList_AsTuple (list.get ());
 436 }
 437
 438 /* Membuf and memory manipulation.  */
 439
 440 /* Implementation of Inferior.read_memory (address, length).
 441    Returns a Python buffer object with LENGTH bytes of the inferior's
 442    memory at ADDRESS.  Both arguments are integers.  Returns NULL on error,
 443    with a python exception set.  */
 444 static PyObject *
 445 infpy_read_memory (PyObject *self, PyObject *args, PyObject *kw)
 446 {
 447   CORE_ADDR addr, length;
 448   gdb_byte *buffer = NULL;
 449   membuf_object *membuf_obj;
 450   PyObject *addr_obj, *length_obj, *result;
 451   static char *keywords[] = { "address", "length", NULL };
 452
 453   if (! PyArg_ParseTupleAndKeywords (args, kw, "OO", keywords,
 454                                      &addr_obj, &length_obj))
 455     return NULL;
 456
 457   if (get_addr_from_python (addr_obj, &addr) < 0
 458       || get_addr_from_python (length_obj, &length) < 0)
 459     return NULL;
 460
 461   TRY
 462     {
 463       buffer = (gdb_byte *) xmalloc (length);
 464
 465       read_memory (addr, buffer, length);
 466     }
 467   CATCH (except, RETURN_MASK_ALL)
 468     {
 469       xfree (buffer);
 470       GDB_PY_HANDLE_EXCEPTION (except);
 471     }
 472   END_CATCH
 473
 474   membuf_obj = PyObject_New (membuf_object, &membuf_object_type);
 475   if (membuf_obj == NULL)
 476     {
 477       xfree (buffer);
 478       return NULL;
 479     }
 480
 481   membuf_obj->buffer = buffer;
 482   membuf_obj->addr = addr;
 483   membuf_obj->length = length;
 484
 485 #ifdef IS_PY3K
 486   result = PyMemoryView_FromObject ((PyObject *) membuf_obj);
 487 #else
 488   result = PyBuffer_FromReadWriteObject ((PyObject *) membuf_obj, 0,
 489                                          Py_END_OF_BUFFER);
 490 #endif
 491   Py_DECREF (membuf_obj);
 492
 493   return result;
 494 }
 495
 496 /* Implementation of Inferior.write_memory (address, buffer [, length]).
 497    Writes the contents of BUFFER (a Python object supporting the read
 498    buffer protocol) at ADDRESS in the inferior's memory.  Write LENGTH
 499    bytes from BUFFER, or its entire contents if the argument is not
 500    provided.  The function returns nothing.  Returns NULL on error, with
 501    a python exception set.  */
 502 static PyObject *
 503 infpy_write_memory (PyObject *self, PyObject *args, PyObject *kw)
 504 {
 505   struct gdb_exception except = exception_none;
 506   Py_ssize_t buf_len;
 507   const gdb_byte *buffer;
 508   CORE_ADDR addr, length;
 509   PyObject *addr_obj, *length_obj = NULL;
 510   static char *keywords[] = { "address", "buffer", "length", NULL };
 511 #ifdef IS_PY3K
 512   Py_buffer pybuf;
 513
 514   if (! PyArg_ParseTupleAndKeywords (args, kw, "Os*|O", keywords,
 515                                      &addr_obj, &pybuf,
 516                                      &length_obj))
 517     return NULL;
 518
 519   buffer = (const gdb_byte *) pybuf.buf;
 520   buf_len = pybuf.len;
 521 #else
 522   if (! PyArg_ParseTupleAndKeywords (args, kw, "Os#|O", keywords,
 523                                      &addr_obj, &buffer, &buf_len,
 524                                      &length_obj))
 525     return NULL;
 526
 527   buffer = (const gdb_byte *) buffer;
 528 #endif
 529
 530   if (get_addr_from_python (addr_obj, &addr) < 0)
 531     goto fail;
 532
 533   if (!length_obj)
 534     length = buf_len;
 535   else if (get_addr_from_python (length_obj, &length) < 0)
 536     goto fail;
 537
 538   TRY
 539     {
 540       write_memory_with_notification (addr, buffer, length);
 541     }
 542   CATCH (ex, RETURN_MASK_ALL)
 543     {
 544       except = ex;
 545     }
 546   END_CATCH
 547
 548 #ifdef IS_PY3K
 549   PyBuffer_Release (&pybuf);
 550 #endif
 551   GDB_PY_HANDLE_EXCEPTION (except);
 552
 553   Py_RETURN_NONE;
 554
 555  fail:
 556 #ifdef IS_PY3K
 557   PyBuffer_Release (&pybuf);
 558 #endif
 559   return NULL;
 560 }
 561
 562 /* Destructor of Membuf objects.  */
 563 static void
 564 mbpy_dealloc (PyObject *self)
 565 {
 566   xfree (((membuf_object *) self)->buffer);
 567   Py_TYPE (self)->tp_free (self);
 568 }
 569
 570 /* Return a description of the Membuf object.  */
 571 static PyObject *
 572 mbpy_str (PyObject *self)
 573 {
 574   membuf_object *membuf_obj = (membuf_object *) self;
 575
 576   return PyString_FromFormat (_("Memory buffer for address %s, \
 577 which is %s bytes long."),
 578                               paddress (python_gdbarch, membuf_obj->addr),
 579                               pulongest (membuf_obj->length));
 580 }
 581
 582 #ifdef IS_PY3K
 583
 584 static int
 585 get_buffer (PyObject *self, Py_buffer *buf, int flags)
 586 {
 587   membuf_object *membuf_obj = (membuf_object *) self;
 588   int ret;
 589
 590   ret = PyBuffer_FillInfo (buf, self, membuf_obj->buffer,
 591                            membuf_obj->length, 0,
 592                            PyBUF_CONTIG);
 593   buf->format = "c";
 594
 595   return ret;
 596 }
 597
 598 #else
 599
 600 static Py_ssize_t
 601 get_read_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
 602 {
 603   membuf_object *membuf_obj = (membuf_object *) self;
 604
 605   if (segment)
 606     {
 607       PyErr_SetString (PyExc_SystemError,
 608                        _("The memory buffer supports only one segment."));
 609       return -1;
 610     }
 611
 612   *ptrptr = membuf_obj->buffer;
 613
 614   return membuf_obj->length;
 615 }
 616
 617 static Py_ssize_t
 618 get_write_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
 619 {
 620   return get_read_buffer (self, segment, ptrptr);
 621 }
 622
 623 static Py_ssize_t
 624 get_seg_count (PyObject *self, Py_ssize_t *lenp)
 625 {
 626   if (lenp)
 627     *lenp = ((membuf_object *) self)->length;
 628
 629   return 1;
 630 }
 631
 632 static Py_ssize_t
 633 get_char_buffer (PyObject *self, Py_ssize_t segment, char **ptrptr)
 634 {
 635   void *ptr = NULL;
 636   Py_ssize_t ret;
 637
 638   ret = get_read_buffer (self, segment, &ptr);
 639   *ptrptr = (char *) ptr;
 640
 641   return ret;
 642 }
 643
 644 #endif  /* IS_PY3K */
 645
 646 /* Implementation of
 647    gdb.search_memory (address, length, pattern).  ADDRESS is the
 648    address to start the search.  LENGTH specifies the scope of the
 649    search from ADDRESS.  PATTERN is the pattern to search for (and
 650    must be a Python object supporting the buffer protocol).
 651    Returns a Python Long object holding the address where the pattern
 652    was located, or if the pattern was not found, returns None.  Returns NULL
 653    on error, with a python exception set.  */
 654 static PyObject *
 655 infpy_search_memory (PyObject *self, PyObject *args, PyObject *kw)
 656 {
 657   struct gdb_exception except = exception_none;
 658   CORE_ADDR start_addr, length;
 659   static char *keywords[] = { "address", "length", "pattern", NULL };
 660   PyObject *start_addr_obj, *length_obj;
 661   Py_ssize_t pattern_size;
 662   const gdb_byte *buffer;
 663   CORE_ADDR found_addr;
 664   int found = 0;
 665 #ifdef IS_PY3K
 666   Py_buffer pybuf;
 667
 668   if (! PyArg_ParseTupleAndKeywords (args, kw, "OOs*", keywords,
 669                                      &start_addr_obj, &length_obj,
 670                                      &pybuf))
 671     return NULL;
 672
 673   buffer = (const gdb_byte *) pybuf.buf;
 674   pattern_size = pybuf.len;
 675 #else
 676   PyObject *pattern;
 677   const void *vbuffer;
 678
 679   if (! PyArg_ParseTupleAndKeywords (args, kw, "OOO", keywords,
 680                                      &start_addr_obj, &length_obj,
 681                                      &pattern))
 682      return NULL;
 683
 684   if (!PyObject_CheckReadBuffer (pattern))
 685     {
 686       PyErr_SetString (PyExc_RuntimeError,
 687                        _("The pattern is not a Python buffer."));
 688
 689       return NULL;
 690     }
 691
 692   if (PyObject_AsReadBuffer (pattern, &vbuffer, &pattern_size) == -1)
 693     return NULL;
 694
 695   buffer = (const gdb_byte *) vbuffer;
 696 #endif
 697
 698   if (get_addr_from_python (start_addr_obj, &start_addr) < 0)
 699     goto fail;
 700
 701   if (get_addr_from_python (length_obj, &length) < 0)
 702     goto fail;
 703
 704   if (!length)
 705     {
 706       PyErr_SetString (PyExc_ValueError,
 707                        _("Search range is empty."));
 708       goto fail;
 709     }
 710   /* Watch for overflows.  */
 711   else if (length > CORE_ADDR_MAX
 712            || (start_addr + length - 1) < start_addr)
 713     {
 714       PyErr_SetString (PyExc_ValueError,
 715                        _("The search range is too large."));
 716       goto fail;
 717     }
 718
 719   TRY
 720     {
 721       found = target_search_memory (start_addr, length,
 722                                     buffer, pattern_size,
 723                                     &found_addr);
 724     }
 725   CATCH (ex, RETURN_MASK_ALL)
 726     {
 727       except = ex;
 728     }
 729   END_CATCH
 730
 731 #ifdef IS_PY3K
 732   PyBuffer_Release (&pybuf);
 733 #endif
 734   GDB_PY_HANDLE_EXCEPTION (except);
 735
 736   if (found)
 737     return PyLong_FromLong (found_addr);
 738   else
 739     Py_RETURN_NONE;
 740
 741  fail:
 742 #ifdef IS_PY3K
 743   PyBuffer_Release (&pybuf);
 744 #endif
 745   return NULL;
 746 }
 747
 748 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
 749    Returns True if this inferior object still exists in GDB.  */
 750
 751 static PyObject *
 752 infpy_is_valid (PyObject *self, PyObject *args)
 753 {
 754   inferior_object *inf = (inferior_object *) self;
 755
 756   if (! inf->inferior)
 757     Py_RETURN_FALSE;
 758
 759   Py_RETURN_TRUE;
 760 }
 761
 762 static void
 763 infpy_dealloc (PyObject *obj)
 764 {
 765   inferior_object *inf_obj = (inferior_object *) obj;
 766   struct inferior *inf = inf_obj->inferior;
 767
 768   if (! inf)
 769     return;
 770
 771   set_inferior_data (inf, infpy_inf_data_key, NULL);
 772 }
 773
 774 /* Clear the INFERIOR pointer in an Inferior object and clear the
 775    thread list.  */
 776 static void
 777 py_free_inferior (struct inferior *inf, void *datum)
 778 {
 779   inferior_object *inf_obj = (inferior_object *) datum;
 780   struct threadlist_entry *th_entry, *th_tmp;
 781
 782   if (!gdb_python_initialized)
 783     return;
 784
 785   gdbpy_enter enter_py (python_gdbarch, python_language);
 786
 787   inf_obj->inferior = NULL;
 788
 789   /* Deallocate threads list.  */
 790   for (th_entry = inf_obj->threads; th_entry != NULL;)
 791     {
 792       Py_DECREF (th_entry->thread_obj);
 793
 794       th_tmp = th_entry;
 795       th_entry = th_entry->next;
 796       xfree (th_tmp);
 797     }
 798
 799   inf_obj->nthreads = 0;
 800
 801   Py_DECREF ((PyObject *) inf_obj);
 802 }
 803
 804 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
 805    Returns the current inferior object.  */
 806
 807 PyObject *
 808 gdbpy_selected_inferior (PyObject *self, PyObject *args)
 809 {
 810   return inferior_to_inferior_object (current_inferior ());
 811 }
 812
 813 int
 814 gdbpy_initialize_inferior (void)
 815 {
 816   if (PyType_Ready (&inferior_object_type) < 0)
 817     return -1;
 818
 819   if (gdb_pymodule_addobject (gdb_module, "Inferior",
 820                               (PyObject *) &inferior_object_type) < 0)
 821     return -1;
 822
 823   infpy_inf_data_key =
 824     register_inferior_data_with_cleanup (NULL, py_free_inferior);
 825
 826   observer_attach_new_thread (add_thread_object);
 827   observer_attach_thread_exit (delete_thread_object);
 828   observer_attach_normal_stop (python_on_normal_stop);
 829   observer_attach_target_resumed (python_on_resume);
 830   observer_attach_inferior_call_pre (python_on_inferior_call_pre);
 831   observer_attach_inferior_call_post (python_on_inferior_call_post);
 832   observer_attach_memory_changed (python_on_memory_change);
 833   observer_attach_register_changed (python_on_register_change);
 834   observer_attach_inferior_exit (python_inferior_exit);
 835   observer_attach_new_objfile (python_new_objfile);
 836
 837   membuf_object_type.tp_new = PyType_GenericNew;
 838   if (PyType_Ready (&membuf_object_type) < 0)
 839     return -1;
 840
 841   return gdb_pymodule_addobject (gdb_module, "Membuf", (PyObject *)
 842                                  &membuf_object_type);
 843 }
 844
 845 static PyGetSetDef inferior_object_getset[] =
 846 {
 847   { "num", infpy_get_num, NULL, "ID of inferior, as assigned by GDB.", NULL },
 848   { "pid", infpy_get_pid, NULL, "PID of inferior, as assigned by the OS.",
 849     NULL },
 850   { "was_attached", infpy_get_was_attached, NULL,
 851     "True if the inferior was created using 'attach'.", NULL },
 852   { NULL }
 853 };
 854
 855 static PyMethodDef inferior_object_methods[] =
 856 {
 857   { "is_valid", infpy_is_valid, METH_NOARGS,
 858     "is_valid () -> Boolean.\n\
 859 Return true if this inferior is valid, false if not." },
 860   { "threads", infpy_threads, METH_NOARGS,
 861     "Return all the threads of this inferior." },
 862   { "read_memory", (PyCFunction) infpy_read_memory,
 863     METH_VARARGS | METH_KEYWORDS,
 864     "read_memory (address, length) -> buffer\n\
 865 Return a buffer object for reading from the inferior's memory." },
 866   { "write_memory", (PyCFunction) infpy_write_memory,
 867     METH_VARARGS | METH_KEYWORDS,
 868     "write_memory (address, buffer [, length])\n\
 869 Write the given buffer object to the inferior's memory." },
 870   { "search_memory", (PyCFunction) infpy_search_memory,
 871     METH_VARARGS | METH_KEYWORDS,
 872     "search_memory (address, length, pattern) -> long\n\
 873 Return a long with the address of a match, or None." },
 874   { NULL }
 875 };
 876
 877 PyTypeObject inferior_object_type =
 878 {
 879   PyVarObject_HEAD_INIT (NULL, 0)
 880   "gdb.Inferior",                 /* tp_name */
 881   sizeof (inferior_object),       /* tp_basicsize */
 882   0,                              /* tp_itemsize */
 883   infpy_dealloc,                  /* tp_dealloc */
 884   0,                              /* tp_print */
 885   0,                              /* tp_getattr */
 886   0,                              /* tp_setattr */
 887   0,                              /* tp_compare */
 888   0,                              /* tp_repr */
 889   0,                              /* tp_as_number */
 890   0,                              /* tp_as_sequence */
 891   0,                              /* tp_as_mapping */
 892   0,                              /* tp_hash  */
 893   0,                              /* tp_call */
 894   0,                              /* tp_str */
 895   0,                              /* tp_getattro */
 896   0,                              /* tp_setattro */
 897   0,                              /* tp_as_buffer */
 898   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /* tp_flags */
 899   "GDB inferior object",          /* tp_doc */
 900   0,                              /* tp_traverse */
 901   0,                              /* tp_clear */
 902   0,                              /* tp_richcompare */
 903   0,                              /* tp_weaklistoffset */
 904   0,                              /* tp_iter */
 905   0,                              /* tp_iternext */
 906   inferior_object_methods,        /* tp_methods */
 907   0,                              /* tp_members */
 908   inferior_object_getset,         /* tp_getset */
 909   0,                              /* tp_base */
 910   0,                              /* tp_dict */
 911   0,                              /* tp_descr_get */
 912   0,                              /* tp_descr_set */
 913   0,                              /* tp_dictoffset */
 914   0,                              /* tp_init */
 915   0                               /* tp_alloc */
 916 };
 917
 918 #ifdef IS_PY3K
 919
 920 static PyBufferProcs buffer_procs =
 921 {
 922   get_buffer
 923 };
 924
 925 #else
 926
 927 /* Python doesn't provide a decent way to get compatibility here.  */
 928 #if HAVE_LIBPYTHON2_4
 929 #define CHARBUFFERPROC_NAME getcharbufferproc
 930 #else
 931 #define CHARBUFFERPROC_NAME charbufferproc
 932 #endif
 933
 934 static PyBufferProcs buffer_procs = {
 935   get_read_buffer,
 936   get_write_buffer,
 937   get_seg_count,
 938   /* The cast here works around a difference between Python 2.4 and
 939      Python 2.5.  */
 940   (CHARBUFFERPROC_NAME) get_char_buffer
 941 };
 942 #endif  /* IS_PY3K */
 943
 944 PyTypeObject membuf_object_type = {
 945   PyVarObject_HEAD_INIT (NULL, 0)
 946   "gdb.Membuf",                   /*tp_name*/
 947   sizeof (membuf_object),         /*tp_basicsize*/
 948   0,                              /*tp_itemsize*/
 949   mbpy_dealloc,                   /*tp_dealloc*/
 950   0,                              /*tp_print*/
 951   0,                              /*tp_getattr*/
 952   0,                              /*tp_setattr*/
 953   0,                              /*tp_compare*/
 954   0,                              /*tp_repr*/
 955   0,                              /*tp_as_number*/
 956   0,                              /*tp_as_sequence*/
 957   0,                              /*tp_as_mapping*/
 958   0,                              /*tp_hash */
 959   0,                              /*tp_call*/
 960   mbpy_str,                       /*tp_str*/
 961   0,                              /*tp_getattro*/
 962   0,                              /*tp_setattro*/
 963   &buffer_procs,                  /*tp_as_buffer*/
 964   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 965   "GDB memory buffer object",     /*tp_doc*/
 966   0,                              /* tp_traverse */
 967   0,                              /* tp_clear */
 968   0,                              /* tp_richcompare */
 969   0,                              /* tp_weaklistoffset */
 970   0,                              /* tp_iter */
 971   0,                              /* tp_iternext */
 972   0,                              /* tp_methods */
 973   0,                              /* tp_members */
 974   0,                              /* tp_getset */
 975   0,                              /* tp_base */
 976   0,                              /* tp_dict */
 977   0,                              /* tp_descr_get */
 978   0,                              /* tp_descr_set */
 979   0,                              /* tp_dictoffset */
 980   0,                              /* tp_init */
 981   0,                              /* tp_alloc */
 982 };