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"
34 /* Function that is called when a Python finish bp is found out of scope. */
35 static char * const outofscope_func
= "out_of_scope";
37 /* struct implementing the gdb.FinishBreakpoint object by extending
38 the gdb.Breakpoint class. */
39 struct finish_breakpoint_object
41 /* gdb.Breakpoint base class. */
42 gdbpy_breakpoint_object py_bp
;
43 /* gdb.Type object of the value return by the breakpointed function.
44 May be NULL if no debug information was available or return type
46 PyObject
*return_type
;
47 /* gdb.Value object of the function finished by this breakpoint. Will be
48 NULL if return_type is NULL. */
49 PyObject
*function_value
;
50 /* When stopped at this FinishBreakpoint, gdb.Value object returned by
51 the function; Py_None if the value is not computable; NULL if GDB is
52 not stopped at a FinishBreakpoint. */
53 PyObject
*return_value
;
56 extern PyTypeObject finish_breakpoint_object_type
57 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("finish_breakpoint_object");
59 /* Python function to get the 'return_value' attribute of
63 bpfinishpy_get_returnvalue (PyObject
*self
, void *closure
)
65 struct finish_breakpoint_object
*self_finishbp
=
66 (struct finish_breakpoint_object
*) self
;
68 if (!self_finishbp
->return_value
)
71 Py_INCREF (self_finishbp
->return_value
);
72 return self_finishbp
->return_value
;
75 /* Deallocate FinishBreakpoint object. */
78 bpfinishpy_dealloc (PyObject
*self
)
80 struct finish_breakpoint_object
*self_bpfinish
=
81 (struct finish_breakpoint_object
*) self
;
83 Py_XDECREF (self_bpfinish
->function_value
);
84 Py_XDECREF (self_bpfinish
->return_type
);
85 Py_XDECREF (self_bpfinish
->return_value
);
88 /* Triggered when gdbpy_should_stop is about to execute the `stop' callback
89 of the gdb.FinishBreakpoint object BP_OBJ. Will compute and cache the
90 `return_value', if possible. */
93 bpfinishpy_pre_stop_hook (struct gdbpy_breakpoint_object
*bp_obj
)
95 struct finish_breakpoint_object
*self_finishbp
=
96 (struct finish_breakpoint_object
*) bp_obj
;
98 /* Can compute return_value only once. */
99 gdb_assert (!self_finishbp
->return_value
);
101 if (!self_finishbp
->return_type
)
106 struct value
*function
=
107 value_object_to_value (self_finishbp
->function_value
);
108 struct type
*value_type
=
109 type_object_to_type (self_finishbp
->return_type
);
111 /* bpfinishpy_init cannot finish into DUMMY_FRAME (throws an error
112 in such case) so it is OK to always pass CTX_SAVER as NULL. */
113 struct value
*ret
= get_return_value (function
, value_type
, NULL
);
117 self_finishbp
->return_value
= value_to_value_object (ret
);
118 if (!self_finishbp
->return_value
)
119 gdbpy_print_stack ();
124 self_finishbp
->return_value
= Py_None
;
127 CATCH (except
, RETURN_MASK_ALL
)
129 gdbpy_convert_exception (except
);
130 gdbpy_print_stack ();
135 /* Triggered when gdbpy_should_stop has triggered the `stop' callback
136 of the gdb.FinishBreakpoint object BP_OBJ. */
139 bpfinishpy_post_stop_hook (struct gdbpy_breakpoint_object
*bp_obj
)
144 /* Can't delete it here, but it will be removed at the next stop. */
145 disable_breakpoint (bp_obj
->bp
);
146 gdb_assert (bp_obj
->bp
->disposition
== disp_del
);
148 CATCH (except
, RETURN_MASK_ALL
)
150 gdbpy_convert_exception (except
);
151 gdbpy_print_stack ();
156 /* Python function to create a new breakpoint. */
159 bpfinishpy_init (PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
161 static char *keywords
[] = { "frame", "internal", NULL
};
162 struct finish_breakpoint_object
*self_bpfinish
=
163 (struct finish_breakpoint_object
*) self
;
164 int type
= bp_breakpoint
;
165 PyObject
*frame_obj
= NULL
;
167 struct frame_info
*frame
= NULL
; /* init for gcc -Wall */
168 struct frame_info
*prev_frame
= NULL
;
169 struct frame_id frame_id
;
170 PyObject
*internal
= NULL
;
173 struct symbol
*function
;
175 if (!PyArg_ParseTupleAndKeywords (args
, kwargs
, "|OO", keywords
,
176 &frame_obj
, &internal
))
181 /* Default frame to newest frame if necessary. */
182 if (frame_obj
== NULL
)
183 frame
= get_current_frame ();
185 frame
= frame_object_to_frame_info (frame_obj
);
189 PyErr_SetString (PyExc_ValueError
,
190 _("Invalid ID for the `frame' object."));
194 prev_frame
= get_prev_frame (frame
);
197 PyErr_SetString (PyExc_ValueError
,
198 _("\"FinishBreakpoint\" not "
199 "meaningful in the outermost "
202 else if (get_frame_type (prev_frame
) == DUMMY_FRAME
)
204 PyErr_SetString (PyExc_ValueError
,
205 _("\"FinishBreakpoint\" cannot "
206 "be set on a dummy frame."));
210 frame_id
= get_frame_id (prev_frame
);
211 if (frame_id_eq (frame_id
, null_frame_id
))
212 PyErr_SetString (PyExc_ValueError
,
213 _("Invalid ID for the `frame' object."));
217 CATCH (except
, RETURN_MASK_ALL
)
219 gdbpy_convert_exception (except
);
224 if (PyErr_Occurred ())
227 thread
= pid_to_thread_id (inferior_ptid
);
230 PyErr_SetString (PyExc_ValueError
,
231 _("No thread currently selected."));
237 internal_bp
= PyObject_IsTrue (internal
);
238 if (internal_bp
== -1)
240 PyErr_SetString (PyExc_ValueError
,
241 _("The value of `internal' must be a boolean."));
246 /* Find the function we will return from. */
247 self_bpfinish
->return_type
= NULL
;
248 self_bpfinish
->function_value
= NULL
;
252 if (get_frame_pc_if_available (frame
, &pc
))
254 function
= find_pc_function (pc
);
255 if (function
!= NULL
)
257 struct type
*ret_type
=
258 TYPE_TARGET_TYPE (SYMBOL_TYPE (function
));
260 /* Remember only non-void return types. */
261 if (TYPE_CODE (ret_type
) != TYPE_CODE_VOID
)
263 struct value
*func_value
;
265 /* Ignore Python errors at this stage. */
266 self_bpfinish
->return_type
= type_to_type_object (ret_type
);
268 func_value
= read_var_value (function
, NULL
, frame
);
269 self_bpfinish
->function_value
=
270 value_to_value_object (func_value
);
276 CATCH (except
, RETURN_MASK_ALL
)
278 /* Just swallow. Either the return type or the function value
283 if (self_bpfinish
->return_type
== NULL
|| self_bpfinish
->function_value
== NULL
)
285 /* Won't be able to compute return value. */
286 Py_XDECREF (self_bpfinish
->return_type
);
287 Py_XDECREF (self_bpfinish
->function_value
);
289 self_bpfinish
->return_type
= NULL
;
290 self_bpfinish
->function_value
= NULL
;
293 bppy_pending_object
= &self_bpfinish
->py_bp
;
294 bppy_pending_object
->number
= -1;
295 bppy_pending_object
->bp
= NULL
;
299 struct event_location
*location
;
300 struct cleanup
*back_to
;
302 /* Set a breakpoint on the return address. */
303 location
= new_address_location (get_frame_pc (prev_frame
));
304 back_to
= make_cleanup_delete_event_location (location
);
305 create_breakpoint (python_gdbarch
,
306 location
, NULL
, thread
, NULL
,
312 &bkpt_breakpoint_ops
,
313 0, 1, internal_bp
, 0);
314 do_cleanups (back_to
);
316 CATCH (except
, RETURN_MASK_ALL
)
318 GDB_PY_SET_HANDLE_EXCEPTION (except
);
322 self_bpfinish
->py_bp
.bp
->frame_id
= frame_id
;
323 self_bpfinish
->py_bp
.is_finish_bp
= 1;
325 /* Bind the breakpoint with the current program space. */
326 self_bpfinish
->py_bp
.bp
->pspace
= current_program_space
;
331 /* Called when GDB notices that the finish breakpoint BP_OBJ is out of
332 the current callstack. Triggers the method OUT_OF_SCOPE if implemented,
333 then delete the breakpoint. */
336 bpfinishpy_out_of_scope (struct finish_breakpoint_object
*bpfinish_obj
)
338 gdbpy_breakpoint_object
*bp_obj
= (gdbpy_breakpoint_object
*) bpfinish_obj
;
339 PyObject
*py_obj
= (PyObject
*) bp_obj
;
341 if (bpfinish_obj
->py_bp
.bp
->enable_state
== bp_enabled
342 && PyObject_HasAttrString (py_obj
, outofscope_func
))
344 PyObject
*meth_result
;
346 meth_result
= PyObject_CallMethod (py_obj
, outofscope_func
, NULL
);
347 if (meth_result
== NULL
)
348 gdbpy_print_stack ();
349 Py_XDECREF (meth_result
);
352 delete_breakpoint (bpfinish_obj
->py_bp
.bp
);
355 /* Callback for `bpfinishpy_detect_out_scope'. Triggers Python's
356 `B->out_of_scope' function if B is a FinishBreakpoint out of its scope. */
359 bpfinishpy_detect_out_scope_cb (struct breakpoint
*b
, void *args
)
361 struct breakpoint
*bp_stopped
= (struct breakpoint
*) args
;
362 PyObject
*py_bp
= (PyObject
*) b
->py_bp_object
;
363 struct gdbarch
*garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
365 /* Trigger out_of_scope if this is a FinishBreakpoint and its frame is
366 not anymore in the current callstack. */
367 if (py_bp
!= NULL
&& b
->py_bp_object
->is_finish_bp
)
369 struct finish_breakpoint_object
*finish_bp
=
370 (struct finish_breakpoint_object
*) py_bp
;
372 /* Check scope if not currently stopped at the FinishBreakpoint. */
377 if (b
->pspace
== current_inferior ()->pspace
378 && (!target_has_registers
379 || frame_find_by_id (b
->frame_id
) == NULL
))
380 bpfinishpy_out_of_scope (finish_bp
);
382 CATCH (except
, RETURN_MASK_ALL
)
384 gdbpy_convert_exception (except
);
385 gdbpy_print_stack ();
394 /* Attached to `stop' notifications, check if the execution has run
395 out of the scope of any FinishBreakpoint before it has been hit. */
398 bpfinishpy_handle_stop (struct bpstats
*bs
, int print_frame
)
400 struct cleanup
*cleanup
= ensure_python_env (get_current_arch (),
403 iterate_over_breakpoints (bpfinishpy_detect_out_scope_cb
,
404 bs
== NULL
? NULL
: bs
->breakpoint_at
);
406 do_cleanups (cleanup
);
409 /* Attached to `exit' notifications, triggers all the necessary out of
410 scope notifications. */
413 bpfinishpy_handle_exit (struct inferior
*inf
)
415 struct cleanup
*cleanup
= ensure_python_env (target_gdbarch (),
418 iterate_over_breakpoints (bpfinishpy_detect_out_scope_cb
, NULL
);
420 do_cleanups (cleanup
);
423 /* Initialize the Python finish breakpoint code. */
426 gdbpy_initialize_finishbreakpoints (void)
428 if (PyType_Ready (&finish_breakpoint_object_type
) < 0)
431 if (gdb_pymodule_addobject (gdb_module
, "FinishBreakpoint",
432 (PyObject
*) &finish_breakpoint_object_type
) < 0)
435 observer_attach_normal_stop (bpfinishpy_handle_stop
);
436 observer_attach_inferior_exit (bpfinishpy_handle_exit
);
441 static PyGetSetDef finish_breakpoint_object_getset
[] = {
442 { "return_value", bpfinishpy_get_returnvalue
, NULL
,
443 "gdb.Value object representing the return value, if any. \
444 None otherwise.", NULL
},
445 { NULL
} /* Sentinel. */
448 PyTypeObject finish_breakpoint_object_type
=
450 PyVarObject_HEAD_INIT (NULL
, 0)
451 "gdb.FinishBreakpoint", /*tp_name*/
452 sizeof (struct finish_breakpoint_object
), /*tp_basicsize*/
454 bpfinishpy_dealloc
, /*tp_dealloc*/
461 0, /*tp_as_sequence*/
469 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /*tp_flags*/
470 "GDB finish breakpoint object", /* tp_doc */
473 0, /* tp_richcompare */
474 0, /* tp_weaklistoffset */
479 finish_breakpoint_object_getset
,/* tp_getset */
480 &breakpoint_object_type
, /* tp_base */
482 0, /* tp_descr_get */
483 0, /* tp_descr_set */
484 0, /* tp_dictoffset */
485 bpfinishpy_init
, /* tp_init */