1 /* Python frame unwinder interface.
3 Copyright (C) 2015-2018 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"
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. */
51 saved_reg (int n
, gdbpy_ref
<> &&v
)
61 /* The data we keep for the PyUnwindInfo: pending_frame, saved registers
68 /* gdb.PendingFrame for the frame we are unwinding. */
69 PyObject
*pending_frame
;
72 struct frame_id frame_id
;
74 /* Saved registers array. */
75 std::vector
<saved_reg
> *saved_regs
;
78 /* The data we keep for a frame we can unwind: frame ID and an array of
79 (register_number, register_value) pairs. */
84 struct frame_id frame_id
;
86 /* GDB Architecture. */
87 struct gdbarch
*gdbarch
;
89 /* Length of the `reg' array below. */
95 extern PyTypeObject pending_frame_object_type
96 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("pending_frame_object");
98 extern PyTypeObject unwind_info_object_type
99 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("unwind_info_object");
101 static unsigned int pyuw_debug
= 0;
103 static struct gdbarch_data
*pyuw_gdbarch_data
;
105 /* Parses register id, which can be either a number or a name.
106 Returns 1 on success, 0 otherwise. */
109 pyuw_parse_register_id (struct gdbarch
*gdbarch
, PyObject
*pyo_reg_id
,
112 if (pyo_reg_id
== NULL
)
114 if (gdbpy_is_string (pyo_reg_id
))
116 gdb::unique_xmalloc_ptr
<char> reg_name (gdbpy_obj_to_string (pyo_reg_id
));
118 if (reg_name
== NULL
)
120 *reg_num
= user_reg_map_name_to_regnum (gdbarch
, reg_name
.get (),
121 strlen (reg_name
.get ()));
122 return *reg_num
>= 0;
124 else if (PyInt_Check (pyo_reg_id
))
127 if (gdb_py_int_as_long (pyo_reg_id
, &value
) && (int) value
== value
)
129 *reg_num
= (int) value
;
130 return user_reg_map_regnum_to_name (gdbarch
, *reg_num
) != NULL
;
136 /* Convert gdb.Value instance to inferior's pointer. Return 1 on success,
140 pyuw_value_obj_to_pointer (PyObject
*pyo_value
, CORE_ADDR
*addr
)
147 if ((value
= value_object_to_value (pyo_value
)) != NULL
)
149 *addr
= unpack_pointer (value_type (value
),
150 value_contents (value
));
154 CATCH (except
, RETURN_MASK_ALL
)
156 gdbpy_convert_exception (except
);
162 /* Get attribute from an object and convert it to the inferior's
163 pointer value. Return 1 if attribute exists and its value can be
164 converted. Otherwise, if attribute does not exist or its value is
165 None, return 0. In all other cases set Python error and return
169 pyuw_object_attribute_to_pointer (PyObject
*pyo
, const char *attr_name
,
174 if (PyObject_HasAttrString (pyo
, attr_name
))
176 gdbpy_ref
<> pyo_value (PyObject_GetAttrString (pyo
, attr_name
));
178 if (pyo_value
!= NULL
&& pyo_value
!= Py_None
)
180 rc
= pyuw_value_obj_to_pointer (pyo_value
.get (), addr
);
184 _("The value of the '%s' attribute is not a pointer."),
191 /* Called by the Python interpreter to obtain string representation
192 of the UnwindInfo object. */
195 unwind_infopy_str (PyObject
*self
)
197 unwind_info_object
*unwind_info
= (unwind_info_object
*) self
;
200 stb
.puts ("Frame ID: ");
201 fprint_frame_id (&stb
, unwind_info
->frame_id
);
203 const char *sep
= "";
204 struct value_print_options opts
;
206 get_user_print_options (&opts
);
207 stb
.printf ("\nSaved registers: (");
208 for (const saved_reg
®
: *unwind_info
->saved_regs
)
210 struct value
*value
= value_object_to_value (reg
.value
.get ());
212 stb
.printf ("%s(%d, ", sep
, reg
.number
);
217 value_print (value
, &stb
, &opts
);
220 CATCH (except
, RETURN_MASK_ALL
)
222 GDB_PY_HANDLE_EXCEPTION (except
);
233 return PyString_FromString (stb
.c_str ());
236 /* Create UnwindInfo instance for given PendingFrame and frame ID.
237 Sets Python error and returns NULL on error. */
240 pyuw_create_unwind_info (PyObject
*pyo_pending_frame
,
241 struct frame_id frame_id
)
243 unwind_info_object
*unwind_info
244 = PyObject_New (unwind_info_object
, &unwind_info_object_type
);
246 if (((pending_frame_object
*) pyo_pending_frame
)->frame_info
== NULL
)
248 PyErr_SetString (PyExc_ValueError
,
249 "Attempting to use stale PendingFrame");
252 unwind_info
->frame_id
= frame_id
;
253 Py_INCREF (pyo_pending_frame
);
254 unwind_info
->pending_frame
= pyo_pending_frame
;
255 unwind_info
->saved_regs
= new std::vector
<saved_reg
>;
256 return (PyObject
*) unwind_info
;
259 /* The implementation of
260 gdb.UnwindInfo.add_saved_register (REG, VALUE) -> None. */
263 unwind_infopy_add_saved_register (PyObject
*self
, PyObject
*args
)
265 unwind_info_object
*unwind_info
= (unwind_info_object
*) self
;
266 pending_frame_object
*pending_frame
267 = (pending_frame_object
*) (unwind_info
->pending_frame
);
268 PyObject
*pyo_reg_id
;
269 PyObject
*pyo_reg_value
;
272 if (pending_frame
->frame_info
== NULL
)
274 PyErr_SetString (PyExc_ValueError
,
275 "UnwindInfo instance refers to a stale PendingFrame");
278 if (!PyArg_UnpackTuple (args
, "previous_frame_register", 2, 2,
279 &pyo_reg_id
, &pyo_reg_value
))
281 if (!pyuw_parse_register_id (pending_frame
->gdbarch
, pyo_reg_id
, ®num
))
283 PyErr_SetString (PyExc_ValueError
, "Bad register");
290 if (pyo_reg_value
== NULL
291 || (value
= value_object_to_value (pyo_reg_value
)) == NULL
)
293 PyErr_SetString (PyExc_ValueError
, "Bad register value");
296 data_size
= register_size (pending_frame
->gdbarch
, regnum
);
297 if (data_size
!= TYPE_LENGTH (value_type (value
)))
301 "The value of the register returned by the Python "
302 "sniffer has unexpected size: %u instead of %u.",
303 (unsigned) TYPE_LENGTH (value_type (value
)),
304 (unsigned) data_size
);
309 gdbpy_ref
<> new_value
= gdbpy_ref
<>::new_reference (pyo_reg_value
);
311 for (saved_reg
®
: *unwind_info
->saved_regs
)
313 if (regnum
== reg
.number
)
316 reg
.value
= std::move (new_value
);
321 unwind_info
->saved_regs
->emplace_back (regnum
, std::move (new_value
));
326 /* UnwindInfo cleanup. */
329 unwind_infopy_dealloc (PyObject
*self
)
331 unwind_info_object
*unwind_info
= (unwind_info_object
*) self
;
333 Py_XDECREF (unwind_info
->pending_frame
);
334 delete unwind_info
->saved_regs
;
335 Py_TYPE (self
)->tp_free (self
);
338 /* Called by the Python interpreter to obtain string representation
339 of the PendingFrame object. */
342 pending_framepy_str (PyObject
*self
)
344 struct frame_info
*frame
= ((pending_frame_object
*) self
)->frame_info
;
345 const char *sp_str
= NULL
;
346 const char *pc_str
= NULL
;
349 return PyString_FromString ("Stale PendingFrame instance");
352 sp_str
= core_addr_to_string_nz (get_frame_sp (frame
));
353 pc_str
= core_addr_to_string_nz (get_frame_pc (frame
));
355 CATCH (except
, RETURN_MASK_ALL
)
357 GDB_PY_HANDLE_EXCEPTION (except
);
361 return PyString_FromFormat ("SP=%s,PC=%s", sp_str
, pc_str
);
364 /* Implementation of gdb.PendingFrame.read_register (self, reg) -> gdb.Value.
365 Returns the value of register REG as gdb.Value instance. */
368 pending_framepy_read_register (PyObject
*self
, PyObject
*args
)
370 pending_frame_object
*pending_frame
= (pending_frame_object
*) self
;
371 struct value
*val
= NULL
;
373 PyObject
*pyo_reg_id
;
375 if (pending_frame
->frame_info
== NULL
)
377 PyErr_SetString (PyExc_ValueError
,
378 "Attempting to read register from stale PendingFrame");
381 if (!PyArg_UnpackTuple (args
, "read_register", 1, 1, &pyo_reg_id
))
383 if (!pyuw_parse_register_id (pending_frame
->gdbarch
, pyo_reg_id
, ®num
))
385 PyErr_SetString (PyExc_ValueError
, "Bad register");
391 /* Fetch the value associated with a register, whether it's
392 a real register or a so called "user" register, like "pc",
393 which maps to a real register. In the past,
394 get_frame_register_value() was used here, which did not
395 handle the user register case. */
396 val
= value_of_register (regnum
, pending_frame
->frame_info
);
398 PyErr_Format (PyExc_ValueError
,
399 "Cannot read register %d from frame.",
402 CATCH (except
, RETURN_MASK_ALL
)
404 GDB_PY_HANDLE_EXCEPTION (except
);
408 return val
== NULL
? NULL
: value_to_value_object (val
);
412 PendingFrame.create_unwind_info (self, frameId) -> UnwindInfo. */
415 pending_framepy_create_unwind_info (PyObject
*self
, PyObject
*args
)
417 PyObject
*pyo_frame_id
;
422 if (!PyArg_ParseTuple (args
, "O:create_unwind_info", &pyo_frame_id
))
424 if (!pyuw_object_attribute_to_pointer (pyo_frame_id
, "sp", &sp
))
426 PyErr_SetString (PyExc_ValueError
,
427 _("frame_id should have 'sp' attribute."));
431 /* The logic of building frame_id depending on the attributes of
433 Has Has Has Function to call
434 'sp'? 'pc'? 'special'?
435 ------|------|--------------|-------------------------
436 Y N * frame_id_build_wild (sp)
437 Y Y N frame_id_build (sp, pc)
438 Y Y Y frame_id_build_special (sp, pc, special)
440 if (!pyuw_object_attribute_to_pointer (pyo_frame_id
, "pc", &pc
))
441 return pyuw_create_unwind_info (self
, frame_id_build_wild (sp
));
442 if (!pyuw_object_attribute_to_pointer (pyo_frame_id
, "special", &special
))
443 return pyuw_create_unwind_info (self
, frame_id_build (sp
, pc
));
445 return pyuw_create_unwind_info (self
,
446 frame_id_build_special (sp
, pc
, special
));
449 /* frame_unwind.this_id method. */
452 pyuw_this_id (struct frame_info
*this_frame
, void **cache_ptr
,
453 struct frame_id
*this_id
)
455 *this_id
= ((cached_frame_info
*) *cache_ptr
)->frame_id
;
458 fprintf_unfiltered (gdb_stdlog
, "%s: frame_id: ", __FUNCTION__
);
459 fprint_frame_id (gdb_stdlog
, *this_id
);
460 fprintf_unfiltered (gdb_stdlog
, "\n");
464 /* frame_unwind.prev_register. */
466 static struct value
*
467 pyuw_prev_register (struct frame_info
*this_frame
, void **cache_ptr
,
470 cached_frame_info
*cached_frame
= (cached_frame_info
*) *cache_ptr
;
471 cached_reg_t
*reg_info
= cached_frame
->reg
;
472 cached_reg_t
*reg_info_end
= reg_info
+ cached_frame
->reg_count
;
474 TRACE_PY_UNWIND (1, "%s (frame=%p,...,reg=%d)\n", __FUNCTION__
, this_frame
,
476 for (; reg_info
< reg_info_end
; ++reg_info
)
478 if (regnum
== reg_info
->num
)
479 return frame_unwind_got_bytes (this_frame
, regnum
, reg_info
->data
);
482 return frame_unwind_got_optimized (this_frame
, regnum
);
485 /* Frame sniffer dispatch. */
488 pyuw_sniffer (const struct frame_unwind
*self
, struct frame_info
*this_frame
,
491 struct gdbarch
*gdbarch
= (struct gdbarch
*) (self
->unwind_data
);
492 cached_frame_info
*cached_frame
;
494 gdbpy_enter
enter_py (gdbarch
, current_language
);
496 TRACE_PY_UNWIND (3, "%s (SP=%s, PC=%s)\n", __FUNCTION__
,
497 paddress (gdbarch
, get_frame_sp (this_frame
)),
498 paddress (gdbarch
, get_frame_pc (this_frame
)));
500 /* Create PendingFrame instance to pass to sniffers. */
501 pending_frame_object
*pfo
= PyObject_New (pending_frame_object
,
502 &pending_frame_object_type
);
503 gdbpy_ref
<> pyo_pending_frame ((PyObject
*) pfo
);
504 if (pyo_pending_frame
== NULL
)
506 gdbpy_print_stack ();
509 pfo
->gdbarch
= gdbarch
;
510 scoped_restore invalidate_frame
= make_scoped_restore (&pfo
->frame_info
,
514 if (gdb_python_module
== NULL
515 || ! PyObject_HasAttrString (gdb_python_module
, "execute_unwinders"))
517 PyErr_SetString (PyExc_NameError
,
518 "Installation error: gdb.execute_unwinders function "
520 gdbpy_print_stack ();
523 gdbpy_ref
<> pyo_execute (PyObject_GetAttrString (gdb_python_module
,
524 "execute_unwinders"));
525 if (pyo_execute
== NULL
)
527 gdbpy_print_stack ();
531 gdbpy_ref
<> pyo_unwind_info
532 (PyObject_CallFunctionObjArgs (pyo_execute
.get (),
533 pyo_pending_frame
.get (), NULL
));
534 if (pyo_unwind_info
== NULL
)
536 /* If the unwinder is cancelled due to a Ctrl-C, then propagate
537 the Ctrl-C as a GDB exception instead of swallowing it. */
538 gdbpy_print_stack_or_quit ();
541 if (pyo_unwind_info
== Py_None
)
544 /* Received UnwindInfo, cache data. */
545 if (PyObject_IsInstance (pyo_unwind_info
.get (),
546 (PyObject
*) &unwind_info_object_type
) <= 0)
547 error (_("A Unwinder should return gdb.UnwindInfo instance."));
550 unwind_info_object
*unwind_info
=
551 (unwind_info_object
*) pyo_unwind_info
.get ();
552 int reg_count
= unwind_info
->saved_regs
->size ();
555 = ((cached_frame_info
*)
556 xmalloc (sizeof (*cached_frame
)
557 + reg_count
* sizeof (cached_frame
->reg
[0])));
558 cached_frame
->gdbarch
= gdbarch
;
559 cached_frame
->frame_id
= unwind_info
->frame_id
;
560 cached_frame
->reg_count
= reg_count
;
562 /* Populate registers array. */
563 for (int i
= 0; i
< unwind_info
->saved_regs
->size (); ++i
)
565 saved_reg
*reg
= &(*unwind_info
->saved_regs
)[i
];
567 struct value
*value
= value_object_to_value (reg
->value
.get ());
568 size_t data_size
= register_size (gdbarch
, reg
->number
);
570 cached_frame
->reg
[i
].num
= reg
->number
;
572 /* `value' validation was done before, just assert. */
573 gdb_assert (value
!= NULL
);
574 gdb_assert (data_size
== TYPE_LENGTH (value_type (value
)));
576 cached_frame
->reg
[i
].data
= (gdb_byte
*) xmalloc (data_size
);
577 memcpy (cached_frame
->reg
[i
].data
, value_contents (value
), data_size
);
581 *cache_ptr
= cached_frame
;
585 /* Frame cache release shim. */
588 pyuw_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
590 TRACE_PY_UNWIND (3, "%s: enter", __FUNCTION__
);
591 cached_frame_info
*cached_frame
= (cached_frame_info
*) cache
;
593 for (int i
= 0; i
< cached_frame
->reg_count
; i
++)
594 xfree (cached_frame
->reg
[i
].data
);
599 struct pyuw_gdbarch_data_type
601 /* Has the unwinder shim been prepended? */
602 int unwinder_registered
;
606 pyuw_gdbarch_data_init (struct gdbarch
*gdbarch
)
608 return GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct pyuw_gdbarch_data_type
);
611 /* New inferior architecture callback: register the Python unwinders
615 pyuw_on_new_gdbarch (struct gdbarch
*newarch
)
617 struct pyuw_gdbarch_data_type
*data
618 = (struct pyuw_gdbarch_data_type
*) gdbarch_data (newarch
,
621 if (!data
->unwinder_registered
)
623 struct frame_unwind
*unwinder
624 = GDBARCH_OBSTACK_ZALLOC (newarch
, struct frame_unwind
);
626 unwinder
->type
= NORMAL_FRAME
;
627 unwinder
->stop_reason
= default_frame_unwind_stop_reason
;
628 unwinder
->this_id
= pyuw_this_id
;
629 unwinder
->prev_register
= pyuw_prev_register
;
630 unwinder
->unwind_data
= (const struct frame_data
*) newarch
;
631 unwinder
->sniffer
= pyuw_sniffer
;
632 unwinder
->dealloc_cache
= pyuw_dealloc_cache
;
633 frame_unwind_prepend_unwinder (newarch
, unwinder
);
634 data
->unwinder_registered
= 1;
638 /* Initialize unwind machinery. */
641 gdbpy_initialize_unwind (void)
644 add_setshow_zuinteger_cmd
645 ("py-unwind", class_maintenance
, &pyuw_debug
,
646 _("Set Python unwinder debugging."),
647 _("Show Python unwinder debugging."),
648 _("When non-zero, Python unwinder debugging is enabled."),
651 &setdebuglist
, &showdebuglist
);
653 = gdbarch_data_register_post_init (pyuw_gdbarch_data_init
);
654 gdb::observers::architecture_changed
.attach (pyuw_on_new_gdbarch
);
656 if (PyType_Ready (&pending_frame_object_type
) < 0)
658 rc
= gdb_pymodule_addobject (gdb_module
, "PendingFrame",
659 (PyObject
*) &pending_frame_object_type
);
663 if (PyType_Ready (&unwind_info_object_type
) < 0)
665 return gdb_pymodule_addobject (gdb_module
, "UnwindInfo",
666 (PyObject
*) &unwind_info_object_type
);
669 static PyMethodDef pending_frame_object_methods
[] =
671 { "read_register", pending_framepy_read_register
, METH_VARARGS
,
672 "read_register (REG) -> gdb.Value\n"
673 "Return the value of the REG in the frame." },
674 { "create_unwind_info",
675 pending_framepy_create_unwind_info
, METH_VARARGS
,
676 "create_unwind_info (FRAME_ID) -> gdb.UnwindInfo\n"
677 "Construct UnwindInfo for this PendingFrame, using FRAME_ID\n"
679 {NULL
} /* Sentinel */
682 PyTypeObject pending_frame_object_type
=
684 PyVarObject_HEAD_INIT (NULL
, 0)
685 "gdb.PendingFrame", /* tp_name */
686 sizeof (pending_frame_object
), /* tp_basicsize */
694 0, /* tp_as_number */
695 0, /* tp_as_sequence */
696 0, /* tp_as_mapping */
699 pending_framepy_str
, /* tp_str */
702 0, /* tp_as_buffer */
703 Py_TPFLAGS_DEFAULT
, /* tp_flags */
704 "GDB PendingFrame object", /* tp_doc */
707 0, /* tp_richcompare */
708 0, /* tp_weaklistoffset */
711 pending_frame_object_methods
, /* tp_methods */
716 0, /* tp_descr_get */
717 0, /* tp_descr_set */
718 0, /* tp_dictoffset */
723 static PyMethodDef unwind_info_object_methods
[] =
725 { "add_saved_register",
726 unwind_infopy_add_saved_register
, METH_VARARGS
,
727 "add_saved_register (REG, VALUE) -> None\n"
728 "Set the value of the REG in the previous frame to VALUE." },
729 { NULL
} /* Sentinel */
732 PyTypeObject unwind_info_object_type
=
734 PyVarObject_HEAD_INIT (NULL
, 0)
735 "gdb.UnwindInfo", /* tp_name */
736 sizeof (unwind_info_object
), /* tp_basicsize */
738 unwind_infopy_dealloc
, /* tp_dealloc */
744 0, /* tp_as_number */
745 0, /* tp_as_sequence */
746 0, /* tp_as_mapping */
749 unwind_infopy_str
, /* tp_str */
752 0, /* tp_as_buffer */
753 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /* tp_flags */
754 "GDB UnwindInfo object", /* tp_doc */
757 0, /* tp_richcompare */
758 0, /* tp_weaklistoffset */
761 unwind_info_object_methods
, /* tp_methods */
766 0, /* tp_descr_get */
767 0, /* tp_descr_set */
768 0, /* tp_dictoffset */