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