gdb/python/py-inferior.c

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