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