1 /* Python interface to finish breakpoints
3 Copyright (C) 2011-2015 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/>. */
23 #include "python-internal.h"
24 #include "breakpoint.h"
26 #include "gdbthread.h"
27 #include "arch-utils.h"
33 /* Function that is called when a Python finish bp is found out of scope. */
34 static char * const outofscope_func = "out_of_scope";
36 /* struct implementing the gdb.FinishBreakpoint object by extending
37 the gdb.Breakpoint class. */
38 struct finish_breakpoint_object
40 /* gdb.Breakpoint base class. */
41 gdbpy_breakpoint_object py_bp;
42 /* gdb.Type object of the value return by the breakpointed function.
43 May be NULL if no debug information was available or return type
45 PyObject *return_type;
46 /* gdb.Value object of the function finished by this breakpoint. Will be
47 NULL if return_type is NULL. */
48 PyObject *function_value;
49 /* When stopped at this FinishBreakpoint, gdb.Value object returned by
50 the function; Py_None if the value is not computable; NULL if GDB is
51 not stopped at a FinishBreakpoint. */
52 PyObject *return_value;
55 extern PyTypeObject finish_breakpoint_object_type
56 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("finish_breakpoint_object");
58 /* Python function to get the 'return_value' attribute of
62 bpfinishpy_get_returnvalue (PyObject *self, void *closure)
64 struct finish_breakpoint_object *self_finishbp =
65 (struct finish_breakpoint_object *) self;
67 if (!self_finishbp->return_value)
70 Py_INCREF (self_finishbp->return_value);
71 return self_finishbp->return_value;
74 /* Deallocate FinishBreakpoint object. */
77 bpfinishpy_dealloc (PyObject *self)
79 struct finish_breakpoint_object *self_bpfinish =
80 (struct finish_breakpoint_object *) self;
82 Py_XDECREF (self_bpfinish->function_value);
83 Py_XDECREF (self_bpfinish->return_type);
84 Py_XDECREF (self_bpfinish->return_value);
87 /* Triggered when gdbpy_should_stop is about to execute the `stop' callback
88 of the gdb.FinishBreakpoint object BP_OBJ. Will compute and cache the
89 `return_value', if possible. */
92 bpfinishpy_pre_stop_hook (struct gdbpy_breakpoint_object *bp_obj)
94 struct finish_breakpoint_object *self_finishbp =
95 (struct finish_breakpoint_object *) bp_obj;
97 /* Can compute return_value only once. */
98 gdb_assert (!self_finishbp->return_value);
100 if (!self_finishbp->return_type)
105 struct value *function =
106 value_object_to_value (self_finishbp->function_value);
107 struct type *value_type =
108 type_object_to_type (self_finishbp->return_type);
109 struct value *ret = get_return_value (function, value_type);
113 self_finishbp->return_value = value_to_value_object (ret);
114 if (!self_finishbp->return_value)
115 gdbpy_print_stack ();
120 self_finishbp->return_value = Py_None;
123 CATCH (except, RETURN_MASK_ALL)
125 gdbpy_convert_exception (except);
126 gdbpy_print_stack ();
131 /* Triggered when gdbpy_should_stop has triggered the `stop' callback
132 of the gdb.FinishBreakpoint object BP_OBJ. */
135 bpfinishpy_post_stop_hook (struct gdbpy_breakpoint_object *bp_obj)
140 /* Can't delete it here, but it will be removed at the next stop. */
141 disable_breakpoint (bp_obj->bp);
142 gdb_assert (bp_obj->bp->disposition == disp_del);
144 CATCH (except, RETURN_MASK_ALL)
146 gdbpy_convert_exception (except);
147 gdbpy_print_stack ();
152 /* Python function to create a new breakpoint. */
155 bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs)
157 static char *keywords[] = { "frame", "internal", NULL };
158 struct finish_breakpoint_object *self_bpfinish =
159 (struct finish_breakpoint_object *) self;
160 int type = bp_breakpoint;
161 PyObject *frame_obj = NULL;
163 struct frame_info *frame = NULL; /* init for gcc -Wall */
164 struct frame_info *prev_frame = NULL;
165 struct frame_id frame_id;
166 PyObject *internal = NULL;
168 CORE_ADDR finish_pc, pc;
169 char *addr_str, small_buf[100];
170 struct symbol *function;
172 if (!PyArg_ParseTupleAndKeywords (args, kwargs, "|OO", keywords,
173 &frame_obj, &internal))
178 /* Default frame to newest frame if necessary. */
179 if (frame_obj == NULL)
180 frame = get_current_frame ();
182 frame = frame_object_to_frame_info (frame_obj);
186 PyErr_SetString (PyExc_ValueError,
187 _("Invalid ID for the `frame' object."));
191 prev_frame = get_prev_frame (frame);
194 PyErr_SetString (PyExc_ValueError,
195 _("\"FinishBreakpoint\" not "
196 "meaningful in the outermost "
199 else if (get_frame_type (prev_frame) == DUMMY_FRAME)
201 PyErr_SetString (PyExc_ValueError,
202 _("\"FinishBreakpoint\" cannot "
203 "be set on a dummy frame."));
207 frame_id = get_frame_id (prev_frame);
208 if (frame_id_eq (frame_id, null_frame_id))
209 PyErr_SetString (PyExc_ValueError,
210 _("Invalid ID for the `frame' object."));
214 CATCH (except, RETURN_MASK_ALL)
216 gdbpy_convert_exception (except);
221 if (PyErr_Occurred ())
224 thread = pid_to_thread_id (inferior_ptid);
227 PyErr_SetString (PyExc_ValueError,
228 _("No thread currently selected."));
234 internal_bp = PyObject_IsTrue (internal);
235 if (internal_bp == -1)
237 PyErr_SetString (PyExc_ValueError,
238 _("The value of `internal' must be a boolean."));
243 /* Find the function we will return from. */
244 self_bpfinish->return_type = NULL;
245 self_bpfinish->function_value = NULL;
249 if (get_frame_pc_if_available (frame, &pc))
251 function = find_pc_function (pc);
252 if (function != NULL)
254 struct type *ret_type =
255 TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
257 /* Remember only non-void return types. */
258 if (TYPE_CODE (ret_type) != TYPE_CODE_VOID)
260 struct value *func_value;
262 /* Ignore Python errors at this stage. */
263 self_bpfinish->return_type = type_to_type_object (ret_type);
265 func_value = read_var_value (function, frame);
266 self_bpfinish->function_value =
267 value_to_value_object (func_value);
273 CATCH (except, RETURN_MASK_ALL)
275 /* Just swallow. Either the return type or the function value
280 if (self_bpfinish->return_type == NULL || self_bpfinish->function_value == NULL)
282 /* Won't be able to compute return value. */
283 Py_XDECREF (self_bpfinish->return_type);
284 Py_XDECREF (self_bpfinish->function_value);
286 self_bpfinish->return_type = NULL;
287 self_bpfinish->function_value = NULL;
290 bppy_pending_object = &self_bpfinish->py_bp;
291 bppy_pending_object->number = -1;
292 bppy_pending_object->bp = NULL;
296 /* Set a breakpoint on the return address. */
297 finish_pc = get_frame_pc (prev_frame);
298 xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (finish_pc));
299 addr_str = small_buf;
301 create_breakpoint (python_gdbarch,
302 addr_str, NULL, thread, NULL,
308 &bkpt_breakpoint_ops,
309 0, 1, internal_bp, 0);
311 CATCH (except, RETURN_MASK_ALL)
313 GDB_PY_SET_HANDLE_EXCEPTION (except);
317 self_bpfinish->py_bp.bp->frame_id = frame_id;
318 self_bpfinish->py_bp.is_finish_bp = 1;
320 /* Bind the breakpoint with the current program space. */
321 self_bpfinish->py_bp.bp->pspace = current_program_space;
326 /* Called when GDB notices that the finish breakpoint BP_OBJ is out of
327 the current callstack. Triggers the method OUT_OF_SCOPE if implemented,
328 then delete the breakpoint. */
331 bpfinishpy_out_of_scope (struct finish_breakpoint_object *bpfinish_obj)
333 gdbpy_breakpoint_object *bp_obj = (gdbpy_breakpoint_object *) bpfinish_obj;
334 PyObject *py_obj = (PyObject *) bp_obj;
336 if (bpfinish_obj->py_bp.bp->enable_state == bp_enabled
337 && PyObject_HasAttrString (py_obj, outofscope_func))
339 PyObject *meth_result;
341 meth_result = PyObject_CallMethod (py_obj, outofscope_func, NULL);
342 if (meth_result == NULL)
343 gdbpy_print_stack ();
344 Py_XDECREF (meth_result);
347 delete_breakpoint (bpfinish_obj->py_bp.bp);
350 /* Callback for `bpfinishpy_detect_out_scope'. Triggers Python's
351 `B->out_of_scope' function if B is a FinishBreakpoint out of its scope. */
354 bpfinishpy_detect_out_scope_cb (struct breakpoint *b, void *args)
356 struct breakpoint *bp_stopped = (struct breakpoint *) args;
357 PyObject *py_bp = (PyObject *) b->py_bp_object;
358 struct gdbarch *garch = b->gdbarch ? b->gdbarch : get_current_arch ();
360 /* Trigger out_of_scope if this is a FinishBreakpoint and its frame is
361 not anymore in the current callstack. */
362 if (py_bp != NULL && b->py_bp_object->is_finish_bp)
364 struct finish_breakpoint_object *finish_bp =
365 (struct finish_breakpoint_object *) py_bp;
367 /* Check scope if not currently stopped at the FinishBreakpoint. */
372 if (b->pspace == current_inferior ()->pspace
373 && (!target_has_registers
374 || frame_find_by_id (b->frame_id) == NULL))
375 bpfinishpy_out_of_scope (finish_bp);
377 CATCH (except, RETURN_MASK_ALL)
379 gdbpy_convert_exception (except);
380 gdbpy_print_stack ();
389 /* Attached to `stop' notifications, check if the execution has run
390 out of the scope of any FinishBreakpoint before it has been hit. */
393 bpfinishpy_handle_stop (struct bpstats *bs, int print_frame)
395 struct cleanup *cleanup = ensure_python_env (get_current_arch (),
398 iterate_over_breakpoints (bpfinishpy_detect_out_scope_cb,
399 bs == NULL ? NULL : bs->breakpoint_at);
401 do_cleanups (cleanup);
404 /* Attached to `exit' notifications, triggers all the necessary out of
405 scope notifications. */
408 bpfinishpy_handle_exit (struct inferior *inf)
410 struct cleanup *cleanup = ensure_python_env (target_gdbarch (),
413 iterate_over_breakpoints (bpfinishpy_detect_out_scope_cb, NULL);
415 do_cleanups (cleanup);
418 /* Initialize the Python finish breakpoint code. */
421 gdbpy_initialize_finishbreakpoints (void)
423 if (PyType_Ready (&finish_breakpoint_object_type) < 0)
426 if (gdb_pymodule_addobject (gdb_module, "FinishBreakpoint",
427 (PyObject *) &finish_breakpoint_object_type) < 0)
430 observer_attach_normal_stop (bpfinishpy_handle_stop);
431 observer_attach_inferior_exit (bpfinishpy_handle_exit);
436 static PyGetSetDef finish_breakpoint_object_getset[] = {
437 { "return_value", bpfinishpy_get_returnvalue, NULL,
438 "gdb.Value object representing the return value, if any. \
439 None otherwise.", NULL },
440 { NULL } /* Sentinel. */
443 PyTypeObject finish_breakpoint_object_type =
445 PyVarObject_HEAD_INIT (NULL, 0)
446 "gdb.FinishBreakpoint", /*tp_name*/
447 sizeof (struct finish_breakpoint_object), /*tp_basicsize*/
449 bpfinishpy_dealloc, /*tp_dealloc*/
456 0, /*tp_as_sequence*/
464 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
465 "GDB finish breakpoint object", /* tp_doc */
468 0, /* tp_richcompare */
469 0, /* tp_weaklistoffset */
474 finish_breakpoint_object_getset,/* tp_getset */
475 &breakpoint_object_type, /* tp_base */
477 0, /* tp_descr_get */
478 0, /* tp_descr_set */
479 0, /* tp_dictoffset */
480 bpfinishpy_init, /* tp_init */