gdb/python/py-finishbreakpoint.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  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/>.  */



  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"

  33. /* Function that is called when a Python finish bp is found out of scope.  */
  34. ‌static char * const outofscope_func = "out_of_scope";

  36. /* struct implementing the gdb.FinishBreakpoint object by extending
  37.    the gdb.Breakpoint class.  */
  38. ‌struct finish_breakpoint_object
  39. {
  40.   /* gdb.Breakpoint base class.  */
  41.   gdbpy_breakpoint_object py_bp;
  42.   /* gdb.Type object of the value return by the breakpointed function.
  43.      May be NULL if no debug information was available or return type
  44.      was VOID.  */
  45.   PyObject *return_type;
  46.   /* gdb.Value object of the function finished by this breakpoint.  Will be
  47.      NULL if return_type is NULL.  */
  48.   PyObject *function_value;
  49.   /* When stopped at this FinishBreakpoint, gdb.Value object returned by
  50.      the function; Py_None if the value is not computable; NULL if GDB is
  51.      not stopped at a FinishBreakpoint.  */
  52.   PyObject *return_value;
  53. };

  55. static PyTypeObject finish_breakpoint_object_type
  56.     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("finish_breakpoint_object");

  58. /* Python function to get the 'return_value' attribute of
  59.    FinishBreakpoint.  */

  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;

  67.   if (!self_finishbp->return_value)
  68.     Py_RETURN_NONE;

  70.   Py_INCREF (self_finishbp->return_value);
  71.   return self_finishbp->return_value;
  72. }

  74. /* Deallocate FinishBreakpoint object.  */

  76. static void
  77. ‌bpfinishpy_dealloc (PyObject *self)
  78. {
  79.   struct finish_breakpoint_object *self_bpfinish =
  80.         (struct finish_breakpoint_object *) self;

  82.   Py_XDECREF (self_bpfinish->function_value);
  83.   Py_XDECREF (self_bpfinish->return_type);
  84.   Py_XDECREF (self_bpfinish->return_value);
  85. }

  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.  */

  91. void
  92. ‌bpfinishpy_pre_stop_hook (struct gdbpy_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;

  98.   /* Can compute return_value only once.  */
  99.   gdb_assert (!self_finishbp->return_value);

  101.   if (!self_finishbp->return_type)
  102.     return;

  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);

  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. }

  131. /* Triggered when gdbpy_should_stop has triggered the `stop' callback
  132.    of the gdb.FinishBreakpoint object BP_OBJ.  */

  134. void
  135. ‌bpfinishpy_post_stop_hook (struct gdbpy_breakpoint_object *bp_obj)
  136. {
  137.   volatile struct gdb_exception except;

  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. }

  152. /* Python function to create a new breakpoint.  */

  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;

  173.   if (!PyArg_ParseTupleAndKeywords (args, kwargs, "|OO", keywords,
  174.                                     &frame_obj, &internal))
  175.     return -1;

  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);

  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;

  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.     }

  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.     }

  242.   /* Find the function we will return from.  */
  243.   self_bpfinish->return_type = NULL;
  244.   self_bpfinish->function_value = NULL;

  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));

  256.               /* Remember only non-void return types.  */
  257.               if (TYPE_CODE (ret_type) != TYPE_CODE_VOID)
  258.                 {
  259.                   struct value *func_value;

  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);

  279.       self_bpfinish->return_type = NULL;
  280.       self_bpfinish->function_value = NULL;
  281.     }

  283.   bppy_pending_object = &self_bpfinish->py_bp;
  284.   bppy_pending_object->number = -1;
  285.   bppy_pending_object->bp = NULL;

  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;

  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);

  306.   self_bpfinish->py_bp.bp->frame_id = frame_id;
  307.   self_bpfinish->py_bp.is_finish_bp = 1;

  309.   /* Bind the breakpoint with the current program space.  */
  310.   self_bpfinish->py_bp.bp->pspace = current_program_space;

  312.   return 0;
  313. }

  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.  */

  319. static void
  320. ‌bpfinishpy_out_of_scope (struct finish_breakpoint_object *bpfinish_obj)
  321. {
  322.   gdbpy_breakpoint_object *bp_obj = (gdbpy_breakpoint_object *) bpfinish_obj;
  323.   PyObject *py_obj = (PyObject *) bp_obj;

  325.   if (bpfinish_obj->py_bp.bp->enable_state == bp_enabled
  326.       && PyObject_HasAttrString (py_obj, outofscope_func))
  327.     {
  328.       PyObject *meth_result;

  330.       meth_result = PyObject_CallMethod (py_obj, outofscope_func, NULL);
  331.       if (meth_result == NULL)
  332.         gdbpy_print_stack ();
  333.       Py_XDECREF (meth_result);
  334.     }

  336.   delete_breakpoint (bpfinish_obj->py_bp.bp);
  337. }

  339. /* Callback for `bpfinishpy_detect_out_scope'.  Triggers Python's
  340.    `B->out_of_scope' function if B is a FinishBreakpoint out of its scope.  */

  342. static int
  343. ‌bpfinishpy_detect_out_scope_cb (struct breakpoint *b, void *args)
  344. {
  345.   volatile struct gdb_exception except;
  346.   struct breakpoint *bp_stopped = (struct breakpoint *) args;
  347.   PyObject *py_bp = (PyObject *) b->py_bp_object;
  348.   struct gdbarch *garch = b->gdbarch ? b->gdbarch : get_current_arch ();

  350.   /* Trigger out_of_scope if this is a FinishBreakpoint and its frame is
  351.      not anymore in the current callstack.  */
  352.   if (py_bp != NULL && b->py_bp_object->is_finish_bp)
  353.     {
  354.       struct finish_breakpoint_object *finish_bp =
  355.           (struct finish_breakpoint_object *) py_bp;

  357.       /* Check scope if not currently stopped at the FinishBreakpoint.  */
  358.       if (b != bp_stopped)
  359.         {
  360.           TRY_CATCH (except, RETURN_MASK_ALL)
  361.             {
  362.               if (b->pspace == current_inferior ()->pspace
  363.                   && (!target_has_registers
  364.                       || frame_find_by_id (b->frame_id) == NULL))
  365.                 bpfinishpy_out_of_scope (finish_bp);
  366.             }
  367.           if (except.reason < 0)
  368.             {
  369.               gdbpy_convert_exception (except);
  370.               gdbpy_print_stack ();
  371.             }
  372.         }
  373.     }

  375.   return 0;
  376. }

  378. /* Attached to `stop' notifications, check if the execution has run
  379.    out of the scope of any FinishBreakpoint before it has been hit.  */

  381. static void
  382. ‌bpfinishpy_handle_stop (struct bpstats *bs, int print_frame)
  383. {
  384.   struct cleanup *cleanup = ensure_python_env (get_current_arch (),
  385.                                                current_language);

  387.   iterate_over_breakpoints (bpfinishpy_detect_out_scope_cb,
  388.                             bs == NULL ? NULL : bs->breakpoint_at);

  390.   do_cleanups (cleanup);
  391. }

  393. /* Attached to `exit' notifications, triggers all the necessary out of
  394.    scope notifications.  */

  396. static void
  397. ‌bpfinishpy_handle_exit (struct inferior *inf)
  398. {
  399.   struct cleanup *cleanup = ensure_python_env (target_gdbarch (),
  400.                                                current_language);

  402.   iterate_over_breakpoints (bpfinishpy_detect_out_scope_cb, NULL);

  404.   do_cleanups (cleanup);
  405. }

  407. /* Initialize the Python finish breakpoint code.  */

  409. int
  410. ‌gdbpy_initialize_finishbreakpoints (void)
  411. {
  412.   if (PyType_Ready (&finish_breakpoint_object_type) < 0)
  413.     return -1;

  415.   if (gdb_pymodule_addobject (gdb_module, "FinishBreakpoint",
  416.                               (PyObject *) &finish_breakpoint_object_type) < 0)
  417.     return -1;

  419.   observer_attach_normal_stop (bpfinishpy_handle_stop);
  420.   observer_attach_inferior_exit (bpfinishpy_handle_exit);

  422.   return 0;
  423. }

  425. ‌static PyGetSetDef finish_breakpoint_object_getset[] = {
  426.   { "return_value", bpfinishpy_get_returnvalue, NULL,
  427.   "gdb.Value object representing the return value, if any. \
  428. None otherwise.", NULL },
  429.     { NULL }  /* Sentinel.  */
  430. };

  432. ‌static PyTypeObject finish_breakpoint_object_type =
  433. {
  434.   PyVarObject_HEAD_INIT (NULL, 0)
  435.   "gdb.FinishBreakpoint",         /*tp_name*/
  436.   sizeof (struct finish_breakpoint_object),  /*tp_basicsize*/
  437.   0,                              /*tp_itemsize*/
  438.   bpfinishpy_dealloc,             /*tp_dealloc*/
  439.   0,                              /*tp_print*/
  440.   0,                              /*tp_getattr*/
  441.   0,                              /*tp_setattr*/
  442.   0,                              /*tp_compare*/
  443.   0,                              /*tp_repr*/
  444.   0,                              /*tp_as_number*/
  445.   0,                              /*tp_as_sequence*/
  446.   0,                              /*tp_as_mapping*/
  447.   0,                              /*tp_hash */
  448.   0,                              /*tp_call*/
  449.   0,                              /*tp_str*/
  450.   0,                              /*tp_getattro*/
  451.   0,                              /*tp_setattro */
  452.   0,                              /*tp_as_buffer*/
  453.   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /*tp_flags*/
  454.   "GDB finish breakpoint object", /* tp_doc */
  455.   0,                              /* tp_traverse */
  456.   0,                              /* tp_clear */
  457.   0,                              /* tp_richcompare */
  458.   0,                              /* tp_weaklistoffset */
  459.   0,                              /* tp_iter */
  460.   0,                              /* tp_iternext */
  461.   0,                              /* tp_methods */
  462.   0,                              /* tp_members */
  463.   finish_breakpoint_object_getset,/* tp_getset */
  464.   &breakpoint_object_type,        /* tp_base */
  465.   0,                              /* tp_dict */
  466.   0,                              /* tp_descr_get */
  467.   0,                              /* tp_descr_set */
  468.   0,                              /* tp_dictoffset */
  469.   bpfinishpy_init,                /* tp_init */
  470.   0,                              /* tp_alloc */
  471.   0                               /* tp_new */
  472. };