Merge GDB 7.5.1

gdb/python/py-finishbreakpoint.c

 /* Python interface to finish breakpoints
 
    Copyright (C) 2011-2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
@@ skipping 11 matching lines @@
 #include "defs.h"
 #include "exceptions.h"
 #include "python-internal.h"
 #include "breakpoint.h"
 #include "frame.h"
 #include "gdbthread.h"
 #include "arch-utils.h"
 #include "language.h"
 #include "observer.h"
 #include "inferior.h"
+#include "block.h"
 
 static PyTypeObject finish_breakpoint_object_type;
 
 /* Function that is called when a Python finish bp is found out of scope.  */
 static char * const outofscope_func = "out_of_scope";
 
 /* struct implementing the gdb.FinishBreakpoint object by extending
    the gdb.Breakpoint class.  */
 struct finish_breakpoint_object
 {
   /* gdb.Breakpoint base class.  */
   breakpoint_object py_bp;
   /* gdb.Type object of the value return by the breakpointed function.
      May be NULL if no debug information was available or return type
      was VOID.  */
   PyObject *return_type;
-  /* gdb.Type object of the function finished by this breakpoint.  Will be
+  /* gdb.Value object of the function finished by this breakpoint.  Will be
      NULL if return_type is NULL.  */
-  PyObject *function_type;
+  PyObject *function_value;
   /* When stopped at this FinishBreakpoint, gdb.Value object returned by
      the function; Py_None if the value is not computable; NULL if GDB is
      not stopped at a FinishBreakpoint.  */
   PyObject *return_value;
 };
 
 /* Python function to get the 'return_value' attribute of
    FinishBreakpoint.  */
 
 static PyObject *
@@ skipping 10 matching lines @@
 }
 
 /* Deallocate FinishBreakpoint object.  */
 
 static void
 bpfinishpy_dealloc (PyObject *self)
 {
   struct finish_breakpoint_object *self_bpfinish =
         (struct finish_breakpoint_object *) self;
 
-  Py_XDECREF (self_bpfinish->function_type);
+  Py_XDECREF (self_bpfinish->function_value);
   Py_XDECREF (self_bpfinish->return_type);
   Py_XDECREF (self_bpfinish->return_value);
 }
 
 /* Triggered when gdbpy_should_stop is about to execute the `stop' callback
    of the gdb.FinishBreakpoint object BP_OBJ.  Will compute and cache the
    `return_value', if possible.  */
 
 void
 bpfinishpy_pre_stop_hook (struct breakpoint_object *bp_obj)
 {
   struct finish_breakpoint_object *self_finishbp =
         (struct finish_breakpoint_object *) bp_obj;
   volatile struct gdb_exception except;
 
   /* Can compute return_value only once.  */
   gdb_assert (!self_finishbp->return_value);
 
   if (!self_finishbp->return_type)
     return;
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
-      struct value *ret =
-          get_return_value (type_object_to_type (self_finishbp->function_type),
-                            type_object_to_type (self_finishbp->return_type));
+      struct value *function =
+        value_object_to_value (self_finishbp->function_value);
+      struct type *value_type =
+        type_object_to_type (self_finishbp->return_type);
+      struct value *ret = get_return_value (function, value_type);
 
       if (ret)
         {
           self_finishbp->return_value = value_to_value_object (ret);
           if (!self_finishbp->return_value)
               gdbpy_print_stack ();
         }
       else
         {
           Py_INCREF (Py_None);
@@ skipping 108 matching lines @@
       if (internal_bp == -1) 
         {
           PyErr_SetString (PyExc_ValueError, 
                            _("The value of `internal' must be a boolean."));
           return -1;
         }
     }
 
   /* Find the function we will return from.  */
   self_bpfinish->return_type = NULL;
-  self_bpfinish->function_type = NULL;
+  self_bpfinish->function_value = NULL;
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
       if (get_frame_pc_if_available (frame, &pc))
         {
           function = find_pc_function (pc);
           if (function != NULL)
             {
               struct type *ret_type =
                   TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
 
               /* Remember only non-void return types.  */
               if (TYPE_CODE (ret_type) != TYPE_CODE_VOID)
                 {
+                  struct value *func_value;
+
                   /* Ignore Python errors at this stage.  */
                   self_bpfinish->return_type = type_to_type_object (ret_type);
                   PyErr_Clear ();
-                  self_bpfinish->function_type =
-                      type_to_type_object (SYMBOL_TYPE (function));
+                  func_value = read_var_value (function, frame);
+                  self_bpfinish->function_value =
+                      value_to_value_object (func_value);
                   PyErr_Clear ();
                 }
             }
         }
     }
   if (except.reason < 0
-      || !self_bpfinish->return_type || !self_bpfinish->function_type)
+      || !self_bpfinish->return_type || !self_bpfinish->function_value)
     {
       /* Won't be able to compute return value.  */
       Py_XDECREF (self_bpfinish->return_type);
-      Py_XDECREF (self_bpfinish->function_type);
+      Py_XDECREF (self_bpfinish->function_value);
 
       self_bpfinish->return_type = NULL;
-      self_bpfinish->function_type = NULL;
+      self_bpfinish->function_value = NULL;
     }
 
   bppy_pending_object = &self_bpfinish->py_bp;
   bppy_pending_object->number = -1;
   bppy_pending_object->bp = NULL;
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
       /* Set a breakpoint on the return address.  */
       finish_pc = get_frame_pc (prev_frame);
-      sprintf (small_buf, "*%s", hex_string (finish_pc));
+      xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (finish_pc));
       addr_str = small_buf;
 
       create_breakpoint (python_gdbarch,
-                         addr_str, NULL, thread,
+                         addr_str, NULL, thread, NULL,
                          0,
                          1 /*temp_flag*/,
                          bp_breakpoint,
                          0,
                          AUTO_BOOLEAN_TRUE,
                          &bkpt_breakpoint_ops,
                          0, 1, internal_bp, 0);
     }
   GDB_PY_SET_HANDLE_EXCEPTION (except);
   
@@ skipping 11 matching lines @@
   return -1;
 }
 
 /* Called when GDB notices that the finish breakpoint BP_OBJ is out of
    the current callstack.  Triggers the method OUT_OF_SCOPE if implemented,
    then delete the breakpoint.  */
 
 static void
 bpfinishpy_out_of_scope (struct finish_breakpoint_object *bpfinish_obj)
 {
-  volatile struct gdb_exception except;
   breakpoint_object *bp_obj = (breakpoint_object *) bpfinish_obj;
   PyObject *py_obj = (PyObject *) bp_obj;
 
   if (bpfinish_obj->py_bp.bp->enable_state == bp_enabled
       && PyObject_HasAttrString (py_obj, outofscope_func))
     {
       if (!PyObject_CallMethod (py_obj, outofscope_func, NULL))
           gdbpy_print_stack ();
     }
 
@@ skipping 126 matching lines @@
   finish_breakpoint_object_getset,/* tp_getset */
   &breakpoint_object_type,        /* tp_base */
   0,                              /* tp_dict */
   0,                              /* tp_descr_get */
   0,                              /* tp_descr_set */
   0,                              /* tp_dictoffset */
   bpfinishpy_init,                /* tp_init */
   0,                              /* tp_alloc */
   0                               /* tp_new */
 };