]> Git Repo - binutils.git/blob - gdb/python/py-unwind.c
gdb: remove TYPE_LENGTH
[binutils.git] / gdb / python / py-unwind.c
1 /* Python frame unwinder interface.
2
3    Copyright (C) 2015-2022 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   struct frame_info *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   struct frame_info *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 (struct frame_info *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 (struct frame_info *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, struct frame_info *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 (struct 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 };
This page took 0.071668 seconds and 4 git commands to generate.