gdb/python/py-inferior.c

   1 /* Python interface to inferiors.
   2
   3    Copyright (C) 2009-2018 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 "observable.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 struct inferior_object
  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 };
  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
 211 inferior_object *
 212 inferior_to_inferior_object (struct inferior *inferior)
 213 {
 214   inferior_object *inf_obj;
 215
 216   inf_obj = (inferior_object *) inferior_data (inferior, infpy_inf_data_key);
 217   if (!inf_obj)
 218     {
 219       inf_obj = PyObject_New (inferior_object, &inferior_object_type);
 220       if (!inf_obj)
 221           return NULL;
 222
 223       inf_obj->inferior = inferior;
 224       inf_obj->threads = NULL;
 225       inf_obj->nthreads = 0;
 226
 227       /* PyObject_New initializes the new object with a refcount of 1.  This
 228          counts for the reference we are keeping in the inferior data.  */
 229       set_inferior_data (inferior, infpy_inf_data_key, inf_obj);
 230
 231     }
 232
 233   /* We are returning a new reference.  */
 234   Py_INCREF ((PyObject *)inf_obj);
 235
 236   return inf_obj;
 237 }
 238
 239 /* Called when a new inferior is created.  Notifies any Python event
 240    listeners.  */
 241 static void
 242 python_new_inferior (struct inferior *inf)
 243 {
 244   if (!gdb_python_initialized)
 245     return;
 246
 247   gdbpy_enter enter_py (python_gdbarch, python_language);
 248
 249   if (evregpy_no_listeners_p (gdb_py_events.new_inferior))
 250     return;
 251
 252   gdbpy_ref<inferior_object> inf_obj (inferior_to_inferior_object (inf));
 253   if (inf_obj == NULL)
 254     {
 255       gdbpy_print_stack ();
 256       return;
 257     }
 258
 259   gdbpy_ref<> event = create_event_object (&new_inferior_event_object_type);
 260   if (event == NULL
 261       || evpy_add_attribute (event.get (), "inferior",
 262                              (PyObject *) inf_obj.get ()) < 0
 263       || evpy_emit_event (event.get (), gdb_py_events.new_inferior) < 0)
 264     gdbpy_print_stack ();
 265 }
 266
 267 /* Called when an inferior is removed.  Notifies any Python event
 268    listeners.  */
 269 static void
 270 python_inferior_deleted (struct inferior *inf)
 271 {
 272   if (!gdb_python_initialized)
 273     return;
 274
 275   gdbpy_enter enter_py (python_gdbarch, python_language);
 276
 277   if (evregpy_no_listeners_p (gdb_py_events.inferior_deleted))
 278     return;
 279
 280   gdbpy_ref<inferior_object> inf_obj (inferior_to_inferior_object (inf));
 281   if (inf_obj == NULL)
 282     {
 283       gdbpy_print_stack ();
 284       return;
 285     }
 286
 287   gdbpy_ref<> event = create_event_object (&inferior_deleted_event_object_type);
 288   if (event == NULL
 289       || evpy_add_attribute (event.get (), "inferior",
 290                              (PyObject *) inf_obj.get ()) < 0
 291       || evpy_emit_event (event.get (), gdb_py_events.inferior_deleted) < 0)
 292     gdbpy_print_stack ();
 293 }
 294
 295 /* Finds the Python Inferior object for the given PID.  Returns a
 296    reference, or NULL if PID does not match any inferior object. */
 297
 298 PyObject *
 299 find_inferior_object (int pid)
 300 {
 301   struct inferior *inf = find_inferior_pid (pid);
 302
 303   if (inf)
 304     return (PyObject *) inferior_to_inferior_object (inf);
 305
 306   return NULL;
 307 }
 308
 309 gdbpy_ref<>
 310 thread_to_thread_object (thread_info *thr)
 311 {
 312   gdbpy_ref<inferior_object> inf_obj (inferior_to_inferior_object (thr->inf));
 313   if (inf_obj == NULL)
 314     return NULL;
 315
 316   for (threadlist_entry *thread = inf_obj->threads;
 317        thread != NULL;
 318        thread = thread->next)
 319     if (thread->thread_obj->thread == thr)
 320       return gdbpy_ref<>::new_reference ((PyObject *) thread->thread_obj);
 321
 322   PyErr_SetString (PyExc_SystemError,
 323                    _("could not find gdb thread object"));
 324   return NULL;
 325 }
 326
 327 static void
 328 add_thread_object (struct thread_info *tp)
 329 {
 330   thread_object *thread_obj;
 331   inferior_object *inf_obj;
 332   struct threadlist_entry *entry;
 333
 334   if (!gdb_python_initialized)
 335     return;
 336
 337   gdbpy_enter enter_py (python_gdbarch, python_language);
 338
 339   thread_obj = create_thread_object (tp);
 340   if (!thread_obj)
 341     {
 342       gdbpy_print_stack ();
 343       return;
 344     }
 345
 346   inf_obj = (inferior_object *) thread_obj->inf_obj;
 347
 348   entry = XNEW (struct threadlist_entry);
 349   entry->thread_obj = thread_obj;
 350   entry->next = inf_obj->threads;
 351
 352   inf_obj->threads = entry;
 353   inf_obj->nthreads++;
 354
 355   if (evregpy_no_listeners_p (gdb_py_events.new_thread))
 356     return;
 357
 358   gdbpy_ref<> event = create_thread_event_object (&new_thread_event_object_type,
 359                                                   (PyObject *) thread_obj);
 360   if (event == NULL
 361       || evpy_emit_event (event.get (), gdb_py_events.new_thread) < 0)
 362     gdbpy_print_stack ();
 363 }
 364
 365 static void
 366 delete_thread_object (struct thread_info *tp, int ignore)
 367 {
 368   struct threadlist_entry **entry, *tmp;
 369
 370   if (!gdb_python_initialized)
 371     return;
 372
 373   gdbpy_enter enter_py (python_gdbarch, python_language);
 374
 375   gdbpy_ref<inferior_object> inf_obj
 376     ((inferior_object *) inferior_to_inferior_object (tp->inf));
 377   if (inf_obj == NULL)
 378     return;
 379
 380   /* Find thread entry in its inferior's thread_list.  */
 381   for (entry = &inf_obj->threads; *entry != NULL; entry =
 382          &(*entry)->next)
 383     if ((*entry)->thread_obj->thread == tp)
 384       break;
 385
 386   if (!*entry)
 387     return;
 388
 389   tmp = *entry;
 390   tmp->thread_obj->thread = NULL;
 391
 392   *entry = (*entry)->next;
 393   inf_obj->nthreads--;
 394
 395   Py_DECREF (tmp->thread_obj);
 396   xfree (tmp);
 397 }
 398
 399 static PyObject *
 400 infpy_threads (PyObject *self, PyObject *args)
 401 {
 402   int i;
 403   struct threadlist_entry *entry;
 404   inferior_object *inf_obj = (inferior_object *) self;
 405   PyObject *tuple;
 406
 407   INFPY_REQUIRE_VALID (inf_obj);
 408
 409   TRY
 410     {
 411       update_thread_list ();
 412     }
 413   CATCH (except, RETURN_MASK_ALL)
 414     {
 415       GDB_PY_HANDLE_EXCEPTION (except);
 416     }
 417   END_CATCH
 418
 419   tuple = PyTuple_New (inf_obj->nthreads);
 420   if (!tuple)
 421     return NULL;
 422
 423   for (i = 0, entry = inf_obj->threads; i < inf_obj->nthreads;
 424        i++, entry = entry->next)
 425     {
 426       Py_INCREF (entry->thread_obj);
 427       PyTuple_SET_ITEM (tuple, i, (PyObject *) entry->thread_obj);
 428     }
 429
 430   return tuple;
 431 }
 432
 433 static PyObject *
 434 infpy_get_num (PyObject *self, void *closure)
 435 {
 436   inferior_object *inf = (inferior_object *) self;
 437
 438   INFPY_REQUIRE_VALID (inf);
 439
 440   return PyLong_FromLong (inf->inferior->num);
 441 }
 442
 443 static PyObject *
 444 infpy_get_pid (PyObject *self, void *closure)
 445 {
 446   inferior_object *inf = (inferior_object *) self;
 447
 448   INFPY_REQUIRE_VALID (inf);
 449
 450   return PyLong_FromLong (inf->inferior->pid);
 451 }
 452
 453 static PyObject *
 454 infpy_get_was_attached (PyObject *self, void *closure)
 455 {
 456   inferior_object *inf = (inferior_object *) self;
 457
 458   INFPY_REQUIRE_VALID (inf);
 459   if (inf->inferior->attach_flag)
 460     Py_RETURN_TRUE;
 461   Py_RETURN_FALSE;
 462 }
 463
 464 /* Getter of gdb.Inferior.progspace.  */
 465
 466 static PyObject *
 467 infpy_get_progspace (PyObject *self, void *closure)
 468 {
 469   inferior_object *inf = (inferior_object *) self;
 470
 471   INFPY_REQUIRE_VALID (inf);
 472
 473   program_space *pspace = inf->inferior->pspace;
 474   gdb_assert (pspace != nullptr);
 475
 476   return pspace_to_pspace_object (pspace).release ();
 477 }
 478
 479 static int
 480 build_inferior_list (struct inferior *inf, void *arg)
 481 {
 482   PyObject *list = (PyObject *) arg;
 483   gdbpy_ref<inferior_object> inferior (inferior_to_inferior_object (inf));
 484
 485   if (inferior == NULL)
 486     return 0;
 487
 488   return PyList_Append (list, (PyObject *) inferior.get ()) ? 1 : 0;
 489 }
 490
 491 /* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
 492    Returns a tuple of all inferiors.  */
 493 PyObject *
 494 gdbpy_inferiors (PyObject *unused, PyObject *unused2)
 495 {
 496   gdbpy_ref<> list (PyList_New (0));
 497   if (list == NULL)
 498     return NULL;
 499
 500   if (iterate_over_inferiors (build_inferior_list, list.get ()))
 501     return NULL;
 502
 503   return PyList_AsTuple (list.get ());
 504 }
 505
 506 /* Membuf and memory manipulation.  */
 507
 508 /* Implementation of Inferior.read_memory (address, length).
 509    Returns a Python buffer object with LENGTH bytes of the inferior's
 510    memory at ADDRESS.  Both arguments are integers.  Returns NULL on error,
 511    with a python exception set.  */
 512 static PyObject *
 513 infpy_read_memory (PyObject *self, PyObject *args, PyObject *kw)
 514 {
 515   CORE_ADDR addr, length;
 516   gdb_byte *buffer = NULL;
 517   PyObject *addr_obj, *length_obj, *result;
 518   static const char *keywords[] = { "address", "length", NULL };
 519
 520   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "OO", keywords,
 521                                         &addr_obj, &length_obj))
 522     return NULL;
 523
 524   if (get_addr_from_python (addr_obj, &addr) < 0
 525       || get_addr_from_python (length_obj, &length) < 0)
 526     return NULL;
 527
 528   TRY
 529     {
 530       buffer = (gdb_byte *) xmalloc (length);
 531
 532       read_memory (addr, buffer, length);
 533     }
 534   CATCH (except, RETURN_MASK_ALL)
 535     {
 536       xfree (buffer);
 537       GDB_PY_HANDLE_EXCEPTION (except);
 538     }
 539   END_CATCH
 540
 541   gdbpy_ref<membuf_object> membuf_obj (PyObject_New (membuf_object,
 542                                                      &membuf_object_type));
 543   if (membuf_obj == NULL)
 544     {
 545       xfree (buffer);
 546       return NULL;
 547     }
 548
 549   membuf_obj->buffer = buffer;
 550   membuf_obj->addr = addr;
 551   membuf_obj->length = length;
 552
 553 #ifdef IS_PY3K
 554   result = PyMemoryView_FromObject ((PyObject *) membuf_obj.get ());
 555 #else
 556   result = PyBuffer_FromReadWriteObject ((PyObject *) membuf_obj.get (), 0,
 557                                          Py_END_OF_BUFFER);
 558 #endif
 559
 560   return result;
 561 }
 562
 563 /* Implementation of Inferior.write_memory (address, buffer [, length]).
 564    Writes the contents of BUFFER (a Python object supporting the read
 565    buffer protocol) at ADDRESS in the inferior's memory.  Write LENGTH
 566    bytes from BUFFER, or its entire contents if the argument is not
 567    provided.  The function returns nothing.  Returns NULL on error, with
 568    a python exception set.  */
 569 static PyObject *
 570 infpy_write_memory (PyObject *self, PyObject *args, PyObject *kw)
 571 {
 572   struct gdb_exception except = exception_none;
 573   Py_ssize_t buf_len;
 574   const gdb_byte *buffer;
 575   CORE_ADDR addr, length;
 576   PyObject *addr_obj, *length_obj = NULL;
 577   static const char *keywords[] = { "address", "buffer", "length", NULL };
 578 #ifdef IS_PY3K
 579   Py_buffer pybuf;
 580
 581   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "Os*|O", keywords,
 582                                         &addr_obj, &pybuf, &length_obj))
 583     return NULL;
 584
 585   buffer = (const gdb_byte *) pybuf.buf;
 586   buf_len = pybuf.len;
 587 #else
 588   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "Os#|O", keywords,
 589                                         &addr_obj, &buffer, &buf_len,
 590                                         &length_obj))
 591     return NULL;
 592
 593   buffer = (const gdb_byte *) buffer;
 594 #endif
 595
 596   if (get_addr_from_python (addr_obj, &addr) < 0)
 597     goto fail;
 598
 599   if (!length_obj)
 600     length = buf_len;
 601   else if (get_addr_from_python (length_obj, &length) < 0)
 602     goto fail;
 603
 604   TRY
 605     {
 606       write_memory_with_notification (addr, buffer, length);
 607     }
 608   CATCH (ex, RETURN_MASK_ALL)
 609     {
 610       except = ex;
 611     }
 612   END_CATCH
 613
 614 #ifdef IS_PY3K
 615   PyBuffer_Release (&pybuf);
 616 #endif
 617   GDB_PY_HANDLE_EXCEPTION (except);
 618
 619   Py_RETURN_NONE;
 620
 621  fail:
 622 #ifdef IS_PY3K
 623   PyBuffer_Release (&pybuf);
 624 #endif
 625   return NULL;
 626 }
 627
 628 /* Destructor of Membuf objects.  */
 629 static void
 630 mbpy_dealloc (PyObject *self)
 631 {
 632   xfree (((membuf_object *) self)->buffer);
 633   Py_TYPE (self)->tp_free (self);
 634 }
 635
 636 /* Return a description of the Membuf object.  */
 637 static PyObject *
 638 mbpy_str (PyObject *self)
 639 {
 640   membuf_object *membuf_obj = (membuf_object *) self;
 641
 642   return PyString_FromFormat (_("Memory buffer for address %s, \
 643 which is %s bytes long."),
 644                               paddress (python_gdbarch, membuf_obj->addr),
 645                               pulongest (membuf_obj->length));
 646 }
 647
 648 #ifdef IS_PY3K
 649
 650 static int
 651 get_buffer (PyObject *self, Py_buffer *buf, int flags)
 652 {
 653   membuf_object *membuf_obj = (membuf_object *) self;
 654   int ret;
 655
 656   ret = PyBuffer_FillInfo (buf, self, membuf_obj->buffer,
 657                            membuf_obj->length, 0,
 658                            PyBUF_CONTIG);
 659
 660   /* Despite the documentation saying this field is a "const char *",
 661      in Python 3.4 at least, it's really a "char *".  */
 662   buf->format = (char *) "c";
 663
 664   return ret;
 665 }
 666
 667 #else
 668
 669 static Py_ssize_t
 670 get_read_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
 671 {
 672   membuf_object *membuf_obj = (membuf_object *) self;
 673
 674   if (segment)
 675     {
 676       PyErr_SetString (PyExc_SystemError,
 677                        _("The memory buffer supports only one segment."));
 678       return -1;
 679     }
 680
 681   *ptrptr = membuf_obj->buffer;
 682
 683   return membuf_obj->length;
 684 }
 685
 686 static Py_ssize_t
 687 get_write_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
 688 {
 689   return get_read_buffer (self, segment, ptrptr);
 690 }
 691
 692 static Py_ssize_t
 693 get_seg_count (PyObject *self, Py_ssize_t *lenp)
 694 {
 695   if (lenp)
 696     *lenp = ((membuf_object *) self)->length;
 697
 698   return 1;
 699 }
 700
 701 static Py_ssize_t
 702 get_char_buffer (PyObject *self, Py_ssize_t segment, char **ptrptr)
 703 {
 704   void *ptr = NULL;
 705   Py_ssize_t ret;
 706
 707   ret = get_read_buffer (self, segment, &ptr);
 708   *ptrptr = (char *) ptr;
 709
 710   return ret;
 711 }
 712
 713 #endif  /* IS_PY3K */
 714
 715 /* Implementation of
 716    gdb.search_memory (address, length, pattern).  ADDRESS is the
 717    address to start the search.  LENGTH specifies the scope of the
 718    search from ADDRESS.  PATTERN is the pattern to search for (and
 719    must be a Python object supporting the buffer protocol).
 720    Returns a Python Long object holding the address where the pattern
 721    was located, or if the pattern was not found, returns None.  Returns NULL
 722    on error, with a python exception set.  */
 723 static PyObject *
 724 infpy_search_memory (PyObject *self, PyObject *args, PyObject *kw)
 725 {
 726   struct gdb_exception except = exception_none;
 727   CORE_ADDR start_addr, length;
 728   static const char *keywords[] = { "address", "length", "pattern", NULL };
 729   PyObject *start_addr_obj, *length_obj;
 730   Py_ssize_t pattern_size;
 731   const gdb_byte *buffer;
 732   CORE_ADDR found_addr;
 733   int found = 0;
 734 #ifdef IS_PY3K
 735   Py_buffer pybuf;
 736
 737   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "OOs*", keywords,
 738                                         &start_addr_obj, &length_obj,
 739                                         &pybuf))
 740     return NULL;
 741
 742   buffer = (const gdb_byte *) pybuf.buf;
 743   pattern_size = pybuf.len;
 744 #else
 745   PyObject *pattern;
 746   const void *vbuffer;
 747
 748   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "OOO", keywords,
 749                                         &start_addr_obj, &length_obj,
 750                                         &pattern))
 751      return NULL;
 752
 753   if (!PyObject_CheckReadBuffer (pattern))
 754     {
 755       PyErr_SetString (PyExc_RuntimeError,
 756                        _("The pattern is not a Python buffer."));
 757
 758       return NULL;
 759     }
 760
 761   if (PyObject_AsReadBuffer (pattern, &vbuffer, &pattern_size) == -1)
 762     return NULL;
 763
 764   buffer = (const gdb_byte *) vbuffer;
 765 #endif
 766
 767   if (get_addr_from_python (start_addr_obj, &start_addr) < 0)
 768     goto fail;
 769
 770   if (get_addr_from_python (length_obj, &length) < 0)
 771     goto fail;
 772
 773   if (!length)
 774     {
 775       PyErr_SetString (PyExc_ValueError,
 776                        _("Search range is empty."));
 777       goto fail;
 778     }
 779   /* Watch for overflows.  */
 780   else if (length > CORE_ADDR_MAX
 781            || (start_addr + length - 1) < start_addr)
 782     {
 783       PyErr_SetString (PyExc_ValueError,
 784                        _("The search range is too large."));
 785       goto fail;
 786     }
 787
 788   TRY
 789     {
 790       found = target_search_memory (start_addr, length,
 791                                     buffer, pattern_size,
 792                                     &found_addr);
 793     }
 794   CATCH (ex, RETURN_MASK_ALL)
 795     {
 796       except = ex;
 797     }
 798   END_CATCH
 799
 800 #ifdef IS_PY3K
 801   PyBuffer_Release (&pybuf);
 802 #endif
 803   GDB_PY_HANDLE_EXCEPTION (except);
 804
 805   if (found)
 806     return PyLong_FromLong (found_addr);
 807   else
 808     Py_RETURN_NONE;
 809
 810  fail:
 811 #ifdef IS_PY3K
 812   PyBuffer_Release (&pybuf);
 813 #endif
 814   return NULL;
 815 }
 816
 817 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
 818    Returns True if this inferior object still exists in GDB.  */
 819
 820 static PyObject *
 821 infpy_is_valid (PyObject *self, PyObject *args)
 822 {
 823   inferior_object *inf = (inferior_object *) self;
 824
 825   if (! inf->inferior)
 826     Py_RETURN_FALSE;
 827
 828   Py_RETURN_TRUE;
 829 }
 830
 831 /* Implementation of gdb.Inferior.thread_from_thread_handle (self, handle)
 832                         ->  gdb.InferiorThread.  */
 833
 834 static PyObject *
 835 infpy_thread_from_thread_handle (PyObject *self, PyObject *args, PyObject *kw)
 836 {
 837   PyObject *handle_obj;
 838   inferior_object *inf_obj = (inferior_object *) self;
 839   static const char *keywords[] = { "thread_handle", NULL };
 840
 841   INFPY_REQUIRE_VALID (inf_obj);
 842
 843   if (! gdb_PyArg_ParseTupleAndKeywords (args, kw, "O", keywords, &handle_obj))
 844     return NULL;
 845
 846   if (!gdbpy_is_value_object (handle_obj))
 847     {
 848       PyErr_SetString (PyExc_TypeError,
 849                        _("Argument 'handle_obj' must be a thread handle object."));
 850
 851       return NULL;
 852     }
 853
 854   TRY
 855     {
 856       struct thread_info *thread_info;
 857       struct value *val = value_object_to_value (handle_obj);
 858
 859       thread_info = find_thread_by_handle (val, inf_obj->inferior);
 860       if (thread_info != NULL)
 861         return thread_to_thread_object (thread_info).release ();
 862     }
 863   CATCH (except, RETURN_MASK_ALL)
 864     {
 865       GDB_PY_HANDLE_EXCEPTION (except);
 866     }
 867   END_CATCH
 868
 869   Py_RETURN_NONE;
 870 }
 871
 872 /* Implement repr() for gdb.Inferior.  */
 873
 874 static PyObject *
 875 infpy_repr (PyObject *obj)
 876 {
 877   inferior_object *self = (inferior_object *) obj;
 878   inferior *inf = self->inferior;
 879
 880   if (inf == nullptr)
 881     return PyString_FromString ("<gdb.Inferior (invalid)>");
 882
 883   return PyString_FromFormat ("<gdb.Inferior num=%d, pid=%d>",
 884                               inf->num, inf->pid);
 885 }
 886
 887
 888 static void
 889 infpy_dealloc (PyObject *obj)
 890 {
 891   inferior_object *inf_obj = (inferior_object *) obj;
 892   struct inferior *inf = inf_obj->inferior;
 893
 894   if (! inf)
 895     return;
 896
 897   set_inferior_data (inf, infpy_inf_data_key, NULL);
 898 }
 899
 900 /* Clear the INFERIOR pointer in an Inferior object and clear the
 901    thread list.  */
 902 static void
 903 py_free_inferior (struct inferior *inf, void *datum)
 904 {
 905   gdbpy_ref<inferior_object> inf_obj ((inferior_object *) datum);
 906   struct threadlist_entry *th_entry, *th_tmp;
 907
 908   if (!gdb_python_initialized)
 909     return;
 910
 911   gdbpy_enter enter_py (python_gdbarch, python_language);
 912
 913   inf_obj->inferior = NULL;
 914
 915   /* Deallocate threads list.  */
 916   for (th_entry = inf_obj->threads; th_entry != NULL;)
 917     {
 918       Py_DECREF (th_entry->thread_obj);
 919
 920       th_tmp = th_entry;
 921       th_entry = th_entry->next;
 922       xfree (th_tmp);
 923     }
 924
 925   inf_obj->nthreads = 0;
 926 }
 927
 928 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
 929    Returns the current inferior object.  */
 930
 931 PyObject *
 932 gdbpy_selected_inferior (PyObject *self, PyObject *args)
 933 {
 934   return (PyObject *) inferior_to_inferior_object (current_inferior ());
 935 }
 936
 937 int
 938 gdbpy_initialize_inferior (void)
 939 {
 940   if (PyType_Ready (&inferior_object_type) < 0)
 941     return -1;
 942
 943   if (gdb_pymodule_addobject (gdb_module, "Inferior",
 944                               (PyObject *) &inferior_object_type) < 0)
 945     return -1;
 946
 947   infpy_inf_data_key =
 948     register_inferior_data_with_cleanup (NULL, py_free_inferior);
 949
 950   gdb::observers::new_thread.attach (add_thread_object);
 951   gdb::observers::thread_exit.attach (delete_thread_object);
 952   gdb::observers::normal_stop.attach (python_on_normal_stop);
 953   gdb::observers::target_resumed.attach (python_on_resume);
 954   gdb::observers::inferior_call_pre.attach (python_on_inferior_call_pre);
 955   gdb::observers::inferior_call_post.attach (python_on_inferior_call_post);
 956   gdb::observers::memory_changed.attach (python_on_memory_change);
 957   gdb::observers::register_changed.attach (python_on_register_change);
 958   gdb::observers::inferior_exit.attach (python_inferior_exit);
 959   gdb::observers::new_objfile.attach (python_new_objfile);
 960   gdb::observers::inferior_added.attach (python_new_inferior);
 961   gdb::observers::inferior_removed.attach (python_inferior_deleted);
 962
 963   membuf_object_type.tp_new = PyType_GenericNew;
 964   if (PyType_Ready (&membuf_object_type) < 0)
 965     return -1;
 966
 967   return gdb_pymodule_addobject (gdb_module, "Membuf", (PyObject *)
 968                                  &membuf_object_type);
 969 }
 970
 971 static gdb_PyGetSetDef inferior_object_getset[] =
 972 {
 973   { "num", infpy_get_num, NULL, "ID of inferior, as assigned by GDB.", NULL },
 974   { "pid", infpy_get_pid, NULL, "PID of inferior, as assigned by the OS.",
 975     NULL },
 976   { "was_attached", infpy_get_was_attached, NULL,
 977     "True if the inferior was created using 'attach'.", NULL },
 978   { "progspace", infpy_get_progspace, NULL, "Program space of this inferior" },
 979   { NULL }
 980 };
 981
 982 static PyMethodDef inferior_object_methods[] =
 983 {
 984   { "is_valid", infpy_is_valid, METH_NOARGS,
 985     "is_valid () -> Boolean.\n\
 986 Return true if this inferior is valid, false if not." },
 987   { "threads", infpy_threads, METH_NOARGS,
 988     "Return all the threads of this inferior." },
 989   { "read_memory", (PyCFunction) infpy_read_memory,
 990     METH_VARARGS | METH_KEYWORDS,
 991     "read_memory (address, length) -> buffer\n\
 992 Return a buffer object for reading from the inferior's memory." },
 993   { "write_memory", (PyCFunction) infpy_write_memory,
 994     METH_VARARGS | METH_KEYWORDS,
 995     "write_memory (address, buffer [, length])\n\
 996 Write the given buffer object to the inferior's memory." },
 997   { "search_memory", (PyCFunction) infpy_search_memory,
 998     METH_VARARGS | METH_KEYWORDS,
 999     "search_memory (address, length, pattern) -> long\n\
1000 Return a long with the address of a match, or None." },
1001   { "thread_from_thread_handle", (PyCFunction) infpy_thread_from_thread_handle,
1002     METH_VARARGS | METH_KEYWORDS,
1003     "thread_from_thread_handle (handle) -> gdb.InferiorThread.\n\
1004 Return thread object corresponding to thread handle." },
1005   { NULL }
1006 };
1007
1008 PyTypeObject inferior_object_type =
1009 {
1010   PyVarObject_HEAD_INIT (NULL, 0)
1011   "gdb.Inferior",                 /* tp_name */
1012   sizeof (inferior_object),       /* tp_basicsize */
1013   0,                              /* tp_itemsize */
1014   infpy_dealloc,                  /* tp_dealloc */
1015   0,                              /* tp_print */
1016   0,                              /* tp_getattr */
1017   0,                              /* tp_setattr */
1018   0,                              /* tp_compare */
1019   infpy_repr,                     /* tp_repr */
1020   0,                              /* tp_as_number */
1021   0,                              /* tp_as_sequence */
1022   0,                              /* tp_as_mapping */
1023   0,                              /* tp_hash  */
1024   0,                              /* tp_call */
1025   0,                              /* tp_str */
1026   0,                              /* tp_getattro */
1027   0,                              /* tp_setattro */
1028   0,                              /* tp_as_buffer */
1029   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /* tp_flags */
1030   "GDB inferior object",          /* tp_doc */
1031   0,                              /* tp_traverse */
1032   0,                              /* tp_clear */
1033   0,                              /* tp_richcompare */
1034   0,                              /* tp_weaklistoffset */
1035   0,                              /* tp_iter */
1036   0,                              /* tp_iternext */
1037   inferior_object_methods,        /* tp_methods */
1038   0,                              /* tp_members */
1039   inferior_object_getset,         /* tp_getset */
1040   0,                              /* tp_base */
1041   0,                              /* tp_dict */
1042   0,                              /* tp_descr_get */
1043   0,                              /* tp_descr_set */
1044   0,                              /* tp_dictoffset */
1045   0,                              /* tp_init */
1046   0                               /* tp_alloc */
1047 };
1048
1049 #ifdef IS_PY3K
1050
1051 static PyBufferProcs buffer_procs =
1052 {
1053   get_buffer
1054 };
1055
1056 #else
1057
1058 /* Python doesn't provide a decent way to get compatibility here.  */
1059 #if HAVE_LIBPYTHON2_4
1060 #define CHARBUFFERPROC_NAME getcharbufferproc
1061 #else
1062 #define CHARBUFFERPROC_NAME charbufferproc
1063 #endif
1064
1065 static PyBufferProcs buffer_procs = {
1066   get_read_buffer,
1067   get_write_buffer,
1068   get_seg_count,
1069   /* The cast here works around a difference between Python 2.4 and
1070      Python 2.5.  */
1071   (CHARBUFFERPROC_NAME) get_char_buffer
1072 };
1073 #endif  /* IS_PY3K */
1074
1075 PyTypeObject membuf_object_type = {
1076   PyVarObject_HEAD_INIT (NULL, 0)
1077   "gdb.Membuf",                   /*tp_name*/
1078   sizeof (membuf_object),         /*tp_basicsize*/
1079   0,                              /*tp_itemsize*/
1080   mbpy_dealloc,                   /*tp_dealloc*/
1081   0,                              /*tp_print*/
1082   0,                              /*tp_getattr*/
1083   0,                              /*tp_setattr*/
1084   0,                              /*tp_compare*/
1085   0,                              /*tp_repr*/
1086   0,                              /*tp_as_number*/
1087   0,                              /*tp_as_sequence*/
1088   0,                              /*tp_as_mapping*/
1089   0,                              /*tp_hash */
1090   0,                              /*tp_call*/
1091   mbpy_str,                       /*tp_str*/
1092   0,                              /*tp_getattro*/
1093   0,                              /*tp_setattro*/
1094   &buffer_procs,                  /*tp_as_buffer*/
1095   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
1096   "GDB memory buffer object",     /*tp_doc*/
1097   0,                              /* tp_traverse */
1098   0,                              /* tp_clear */
1099   0,                              /* tp_richcompare */
1100   0,                              /* tp_weaklistoffset */
1101   0,                              /* tp_iter */
1102   0,                              /* tp_iternext */
1103   0,                              /* tp_methods */
1104   0,                              /* tp_members */
1105   0,                              /* tp_getset */
1106   0,                              /* tp_base */
1107   0,                              /* tp_dict */
1108   0,                              /* tp_descr_get */
1109   0,                              /* tp_descr_set */
1110   0,                              /* tp_dictoffset */
1111   0,                              /* tp_init */
1112   0,                              /* tp_alloc */
1113 };