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