gdb/python/py-finishbreakpoint.c

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