1 /* Python frame unwinder interface.
3 Copyright (C) 2015-2019 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"
26 #include "observable.h"
27 #include "python-internal.h"
30 #include "user-regs.h"
32 #define TRACE_PY_UNWIND(level, args...) if (pyuw_debug >= level) \
33 { fprintf_unfiltered (gdb_stdlog, args); }
39 /* Frame we are unwinding. */
40 struct frame_info
*frame_info
;
42 /* Its architecture, passed by the sniffer caller. */
43 struct gdbarch
*gdbarch
;
44 } pending_frame_object
;
46 /* Saved registers array item. */
50 saved_reg (int n
, gdbpy_ref
<> &&v
)
60 /* The data we keep for the PyUnwindInfo: pending_frame, saved registers
67 /* gdb.PendingFrame for the frame we are unwinding. */
68 PyObject
*pending_frame
;
71 struct frame_id frame_id
;
73 /* Saved registers array. */
74 std::vector
<saved_reg
> *saved_regs
;
77 /* The data we keep for a frame we can unwind: frame ID and an array of
78 (register_number, register_value) pairs. */
83 struct frame_id frame_id
;
85 /* GDB Architecture. */
86 struct gdbarch
*gdbarch
;
88 /* Length of the `reg' array below. */
94 extern PyTypeObject pending_frame_object_type
95 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("pending_frame_object");
97 extern PyTypeObject unwind_info_object_type
98 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("unwind_info_object");
100 static unsigned int pyuw_debug
= 0;
102 static struct gdbarch_data
*pyuw_gdbarch_data
;
104 /* Parses register id, which can be either a number or a name.
105 Returns 1 on success, 0 otherwise. */
108 pyuw_parse_register_id (struct gdbarch
*gdbarch
, PyObject
*pyo_reg_id
,
111 if (pyo_reg_id
== NULL
)
113 if (gdbpy_is_string (pyo_reg_id
))
115 gdb::unique_xmalloc_ptr
<char> reg_name (gdbpy_obj_to_string (pyo_reg_id
));
117 if (reg_name
== NULL
)
119 *reg_num
= user_reg_map_name_to_regnum (gdbarch
, reg_name
.get (),
120 strlen (reg_name
.get ()));
121 return *reg_num
>= 0;
123 else if (PyInt_Check (pyo_reg_id
))
126 if (gdb_py_int_as_long (pyo_reg_id
, &value
) && (int) value
== value
)
128 *reg_num
= (int) value
;
129 return user_reg_map_regnum_to_name (gdbarch
, *reg_num
) != NULL
;
135 /* Convert gdb.Value instance to inferior's pointer. Return 1 on success,
139 pyuw_value_obj_to_pointer (PyObject
*pyo_value
, CORE_ADDR
*addr
)
146 if ((value
= value_object_to_value (pyo_value
)) != NULL
)
148 *addr
= unpack_pointer (value_type (value
),
149 value_contents (value
));
153 CATCH (except
, RETURN_MASK_ALL
)
155 gdbpy_convert_exception (except
);
161 /* Get attribute from an object and convert it to the inferior's
162 pointer value. Return 1 if attribute exists and its value can be
163 converted. Otherwise, if attribute does not exist or its value is
164 None, return 0. In all other cases set Python error and return
168 pyuw_object_attribute_to_pointer (PyObject
*pyo
, const char *attr_name
,
173 if (PyObject_HasAttrString (pyo
, attr_name
))
175 gdbpy_ref
<> pyo_value (PyObject_GetAttrString (pyo
, attr_name
));
177 if (pyo_value
!= NULL
&& pyo_value
!= Py_None
)
179 rc
= pyuw_value_obj_to_pointer (pyo_value
.get (), addr
);
183 _("The value of the '%s' attribute is not a pointer."),
190 /* Called by the Python interpreter to obtain string representation
191 of the UnwindInfo object. */
194 unwind_infopy_str (PyObject
*self
)
196 unwind_info_object
*unwind_info
= (unwind_info_object
*) self
;
199 stb
.puts ("Frame ID: ");
200 fprint_frame_id (&stb
, unwind_info
->frame_id
);
202 const char *sep
= "";
203 struct value_print_options opts
;
205 get_user_print_options (&opts
);
206 stb
.printf ("\nSaved registers: (");
207 for (const saved_reg
®
: *unwind_info
->saved_regs
)
209 struct value
*value
= value_object_to_value (reg
.value
.get ());
211 stb
.printf ("%s(%d, ", sep
, reg
.number
);
216 value_print (value
, &stb
, &opts
);
219 CATCH (except
, RETURN_MASK_ALL
)
221 GDB_PY_HANDLE_EXCEPTION (except
);
232 return PyString_FromString (stb
.c_str ());
235 /* Create UnwindInfo instance for given PendingFrame and frame ID.
236 Sets Python error and returns NULL on error. */
239 pyuw_create_unwind_info (PyObject
*pyo_pending_frame
,
240 struct frame_id frame_id
)
242 unwind_info_object
*unwind_info
243 = PyObject_New (unwind_info_object
, &unwind_info_object_type
);
245 if (((pending_frame_object
*) pyo_pending_frame
)->frame_info
== NULL
)
247 PyErr_SetString (PyExc_ValueError
,
248 "Attempting to use stale PendingFrame");
251 unwind_info
->frame_id
= frame_id
;
252 Py_INCREF (pyo_pending_frame
);
253 unwind_info
->pending_frame
= pyo_pending_frame
;
254 unwind_info
->saved_regs
= new std::vector
<saved_reg
>;
255 return (PyObject
*) unwind_info
;
258 /* The implementation of
259 gdb.UnwindInfo.add_saved_register (REG, VALUE) -> None. */
262 unwind_infopy_add_saved_register (PyObject
*self
, PyObject
*args
)
264 unwind_info_object
*unwind_info
= (unwind_info_object
*) self
;
265 pending_frame_object
*pending_frame
266 = (pending_frame_object
*) (unwind_info
->pending_frame
);
267 PyObject
*pyo_reg_id
;
268 PyObject
*pyo_reg_value
;
271 if (pending_frame
->frame_info
== NULL
)
273 PyErr_SetString (PyExc_ValueError
,
274 "UnwindInfo instance refers to a stale PendingFrame");
277 if (!PyArg_UnpackTuple (args
, "previous_frame_register", 2, 2,
278 &pyo_reg_id
, &pyo_reg_value
))
280 if (!pyuw_parse_register_id (pending_frame
->gdbarch
, pyo_reg_id
, ®num
))
282 PyErr_SetString (PyExc_ValueError
, "Bad register");
289 if (pyo_reg_value
== NULL
290 || (value
= value_object_to_value (pyo_reg_value
)) == NULL
)
292 PyErr_SetString (PyExc_ValueError
, "Bad register value");
295 data_size
= register_size (pending_frame
->gdbarch
, regnum
);
296 if (data_size
!= TYPE_LENGTH (value_type (value
)))
300 "The value of the register returned by the Python "
301 "sniffer has unexpected size: %u instead of %u.",
302 (unsigned) TYPE_LENGTH (value_type (value
)),
303 (unsigned) data_size
);
308 gdbpy_ref
<> new_value
= gdbpy_ref
<>::new_reference (pyo_reg_value
);
310 for (saved_reg
®
: *unwind_info
->saved_regs
)
312 if (regnum
== reg
.number
)
315 reg
.value
= std::move (new_value
);
320 unwind_info
->saved_regs
->emplace_back (regnum
, std::move (new_value
));
325 /* UnwindInfo cleanup. */
328 unwind_infopy_dealloc (PyObject
*self
)
330 unwind_info_object
*unwind_info
= (unwind_info_object
*) self
;
332 Py_XDECREF (unwind_info
->pending_frame
);
333 delete unwind_info
->saved_regs
;
334 Py_TYPE (self
)->tp_free (self
);
337 /* Called by the Python interpreter to obtain string representation
338 of the PendingFrame object. */
341 pending_framepy_str (PyObject
*self
)
343 struct frame_info
*frame
= ((pending_frame_object
*) self
)->frame_info
;
344 const char *sp_str
= NULL
;
345 const char *pc_str
= NULL
;
348 return PyString_FromString ("Stale PendingFrame instance");
351 sp_str
= core_addr_to_string_nz (get_frame_sp (frame
));
352 pc_str
= core_addr_to_string_nz (get_frame_pc (frame
));
354 CATCH (except
, RETURN_MASK_ALL
)
356 GDB_PY_HANDLE_EXCEPTION (except
);
360 return PyString_FromFormat ("SP=%s,PC=%s", sp_str
, pc_str
);
363 /* Implementation of gdb.PendingFrame.read_register (self, reg) -> gdb.Value.
364 Returns the value of register REG as gdb.Value instance. */
367 pending_framepy_read_register (PyObject
*self
, PyObject
*args
)
369 pending_frame_object
*pending_frame
= (pending_frame_object
*) self
;
370 struct value
*val
= NULL
;
372 PyObject
*pyo_reg_id
;
374 if (pending_frame
->frame_info
== NULL
)
376 PyErr_SetString (PyExc_ValueError
,
377 "Attempting to read register from stale PendingFrame");
380 if (!PyArg_UnpackTuple (args
, "read_register", 1, 1, &pyo_reg_id
))
382 if (!pyuw_parse_register_id (pending_frame
->gdbarch
, pyo_reg_id
, ®num
))
384 PyErr_SetString (PyExc_ValueError
, "Bad register");
390 /* Fetch the value associated with a register, whether it's
391 a real register or a so called "user" register, like "pc",
392 which maps to a real register. In the past,
393 get_frame_register_value() was used here, which did not
394 handle the user register case. */
395 val
= value_of_register (regnum
, pending_frame
->frame_info
);
397 PyErr_Format (PyExc_ValueError
,
398 "Cannot read register %d from frame.",
401 CATCH (except
, RETURN_MASK_ALL
)
403 GDB_PY_HANDLE_EXCEPTION (except
);
407 return val
== NULL
? NULL
: value_to_value_object (val
);
411 PendingFrame.create_unwind_info (self, frameId) -> UnwindInfo. */
414 pending_framepy_create_unwind_info (PyObject
*self
, PyObject
*args
)
416 PyObject
*pyo_frame_id
;
421 if (!PyArg_ParseTuple (args
, "O:create_unwind_info", &pyo_frame_id
))
423 if (!pyuw_object_attribute_to_pointer (pyo_frame_id
, "sp", &sp
))
425 PyErr_SetString (PyExc_ValueError
,
426 _("frame_id should have 'sp' attribute."));
430 /* The logic of building frame_id depending on the attributes of
432 Has Has Has Function to call
433 'sp'? 'pc'? 'special'?
434 ------|------|--------------|-------------------------
435 Y N * frame_id_build_wild (sp)
436 Y Y N frame_id_build (sp, pc)
437 Y Y Y frame_id_build_special (sp, pc, special)
439 if (!pyuw_object_attribute_to_pointer (pyo_frame_id
, "pc", &pc
))
440 return pyuw_create_unwind_info (self
, frame_id_build_wild (sp
));
441 if (!pyuw_object_attribute_to_pointer (pyo_frame_id
, "special", &special
))
442 return pyuw_create_unwind_info (self
, frame_id_build (sp
, pc
));
444 return pyuw_create_unwind_info (self
,
445 frame_id_build_special (sp
, pc
, special
));
448 /* frame_unwind.this_id method. */
451 pyuw_this_id (struct frame_info
*this_frame
, void **cache_ptr
,
452 struct frame_id
*this_id
)
454 *this_id
= ((cached_frame_info
*) *cache_ptr
)->frame_id
;
457 fprintf_unfiltered (gdb_stdlog
, "%s: frame_id: ", __FUNCTION__
);
458 fprint_frame_id (gdb_stdlog
, *this_id
);
459 fprintf_unfiltered (gdb_stdlog
, "\n");
463 /* frame_unwind.prev_register. */
465 static struct value
*
466 pyuw_prev_register (struct frame_info
*this_frame
, void **cache_ptr
,
469 cached_frame_info
*cached_frame
= (cached_frame_info
*) *cache_ptr
;
470 cached_reg_t
*reg_info
= cached_frame
->reg
;
471 cached_reg_t
*reg_info_end
= reg_info
+ cached_frame
->reg_count
;
473 TRACE_PY_UNWIND (1, "%s (frame=%p,...,reg=%d)\n", __FUNCTION__
, this_frame
,
475 for (; reg_info
< reg_info_end
; ++reg_info
)
477 if (regnum
== reg_info
->num
)
478 return frame_unwind_got_bytes (this_frame
, regnum
, reg_info
->data
);
481 return frame_unwind_got_optimized (this_frame
, regnum
);
484 /* Frame sniffer dispatch. */
487 pyuw_sniffer (const struct frame_unwind
*self
, struct frame_info
*this_frame
,
490 struct gdbarch
*gdbarch
= (struct gdbarch
*) (self
->unwind_data
);
491 cached_frame_info
*cached_frame
;
493 gdbpy_enter
enter_py (gdbarch
, current_language
);
495 TRACE_PY_UNWIND (3, "%s (SP=%s, PC=%s)\n", __FUNCTION__
,
496 paddress (gdbarch
, get_frame_sp (this_frame
)),
497 paddress (gdbarch
, get_frame_pc (this_frame
)));
499 /* Create PendingFrame instance to pass to sniffers. */
500 pending_frame_object
*pfo
= PyObject_New (pending_frame_object
,
501 &pending_frame_object_type
);
502 gdbpy_ref
<> pyo_pending_frame ((PyObject
*) pfo
);
503 if (pyo_pending_frame
== NULL
)
505 gdbpy_print_stack ();
508 pfo
->gdbarch
= gdbarch
;
509 scoped_restore invalidate_frame
= make_scoped_restore (&pfo
->frame_info
,
513 if (gdb_python_module
== NULL
514 || ! PyObject_HasAttrString (gdb_python_module
, "execute_unwinders"))
516 PyErr_SetString (PyExc_NameError
,
517 "Installation error: gdb.execute_unwinders function "
519 gdbpy_print_stack ();
522 gdbpy_ref
<> pyo_execute (PyObject_GetAttrString (gdb_python_module
,
523 "execute_unwinders"));
524 if (pyo_execute
== NULL
)
526 gdbpy_print_stack ();
530 gdbpy_ref
<> pyo_unwind_info
531 (PyObject_CallFunctionObjArgs (pyo_execute
.get (),
532 pyo_pending_frame
.get (), NULL
));
533 if (pyo_unwind_info
== NULL
)
535 /* If the unwinder is cancelled due to a Ctrl-C, then propagate
536 the Ctrl-C as a GDB exception instead of swallowing it. */
537 gdbpy_print_stack_or_quit ();
540 if (pyo_unwind_info
== Py_None
)
543 /* Received UnwindInfo, cache data. */
544 if (PyObject_IsInstance (pyo_unwind_info
.get (),
545 (PyObject
*) &unwind_info_object_type
) <= 0)
546 error (_("A Unwinder should return gdb.UnwindInfo instance."));
549 unwind_info_object
*unwind_info
=
550 (unwind_info_object
*) pyo_unwind_info
.get ();
551 int reg_count
= unwind_info
->saved_regs
->size ();
554 = ((cached_frame_info
*)
555 xmalloc (sizeof (*cached_frame
)
556 + reg_count
* sizeof (cached_frame
->reg
[0])));
557 cached_frame
->gdbarch
= gdbarch
;
558 cached_frame
->frame_id
= unwind_info
->frame_id
;
559 cached_frame
->reg_count
= reg_count
;
561 /* Populate registers array. */
562 for (int i
= 0; i
< unwind_info
->saved_regs
->size (); ++i
)
564 saved_reg
*reg
= &(*unwind_info
->saved_regs
)[i
];
566 struct value
*value
= value_object_to_value (reg
->value
.get ());
567 size_t data_size
= register_size (gdbarch
, reg
->number
);
569 cached_frame
->reg
[i
].num
= reg
->number
;
571 /* `value' validation was done before, just assert. */
572 gdb_assert (value
!= NULL
);
573 gdb_assert (data_size
== TYPE_LENGTH (value_type (value
)));
575 cached_frame
->reg
[i
].data
= (gdb_byte
*) xmalloc (data_size
);
576 memcpy (cached_frame
->reg
[i
].data
, value_contents (value
), data_size
);
580 *cache_ptr
= cached_frame
;
584 /* Frame cache release shim. */
587 pyuw_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
589 TRACE_PY_UNWIND (3, "%s: enter", __FUNCTION__
);
590 cached_frame_info
*cached_frame
= (cached_frame_info
*) cache
;
592 for (int i
= 0; i
< cached_frame
->reg_count
; i
++)
593 xfree (cached_frame
->reg
[i
].data
);
598 struct pyuw_gdbarch_data_type
600 /* Has the unwinder shim been prepended? */
601 int unwinder_registered
;
605 pyuw_gdbarch_data_init (struct gdbarch
*gdbarch
)
607 return GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct pyuw_gdbarch_data_type
);
610 /* New inferior architecture callback: register the Python unwinders
614 pyuw_on_new_gdbarch (struct gdbarch
*newarch
)
616 struct pyuw_gdbarch_data_type
*data
617 = (struct pyuw_gdbarch_data_type
*) gdbarch_data (newarch
,
620 if (!data
->unwinder_registered
)
622 struct frame_unwind
*unwinder
623 = GDBARCH_OBSTACK_ZALLOC (newarch
, struct frame_unwind
);
625 unwinder
->type
= NORMAL_FRAME
;
626 unwinder
->stop_reason
= default_frame_unwind_stop_reason
;
627 unwinder
->this_id
= pyuw_this_id
;
628 unwinder
->prev_register
= pyuw_prev_register
;
629 unwinder
->unwind_data
= (const struct frame_data
*) newarch
;
630 unwinder
->sniffer
= pyuw_sniffer
;
631 unwinder
->dealloc_cache
= pyuw_dealloc_cache
;
632 frame_unwind_prepend_unwinder (newarch
, unwinder
);
633 data
->unwinder_registered
= 1;
637 /* Initialize unwind machinery. */
640 gdbpy_initialize_unwind (void)
643 add_setshow_zuinteger_cmd
644 ("py-unwind", class_maintenance
, &pyuw_debug
,
645 _("Set Python unwinder debugging."),
646 _("Show Python unwinder debugging."),
647 _("When non-zero, Python unwinder debugging is enabled."),
650 &setdebuglist
, &showdebuglist
);
652 = gdbarch_data_register_post_init (pyuw_gdbarch_data_init
);
653 gdb::observers::architecture_changed
.attach (pyuw_on_new_gdbarch
);
655 if (PyType_Ready (&pending_frame_object_type
) < 0)
657 rc
= gdb_pymodule_addobject (gdb_module
, "PendingFrame",
658 (PyObject
*) &pending_frame_object_type
);
662 if (PyType_Ready (&unwind_info_object_type
) < 0)
664 return gdb_pymodule_addobject (gdb_module
, "UnwindInfo",
665 (PyObject
*) &unwind_info_object_type
);
668 static PyMethodDef pending_frame_object_methods
[] =
670 { "read_register", pending_framepy_read_register
, METH_VARARGS
,
671 "read_register (REG) -> gdb.Value\n"
672 "Return the value of the REG in the frame." },
673 { "create_unwind_info",
674 pending_framepy_create_unwind_info
, METH_VARARGS
,
675 "create_unwind_info (FRAME_ID) -> gdb.UnwindInfo\n"
676 "Construct UnwindInfo for this PendingFrame, using FRAME_ID\n"
678 {NULL
} /* Sentinel */
681 PyTypeObject pending_frame_object_type
=
683 PyVarObject_HEAD_INIT (NULL
, 0)
684 "gdb.PendingFrame", /* tp_name */
685 sizeof (pending_frame_object
), /* tp_basicsize */
693 0, /* tp_as_number */
694 0, /* tp_as_sequence */
695 0, /* tp_as_mapping */
698 pending_framepy_str
, /* tp_str */
701 0, /* tp_as_buffer */
702 Py_TPFLAGS_DEFAULT
, /* tp_flags */
703 "GDB PendingFrame object", /* tp_doc */
706 0, /* tp_richcompare */
707 0, /* tp_weaklistoffset */
710 pending_frame_object_methods
, /* tp_methods */
715 0, /* tp_descr_get */
716 0, /* tp_descr_set */
717 0, /* tp_dictoffset */
722 static PyMethodDef unwind_info_object_methods
[] =
724 { "add_saved_register",
725 unwind_infopy_add_saved_register
, METH_VARARGS
,
726 "add_saved_register (REG, VALUE) -> None\n"
727 "Set the value of the REG in the previous frame to VALUE." },
728 { NULL
} /* Sentinel */
731 PyTypeObject unwind_info_object_type
=
733 PyVarObject_HEAD_INIT (NULL
, 0)
734 "gdb.UnwindInfo", /* tp_name */
735 sizeof (unwind_info_object
), /* tp_basicsize */
737 unwind_infopy_dealloc
, /* tp_dealloc */
743 0, /* tp_as_number */
744 0, /* tp_as_sequence */
745 0, /* tp_as_mapping */
748 unwind_infopy_str
, /* tp_str */
751 0, /* tp_as_buffer */
752 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /* tp_flags */
753 "GDB UnwindInfo object", /* tp_doc */
756 0, /* tp_richcompare */
757 0, /* tp_weaklistoffset */
760 unwind_info_object_methods
, /* tp_methods */
765 0, /* tp_descr_get */
766 0, /* tp_descr_set */
767 0, /* tp_dictoffset */