gdb/python/py-inferior.c

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