gdb/python/py-unwind.c

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