1 /* Python interface to finish breakpoints 2 3 Copyright (C) 2011-2013 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 #include "block.h" 33 34 static PyTypeObject finish_breakpoint_object_type; 35 36 /* Function that is called when a Python finish bp is found out of scope. */ 37 static char * const outofscope_func = "out_of_scope"; 38 39 /* struct implementing the gdb.FinishBreakpoint object by extending 40 the gdb.Breakpoint class. */ 41 struct 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; 49 /* gdb.Value object of the function finished by this breakpoint. Will be 50 NULL if return_type is NULL. */ 51 PyObject *function_value; 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 61 static PyObject * 62 bpfinishpy_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 76 static void 77 bpfinishpy_dealloc (PyObject *self) 78 { 79 struct finish_breakpoint_object *self_bpfinish = 80 (struct finish_breakpoint_object *) self; 81 82 Py_XDECREF (self_bpfinish->function_value); 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 91 void 92 bpfinishpy_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 { 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); 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 134 void 135 bpfinishpy_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 154 static int 155 bpfinishpy_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; 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; 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 177 TRY_CATCH (except, RETURN_MASK_ALL) 178 { 179 /* Default frame to newest frame if necessary. */ 180 if (frame_obj == NULL) 181 frame = get_current_frame (); 182 else 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 } 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; 244 self_bpfinish->function_value = NULL; 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 { 259 struct value *func_value; 260 261 /* Ignore Python errors at this stage. */ 262 self_bpfinish->return_type = type_to_type_object (ret_type); 263 PyErr_Clear (); 264 func_value = read_var_value (function, frame); 265 self_bpfinish->function_value = 266 value_to_value_object (func_value); 267 PyErr_Clear (); 268 } 269 } 270 } 271 } 272 if (except.reason < 0 273 || !self_bpfinish->return_type || !self_bpfinish->function_value) 274 { 275 /* Won't be able to compute return value. */ 276 Py_XDECREF (self_bpfinish->return_type); 277 Py_XDECREF (self_bpfinish->function_value); 278 279 self_bpfinish->return_type = NULL; 280 self_bpfinish->function_value = NULL; 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); 291 xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (finish_pc)); 292 addr_str = small_buf; 293 294 create_breakpoint (python_gdbarch, 295 addr_str, NULL, thread, NULL, 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; 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 319 static void 320 bpfinishpy_out_of_scope (struct finish_breakpoint_object *bpfinish_obj) 321 { 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 338 static int 339 bpfinishpy_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 377 static void 378 bpfinishpy_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 392 static void 393 bpfinishpy_handle_exit (struct inferior *inf) 394 { 395 struct cleanup *cleanup = ensure_python_env (target_gdbarch (), 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 405 void 406 gdbpy_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 419 static PyGetSetDef finish_breakpoint_object_getset[] = { 420 { "return_value", bpfinishpy_get_returnvalue, NULL, 421 "gdb.Value object representing the return value, if any. \ 422 None otherwise.", NULL }, 423 { NULL } /* Sentinel. */ 424 }; 425 426 static PyTypeObject finish_breakpoint_object_type = 427 { 428 PyVarObject_HEAD_INIT (NULL, 0) 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 }; 467