gdb/python/py-unwind.c

   1 /* Python frame unwinder interface.
   2
   3    Copyright (C) 2015-2017 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       gdb::unique_xmalloc_ptr<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.get (),
 124                                               strlen (reg_name.get ()));
 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; VEC_iterate (saved_reg, unwind_info->saved_regs, i, reg); i++)
 216       {
 217         struct value *value = value_object_to_value (reg->value);
 218
 219         fprintf_unfiltered (strfile, "%s(%d, ", sep, reg->number);
 220         if (value != NULL)
 221           {
 222             TRY
 223               {
 224                 value_print (value, strfile, &opts);
 225                 fprintf_unfiltered (strfile, ")");
 226               }
 227             CATCH (except, RETURN_MASK_ALL)
 228               {
 229                 GDB_PY_HANDLE_EXCEPTION (except);
 230               }
 231             END_CATCH
 232           }
 233         else
 234           fprintf_unfiltered (strfile, "<BAD>)");
 235         sep = ", ";
 236       }
 237     fprintf_unfiltered (strfile, ")");
 238   }
 239
 240   std::string s = ui_file_as_string (strfile);
 241   result = PyString_FromString (s.c_str ());
 242   ui_file_delete (strfile);
 243   return result;
 244 }
 245
 246 /* Create UnwindInfo instance for given PendingFrame and frame ID.
 247    Sets Python error and returns NULL on error.  */
 248
 249 static PyObject *
 250 pyuw_create_unwind_info (PyObject *pyo_pending_frame,
 251                          struct frame_id frame_id)
 252 {
 253   unwind_info_object *unwind_info
 254       = PyObject_New (unwind_info_object, &unwind_info_object_type);
 255
 256   if (((pending_frame_object *) pyo_pending_frame)->frame_info == NULL)
 257     {
 258       PyErr_SetString (PyExc_ValueError,
 259                        "Attempting to use stale PendingFrame");
 260       return NULL;
 261     }
 262   unwind_info->frame_id = frame_id;
 263   Py_INCREF (pyo_pending_frame);
 264   unwind_info->pending_frame = pyo_pending_frame;
 265   unwind_info->saved_regs = VEC_alloc (saved_reg, 4);
 266   return (PyObject *) unwind_info;
 267 }
 268
 269 /* The implementation of
 270    gdb.UnwindInfo.add_saved_register (REG, VALUE) -> None.  */
 271
 272 static PyObject *
 273 unwind_infopy_add_saved_register (PyObject *self, PyObject *args)
 274 {
 275   unwind_info_object *unwind_info = (unwind_info_object *) self;
 276   pending_frame_object *pending_frame
 277       = (pending_frame_object *) (unwind_info->pending_frame);
 278   PyObject *pyo_reg_id;
 279   PyObject *pyo_reg_value;
 280   int regnum;
 281
 282   if (pending_frame->frame_info == NULL)
 283     {
 284       PyErr_SetString (PyExc_ValueError,
 285                        "UnwindInfo instance refers to a stale PendingFrame");
 286       return NULL;
 287     }
 288   if (!PyArg_UnpackTuple (args, "previous_frame_register", 2, 2,
 289                           &pyo_reg_id, &pyo_reg_value))
 290     return NULL;
 291   if (!pyuw_parse_register_id (pending_frame->gdbarch, pyo_reg_id, &regnum))
 292     {
 293       PyErr_SetString (PyExc_ValueError, "Bad register");
 294       return NULL;
 295     }
 296   {
 297     struct value *value;
 298     size_t data_size;
 299
 300     if (pyo_reg_value == NULL
 301       || (value = value_object_to_value (pyo_reg_value)) == NULL)
 302       {
 303         PyErr_SetString (PyExc_ValueError, "Bad register value");
 304         return NULL;
 305       }
 306     data_size = register_size (pending_frame->gdbarch, regnum);
 307     if (data_size != TYPE_LENGTH (value_type (value)))
 308       {
 309         PyErr_Format (
 310             PyExc_ValueError,
 311             "The value of the register returned by the Python "
 312             "sniffer has unexpected size: %u instead of %u.",
 313             (unsigned) TYPE_LENGTH (value_type (value)),
 314             (unsigned) data_size);
 315         return NULL;
 316       }
 317   }
 318   {
 319     int i;
 320     saved_reg *reg;
 321
 322     for (i = 0; VEC_iterate (saved_reg, unwind_info->saved_regs, i, reg); i++)
 323       {
 324         if (regnum == reg->number)
 325           {
 326             Py_DECREF (reg->value);
 327             break;
 328           }
 329       }
 330     if (reg == NULL)
 331       {
 332         reg = VEC_safe_push (saved_reg, unwind_info->saved_regs, NULL);
 333         reg->number = regnum;
 334       }
 335     Py_INCREF (pyo_reg_value);
 336     reg->value = pyo_reg_value;
 337   }
 338   Py_RETURN_NONE;
 339 }
 340
 341 /* UnwindInfo cleanup.  */
 342
 343 static void
 344 unwind_infopy_dealloc (PyObject *self)
 345 {
 346   unwind_info_object *unwind_info = (unwind_info_object *) self;
 347   int i;
 348   saved_reg *reg;
 349
 350   Py_XDECREF (unwind_info->pending_frame);
 351   for (i = 0; VEC_iterate (saved_reg, unwind_info->saved_regs, i, reg); i++)
 352       Py_DECREF (reg->value);
 353   VEC_free (saved_reg, unwind_info->saved_regs);
 354   Py_TYPE (self)->tp_free (self);
 355 }
 356
 357 /* Called by the Python interpreter to obtain string representation
 358    of the PendingFrame object.  */
 359
 360 static PyObject *
 361 pending_framepy_str (PyObject *self)
 362 {
 363   struct frame_info *frame = ((pending_frame_object *) self)->frame_info;
 364   const char *sp_str = NULL;
 365   const char *pc_str = NULL;
 366
 367   if (frame == NULL)
 368     return PyString_FromString ("Stale PendingFrame instance");
 369   TRY
 370     {
 371       sp_str = core_addr_to_string_nz (get_frame_sp (frame));
 372       pc_str = core_addr_to_string_nz (get_frame_pc (frame));
 373     }
 374   CATCH (except, RETURN_MASK_ALL)
 375     {
 376       GDB_PY_HANDLE_EXCEPTION (except);
 377     }
 378   END_CATCH
 379
 380   return PyString_FromFormat ("SP=%s,PC=%s", sp_str, pc_str);
 381 }
 382
 383 /* Implementation of gdb.PendingFrame.read_register (self, reg) -> gdb.Value.
 384    Returns the value of register REG as gdb.Value instance.  */
 385
 386 static PyObject *
 387 pending_framepy_read_register (PyObject *self, PyObject *args)
 388 {
 389   pending_frame_object *pending_frame = (pending_frame_object *) self;
 390   struct value *val = NULL;
 391   int regnum;
 392   PyObject *pyo_reg_id;
 393
 394   if (pending_frame->frame_info == NULL)
 395     {
 396       PyErr_SetString (PyExc_ValueError,
 397                        "Attempting to read register from stale PendingFrame");
 398       return NULL;
 399     }
 400   if (!PyArg_UnpackTuple (args, "read_register", 1, 1, &pyo_reg_id))
 401     return NULL;
 402   if (!pyuw_parse_register_id (pending_frame->gdbarch, pyo_reg_id, &regnum))
 403     {
 404       PyErr_SetString (PyExc_ValueError, "Bad register");
 405       return NULL;
 406     }
 407
 408   TRY
 409     {
 410       /* Fetch the value associated with a register, whether it's
 411          a real register or a so called "user" register, like "pc",
 412          which maps to a real register.  In the past,
 413          get_frame_register_value() was used here, which did not
 414          handle the user register case.  */
 415       val = value_of_register (regnum, pending_frame->frame_info);
 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 };