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