gdb/python/py-unwind.c

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