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   int i;
 333   saved_reg *reg;
 334
 335   Py_XDECREF (unwind_info->pending_frame);
 336   delete unwind_info->saved_regs;
 337   Py_TYPE (self)->tp_free (self);
 338 }
 339
 340 /* Called by the Python interpreter to obtain string representation
 341    of the PendingFrame object.  */
 342
 343 static PyObject *
 344 pending_framepy_str (PyObject *self)
 345 {
 346   struct frame_info *frame = ((pending_frame_object *) self)->frame_info;
 347   const char *sp_str = NULL;
 348   const char *pc_str = NULL;
 349
 350   if (frame == NULL)
 351     return PyString_FromString ("Stale PendingFrame instance");
 352   TRY
 353     {
 354       sp_str = core_addr_to_string_nz (get_frame_sp (frame));
 355       pc_str = core_addr_to_string_nz (get_frame_pc (frame));
 356     }
 357   CATCH (except, RETURN_MASK_ALL)
 358     {
 359       GDB_PY_HANDLE_EXCEPTION (except);
 360     }
 361   END_CATCH
 362
 363   return PyString_FromFormat ("SP=%s,PC=%s", sp_str, pc_str);
 364 }
 365
 366 /* Implementation of gdb.PendingFrame.read_register (self, reg) -> gdb.Value.
 367    Returns the value of register REG as gdb.Value instance.  */
 368
 369 static PyObject *
 370 pending_framepy_read_register (PyObject *self, PyObject *args)
 371 {
 372   pending_frame_object *pending_frame = (pending_frame_object *) self;
 373   struct value *val = NULL;
 374   int regnum;
 375   PyObject *pyo_reg_id;
 376
 377   if (pending_frame->frame_info == NULL)
 378     {
 379       PyErr_SetString (PyExc_ValueError,
 380                        "Attempting to read register from stale PendingFrame");
 381       return NULL;
 382     }
 383   if (!PyArg_UnpackTuple (args, "read_register", 1, 1, &pyo_reg_id))
 384     return NULL;
 385   if (!pyuw_parse_register_id (pending_frame->gdbarch, pyo_reg_id, &regnum))
 386     {
 387       PyErr_SetString (PyExc_ValueError, "Bad register");
 388       return NULL;
 389     }
 390
 391   TRY
 392     {
 393       /* Fetch the value associated with a register, whether it's
 394          a real register or a so called "user" register, like "pc",
 395          which maps to a real register.  In the past,
 396          get_frame_register_value() was used here, which did not
 397          handle the user register case.  */
 398       val = value_of_register (regnum, pending_frame->frame_info);
 399       if (val == NULL)
 400         PyErr_Format (PyExc_ValueError,
 401                       "Cannot read register %d from frame.",
 402                       regnum);
 403     }
 404   CATCH (except, RETURN_MASK_ALL)
 405     {
 406       GDB_PY_HANDLE_EXCEPTION (except);
 407     }
 408   END_CATCH
 409
 410   return val == NULL ? NULL : value_to_value_object (val);
 411 }
 412
 413 /* Implementation of
 414    PendingFrame.create_unwind_info (self, frameId) -> UnwindInfo.  */
 415
 416 static PyObject *
 417 pending_framepy_create_unwind_info (PyObject *self, PyObject *args)
 418 {
 419   PyObject *pyo_frame_id;
 420   CORE_ADDR sp;
 421   CORE_ADDR pc;
 422   CORE_ADDR special;
 423
 424   if (!PyArg_ParseTuple (args, "O:create_unwind_info", &pyo_frame_id))
 425       return NULL;
 426   if (!pyuw_object_attribute_to_pointer (pyo_frame_id, "sp", &sp))
 427     {
 428       PyErr_SetString (PyExc_ValueError,
 429                        _("frame_id should have 'sp' attribute."));
 430       return NULL;
 431     }
 432
 433   /* The logic of building frame_id depending on the attributes of
 434      the frame_id object:
 435      Has     Has    Has           Function to call
 436      'sp'?   'pc'?  'special'?
 437      ------|------|--------------|-------------------------
 438      Y       N      *             frame_id_build_wild (sp)
 439      Y       Y      N             frame_id_build (sp, pc)
 440      Y       Y      Y             frame_id_build_special (sp, pc, special)
 441   */
 442   if (!pyuw_object_attribute_to_pointer (pyo_frame_id, "pc", &pc))
 443     return pyuw_create_unwind_info (self, frame_id_build_wild (sp));
 444   if (!pyuw_object_attribute_to_pointer (pyo_frame_id, "special", &special))
 445     return pyuw_create_unwind_info (self, frame_id_build (sp, pc));
 446   else
 447     return pyuw_create_unwind_info (self,
 448                                     frame_id_build_special (sp, pc, special));
 449 }
 450
 451 /* frame_unwind.this_id method.  */
 452
 453 static void
 454 pyuw_this_id (struct frame_info *this_frame, void **cache_ptr,
 455               struct frame_id *this_id)
 456 {
 457   *this_id = ((cached_frame_info *) *cache_ptr)->frame_id;
 458   if (pyuw_debug >= 1)
 459     {
 460       fprintf_unfiltered (gdb_stdlog, "%s: frame_id: ", __FUNCTION__);
 461       fprint_frame_id (gdb_stdlog, *this_id);
 462       fprintf_unfiltered (gdb_stdlog, "\n");
 463     }
 464 }
 465
 466 /* frame_unwind.prev_register.  */
 467
 468 static struct value *
 469 pyuw_prev_register (struct frame_info *this_frame, void **cache_ptr,
 470                     int regnum)
 471 {
 472   cached_frame_info *cached_frame = (cached_frame_info *) *cache_ptr;
 473   cached_reg_t *reg_info = cached_frame->reg;
 474   cached_reg_t *reg_info_end = reg_info + cached_frame->reg_count;
 475
 476   TRACE_PY_UNWIND (1, "%s (frame=%p,...,reg=%d)\n", __FUNCTION__, this_frame,
 477                    regnum);
 478   for (; reg_info < reg_info_end; ++reg_info)
 479     {
 480       if (regnum == reg_info->num)
 481         return frame_unwind_got_bytes (this_frame, regnum, reg_info->data);
 482     }
 483
 484   return frame_unwind_got_optimized (this_frame, regnum);
 485 }
 486
 487 /* Frame sniffer dispatch.  */
 488
 489 static int
 490 pyuw_sniffer (const struct frame_unwind *self, struct frame_info *this_frame,
 491               void **cache_ptr)
 492 {
 493   struct gdbarch *gdbarch = (struct gdbarch *) (self->unwind_data);
 494   cached_frame_info *cached_frame;
 495
 496   gdbpy_enter enter_py (gdbarch, current_language);
 497
 498   TRACE_PY_UNWIND (3, "%s (SP=%s, PC=%s)\n", __FUNCTION__,
 499                    paddress (gdbarch, get_frame_sp (this_frame)),
 500                    paddress (gdbarch, get_frame_pc (this_frame)));
 501
 502   /* Create PendingFrame instance to pass to sniffers.  */
 503   pending_frame_object *pfo = PyObject_New (pending_frame_object,
 504                                             &pending_frame_object_type);
 505   gdbpy_ref<> pyo_pending_frame ((PyObject *) pfo);
 506   if (pyo_pending_frame == NULL)
 507     {
 508       gdbpy_print_stack ();
 509       return 0;
 510     }
 511   pfo->gdbarch = gdbarch;
 512   scoped_restore invalidate_frame = make_scoped_restore (&pfo->frame_info,
 513                                                          this_frame);
 514
 515   /* Run unwinders.  */
 516   if (gdb_python_module == NULL
 517       || ! PyObject_HasAttrString (gdb_python_module, "execute_unwinders"))
 518     {
 519       PyErr_SetString (PyExc_NameError,
 520                        "Installation error: gdb.execute_unwinders function "
 521                        "is missing");
 522       gdbpy_print_stack ();
 523       return 0;
 524     }
 525   gdbpy_ref<> pyo_execute (PyObject_GetAttrString (gdb_python_module,
 526                                                    "execute_unwinders"));
 527   if (pyo_execute == NULL)
 528     {
 529       gdbpy_print_stack ();
 530       return 0;
 531     }
 532
 533   gdbpy_ref<> pyo_unwind_info
 534     (PyObject_CallFunctionObjArgs (pyo_execute.get (),
 535                                    pyo_pending_frame.get (), NULL));
 536   if (pyo_unwind_info == NULL)
 537     {
 538       /* If the unwinder is cancelled due to a Ctrl-C, then propagate
 539          the Ctrl-C as a GDB exception instead of swallowing it.  */
 540       if (PyErr_ExceptionMatches (PyExc_KeyboardInterrupt))
 541         {
 542           PyErr_Clear ();
 543           quit ();
 544         }
 545       gdbpy_print_stack ();
 546       return 0;
 547     }
 548   if (pyo_unwind_info == Py_None)
 549     return 0;
 550
 551   /* Received UnwindInfo, cache data.  */
 552   if (PyObject_IsInstance (pyo_unwind_info.get (),
 553                            (PyObject *) &unwind_info_object_type) <= 0)
 554     error (_("A Unwinder should return gdb.UnwindInfo instance."));
 555
 556   {
 557     unwind_info_object *unwind_info =
 558       (unwind_info_object *) pyo_unwind_info.get ();
 559     int reg_count = unwind_info->saved_regs->size ();
 560
 561     cached_frame
 562       = ((cached_frame_info *)
 563          xmalloc (sizeof (*cached_frame)
 564                   + reg_count * sizeof (cached_frame->reg[0])));
 565     cached_frame->gdbarch = gdbarch;
 566     cached_frame->frame_id = unwind_info->frame_id;
 567     cached_frame->reg_count = reg_count;
 568
 569     /* Populate registers array.  */
 570     for (int i = 0; i < unwind_info->saved_regs->size (); ++i)
 571       {
 572         saved_reg *reg = &(*unwind_info->saved_regs)[i];
 573
 574         struct value *value = value_object_to_value (reg->value.get ());
 575         size_t data_size = register_size (gdbarch, reg->number);
 576
 577         cached_frame->reg[i].num = reg->number;
 578
 579         /* `value' validation was done before, just assert.  */
 580         gdb_assert (value != NULL);
 581         gdb_assert (data_size == TYPE_LENGTH (value_type (value)));
 582
 583         cached_frame->reg[i].data = (gdb_byte *) xmalloc (data_size);
 584         memcpy (cached_frame->reg[i].data, value_contents (value), data_size);
 585       }
 586   }
 587
 588   *cache_ptr = cached_frame;
 589   return 1;
 590 }
 591
 592 /* Frame cache release shim.  */
 593
 594 static void
 595 pyuw_dealloc_cache (struct frame_info *this_frame, void *cache)
 596 {
 597   TRACE_PY_UNWIND (3, "%s: enter", __FUNCTION__);
 598   cached_frame_info *cached_frame = (cached_frame_info *) cache;
 599
 600   for (int i = 0; i < cached_frame->reg_count; i++)
 601     xfree (cached_frame->reg[i].data);
 602
 603   xfree (cache);
 604 }
 605
 606 struct pyuw_gdbarch_data_type
 607 {
 608   /* Has the unwinder shim been prepended? */
 609   int unwinder_registered;
 610 };
 611
 612 static void *
 613 pyuw_gdbarch_data_init (struct gdbarch *gdbarch)
 614 {
 615   return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct pyuw_gdbarch_data_type);
 616 }
 617
 618 /* New inferior architecture callback: register the Python unwinders
 619    intermediary.  */
 620
 621 static void
 622 pyuw_on_new_gdbarch (struct gdbarch *newarch)
 623 {
 624   struct pyuw_gdbarch_data_type *data
 625     = (struct pyuw_gdbarch_data_type *) gdbarch_data (newarch,
 626                                                       pyuw_gdbarch_data);
 627
 628   if (!data->unwinder_registered)
 629     {
 630       struct frame_unwind *unwinder
 631           = GDBARCH_OBSTACK_ZALLOC (newarch, struct frame_unwind);
 632
 633       unwinder->type = NORMAL_FRAME;
 634       unwinder->stop_reason = default_frame_unwind_stop_reason;
 635       unwinder->this_id = pyuw_this_id;
 636       unwinder->prev_register = pyuw_prev_register;
 637       unwinder->unwind_data = (const struct frame_data *) newarch;
 638       unwinder->sniffer = pyuw_sniffer;
 639       unwinder->dealloc_cache = pyuw_dealloc_cache;
 640       frame_unwind_prepend_unwinder (newarch, unwinder);
 641       data->unwinder_registered = 1;
 642     }
 643 }
 644
 645 /* Initialize unwind machinery.  */
 646
 647 int
 648 gdbpy_initialize_unwind (void)
 649 {
 650   int rc;
 651   add_setshow_zuinteger_cmd
 652       ("py-unwind", class_maintenance, &pyuw_debug,
 653         _("Set Python unwinder debugging."),
 654         _("Show Python unwinder debugging."),
 655         _("When non-zero, Python unwinder debugging is enabled."),
 656         NULL,
 657         NULL,
 658         &setdebuglist, &showdebuglist);
 659   pyuw_gdbarch_data
 660       = gdbarch_data_register_post_init (pyuw_gdbarch_data_init);
 661   gdb::observers::architecture_changed.attach (pyuw_on_new_gdbarch);
 662
 663   if (PyType_Ready (&pending_frame_object_type) < 0)
 664     return -1;
 665   rc = gdb_pymodule_addobject (gdb_module, "PendingFrame",
 666       (PyObject *) &pending_frame_object_type);
 667   if (rc)
 668     return rc;
 669
 670   if (PyType_Ready (&unwind_info_object_type) < 0)
 671     return -1;
 672   return gdb_pymodule_addobject (gdb_module, "UnwindInfo",
 673       (PyObject *) &unwind_info_object_type);
 674 }
 675
 676 static PyMethodDef pending_frame_object_methods[] =
 677 {
 678   { "read_register", pending_framepy_read_register, METH_VARARGS,
 679     "read_register (REG) -> gdb.Value\n"
 680     "Return the value of the REG in the frame." },
 681   { "create_unwind_info",
 682     pending_framepy_create_unwind_info, METH_VARARGS,
 683     "create_unwind_info (FRAME_ID) -> gdb.UnwindInfo\n"
 684     "Construct UnwindInfo for this PendingFrame, using FRAME_ID\n"
 685     "to identify it." },
 686   {NULL}  /* Sentinel */
 687 };
 688
 689 PyTypeObject pending_frame_object_type =
 690 {
 691   PyVarObject_HEAD_INIT (NULL, 0)
 692   "gdb.PendingFrame",             /* tp_name */
 693   sizeof (pending_frame_object),  /* tp_basicsize */
 694   0,                              /* tp_itemsize */
 695   0,                              /* tp_dealloc */
 696   0,                              /* tp_print */
 697   0,                              /* tp_getattr */
 698   0,                              /* tp_setattr */
 699   0,                              /* tp_compare */
 700   0,                              /* tp_repr */
 701   0,                              /* tp_as_number */
 702   0,                              /* tp_as_sequence */
 703   0,                              /* tp_as_mapping */
 704   0,                              /* tp_hash  */
 705   0,                              /* tp_call */
 706   pending_framepy_str,            /* tp_str */
 707   0,                              /* tp_getattro */
 708   0,                              /* tp_setattro */
 709   0,                              /* tp_as_buffer */
 710   Py_TPFLAGS_DEFAULT,             /* tp_flags */
 711   "GDB PendingFrame object",      /* tp_doc */
 712   0,                              /* tp_traverse */
 713   0,                              /* tp_clear */
 714   0,                              /* tp_richcompare */
 715   0,                              /* tp_weaklistoffset */
 716   0,                              /* tp_iter */
 717   0,                              /* tp_iternext */
 718   pending_frame_object_methods,   /* tp_methods */
 719   0,                              /* tp_members */
 720   0,                              /* tp_getset */
 721   0,                              /* tp_base */
 722   0,                              /* tp_dict */
 723   0,                              /* tp_descr_get */
 724   0,                              /* tp_descr_set */
 725   0,                              /* tp_dictoffset */
 726   0,                              /* tp_init */
 727   0,                              /* tp_alloc */
 728 };
 729
 730 static PyMethodDef unwind_info_object_methods[] =
 731 {
 732   { "add_saved_register",
 733     unwind_infopy_add_saved_register, METH_VARARGS,
 734     "add_saved_register (REG, VALUE) -> None\n"
 735     "Set the value of the REG in the previous frame to VALUE." },
 736   { NULL }  /* Sentinel */
 737 };
 738
 739 PyTypeObject unwind_info_object_type =
 740 {
 741   PyVarObject_HEAD_INIT (NULL, 0)
 742   "gdb.UnwindInfo",               /* tp_name */
 743   sizeof (unwind_info_object),    /* tp_basicsize */
 744   0,                              /* tp_itemsize */
 745   unwind_infopy_dealloc,          /* tp_dealloc */
 746   0,                              /* tp_print */
 747   0,                              /* tp_getattr */
 748   0,                              /* tp_setattr */
 749   0,                              /* tp_compare */
 750   0,                              /* tp_repr */
 751   0,                              /* tp_as_number */
 752   0,                              /* tp_as_sequence */
 753   0,                              /* tp_as_mapping */
 754   0,                              /* tp_hash  */
 755   0,                              /* tp_call */
 756   unwind_infopy_str,              /* tp_str */
 757   0,                              /* tp_getattro */
 758   0,                              /* tp_setattro */
 759   0,                              /* tp_as_buffer */
 760   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /* tp_flags */
 761   "GDB UnwindInfo object",        /* tp_doc */
 762   0,                              /* tp_traverse */
 763   0,                              /* tp_clear */
 764   0,                              /* tp_richcompare */
 765   0,                              /* tp_weaklistoffset */
 766   0,                              /* tp_iter */
 767   0,                              /* tp_iternext */
 768   unwind_info_object_methods,     /* tp_methods */
 769   0,                              /* tp_members */
 770   0,                              /* tp_getset */
 771   0,                              /* tp_base */
 772   0,                              /* tp_dict */
 773   0,                              /* tp_descr_get */
 774   0,                              /* tp_descr_set */
 775   0,                              /* tp_dictoffset */
 776   0,                              /* tp_init */
 777   0,                              /* tp_alloc */
 778 };