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