gdb vendor branch: Bring in additional source files
[dragonfly.git] / contrib / gdb-7 / gdb / python / py-finishbreakpoint.c
CommitLineData
a45ae5f8
JM
1/* Python interface to finish breakpoints
2
3 Copyright (C) 2011-2012 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20
21
22#include "defs.h"
23#include "exceptions.h"
24#include "python-internal.h"
25#include "breakpoint.h"
26#include "frame.h"
27#include "gdbthread.h"
28#include "arch-utils.h"
29#include "language.h"
30#include "observer.h"
31#include "inferior.h"
32
33static PyTypeObject finish_breakpoint_object_type;
34
35/* Function that is called when a Python finish bp is found out of scope. */
36static char * const outofscope_func = "out_of_scope";
37
38/* struct implementing the gdb.FinishBreakpoint object by extending
39 the gdb.Breakpoint class. */
40struct finish_breakpoint_object
41{
42 /* gdb.Breakpoint base class. */
43 breakpoint_object py_bp;
44 /* gdb.Type object of the value return by the breakpointed function.
45 May be NULL if no debug information was available or return type
46 was VOID. */
47 PyObject *return_type;
48 /* gdb.Type object of the function finished by this breakpoint. Will be
49 NULL if return_type is NULL. */
50 PyObject *function_type;
51 /* When stopped at this FinishBreakpoint, gdb.Value object returned by
52 the function; Py_None if the value is not computable; NULL if GDB is
53 not stopped at a FinishBreakpoint. */
54 PyObject *return_value;
55};
56
57/* Python function to get the 'return_value' attribute of
58 FinishBreakpoint. */
59
60static PyObject *
61bpfinishpy_get_returnvalue (PyObject *self, void *closure)
62{
63 struct finish_breakpoint_object *self_finishbp =
64 (struct finish_breakpoint_object *) self;
65
66 if (!self_finishbp->return_value)
67 Py_RETURN_NONE;
68
69 Py_INCREF (self_finishbp->return_value);
70 return self_finishbp->return_value;
71}
72
73/* Deallocate FinishBreakpoint object. */
74
75static void
76bpfinishpy_dealloc (PyObject *self)
77{
78 struct finish_breakpoint_object *self_bpfinish =
79 (struct finish_breakpoint_object *) self;
80
81 Py_XDECREF (self_bpfinish->function_type);
82 Py_XDECREF (self_bpfinish->return_type);
83 Py_XDECREF (self_bpfinish->return_value);
84}
85
86/* Triggered when gdbpy_should_stop is about to execute the `stop' callback
87 of the gdb.FinishBreakpoint object BP_OBJ. Will compute and cache the
88 `return_value', if possible. */
89
90void
91bpfinishpy_pre_stop_hook (struct breakpoint_object *bp_obj)
92{
93 struct finish_breakpoint_object *self_finishbp =
94 (struct finish_breakpoint_object *) bp_obj;
95 volatile struct gdb_exception except;
96
97 /* Can compute return_value only once. */
98 gdb_assert (!self_finishbp->return_value);
99
100 if (!self_finishbp->return_type)
101 return;
102
103 TRY_CATCH (except, RETURN_MASK_ALL)
104 {
105 struct value *ret =
106 get_return_value (type_object_to_type (self_finishbp->function_type),
107 type_object_to_type (self_finishbp->return_type));
108
109 if (ret)
110 {
111 self_finishbp->return_value = value_to_value_object (ret);
112 if (!self_finishbp->return_value)
113 gdbpy_print_stack ();
114 }
115 else
116 {
117 Py_INCREF (Py_None);
118 self_finishbp->return_value = Py_None;
119 }
120 }
121 if (except.reason < 0)
122 {
123 gdbpy_convert_exception (except);
124 gdbpy_print_stack ();
125 }
126}
127
128/* Triggered when gdbpy_should_stop has triggered the `stop' callback
129 of the gdb.FinishBreakpoint object BP_OBJ. */
130
131void
132bpfinishpy_post_stop_hook (struct breakpoint_object *bp_obj)
133{
134 volatile struct gdb_exception except;
135
136 TRY_CATCH (except, RETURN_MASK_ALL)
137 {
138 /* Can't delete it here, but it will be removed at the next stop. */
139 disable_breakpoint (bp_obj->bp);
140 gdb_assert (bp_obj->bp->disposition == disp_del);
141 }
142 if (except.reason < 0)
143 {
144 gdbpy_convert_exception (except);
145 gdbpy_print_stack ();
146 }
147}
148
149/* Python function to create a new breakpoint. */
150
151static int
152bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs)
153{
154 static char *keywords[] = { "frame", "internal", NULL };
155 struct finish_breakpoint_object *self_bpfinish =
156 (struct finish_breakpoint_object *) self;
157 int type = bp_breakpoint;
158 PyObject *frame_obj = NULL;
159 int thread;
160 struct frame_info *frame, *prev_frame = NULL;
161 struct frame_id frame_id;
162 PyObject *internal = NULL;
163 int internal_bp = 0;
164 CORE_ADDR finish_pc, pc;
165 volatile struct gdb_exception except;
166 char *addr_str, small_buf[100];
167 struct symbol *function;
168
169 if (!PyArg_ParseTupleAndKeywords (args, kwargs, "|OO", keywords,
170 &frame_obj, &internal))
171 return -1;
172
173 /* Default frame to gdb.newest_frame if necessary. */
174 if (!frame_obj)
175 frame_obj = gdbpy_newest_frame (NULL, NULL);
176 else
177 Py_INCREF (frame_obj);
178
179 frame = frame_object_to_frame_info (frame_obj);
180 Py_DECREF (frame_obj);
181
182 if (frame == NULL)
183 goto invalid_frame;
184
185 TRY_CATCH (except, RETURN_MASK_ALL)
186 {
187 prev_frame = get_prev_frame (frame);
188 if (prev_frame == 0)
189 {
190 PyErr_SetString (PyExc_ValueError, _("\"FinishBreakpoint\" not " \
191 "meaningful in the outermost "\
192 "frame."));
193 }
194 else if (get_frame_type (prev_frame) == DUMMY_FRAME)
195 {
196 PyErr_SetString (PyExc_ValueError, _("\"FinishBreakpoint\" cannot "\
197 "be set on a dummy frame."));
198 }
199 else
200 {
201 frame_id = get_frame_id (prev_frame);
202 if (frame_id_eq (frame_id, null_frame_id))
203 PyErr_SetString (PyExc_ValueError,
204 _("Invalid ID for the `frame' object."));
205 }
206 }
207 if (except.reason < 0)
208 {
209 gdbpy_convert_exception (except);
210 return -1;
211 }
212 else if (PyErr_Occurred ())
213 return -1;
214
215 thread = pid_to_thread_id (inferior_ptid);
216 if (thread == 0)
217 {
218 PyErr_SetString (PyExc_ValueError,
219 _("No thread currently selected."));
220 return -1;
221 }
222
223 if (internal)
224 {
225 internal_bp = PyObject_IsTrue (internal);
226 if (internal_bp == -1)
227 {
228 PyErr_SetString (PyExc_ValueError,
229 _("The value of `internal' must be a boolean."));
230 return -1;
231 }
232 }
233
234 /* Find the function we will return from. */
235 self_bpfinish->return_type = NULL;
236 self_bpfinish->function_type = NULL;
237
238 TRY_CATCH (except, RETURN_MASK_ALL)
239 {
240 if (get_frame_pc_if_available (frame, &pc))
241 {
242 function = find_pc_function (pc);
243 if (function != NULL)
244 {
245 struct type *ret_type =
246 TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
247
248 /* Remember only non-void return types. */
249 if (TYPE_CODE (ret_type) != TYPE_CODE_VOID)
250 {
251 /* Ignore Python errors at this stage. */
252 self_bpfinish->return_type = type_to_type_object (ret_type);
253 PyErr_Clear ();
254 self_bpfinish->function_type =
255 type_to_type_object (SYMBOL_TYPE (function));
256 PyErr_Clear ();
257 }
258 }
259 }
260 }
261 if (except.reason < 0
262 || !self_bpfinish->return_type || !self_bpfinish->function_type)
263 {
264 /* Won't be able to compute return value. */
265 Py_XDECREF (self_bpfinish->return_type);
266 Py_XDECREF (self_bpfinish->function_type);
267
268 self_bpfinish->return_type = NULL;
269 self_bpfinish->function_type = NULL;
270 }
271
272 bppy_pending_object = &self_bpfinish->py_bp;
273 bppy_pending_object->number = -1;
274 bppy_pending_object->bp = NULL;
275
276 TRY_CATCH (except, RETURN_MASK_ALL)
277 {
278 /* Set a breakpoint on the return address. */
279 finish_pc = get_frame_pc (prev_frame);
280 sprintf (small_buf, "*%s", hex_string (finish_pc));
281 addr_str = small_buf;
282
283 create_breakpoint (python_gdbarch,
284 addr_str, NULL, thread,
285 0,
286 1 /*temp_flag*/,
287 bp_breakpoint,
288 0,
289 AUTO_BOOLEAN_TRUE,
290 &bkpt_breakpoint_ops,
291 0, 1, internal_bp, 0);
292 }
293 GDB_PY_SET_HANDLE_EXCEPTION (except);
294
295 self_bpfinish->py_bp.bp->frame_id = frame_id;
296 self_bpfinish->py_bp.is_finish_bp = 1;
297
298 /* Bind the breakpoint with the current program space. */
299 self_bpfinish->py_bp.bp->pspace = current_program_space;
300
301 return 0;
302
303 invalid_frame:
304 PyErr_SetString (PyExc_ValueError,
305 _("Invalid ID for the `frame' object."));
306 return -1;
307}
308
309/* Called when GDB notices that the finish breakpoint BP_OBJ is out of
310 the current callstack. Triggers the method OUT_OF_SCOPE if implemented,
311 then delete the breakpoint. */
312
313static void
314bpfinishpy_out_of_scope (struct finish_breakpoint_object *bpfinish_obj)
315{
316 volatile struct gdb_exception except;
317 breakpoint_object *bp_obj = (breakpoint_object *) bpfinish_obj;
318 PyObject *py_obj = (PyObject *) bp_obj;
319
320 if (bpfinish_obj->py_bp.bp->enable_state == bp_enabled
321 && PyObject_HasAttrString (py_obj, outofscope_func))
322 {
323 if (!PyObject_CallMethod (py_obj, outofscope_func, NULL))
324 gdbpy_print_stack ();
325 }
326
327 delete_breakpoint (bpfinish_obj->py_bp.bp);
328}
329
330/* Callback for `bpfinishpy_detect_out_scope'. Triggers Python's
331 `B->out_of_scope' function if B is a FinishBreakpoint out of its scope. */
332
333static int
334bpfinishpy_detect_out_scope_cb (struct breakpoint *b, void *args)
335{
336 volatile struct gdb_exception except;
337 struct breakpoint *bp_stopped = (struct breakpoint *) args;
338 PyObject *py_bp = (PyObject *) b->py_bp_object;
339 struct gdbarch *garch = b->gdbarch ? b->gdbarch : get_current_arch ();
340
341 /* Trigger out_of_scope if this is a FinishBreakpoint and its frame is
342 not anymore in the current callstack. */
343 if (py_bp != NULL && b->py_bp_object->is_finish_bp)
344 {
345 struct finish_breakpoint_object *finish_bp =
346 (struct finish_breakpoint_object *) py_bp;
347
348 /* Check scope if not currently stopped at the FinishBreakpoint. */
349 if (b != bp_stopped)
350 {
351 TRY_CATCH (except, RETURN_MASK_ALL)
352 {
353 if (b->pspace == current_inferior ()->pspace
354 && (!target_has_registers
355 || frame_find_by_id (b->frame_id) == NULL))
356 bpfinishpy_out_of_scope (finish_bp);
357 }
358 if (except.reason < 0)
359 {
360 gdbpy_convert_exception (except);
361 gdbpy_print_stack ();
362 }
363 }
364 }
365
366 return 0;
367}
368
369/* Attached to `stop' notifications, check if the execution has run
370 out of the scope of any FinishBreakpoint before it has been hit. */
371
372static void
373bpfinishpy_handle_stop (struct bpstats *bs, int print_frame)
374{
375 struct cleanup *cleanup = ensure_python_env (get_current_arch (),
376 current_language);
377
378 iterate_over_breakpoints (bpfinishpy_detect_out_scope_cb,
379 bs == NULL ? NULL : bs->breakpoint_at);
380
381 do_cleanups (cleanup);
382}
383
384/* Attached to `exit' notifications, triggers all the necessary out of
385 scope notifications. */
386
387static void
388bpfinishpy_handle_exit (struct inferior *inf)
389{
390 struct cleanup *cleanup = ensure_python_env (target_gdbarch,
391 current_language);
392
393 iterate_over_breakpoints (bpfinishpy_detect_out_scope_cb, NULL);
394
395 do_cleanups (cleanup);
396}
397
398/* Initialize the Python finish breakpoint code. */
399
400void
401gdbpy_initialize_finishbreakpoints (void)
402{
403 if (PyType_Ready (&finish_breakpoint_object_type) < 0)
404 return;
405
406 Py_INCREF (&finish_breakpoint_object_type);
407 PyModule_AddObject (gdb_module, "FinishBreakpoint",
408 (PyObject *) &finish_breakpoint_object_type);
409
410 observer_attach_normal_stop (bpfinishpy_handle_stop);
411 observer_attach_inferior_exit (bpfinishpy_handle_exit);
412}
413
414static PyGetSetDef finish_breakpoint_object_getset[] = {
415 { "return_value", bpfinishpy_get_returnvalue, NULL,
416 "gdb.Value object representing the return value, if any. \
417None otherwise.", NULL },
418 { NULL } /* Sentinel. */
419};
420
421static PyTypeObject finish_breakpoint_object_type =
422{
423 PyObject_HEAD_INIT (NULL)
424 0, /*ob_size*/
425 "gdb.FinishBreakpoint", /*tp_name*/
426 sizeof (struct finish_breakpoint_object), /*tp_basicsize*/
427 0, /*tp_itemsize*/
428 bpfinishpy_dealloc, /*tp_dealloc*/
429 0, /*tp_print*/
430 0, /*tp_getattr*/
431 0, /*tp_setattr*/
432 0, /*tp_compare*/
433 0, /*tp_repr*/
434 0, /*tp_as_number*/
435 0, /*tp_as_sequence*/
436 0, /*tp_as_mapping*/
437 0, /*tp_hash */
438 0, /*tp_call*/
439 0, /*tp_str*/
440 0, /*tp_getattro*/
441 0, /*tp_setattro */
442 0, /*tp_as_buffer*/
443 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
444 "GDB finish breakpoint object", /* tp_doc */
445 0, /* tp_traverse */
446 0, /* tp_clear */
447 0, /* tp_richcompare */
448 0, /* tp_weaklistoffset */
449 0, /* tp_iter */
450 0, /* tp_iternext */
451 0, /* tp_methods */
452 0, /* tp_members */
453 finish_breakpoint_object_getset,/* tp_getset */
454 &breakpoint_object_type, /* tp_base */
455 0, /* tp_dict */
456 0, /* tp_descr_get */
457 0, /* tp_descr_set */
458 0, /* tp_dictoffset */
459 bpfinishpy_init, /* tp_init */
460 0, /* tp_alloc */
461 0 /* tp_new */
462};