gdb/python/py-unwind.c

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