1 /* Python frame unwinder interface.
3 Copyright (C) 2015-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
21 #include "arch-utils.h"
22 #include "frame-unwind.h"
23 #include "gdb_obstack.h"
27 #include "python-internal.h"
30 #include "user-regs.h"
33 #define TRACE_PY_UNWIND(level, args...) if (pyuw_debug >= level) \
34 { fprintf_unfiltered (gdb_stdlog, args); }
40 /* Frame we are unwinding. */
41 struct frame_info
*frame_info
;
43 /* Its architecture, passed by the sniffer caller. */
44 struct gdbarch
*gdbarch
;
45 } pending_frame_object
;
47 /* Saved registers array item. */
54 DEF_VEC_O (saved_reg
);
56 /* The data we keep for the PyUnwindInfo: pending_frame, saved registers
63 /* gdb.PendingFrame for the frame we are unwinding. */
64 PyObject
*pending_frame
;
67 struct frame_id frame_id
;
69 /* Saved registers array. */
70 VEC (saved_reg
) *saved_regs
;
73 /* The data we keep for a frame we can unwind: frame ID and an array of
74 (register_number, register_value) pairs. */
79 struct frame_id frame_id
;
81 /* GDB Architecture. */
82 struct gdbarch
*gdbarch
;
84 /* Length of the `reg' array below. */
90 extern PyTypeObject pending_frame_object_type
91 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("pending_frame_object");
93 extern PyTypeObject unwind_info_object_type
94 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("unwind_info_object");
96 static unsigned int pyuw_debug
= 0;
98 static struct gdbarch_data
*pyuw_gdbarch_data
;
100 /* Parses register id, which can be either a number or a name.
101 Returns 1 on success, 0 otherwise. */
104 pyuw_parse_register_id (struct gdbarch
*gdbarch
, PyObject
*pyo_reg_id
,
107 if (pyo_reg_id
== NULL
)
109 if (gdbpy_is_string (pyo_reg_id
))
111 gdb::unique_xmalloc_ptr
<char> reg_name (gdbpy_obj_to_string (pyo_reg_id
));
113 if (reg_name
== NULL
)
115 *reg_num
= user_reg_map_name_to_regnum (gdbarch
, reg_name
.get (),
116 strlen (reg_name
.get ()));
117 return *reg_num
>= 0;
119 else if (PyInt_Check (pyo_reg_id
))
122 if (gdb_py_int_as_long (pyo_reg_id
, &value
) && (int) value
== value
)
124 *reg_num
= (int) value
;
125 return user_reg_map_regnum_to_name (gdbarch
, *reg_num
) != NULL
;
131 /* Convert gdb.Value instance to inferior's pointer. Return 1 on success,
135 pyuw_value_obj_to_pointer (PyObject
*pyo_value
, CORE_ADDR
*addr
)
142 if ((value
= value_object_to_value (pyo_value
)) != NULL
)
144 *addr
= unpack_pointer (value_type (value
),
145 value_contents (value
));
149 CATCH (except
, RETURN_MASK_ALL
)
151 gdbpy_convert_exception (except
);
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
164 pyuw_object_attribute_to_pointer (PyObject
*pyo
, const char *attr_name
,
169 if (PyObject_HasAttrString (pyo
, attr_name
))
171 gdbpy_ref
<> pyo_value (PyObject_GetAttrString (pyo
, attr_name
));
173 if (pyo_value
!= NULL
&& pyo_value
!= Py_None
)
175 rc
= pyuw_value_obj_to_pointer (pyo_value
.get (), addr
);
179 _("The value of the '%s' attribute is not a pointer."),
186 /* Called by the Python interpreter to obtain string representation
187 of the UnwindInfo object. */
190 unwind_infopy_str (PyObject
*self
)
192 unwind_info_object
*unwind_info
= (unwind_info_object
*) self
;
195 stb
.puts ("Frame ID: ");
196 fprint_frame_id (&stb
, unwind_info
->frame_id
);
198 const char *sep
= "";
200 struct value_print_options opts
;
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
++)
207 struct value
*value
= value_object_to_value (reg
->value
);
209 stb
.printf ("%s(%d, ", sep
, reg
->number
);
214 value_print (value
, &stb
, &opts
);
217 CATCH (except
, RETURN_MASK_ALL
)
219 GDB_PY_HANDLE_EXCEPTION (except
);
230 return PyString_FromString (stb
.c_str ());
233 /* Create UnwindInfo instance for given PendingFrame and frame ID.
234 Sets Python error and returns NULL on error. */
237 pyuw_create_unwind_info (PyObject
*pyo_pending_frame
,
238 struct frame_id frame_id
)
240 unwind_info_object
*unwind_info
241 = PyObject_New (unwind_info_object
, &unwind_info_object_type
);
243 if (((pending_frame_object
*) pyo_pending_frame
)->frame_info
== NULL
)
245 PyErr_SetString (PyExc_ValueError
,
246 "Attempting to use stale PendingFrame");
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
;
256 /* The implementation of
257 gdb.UnwindInfo.add_saved_register (REG, VALUE) -> None. */
260 unwind_infopy_add_saved_register (PyObject
*self
, PyObject
*args
)
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
;
269 if (pending_frame
->frame_info
== NULL
)
271 PyErr_SetString (PyExc_ValueError
,
272 "UnwindInfo instance refers to a stale PendingFrame");
275 if (!PyArg_UnpackTuple (args
, "previous_frame_register", 2, 2,
276 &pyo_reg_id
, &pyo_reg_value
))
278 if (!pyuw_parse_register_id (pending_frame
->gdbarch
, pyo_reg_id
, ®num
))
280 PyErr_SetString (PyExc_ValueError
, "Bad register");
287 if (pyo_reg_value
== NULL
288 || (value
= value_object_to_value (pyo_reg_value
)) == NULL
)
290 PyErr_SetString (PyExc_ValueError
, "Bad register value");
293 data_size
= register_size (pending_frame
->gdbarch
, regnum
);
294 if (data_size
!= TYPE_LENGTH (value_type (value
)))
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
);
309 for (i
= 0; VEC_iterate (saved_reg
, unwind_info
->saved_regs
, i
, reg
); i
++)
311 if (regnum
== reg
->number
)
313 Py_DECREF (reg
->value
);
319 reg
= VEC_safe_push (saved_reg
, unwind_info
->saved_regs
, NULL
);
320 reg
->number
= regnum
;
322 Py_INCREF (pyo_reg_value
);
323 reg
->value
= pyo_reg_value
;
328 /* UnwindInfo cleanup. */
331 unwind_infopy_dealloc (PyObject
*self
)
333 unwind_info_object
*unwind_info
= (unwind_info_object
*) self
;
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
);
344 /* Called by the Python interpreter to obtain string representation
345 of the PendingFrame object. */
348 pending_framepy_str (PyObject
*self
)
350 struct frame_info
*frame
= ((pending_frame_object
*) self
)->frame_info
;
351 const char *sp_str
= NULL
;
352 const char *pc_str
= NULL
;
355 return PyString_FromString ("Stale PendingFrame instance");
358 sp_str
= core_addr_to_string_nz (get_frame_sp (frame
));
359 pc_str
= core_addr_to_string_nz (get_frame_pc (frame
));
361 CATCH (except
, RETURN_MASK_ALL
)
363 GDB_PY_HANDLE_EXCEPTION (except
);
367 return PyString_FromFormat ("SP=%s,PC=%s", sp_str
, pc_str
);
370 /* Implementation of gdb.PendingFrame.read_register (self, reg) -> gdb.Value.
371 Returns the value of register REG as gdb.Value instance. */
374 pending_framepy_read_register (PyObject
*self
, PyObject
*args
)
376 pending_frame_object
*pending_frame
= (pending_frame_object
*) self
;
377 struct value
*val
= NULL
;
379 PyObject
*pyo_reg_id
;
381 if (pending_frame
->frame_info
== NULL
)
383 PyErr_SetString (PyExc_ValueError
,
384 "Attempting to read register from stale PendingFrame");
387 if (!PyArg_UnpackTuple (args
, "read_register", 1, 1, &pyo_reg_id
))
389 if (!pyuw_parse_register_id (pending_frame
->gdbarch
, pyo_reg_id
, ®num
))
391 PyErr_SetString (PyExc_ValueError
, "Bad register");
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
);
404 PyErr_Format (PyExc_ValueError
,
405 "Cannot read register %d from frame.",
408 CATCH (except
, RETURN_MASK_ALL
)
410 GDB_PY_HANDLE_EXCEPTION (except
);
414 return val
== NULL
? NULL
: value_to_value_object (val
);
418 PendingFrame.create_unwind_info (self, frameId) -> UnwindInfo. */
421 pending_framepy_create_unwind_info (PyObject
*self
, PyObject
*args
)
423 PyObject
*pyo_frame_id
;
428 if (!PyArg_ParseTuple (args
, "O:create_unwind_info", &pyo_frame_id
))
430 if (!pyuw_object_attribute_to_pointer (pyo_frame_id
, "sp", &sp
))
432 PyErr_SetString (PyExc_ValueError
,
433 _("frame_id should have 'sp' attribute."));
437 /* The logic of building frame_id depending on the attributes of
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)
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
));
451 return pyuw_create_unwind_info (self
,
452 frame_id_build_special (sp
, pc
, special
));
455 /* frame_unwind.this_id method. */
458 pyuw_this_id (struct frame_info
*this_frame
, void **cache_ptr
,
459 struct frame_id
*this_id
)
461 *this_id
= ((cached_frame_info
*) *cache_ptr
)->frame_id
;
464 fprintf_unfiltered (gdb_stdlog
, "%s: frame_id: ", __FUNCTION__
);
465 fprint_frame_id (gdb_stdlog
, *this_id
);
466 fprintf_unfiltered (gdb_stdlog
, "\n");
470 /* frame_unwind.prev_register. */
472 static struct value
*
473 pyuw_prev_register (struct frame_info
*this_frame
, void **cache_ptr
,
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
;
480 TRACE_PY_UNWIND (1, "%s (frame=%p,...,reg=%d)\n", __FUNCTION__
, this_frame
,
482 for (; reg_info
< reg_info_end
; ++reg_info
)
484 if (regnum
== reg_info
->num
)
485 return frame_unwind_got_bytes (this_frame
, regnum
, reg_info
->data
);
488 return frame_unwind_got_optimized (this_frame
, regnum
);
491 /* Frame sniffer dispatch. */
494 pyuw_sniffer (const struct frame_unwind
*self
, struct frame_info
*this_frame
,
497 struct gdbarch
*gdbarch
= (struct gdbarch
*) (self
->unwind_data
);
498 cached_frame_info
*cached_frame
;
500 gdbpy_enter
enter_py (gdbarch
, current_language
);
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
)));
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
)
512 gdbpy_print_stack ();
515 pfo
->gdbarch
= gdbarch
;
516 scoped_restore invalidate_frame
= make_scoped_restore (&pfo
->frame_info
,
520 if (gdb_python_module
== NULL
521 || ! PyObject_HasAttrString (gdb_python_module
, "execute_unwinders"))
523 PyErr_SetString (PyExc_NameError
,
524 "Installation error: gdb.execute_unwinders function "
526 gdbpy_print_stack ();
529 gdbpy_ref
<> pyo_execute (PyObject_GetAttrString (gdb_python_module
,
530 "execute_unwinders"));
531 if (pyo_execute
== NULL
)
533 gdbpy_print_stack ();
537 gdbpy_ref
<> pyo_unwind_info
538 (PyObject_CallFunctionObjArgs (pyo_execute
.get (),
539 pyo_pending_frame
.get (), NULL
));
540 if (pyo_unwind_info
== NULL
)
542 gdbpy_print_stack ();
545 if (pyo_unwind_info
== Py_None
)
548 /* Received UnwindInfo, cache data. */
549 if (PyObject_IsInstance (pyo_unwind_info
.get (),
550 (PyObject
*) &unwind_info_object_type
) <= 0)
551 error (_("A Unwinder should return gdb.UnwindInfo instance."));
554 unwind_info_object
*unwind_info
=
555 (unwind_info_object
*) pyo_unwind_info
.get ();
556 int reg_count
= VEC_length (saved_reg
, unwind_info
->saved_regs
);
561 = ((cached_frame_info
*)
562 xmalloc (sizeof (*cached_frame
)
563 + reg_count
* sizeof (cached_frame
->reg
[0])));
564 cached_frame
->gdbarch
= gdbarch
;
565 cached_frame
->frame_id
= unwind_info
->frame_id
;
566 cached_frame
->reg_count
= reg_count
;
568 /* Populate registers array. */
569 for (i
= 0; VEC_iterate (saved_reg
, unwind_info
->saved_regs
, i
, reg
); i
++)
571 struct value
*value
= value_object_to_value (reg
->value
);
572 size_t data_size
= register_size (gdbarch
, reg
->number
);
574 cached_frame
->reg
[i
].num
= reg
->number
;
576 /* `value' validation was done before, just assert. */
577 gdb_assert (value
!= NULL
);
578 gdb_assert (data_size
== TYPE_LENGTH (value_type (value
)));
579 gdb_assert (data_size
<= MAX_REGISTER_SIZE
);
581 cached_frame
->reg
[i
].data
= (gdb_byte
*) xmalloc (data_size
);
582 memcpy (cached_frame
->reg
[i
].data
, value_contents (value
), data_size
);
586 *cache_ptr
= cached_frame
;
590 /* Frame cache release shim. */
593 pyuw_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
595 TRACE_PY_UNWIND (3, "%s: enter", __FUNCTION__
);
596 cached_frame_info
*cached_frame
= (cached_frame_info
*) cache
;
598 for (int i
= 0; i
< cached_frame
->reg_count
; i
++)
599 xfree (cached_frame
->reg
[i
].data
);
604 struct pyuw_gdbarch_data_type
606 /* Has the unwinder shim been prepended? */
607 int unwinder_registered
;
611 pyuw_gdbarch_data_init (struct gdbarch
*gdbarch
)
613 return GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct pyuw_gdbarch_data_type
);
616 /* New inferior architecture callback: register the Python unwinders
620 pyuw_on_new_gdbarch (struct gdbarch
*newarch
)
622 struct pyuw_gdbarch_data_type
*data
623 = (struct pyuw_gdbarch_data_type
*) gdbarch_data (newarch
,
626 if (!data
->unwinder_registered
)
628 struct frame_unwind
*unwinder
629 = GDBARCH_OBSTACK_ZALLOC (newarch
, struct frame_unwind
);
631 unwinder
->type
= NORMAL_FRAME
;
632 unwinder
->stop_reason
= default_frame_unwind_stop_reason
;
633 unwinder
->this_id
= pyuw_this_id
;
634 unwinder
->prev_register
= pyuw_prev_register
;
635 unwinder
->unwind_data
= (const struct frame_data
*) newarch
;
636 unwinder
->sniffer
= pyuw_sniffer
;
637 unwinder
->dealloc_cache
= pyuw_dealloc_cache
;
638 frame_unwind_prepend_unwinder (newarch
, unwinder
);
639 data
->unwinder_registered
= 1;
643 /* Initialize unwind machinery. */
646 gdbpy_initialize_unwind (void)
649 add_setshow_zuinteger_cmd
650 ("py-unwind", class_maintenance
, &pyuw_debug
,
651 _("Set Python unwinder debugging."),
652 _("Show Python unwinder debugging."),
653 _("When non-zero, Python unwinder debugging is enabled."),
656 &setdebuglist
, &showdebuglist
);
658 = gdbarch_data_register_post_init (pyuw_gdbarch_data_init
);
659 observer_attach_architecture_changed (pyuw_on_new_gdbarch
);
661 if (PyType_Ready (&pending_frame_object_type
) < 0)
663 rc
= gdb_pymodule_addobject (gdb_module
, "PendingFrame",
664 (PyObject
*) &pending_frame_object_type
);
668 if (PyType_Ready (&unwind_info_object_type
) < 0)
670 return gdb_pymodule_addobject (gdb_module
, "UnwindInfo",
671 (PyObject
*) &unwind_info_object_type
);
674 static PyMethodDef pending_frame_object_methods
[] =
676 { "read_register", pending_framepy_read_register
, METH_VARARGS
,
677 "read_register (REG) -> gdb.Value\n"
678 "Return the value of the REG in the frame." },
679 { "create_unwind_info",
680 pending_framepy_create_unwind_info
, METH_VARARGS
,
681 "create_unwind_info (FRAME_ID) -> gdb.UnwindInfo\n"
682 "Construct UnwindInfo for this PendingFrame, using FRAME_ID\n"
684 {NULL
} /* Sentinel */
687 PyTypeObject pending_frame_object_type
=
689 PyVarObject_HEAD_INIT (NULL
, 0)
690 "gdb.PendingFrame", /* tp_name */
691 sizeof (pending_frame_object
), /* tp_basicsize */
699 0, /* tp_as_number */
700 0, /* tp_as_sequence */
701 0, /* tp_as_mapping */
704 pending_framepy_str
, /* tp_str */
707 0, /* tp_as_buffer */
708 Py_TPFLAGS_DEFAULT
, /* tp_flags */
709 "GDB PendingFrame object", /* tp_doc */
712 0, /* tp_richcompare */
713 0, /* tp_weaklistoffset */
716 pending_frame_object_methods
, /* tp_methods */
721 0, /* tp_descr_get */
722 0, /* tp_descr_set */
723 0, /* tp_dictoffset */
728 static PyMethodDef unwind_info_object_methods
[] =
730 { "add_saved_register",
731 unwind_infopy_add_saved_register
, METH_VARARGS
,
732 "add_saved_register (REG, VALUE) -> None\n"
733 "Set the value of the REG in the previous frame to VALUE." },
734 { NULL
} /* Sentinel */
737 PyTypeObject unwind_info_object_type
=
739 PyVarObject_HEAD_INIT (NULL
, 0)
740 "gdb.UnwindInfo", /* tp_name */
741 sizeof (unwind_info_object
), /* tp_basicsize */
743 unwind_infopy_dealloc
, /* tp_dealloc */
749 0, /* tp_as_number */
750 0, /* tp_as_sequence */
751 0, /* tp_as_mapping */
754 unwind_infopy_str
, /* tp_str */
757 0, /* tp_as_buffer */
758 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /* tp_flags */
759 "GDB UnwindInfo object", /* tp_doc */
762 0, /* tp_richcompare */
763 0, /* tp_weaklistoffset */
766 unwind_info_object_methods
, /* tp_methods */
771 0, /* tp_descr_get */
772 0, /* tp_descr_set */
773 0, /* tp_dictoffset */