gdb/python/py-unwind.c

   1 /* Python frame unwinder interface.
   2
   3    Copyright (C) 2015-2019 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 "arch-utils.h"
  22 #include "frame-unwind.h"
  23 #include "gdb_obstack.h"
  24 #include "gdbcmd.h"
  25 #include "language.h"
  26 #include "observable.h"
  27 #include "python-internal.h"
  28 #include "regcache.h"
  29 #include "valprint.h"
  30 #include "user-regs.h"
  31
  32 #define TRACE_PY_UNWIND(level, args...) if (pyuw_debug >= level)  \
  33   { fprintf_unfiltered (gdb_stdlog, args); }
  34
  35 typedef struct
  36 {
  37   PyObject_HEAD
  38
  39   /* Frame we are unwinding.  */
  40   struct frame_info *frame_info;
  41
  42   /* Its architecture, passed by the sniffer caller.  */
  43   struct gdbarch *gdbarch;
  44 } pending_frame_object;
  45
  46 /* Saved registers array item.  */
  47
  48 struct saved_reg
  49 {
  50   saved_reg (int n, gdbpy_ref<> &&v)
  51     : number (n),
  52       value (std::move (v))
  53   {
  54   }
  55
  56   int number;
  57   gdbpy_ref<> value;
  58 };
  59
  60 /* The data we keep for the PyUnwindInfo: pending_frame, saved registers
  61    and frame ID.  */
  62
  63 typedef struct
  64 {
  65   PyObject_HEAD
  66
  67   /* gdb.PendingFrame for the frame we are unwinding.  */
  68   PyObject *pending_frame;
  69
  70   /* Its ID.  */
  71   struct frame_id frame_id;
  72
  73   /* Saved registers array.  */
  74   std::vector<saved_reg> *saved_regs;
  75 } unwind_info_object;
  76
  77 /* The data we keep for a frame we can unwind: frame ID and an array of
  78    (register_number, register_value) pairs.  */
  79
  80 typedef struct
  81 {
  82   /* Frame ID.  */
  83   struct frame_id frame_id;
  84
  85   /* GDB Architecture.  */
  86   struct gdbarch *gdbarch;
  87
  88   /* Length of the `reg' array below.  */
  89   int reg_count;
  90
  91   cached_reg_t reg[];
  92 } cached_frame_info;
  93
  94 extern PyTypeObject pending_frame_object_type
  95     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("pending_frame_object");
  96
  97 extern PyTypeObject unwind_info_object_type
  98     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("unwind_info_object");
  99
 100 static unsigned int pyuw_debug = 0;
 101
 102 static struct gdbarch_data *pyuw_gdbarch_data;
 103
 104 /* Parses register id, which can be either a number or a name.
 105    Returns 1 on success, 0 otherwise.  */
 106
 107 static int
 108 pyuw_parse_register_id (struct gdbarch *gdbarch, PyObject *pyo_reg_id,
 109                         int *reg_num)
 110 {
 111   if (pyo_reg_id == NULL)
 112     return 0;
 113   if (gdbpy_is_string (pyo_reg_id))
 114     {
 115       gdb::unique_xmalloc_ptr<char> reg_name (gdbpy_obj_to_string (pyo_reg_id));
 116
 117       if (reg_name == NULL)
 118         return 0;
 119       *reg_num = user_reg_map_name_to_regnum (gdbarch, reg_name.get (),
 120                                               strlen (reg_name.get ()));
 121       return *reg_num >= 0;
 122     }
 123   else if (PyInt_Check (pyo_reg_id))
 124     {
 125       long value;
 126       if (gdb_py_int_as_long (pyo_reg_id, &value) && (int) value == value)
 127         {
 128           *reg_num = (int) value;
 129           return user_reg_map_regnum_to_name (gdbarch, *reg_num) != NULL;
 130         }
 131     }
 132   return 0;
 133 }
 134
 135 /* Convert gdb.Value instance to inferior's pointer.  Return 1 on success,
 136    0 on failure.  */
 137
 138 static int
 139 pyuw_value_obj_to_pointer (PyObject *pyo_value, CORE_ADDR *addr)
 140 {
 141   int rc = 0;
 142   struct value *value;
 143
 144   TRY
 145     {
 146       if ((value = value_object_to_value (pyo_value)) != NULL)
 147         {
 148           *addr = unpack_pointer (value_type (value),
 149                                   value_contents (value));
 150           rc = 1;
 151         }
 152     }
 153   CATCH (except, RETURN_MASK_ALL)
 154     {
 155       gdbpy_convert_exception (except);
 156     }
 157   END_CATCH
 158   return rc;
 159 }
 160
 161 /* Get attribute from an object and convert it to the inferior's
 162    pointer value.  Return 1 if attribute exists and its value can be
 163    converted.  Otherwise, if attribute does not exist or its value is
 164    None, return 0.  In all other cases set Python error and return
 165    0.  */
 166
 167 static int
 168 pyuw_object_attribute_to_pointer (PyObject *pyo, const char *attr_name,
 169                                   CORE_ADDR *addr)
 170 {
 171   int rc = 0;
 172
 173   if (PyObject_HasAttrString (pyo, attr_name))
 174     {
 175       gdbpy_ref<> pyo_value (PyObject_GetAttrString (pyo, attr_name));
 176
 177       if (pyo_value != NULL && pyo_value != Py_None)
 178         {
 179           rc = pyuw_value_obj_to_pointer (pyo_value.get (), addr);
 180           if (!rc)
 181             PyErr_Format (
 182                 PyExc_ValueError,
 183                 _("The value of the '%s' attribute is not a pointer."),
 184                 attr_name);
 185         }
 186     }
 187   return rc;
 188 }
 189
 190 /* Called by the Python interpreter to obtain string representation
 191    of the UnwindInfo object.  */
 192
 193 static PyObject *
 194 unwind_infopy_str (PyObject *self)
 195 {
 196   unwind_info_object *unwind_info = (unwind_info_object *) self;
 197   string_file stb;
 198
 199   stb.puts ("Frame ID: ");
 200   fprint_frame_id (&stb, unwind_info->frame_id);
 201   {
 202     const char *sep = "";
 203     struct value_print_options opts;
 204
 205     get_user_print_options (&opts);
 206     stb.printf ("\nSaved registers: (");
 207     for (const saved_reg &reg : *unwind_info->saved_regs)
 208       {
 209         struct value *value = value_object_to_value (reg.value.get ());
 210
 211         stb.printf ("%s(%d, ", sep, reg.number);
 212         if (value != NULL)
 213           {
 214             TRY
 215               {
 216                 value_print (value, &stb, &opts);
 217                 stb.puts (")");
 218               }
 219             CATCH (except, RETURN_MASK_ALL)
 220               {
 221                 GDB_PY_HANDLE_EXCEPTION (except);
 222               }
 223             END_CATCH
 224           }
 225         else
 226           stb.puts ("<BAD>)");
 227         sep = ", ";
 228       }
 229     stb.puts (")");
 230   }
 231
 232   return PyString_FromString (stb.c_str ());
 233 }
 234
 235 /* Create UnwindInfo instance for given PendingFrame and frame ID.
 236    Sets Python error and returns NULL on error.  */
 237
 238 static PyObject *
 239 pyuw_create_unwind_info (PyObject *pyo_pending_frame,
 240                          struct frame_id frame_id)
 241 {
 242   unwind_info_object *unwind_info
 243       = PyObject_New (unwind_info_object, &unwind_info_object_type);
 244
 245   if (((pending_frame_object *) pyo_pending_frame)->frame_info == NULL)
 246     {
 247       PyErr_SetString (PyExc_ValueError,
 248                        "Attempting to use stale PendingFrame");
 249       return NULL;
 250     }
 251   unwind_info->frame_id = frame_id;
 252   Py_INCREF (pyo_pending_frame);
 253   unwind_info->pending_frame = pyo_pending_frame;
 254   unwind_info->saved_regs = new std::vector<saved_reg>;
 255   return (PyObject *) unwind_info;
 256 }
 257
 258 /* The implementation of
 259    gdb.UnwindInfo.add_saved_register (REG, VALUE) -> None.  */
 260
 261 static PyObject *
 262 unwind_infopy_add_saved_register (PyObject *self, PyObject *args)
 263 {
 264   unwind_info_object *unwind_info = (unwind_info_object *) self;
 265   pending_frame_object *pending_frame
 266       = (pending_frame_object *) (unwind_info->pending_frame);
 267   PyObject *pyo_reg_id;
 268   PyObject *pyo_reg_value;
 269   int regnum;
 270
 271   if (pending_frame->frame_info == NULL)
 272     {
 273       PyErr_SetString (PyExc_ValueError,
 274                        "UnwindInfo instance refers to a stale PendingFrame");
 275       return NULL;
 276     }
 277   if (!PyArg_UnpackTuple (args, "previous_frame_register", 2, 2,
 278                           &pyo_reg_id, &pyo_reg_value))
 279     return NULL;
 280   if (!pyuw_parse_register_id (pending_frame->gdbarch, pyo_reg_id, &regnum))
 281     {
 282       PyErr_SetString (PyExc_ValueError, "Bad register");
 283       return NULL;
 284     }
 285   {
 286     struct value *value;
 287     size_t data_size;
 288
 289     if (pyo_reg_value == NULL
 290       || (value = value_object_to_value (pyo_reg_value)) == NULL)
 291       {
 292         PyErr_SetString (PyExc_ValueError, "Bad register value");
 293         return NULL;
 294       }
 295     data_size = register_size (pending_frame->gdbarch, regnum);
 296     if (data_size != TYPE_LENGTH (value_type (value)))
 297       {
 298         PyErr_Format (
 299             PyExc_ValueError,
 300             "The value of the register returned by the Python "
 301             "sniffer has unexpected size: %u instead of %u.",
 302             (unsigned) TYPE_LENGTH (value_type (value)),
 303             (unsigned) data_size);
 304         return NULL;
 305       }
 306   }
 307   {
 308     gdbpy_ref<> new_value = gdbpy_ref<>::new_reference (pyo_reg_value);
 309     bool found = false;
 310     for (saved_reg &reg : *unwind_info->saved_regs)
 311       {
 312         if (regnum == reg.number)
 313           {
 314             found = true;
 315             reg.value = std::move (new_value);
 316             break;
 317           }
 318       }
 319     if (!found)
 320       unwind_info->saved_regs->emplace_back (regnum, std::move (new_value));
 321   }
 322   Py_RETURN_NONE;
 323 }
 324
 325 /* UnwindInfo cleanup.  */
 326
 327 static void
 328 unwind_infopy_dealloc (PyObject *self)
 329 {
 330   unwind_info_object *unwind_info = (unwind_info_object *) self;
 331
 332   Py_XDECREF (unwind_info->pending_frame);
 333   delete unwind_info->saved_regs;
 334   Py_TYPE (self)->tp_free (self);
 335 }
 336
 337 /* Called by the Python interpreter to obtain string representation
 338    of the PendingFrame object.  */
 339
 340 static PyObject *
 341 pending_framepy_str (PyObject *self)
 342 {
 343   struct frame_info *frame = ((pending_frame_object *) self)->frame_info;
 344   const char *sp_str = NULL;
 345   const char *pc_str = NULL;
 346
 347   if (frame == NULL)
 348     return PyString_FromString ("Stale PendingFrame instance");
 349   TRY
 350     {
 351       sp_str = core_addr_to_string_nz (get_frame_sp (frame));
 352       pc_str = core_addr_to_string_nz (get_frame_pc (frame));
 353     }
 354   CATCH (except, RETURN_MASK_ALL)
 355     {
 356       GDB_PY_HANDLE_EXCEPTION (except);
 357     }
 358   END_CATCH
 359
 360   return PyString_FromFormat ("SP=%s,PC=%s", sp_str, pc_str);
 361 }
 362
 363 /* Implementation of gdb.PendingFrame.read_register (self, reg) -> gdb.Value.
 364    Returns the value of register REG as gdb.Value instance.  */
 365
 366 static PyObject *
 367 pending_framepy_read_register (PyObject *self, PyObject *args)
 368 {
 369   pending_frame_object *pending_frame = (pending_frame_object *) self;
 370   struct value *val = NULL;
 371   int regnum;
 372   PyObject *pyo_reg_id;
 373
 374   if (pending_frame->frame_info == NULL)
 375     {
 376       PyErr_SetString (PyExc_ValueError,
 377                        "Attempting to read register from stale PendingFrame");
 378       return NULL;
 379     }
 380   if (!PyArg_UnpackTuple (args, "read_register", 1, 1, &pyo_reg_id))
 381     return NULL;
 382   if (!pyuw_parse_register_id (pending_frame->gdbarch, pyo_reg_id, &regnum))
 383     {
 384       PyErr_SetString (PyExc_ValueError, "Bad register");
 385       return NULL;
 386     }
 387
 388   TRY
 389     {
 390       /* Fetch the value associated with a register, whether it's
 391          a real register or a so called "user" register, like "pc",
 392          which maps to a real register.  In the past,
 393          get_frame_register_value() was used here, which did not
 394          handle the user register case.  */
 395       val = value_of_register (regnum, pending_frame->frame_info);
 396       if (val == NULL)
 397         PyErr_Format (PyExc_ValueError,
 398                       "Cannot read register %d from frame.",
 399                       regnum);
 400     }
 401   CATCH (except, RETURN_MASK_ALL)
 402     {
 403       GDB_PY_HANDLE_EXCEPTION (except);
 404     }
 405   END_CATCH
 406
 407   return val == NULL ? NULL : value_to_value_object (val);
 408 }
 409
 410 /* Implementation of
 411    PendingFrame.create_unwind_info (self, frameId) -> UnwindInfo.  */
 412
 413 static PyObject *
 414 pending_framepy_create_unwind_info (PyObject *self, PyObject *args)
 415 {
 416   PyObject *pyo_frame_id;
 417   CORE_ADDR sp;
 418   CORE_ADDR pc;
 419   CORE_ADDR special;
 420
 421   if (!PyArg_ParseTuple (args, "O:create_unwind_info", &pyo_frame_id))
 422       return NULL;
 423   if (!pyuw_object_attribute_to_pointer (pyo_frame_id, "sp", &sp))
 424     {
 425       PyErr_SetString (PyExc_ValueError,
 426                        _("frame_id should have 'sp' attribute."));
 427       return NULL;
 428     }
 429
 430   /* The logic of building frame_id depending on the attributes of
 431      the frame_id object:
 432      Has     Has    Has           Function to call
 433      'sp'?   'pc'?  'special'?
 434      ------|------|--------------|-------------------------
 435      Y       N      *             frame_id_build_wild (sp)
 436      Y       Y      N             frame_id_build (sp, pc)
 437      Y       Y      Y             frame_id_build_special (sp, pc, special)
 438   */
 439   if (!pyuw_object_attribute_to_pointer (pyo_frame_id, "pc", &pc))
 440     return pyuw_create_unwind_info (self, frame_id_build_wild (sp));
 441   if (!pyuw_object_attribute_to_pointer (pyo_frame_id, "special", &special))
 442     return pyuw_create_unwind_info (self, frame_id_build (sp, pc));
 443   else
 444     return pyuw_create_unwind_info (self,
 445                                     frame_id_build_special (sp, pc, special));
 446 }
 447
 448 /* frame_unwind.this_id method.  */
 449
 450 static void
 451 pyuw_this_id (struct frame_info *this_frame, void **cache_ptr,
 452               struct frame_id *this_id)
 453 {
 454   *this_id = ((cached_frame_info *) *cache_ptr)->frame_id;
 455   if (pyuw_debug >= 1)
 456     {
 457       fprintf_unfiltered (gdb_stdlog, "%s: frame_id: ", __FUNCTION__);
 458       fprint_frame_id (gdb_stdlog, *this_id);
 459       fprintf_unfiltered (gdb_stdlog, "\n");
 460     }
 461 }
 462
 463 /* frame_unwind.prev_register.  */
 464
 465 static struct value *
 466 pyuw_prev_register (struct frame_info *this_frame, void **cache_ptr,
 467                     int regnum)
 468 {
 469   cached_frame_info *cached_frame = (cached_frame_info *) *cache_ptr;
 470   cached_reg_t *reg_info = cached_frame->reg;
 471   cached_reg_t *reg_info_end = reg_info + cached_frame->reg_count;
 472
 473   TRACE_PY_UNWIND (1, "%s (frame=%p,...,reg=%d)\n", __FUNCTION__, this_frame,
 474                    regnum);
 475   for (; reg_info < reg_info_end; ++reg_info)
 476     {
 477       if (regnum == reg_info->num)
 478         return frame_unwind_got_bytes (this_frame, regnum, reg_info->data);
 479     }
 480
 481   return frame_unwind_got_optimized (this_frame, regnum);
 482 }
 483
 484 /* Frame sniffer dispatch.  */
 485
 486 static int
 487 pyuw_sniffer (const struct frame_unwind *self, struct frame_info *this_frame,
 488               void **cache_ptr)
 489 {
 490   struct gdbarch *gdbarch = (struct gdbarch *) (self->unwind_data);
 491   cached_frame_info *cached_frame;
 492
 493   gdbpy_enter enter_py (gdbarch, current_language);
 494
 495   TRACE_PY_UNWIND (3, "%s (SP=%s, PC=%s)\n", __FUNCTION__,
 496                    paddress (gdbarch, get_frame_sp (this_frame)),
 497                    paddress (gdbarch, get_frame_pc (this_frame)));
 498
 499   /* Create PendingFrame instance to pass to sniffers.  */
 500   pending_frame_object *pfo = PyObject_New (pending_frame_object,
 501                                             &pending_frame_object_type);
 502   gdbpy_ref<> pyo_pending_frame ((PyObject *) pfo);
 503   if (pyo_pending_frame == NULL)
 504     {
 505       gdbpy_print_stack ();
 506       return 0;
 507     }
 508   pfo->gdbarch = gdbarch;
 509   scoped_restore invalidate_frame = make_scoped_restore (&pfo->frame_info,
 510                                                          this_frame);
 511
 512   /* Run unwinders.  */
 513   if (gdb_python_module == NULL
 514       || ! PyObject_HasAttrString (gdb_python_module, "execute_unwinders"))
 515     {
 516       PyErr_SetString (PyExc_NameError,
 517                        "Installation error: gdb.execute_unwinders function "
 518                        "is missing");
 519       gdbpy_print_stack ();
 520       return 0;
 521     }
 522   gdbpy_ref<> pyo_execute (PyObject_GetAttrString (gdb_python_module,
 523                                                    "execute_unwinders"));
 524   if (pyo_execute == NULL)
 525     {
 526       gdbpy_print_stack ();
 527       return 0;
 528     }
 529
 530   gdbpy_ref<> pyo_unwind_info
 531     (PyObject_CallFunctionObjArgs (pyo_execute.get (),
 532                                    pyo_pending_frame.get (), NULL));
 533   if (pyo_unwind_info == NULL)
 534     {
 535       /* If the unwinder is cancelled due to a Ctrl-C, then propagate
 536          the Ctrl-C as a GDB exception instead of swallowing it.  */
 537       gdbpy_print_stack_or_quit ();
 538       return 0;
 539     }
 540   if (pyo_unwind_info == Py_None)
 541     return 0;
 542
 543   /* Received UnwindInfo, cache data.  */
 544   if (PyObject_IsInstance (pyo_unwind_info.get (),
 545                            (PyObject *) &unwind_info_object_type) <= 0)
 546     error (_("A Unwinder should return gdb.UnwindInfo instance."));
 547
 548   {
 549     unwind_info_object *unwind_info =
 550       (unwind_info_object *) pyo_unwind_info.get ();
 551     int reg_count = unwind_info->saved_regs->size ();
 552
 553     cached_frame
 554       = ((cached_frame_info *)
 555          xmalloc (sizeof (*cached_frame)
 556                   + reg_count * sizeof (cached_frame->reg[0])));
 557     cached_frame->gdbarch = gdbarch;
 558     cached_frame->frame_id = unwind_info->frame_id;
 559     cached_frame->reg_count = reg_count;
 560
 561     /* Populate registers array.  */
 562     for (int i = 0; i < unwind_info->saved_regs->size (); ++i)
 563       {
 564         saved_reg *reg = &(*unwind_info->saved_regs)[i];
 565
 566         struct value *value = value_object_to_value (reg->value.get ());
 567         size_t data_size = register_size (gdbarch, reg->number);
 568
 569         cached_frame->reg[i].num = reg->number;
 570
 571         /* `value' validation was done before, just assert.  */
 572         gdb_assert (value != NULL);
 573         gdb_assert (data_size == TYPE_LENGTH (value_type (value)));
 574
 575         cached_frame->reg[i].data = (gdb_byte *) xmalloc (data_size);
 576         memcpy (cached_frame->reg[i].data, value_contents (value), data_size);
 577       }
 578   }
 579
 580   *cache_ptr = cached_frame;
 581   return 1;
 582 }
 583
 584 /* Frame cache release shim.  */
 585
 586 static void
 587 pyuw_dealloc_cache (struct frame_info *this_frame, void *cache)
 588 {
 589   TRACE_PY_UNWIND (3, "%s: enter", __FUNCTION__);
 590   cached_frame_info *cached_frame = (cached_frame_info *) cache;
 591
 592   for (int i = 0; i < cached_frame->reg_count; i++)
 593     xfree (cached_frame->reg[i].data);
 594
 595   xfree (cache);
 596 }
 597
 598 struct pyuw_gdbarch_data_type
 599 {
 600   /* Has the unwinder shim been prepended? */
 601   int unwinder_registered;
 602 };
 603
 604 static void *
 605 pyuw_gdbarch_data_init (struct gdbarch *gdbarch)
 606 {
 607   return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct pyuw_gdbarch_data_type);
 608 }
 609
 610 /* New inferior architecture callback: register the Python unwinders
 611    intermediary.  */
 612
 613 static void
 614 pyuw_on_new_gdbarch (struct gdbarch *newarch)
 615 {
 616   struct pyuw_gdbarch_data_type *data
 617     = (struct pyuw_gdbarch_data_type *) gdbarch_data (newarch,
 618                                                       pyuw_gdbarch_data);
 619
 620   if (!data->unwinder_registered)
 621     {
 622       struct frame_unwind *unwinder
 623           = GDBARCH_OBSTACK_ZALLOC (newarch, struct frame_unwind);
 624
 625       unwinder->type = NORMAL_FRAME;
 626       unwinder->stop_reason = default_frame_unwind_stop_reason;
 627       unwinder->this_id = pyuw_this_id;
 628       unwinder->prev_register = pyuw_prev_register;
 629       unwinder->unwind_data = (const struct frame_data *) newarch;
 630       unwinder->sniffer = pyuw_sniffer;
 631       unwinder->dealloc_cache = pyuw_dealloc_cache;
 632       frame_unwind_prepend_unwinder (newarch, unwinder);
 633       data->unwinder_registered = 1;
 634     }
 635 }
 636
 637 /* Initialize unwind machinery.  */
 638
 639 int
 640 gdbpy_initialize_unwind (void)
 641 {
 642   int rc;
 643   add_setshow_zuinteger_cmd
 644       ("py-unwind", class_maintenance, &pyuw_debug,
 645         _("Set Python unwinder debugging."),
 646         _("Show Python unwinder debugging."),
 647         _("When non-zero, Python unwinder debugging is enabled."),
 648         NULL,
 649         NULL,
 650         &setdebuglist, &showdebuglist);
 651   pyuw_gdbarch_data
 652       = gdbarch_data_register_post_init (pyuw_gdbarch_data_init);
 653   gdb::observers::architecture_changed.attach (pyuw_on_new_gdbarch);
 654
 655   if (PyType_Ready (&pending_frame_object_type) < 0)
 656     return -1;
 657   rc = gdb_pymodule_addobject (gdb_module, "PendingFrame",
 658       (PyObject *) &pending_frame_object_type);
 659   if (rc)
 660     return rc;
 661
 662   if (PyType_Ready (&unwind_info_object_type) < 0)
 663     return -1;
 664   return gdb_pymodule_addobject (gdb_module, "UnwindInfo",
 665       (PyObject *) &unwind_info_object_type);
 666 }
 667
 668 static PyMethodDef pending_frame_object_methods[] =
 669 {
 670   { "read_register", pending_framepy_read_register, METH_VARARGS,
 671     "read_register (REG) -> gdb.Value\n"
 672     "Return the value of the REG in the frame." },
 673   { "create_unwind_info",
 674     pending_framepy_create_unwind_info, METH_VARARGS,
 675     "create_unwind_info (FRAME_ID) -> gdb.UnwindInfo\n"
 676     "Construct UnwindInfo for this PendingFrame, using FRAME_ID\n"
 677     "to identify it." },
 678   {NULL}  /* Sentinel */
 679 };
 680
 681 PyTypeObject pending_frame_object_type =
 682 {
 683   PyVarObject_HEAD_INIT (NULL, 0)
 684   "gdb.PendingFrame",             /* tp_name */
 685   sizeof (pending_frame_object),  /* tp_basicsize */
 686   0,                              /* tp_itemsize */
 687   0,                              /* tp_dealloc */
 688   0,                              /* tp_print */
 689   0,                              /* tp_getattr */
 690   0,                              /* tp_setattr */
 691   0,                              /* tp_compare */
 692   0,                              /* tp_repr */
 693   0,                              /* tp_as_number */
 694   0,                              /* tp_as_sequence */
 695   0,                              /* tp_as_mapping */
 696   0,                              /* tp_hash  */
 697   0,                              /* tp_call */
 698   pending_framepy_str,            /* tp_str */
 699   0,                              /* tp_getattro */
 700   0,                              /* tp_setattro */
 701   0,                              /* tp_as_buffer */
 702   Py_TPFLAGS_DEFAULT,             /* tp_flags */
 703   "GDB PendingFrame object",      /* tp_doc */
 704   0,                              /* tp_traverse */
 705   0,                              /* tp_clear */
 706   0,                              /* tp_richcompare */
 707   0,                              /* tp_weaklistoffset */
 708   0,                              /* tp_iter */
 709   0,                              /* tp_iternext */
 710   pending_frame_object_methods,   /* tp_methods */
 711   0,                              /* tp_members */
 712   0,                              /* tp_getset */
 713   0,                              /* tp_base */
 714   0,                              /* tp_dict */
 715   0,                              /* tp_descr_get */
 716   0,                              /* tp_descr_set */
 717   0,                              /* tp_dictoffset */
 718   0,                              /* tp_init */
 719   0,                              /* tp_alloc */
 720 };
 721
 722 static PyMethodDef unwind_info_object_methods[] =
 723 {
 724   { "add_saved_register",
 725     unwind_infopy_add_saved_register, METH_VARARGS,
 726     "add_saved_register (REG, VALUE) -> None\n"
 727     "Set the value of the REG in the previous frame to VALUE." },
 728   { NULL }  /* Sentinel */
 729 };
 730
 731 PyTypeObject unwind_info_object_type =
 732 {
 733   PyVarObject_HEAD_INIT (NULL, 0)
 734   "gdb.UnwindInfo",               /* tp_name */
 735   sizeof (unwind_info_object),    /* tp_basicsize */
 736   0,                              /* tp_itemsize */
 737   unwind_infopy_dealloc,          /* tp_dealloc */
 738   0,                              /* tp_print */
 739   0,                              /* tp_getattr */
 740   0,                              /* tp_setattr */
 741   0,                              /* tp_compare */
 742   0,                              /* tp_repr */
 743   0,                              /* tp_as_number */
 744   0,                              /* tp_as_sequence */
 745   0,                              /* tp_as_mapping */
 746   0,                              /* tp_hash  */
 747   0,                              /* tp_call */
 748   unwind_infopy_str,              /* tp_str */
 749   0,                              /* tp_getattro */
 750   0,                              /* tp_setattro */
 751   0,                              /* tp_as_buffer */
 752   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /* tp_flags */
 753   "GDB UnwindInfo object",        /* tp_doc */
 754   0,                              /* tp_traverse */
 755   0,                              /* tp_clear */
 756   0,                              /* tp_richcompare */
 757   0,                              /* tp_weaklistoffset */
 758   0,                              /* tp_iter */
 759   0,                              /* tp_iternext */
 760   unwind_info_object_methods,     /* tp_methods */
 761   0,                              /* tp_members */
 762   0,                              /* tp_getset */
 763   0,                              /* tp_base */
 764   0,                              /* tp_dict */
 765   0,                              /* tp_descr_get */
 766   0,                              /* tp_descr_set */
 767   0,                              /* tp_dictoffset */
 768   0,                              /* tp_init */
 769   0,                              /* tp_alloc */
 770 };