This is the mail archive of the
gdb@sourceware.org
mailing list for the GDB project.
Re: [RFC] Python Finish Breakpoints
On Mon, May 9, 2011 at 10:10 AM, Kevin Pouget <kevin.pouget@gmail.com> wrote:
> Hello,
>
> I would like to discuss with you guys a new Python interface for
> breakpoint handling. Based on the `finish' command, I prepared a
> Python class which allows to catch the return of a given frame.
> Basically, the motivation behind this class is to allow Python script
> to wrap inferior function calls:
>
> with a code like
> int do_something(int *a)
> {
> ? *a += 5;
> ? sleep(a);
> ? return 10;
> }
> which may take a few seconds to execute, there was no way to know the
> updated value of `a' and the return value (`gdb.execute("finish")'
> could do that, but a Ctrl^C during the `sleep' would have screwed up
> your results).
>
>
> The patch is not supposed to be complete, no CHANGELOG, no
> documentation, and certainly more unit tests required, but that will
> be ready soon.
>
> the class gdb.FinishBreakpoint extends gdb.Breakpoint
>
> the function FinishBreakpoint.__init__ takes the frame to finish as parameter,
>
> the function FinishBreakpoint.stop is triggered as usual (gdb.Breakpoint)
>
> the function FinishBreakpoint.out_of_scope is triggered when GDB
> notices (by observing STOP events) that the breakpointed frame is not
> in the callstack anymore and GDB did not hit the breakpoint yet
> (namely after a `return' command)
>
> the attribute FinishBreakpoint.out_of_scoped is a flag indicating
> whether the breakpointed frame is still the callstack
>
> * by breakpointed frame I mean the frame into which the breakpoint is
> set, not the one that we want to finish (because of sibling calls).
> Currently, reading the value of `FinishBreakpoint.out_of_scoped'
> actually check if the frame exists and update the value. IF it is not
> (=True), the callback is not triggered, and won't be, until
> `out_of_scoped' is re-enabled (set to False)
>
>
> the attribute FinishBreakpoint.return_value gives, if GDB is stopped
> at a FinishBreakpoint, the gdb.Value object corresponding to the
> return value.
> there is one problem behind this function, I had to change the code:
>
> +++ b/gdb/infrun.c
> @@ -5826,7 +5826,7 @@ normal_stop (void)
> ? /* Save the function value return registers, if we care.
> ? ? ?We might be about to restore their previous contents. ?*/
> - ?if (inferior_thread ()->control.proceed_to_finish)
> + ?/*if (inferior_thread ()->control.proceed_to_finish)*/
> ? ?...
> ? ?stop_registers = regcache_dup (get_current_regcache ());
>
> to correctly set `stop_registers', but I don't really know the
> implication of this modification ...
>
> the testsuite gives some examples about how it works
here is a version of the patch which better reflects what I described,
some parts were missing in the former post.
Kevin
--
From 94c7e70354b4eef80352c6306365f37339bc1a5e Mon Sep 17 00:00:00 2001
From: Kevin Pouget <kevin.pouget@st.com>
Date: Mon, 9 May 2011 15:20:48 -0400
Subject: [PATCH] Python Finish Breakpoints
---
gdb/Makefile.in | 6 +
gdb/breakpoint.c | 2 +-
gdb/breakpoint.h | 10 +
gdb/infcmd.c | 19 +-
gdb/inferior.h | 3 +
gdb/infrun.c | 2 +-
gdb/python/py-breakpoint.c | 79 ++---
gdb/python/py-breakpoint.h | 61 ++++
gdb/python/py-finishbreakpoint.c | 384 +++++++++++++++++++++
gdb/python/py-frame.c | 32 +-
gdb/python/python-internal.h | 3 +
gdb/python/python.c | 1 +
gdb/testsuite/gdb.python/py-breakpoint.c | 16 +-
gdb/testsuite/gdb.python/py-breakpoint.exp | 7 +-
gdb/testsuite/gdb.python/py-finish-breakpoint.exp | 63 ++++
gdb/testsuite/gdb.python/py-finish-breakpoint.py | 21 ++
16 files changed, 629 insertions(+), 80 deletions(-)
create mode 100644 gdb/python/py-breakpoint.h
create mode 100644 gdb/python/py-finishbreakpoint.c
create mode 100644 gdb/testsuite/gdb.python/py-finish-breakpoint.exp
create mode 100644 gdb/testsuite/gdb.python/py-finish-breakpoint.py
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index 5bab360..3955b38 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -279,6 +279,7 @@ SUBDIR_PYTHON_OBS = \
py-block.o \
py-bpevent.o \
py-breakpoint.o \
+ py-finishbreakpoint.o \
py-cmd.o \
py-continueevent.o \
py-event.o \
@@ -309,6 +310,7 @@ SUBDIR_PYTHON_SRCS = \
python/py-block.c \
python/py-bpevent.c \
python/py-breakpoint.c \
+ python/py-finishbreakpoint.c \
python/py-cmd.c \
python/py-continueevent.c \
python/py-event.c \
@@ -2038,6 +2040,10 @@ py-breakpoint.o: $(srcdir)/python/py-breakpoint.c
$(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-breakpoint.c
$(POSTCOMPILE)
+py-finishbreakpoint.o: $(srcdir)/python/py-finishbreakpoint.c
+ $(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-finishbreakpoint.c
+ $(POSTCOMPILE)
+
py-cmd.o: $(srcdir)/python/py-cmd.c
$(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-cmd.c
$(POSTCOMPILE)
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index b5fc448..eff5e23 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -7330,7 +7330,7 @@ bp_loc_is_permanent (struct bp_location *loc)
as textual description of the location, and COND_STRING
as condition expression. */
-static void
+void
create_breakpoint_sal (struct gdbarch *gdbarch,
struct symtabs_and_lines sals, char *addr_string,
char *cond_string,
diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h
index 7a9c2d4..a003651 100644
--- a/gdb/breakpoint.h
+++ b/gdb/breakpoint.h
@@ -986,6 +986,16 @@ extern int create_breakpoint (struct gdbarch
*gdbarch, char *arg,
int enabled,
int internal);
+extern void create_breakpoint_sal (struct gdbarch *gdbarch,
+ struct symtabs_and_lines sals,
+ char *addr_string,
+ char *cond_string,
+ enum bptype type, enum bpdisp disposition,
+ int thread, int task, int ignore_count,
+ struct breakpoint_ops *ops, int from_tty,
+ int enabled, int internal,
+ int display_canonical);
+
extern void insert_breakpoints (void);
extern int remove_breakpoints (void);
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index fce1e8f..c19a04b 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -1378,14 +1378,12 @@ advance_command (char *arg, int from_tty)
until_break_command (arg, from_tty, 1);
}
-/* Print the result of a function at the end of a 'finish' command. */
+/* Returns the value of the result at the end of a 'finish' command/BP. */
-static void
-print_return_value (struct type *func_type, struct type *value_type)
+struct value *
+get_return_value (struct type *func_type, struct type *value_type)
{
struct gdbarch *gdbarch = get_regcache_arch (stop_registers);
- struct cleanup *old_chain;
- struct ui_stream *stb;
struct value *value;
CHECK_TYPEDEF (value_type);
@@ -1415,6 +1413,17 @@ print_return_value (struct type *func_type,
struct type *value_type)
internal_error (__FILE__, __LINE__, _("bad switch"));
}
+ return value;
+}
+/* Print the result of a function at the end of a 'finish' command. */
+
+static void
+print_return_value (struct type *func_type, struct type *value_type)
+{
+ struct value *value = get_return_value(func_type, value_type);
+ struct cleanup *old_chain;
+ struct ui_stream *stb;
+
if (value)
{
struct value_print_options opts;
diff --git a/gdb/inferior.h b/gdb/inferior.h
index f8adb6c..b8d5b13 100644
--- a/gdb/inferior.h
+++ b/gdb/inferior.h
@@ -285,6 +285,9 @@ extern void detach_command (char *, int);
extern void notice_new_inferior (ptid_t, int, int);
+extern struct value *get_return_value (struct type *func_type,
+ struct type *value_type);
+
/* Address at which inferior stopped. */
extern CORE_ADDR stop_pc;
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 2d6d523..11fd0da 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -5826,7 +5826,7 @@ normal_stop (void)
/* Save the function value return registers, if we care.
We might be about to restore their previous contents. */
- if (inferior_thread ()->control.proceed_to_finish)
+ /*if (inferior_thread ()->control.proceed_to_finish)*/
{
/* This should not be necessary. */
if (stop_registers)
diff --git a/gdb/python/py-breakpoint.c b/gdb/python/py-breakpoint.c
index 9c33848..db2c411 100644
--- a/gdb/python/py-breakpoint.c
+++ b/gdb/python/py-breakpoint.c
@@ -17,6 +17,8 @@
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+
#include "defs.h"
#include "value.h"
#include "exceptions.h"
@@ -30,53 +32,18 @@
#include "ada-lang.h"
#include "arch-utils.h"
#include "language.h"
-
-static PyTypeObject breakpoint_object_type;
+#include "py-breakpoint.h"
/* Number of live breakpoints. */
static int bppy_live;
/* Variables used to pass information between the Breakpoint
constructor and the breakpoint-created hook function. */
-static breakpoint_object *bppy_pending_object;
+breakpoint_object *bppy_pending_object;
/* Function that is called when a Python condition is evaluated. */
static char * const stop_func = "stop";
-struct breakpoint_object
-{
- PyObject_HEAD
-
- /* The breakpoint number according to gdb. */
- int number;
-
- /* The gdb breakpoint object, or NULL if the breakpoint has been
- deleted. */
- struct breakpoint *bp;
-};
-
-/* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
- exception if it is invalid. */
-#define BPPY_REQUIRE_VALID(Breakpoint) \
- do { \
- if ((Breakpoint)->bp == NULL) \
- return PyErr_Format (PyExc_RuntimeError, \
- _("Breakpoint %d is invalid."), \
- (Breakpoint)->number); \
- } while (0)
-
-/* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
- exception if it is invalid. This macro is for use in setter functions. */
-#define BPPY_SET_REQUIRE_VALID(Breakpoint) \
- do { \
- if ((Breakpoint)->bp == NULL) \
- { \
- PyErr_Format (PyExc_RuntimeError, _("Breakpoint %d is invalid."), \
- (Breakpoint)->number); \
- return -1; \
- } \
- } while (0)
-
/* This is used to initialize various gdb.bp_* constants. */
struct pybp_code
{
@@ -806,21 +773,25 @@ gdbpy_breakpoint_created (struct breakpoint *bp)
}
else
newbp = PyObject_New (breakpoint_object, &breakpoint_object_type);
- if (newbp)
- {
- newbp->number = bp->number;
- newbp->bp = bp;
- newbp->bp->py_bp_object = newbp;
- Py_INCREF (newbp);
- ++bppy_live;
- }
- else
- {
- PyErr_SetString (PyExc_RuntimeError,
- _("Error while creating breakpoint from GDB."));
- gdbpy_print_stack ();
- }
+
+ if (!newbp)
+ goto fail;
+
+ newbp->number = bp->number;
+ newbp->bp = bp;
+ newbp->bp->py_bp_object = newbp;
+
+ Py_INCREF (newbp);
+ ++bppy_live;
+
+ goto success;
+
+fail:
+ PyErr_SetString (PyExc_RuntimeError,
+ _("Error while creating breakpoint from GDB."));
+ gdbpy_print_stack ();
+success:
PyGILState_Release (state);
}
@@ -971,14 +942,14 @@ static PyMethodDef breakpoint_object_methods[] =
{ NULL } /* Sentinel. */
};
-static PyTypeObject breakpoint_object_type =
+PyTypeObject breakpoint_object_type =
{
PyObject_HEAD_INIT (NULL)
0, /*ob_size*/
"gdb.Breakpoint", /*tp_name*/
sizeof (breakpoint_object), /*tp_basicsize*/
0, /*tp_itemsize*/
- 0, /*tp_dealloc*/
+ 0, /*tp_dealloc*/
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tp_setattr*/
@@ -1008,7 +979,7 @@ static PyTypeObject breakpoint_object_type =
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
- 0, /* tp_dictoffset */
+ 0, /* tp_dictoffset */
bppy_init, /* tp_init */
0, /* tp_alloc */
PyType_GenericNew /* tp_new */
diff --git a/gdb/python/py-breakpoint.h b/gdb/python/py-breakpoint.h
new file mode 100644
index 0000000..827f488
--- /dev/null
+++ b/gdb/python/py-breakpoint.h
@@ -0,0 +1,61 @@
+/* Python interface to breakpoints
+
+ Copyright (C) 2008, 2009, 2010, 2011 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.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef GDB_PY_BREAKPOINT_H
+#define GDB_PY_BREAKPOINT_H
+
+/* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
+ exception if it is invalid. */
+#define BPPY_REQUIRE_VALID(Breakpoint) \
+ do { \
+ if ((Breakpoint)->bp == NULL) \
+ return PyErr_Format (PyExc_RuntimeError, \
+ _("Breakpoint %d is invalid."), \
+ (Breakpoint)->number); \
+ } while (0)
+
+/* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
+ exception if it is invalid. This macro is for use in setter functions. */
+#define BPPY_SET_REQUIRE_VALID(Breakpoint) \
+ do { \
+ if ((Breakpoint)->bp == NULL) \
+ { \
+ PyErr_Format (PyExc_RuntimeError, _("Breakpoint %d is invalid."), \
+ (Breakpoint)->number); \
+ return -1; \
+ } \
+ } while (0)
+
+struct breakpoint_object
+{
+ PyObject_HEAD
+
+ /* The breakpoint number according to gdb. */
+ int number;
+
+ /* The gdb breakpoint object, or NULL if the breakpoint has been
+ deleted. */
+ struct breakpoint *bp;
+};
+
+/* Variables used to pass information between the Breakpoint
+ constructor and the breakpoint-created hook function. */
+extern breakpoint_object *bppy_pending_object;
+
+#endif /* GDB_PY_BREAKPOINT_H */
diff --git a/gdb/python/py-finishbreakpoint.c b/gdb/python/py-finishbreakpoint.c
new file mode 100644
index 0000000..bccb69f
--- /dev/null
+++ b/gdb/python/py-finishbreakpoint.c
@@ -0,0 +1,384 @@
+/* Python interface to finish breakpoints
+
+ Copyright (C) 2011 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.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+
+
+#include "defs.h"
+#include "exceptions.h"
+#include "python-internal.h"
+#include "breakpoint.h"
+#include "py-breakpoint.h"
+#include "frame.h"
+#include "gdbthread.h"
+#include "arch-utils.h"
+#include "language.h"
+#include "observer.h"
+#include "inferior.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. */
+ struct breakpoint_object py_bp;
+ /* Flag indicating that the BP is out of the callstack and Python callback
+ has been triggered. */
+ int out_of_scoped;
+ /* The function finished by this breakpoint. */
+ struct symbol *function;
+};
+
+/* Python function to set the 'out_of_scoped' attribute of
+ FinishBreakpoint. */
+
+static int
+bpfinishpy_set_outofscoped (PyObject *self, PyObject *newvalue, void *closure)
+{
+ struct finish_breakpoint_object *self_finishbp =
+ (struct finish_breakpoint_object *) self;
+ int cmp;
+
+ BPPY_SET_REQUIRE_VALID (&self_finishbp->py_bp);
+
+ if (newvalue == NULL)
+ {
+ PyErr_SetString (PyExc_TypeError,
+ _("Cannot delete `out_of_scoped' attribute."));
+ return -1;
+ }
+ else if (! PyBool_Check (newvalue))
+ {
+ PyErr_SetString (PyExc_TypeError,
+ _("The value of `out_of_scoped' must be a boolean."));
+ return -1;
+ }
+
+ cmp = PyObject_IsTrue (newvalue);
+ if (cmp < 0)
+ return -1;
+ else
+ self_finishbp->out_of_scoped = cmp;
+
+ return 0;
+}
+
+/* Python function to update and get the 'out_of_scoped' attribute
+ of FinishBreakpoint. */
+
+static PyObject *
+bpfinishpy_get_outofscoped (PyObject *self, void *closure)
+{
+ struct finish_breakpoint_object *self_finishbp =
+ (struct finish_breakpoint_object *) self;
+
+ BPPY_REQUIRE_VALID (&self_finishbp->py_bp);
+
+ if (!self_finishbp->out_of_scoped)
+ self_finishbp->out_of_scoped =
+ frame_find_by_id(self_finishbp->py_bp.bp->frame_id) == NULL ;
+
+ if (self_finishbp->out_of_scoped)
+ Py_RETURN_TRUE;
+ Py_RETURN_FALSE;
+}
+
+/* Python function to get the 'return_value' attribute of
+ FinishBreakpoint. */
+
+static PyObject *
+bpfinishpy_get_returnvalue (PyObject *self, void *closure)
+{
+ struct finish_breakpoint_object *self_finishbp =
+ (struct finish_breakpoint_object *) self;
+
+ BPPY_REQUIRE_VALID (&self_finishbp->py_bp);
+
+ if (self_finishbp->function == NULL)
+ goto return_none;
+
+ /* Ensure that GDB is stopped at this FinishBreakpoint. */
+ if (inferior_thread ()->control.stop_bpstat != NULL)
+ {
+ bpstat bs;
+
+ for(bs = inferior_thread ()->control.stop_bpstat;
+ bs; bs = bs->next)
+ {
+ struct breakpoint *bp = bs->breakpoint_at;
+ if (bp != NULL
+ && (PyObject *) bp->py_bp_object == self)
+ {
+ struct type *v_type;
+
+ v_type = TYPE_TARGET_TYPE (SYMBOL_TYPE
+ (self_finishbp->function));
+ if (!v_type)
+ internal_error (__FILE__, __LINE__,
+ _("bpfinishpy_get_returnvalue: function has no target type"));
+
+ if (TYPE_CODE (v_type) != TYPE_CODE_VOID)
+ {
+ struct value *ret = get_return_value
+ (SYMBOL_TYPE (self_finishbp->function), v_type);
+ PyObject *return_value = value_to_value_object (ret);
+
+ Py_INCREF (return_value);
+ return return_value;
+ }
+ else
+ goto return_none;
+ }
+ }
+ }
+
+return_none:
+ Py_INCREF (Py_None);
+ return Py_None ;
+}
+
+/* Called when GDB notices that the finish breakpoint BP_OBJ is out of
+ the current callstack. If BP_OBJ has the attribute OUT_OF_SCOPED and
+ its value is FALSE, trigger the method OUT_OF_SCOPE and set the flag to
+ TRUE. */
+
+void
+gdbpy_out_of_scope (struct finish_breakpoint_object *bpfinish_obj)
+{
+ breakpoint_object *bp_obj = (breakpoint_object *) bpfinish_obj;
+ PyObject *py_obj = (PyObject *) bp_obj ;
+
+ if (PyObject_HasAttrString (py_obj, outofscope_func))
+ {
+ struct gdbarch *garch = bp_obj->bp->gdbarch ?
+ bp_obj->bp->gdbarch : get_current_arch ();
+ struct cleanup *cleanup = ensure_python_env (garch, current_language);
+
+ if (!PyObject_CallMethod (py_obj, outofscope_func, NULL))
+ gdbpy_print_stack ();
+
+ do_cleanups (cleanup);
+ }
+ bpfinish_obj->out_of_scoped = 1;
+}
+
+/* Python function to create a new breakpoint. */
+
+static int
+bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs)
+{
+ static char *keywords[] = { "frame", "internal", NULL };
+ breakpoint_object *self_bp = (breakpoint_object *) self;
+ struct finish_breakpoint_object *self_bpfinish =
+ (struct finish_breakpoint_object *) self;
+ int type = bp_breakpoint;
+ PyObject *frame_obj = NULL;
+ struct frame_info *frame, *prev_frame;
+ struct frame_id frame_id;
+ struct symtabs_and_lines sals;
+ struct symtab_and_line sal;
+ PyObject *internal = NULL;
+ int internal_bp = 0;
+ CORE_ADDR pc ;
+ volatile struct gdb_exception except;
+
+ if (! PyArg_ParseTupleAndKeywords (args, kwargs, "O|O", keywords,
+ &frame_obj, &internal))
+ return -1;
+
+ if (!frame_obj)
+ goto invalid_frame;
+
+ frame = frame_object_to_frame_info (frame_obj);
+ if (frame == NULL)
+ goto invalid_frame;
+
+ prev_frame = get_prev_frame(frame);
+ if (prev_frame == 0)
+ {
+ PyErr_SetString (PyExc_ValueError,
+ _("\"FinishBreakpoint\" not meaningful in the outermost frame."));
+ return -1;
+ }
+
+ frame_id = get_frame_id (prev_frame);
+ if (frame_id_eq(frame_id, null_frame_id))
+ goto invalid_frame;
+
+ pc = get_frame_pc (prev_frame);
+
+ sal = find_pc_line (pc, 0);
+ sal.pc = pc;
+ sals.sals = &sal;
+ sals.nelts = 1;
+
+ /* Find the function we will return from. */
+ self_bpfinish->function = find_pc_function (get_frame_pc (frame));
+
+ if (internal)
+ {
+ internal_bp = PyObject_IsTrue (internal);
+ if (internal_bp == -1)
+ {
+ PyErr_SetString (PyExc_ValueError,
+ _("The value of `internal' must be a boolean."));
+ return -1;
+ }
+ }
+
+ bppy_pending_object = self_bp;
+ bppy_pending_object->number = -1;
+ bppy_pending_object->bp = NULL;
+
+ TRY_CATCH (except, RETURN_MASK_ALL)
+ {
+ create_breakpoint_sal (python_gdbarch, sals, NULL, NULL,
+ bp_breakpoint, disp_donttouch, -1,
+ 0, 0, NULL, 0, 1, internal_bp, 0) ;
+ }
+ if (except.reason < 0)
+ {
+ PyErr_Format (except.reason == RETURN_QUIT
+ ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
+ "%s", except.message);
+ return -1;
+ }
+ BPPY_SET_REQUIRE_VALID (self_bp);
+
+ self_bp->bp->frame_id = frame_id;
+
+ self_bpfinish->out_of_scoped = 0;
+
+ return 0;
+
+invalid_frame:
+ PyErr_SetString (PyExc_ValueError,
+ _("Invalid ID for the `frame' object."));
+ return -1;
+}
+
+/* Callback for `bpfinishpy_detect_out_scope'*/
+
+static int
+bpfinishpy_detect_out_scope_cb (struct breakpoint *b, void *args)
+{
+ struct breakpoint *bp_stopped = (struct breakpoint *) args;
+ PyObject *py_bp = (PyObject *) b->py_bp_object;
+ PyGILState_STATE state;
+
+ /* Prevent python SEGFAULT because of missing thread state. */
+ state = PyGILState_Ensure();
+
+ /* Trigger out_of_scope notification if this is a FinishBreakpoint
+ and GDB is stopped at this bp or its frame is not in the current
+ callstack and the notification has not been sent yet. */
+ if (py_bp != NULL
+ && PyObject_TypeCheck (py_bp, &finish_breakpoint_object_type)
+ && (b == bp_stopped || frame_find_by_id(b->frame_id) == NULL)
+ && !((struct finish_breakpoint_object *) py_bp)->out_of_scoped)
+ {
+ gdbpy_out_of_scope ((struct finish_breakpoint_object *) py_bp);
+ }
+
+ PyGILState_Release (state);
+
+ return 0;
+}
+
+/* Attached to `stop' notifications, check if the execution has run out
+ out of the scope of any FinishBreakpoint before it has been hit. */
+
+static void
+bpfinishpy_handle_stop (struct bpstats *bs, int print_frame)
+{
+ iterate_over_breakpoints (bpfinishpy_detect_out_scope_cb,
+ bs == NULL ? NULL : bs->breakpoint_at);
+}
+
+/* Initialize the Python finish breakpoint code. */
+
+void
+gdbpy_initialize_finishbreakpoints (void)
+{
+ if (PyType_Ready (&finish_breakpoint_object_type) < 0)
+ return;
+
+ Py_INCREF (&finish_breakpoint_object_type);
+ PyModule_AddObject (gdb_module, "FinishBreakpoint",
+ (PyObject *) &finish_breakpoint_object_type);
+
+ observer_attach_normal_stop (bpfinishpy_handle_stop);
+}
+
+static PyGetSetDef finish_breakpoint_object_getset[] = {
+ { "out_of_scoped", bpfinishpy_get_outofscoped, bpfinishpy_set_outofscoped,
+ "Boolean telling whether the breakpoint is still within the scope \
+of the current callstack.", NULL },
+ { "return_value", bpfinishpy_get_returnvalue, NULL,
+ "gdb.Value object representing the return value, if any. \
+None otherwise.", NULL },
+ { NULL } /* Sentinel. */
+};
+
+static PyTypeObject finish_breakpoint_object_type =
+{
+ PyObject_HEAD_INIT (NULL)
+ 0, /*ob_size*/
+ "gdb.FinishBreakpoint", /*tp_name*/
+ sizeof (struct finish_breakpoint_object), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ 0, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash */
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro */
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "GDB finish breakpoint object", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ 0, /* tp_methods */
+ 0, /* tp_members */
+ 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 */
+};
diff --git a/gdb/python/py-frame.c b/gdb/python/py-frame.c
index d7128a9..2109c73 100644
--- a/gdb/python/py-frame.c
+++ b/gdb/python/py-frame.c
@@ -60,9 +60,10 @@ static PyTypeObject frame_object_type;
object. If the frame doesn't exist anymore (the frame id doesn't
correspond to any frame in the inferior), returns NULL. */
-static struct frame_info *
-frame_object_to_frame_info (frame_object *frame_obj)
+struct frame_info *
+frame_object_to_frame_info (PyObject *obj)
{
+ frame_object *frame_obj = (frame_object *) obj;
struct frame_info *frame;
frame = frame_find_by_id (frame_obj->frame_id);
@@ -103,7 +104,7 @@ frapy_is_valid (PyObject *self, PyObject *args)
{
struct frame_info *frame;
- frame = frame_object_to_frame_info ((frame_object *) self);
+ frame = frame_object_to_frame_info (self);
if (frame == NULL)
Py_RETURN_FALSE;
@@ -124,7 +125,7 @@ frapy_name (PyObject *self, PyObject *args)
TRY_CATCH (except, RETURN_MASK_ALL)
{
- FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
+ FRAPY_REQUIRE_VALID (self, frame);
find_frame_funname (frame, &name, &lang, NULL);
}
@@ -153,7 +154,7 @@ frapy_type (PyObject *self, PyObject *args)
TRY_CATCH (except, RETURN_MASK_ALL)
{
- FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
+ FRAPY_REQUIRE_VALID (self, frame);
type = get_frame_type (frame);
}
@@ -174,7 +175,7 @@ frapy_unwind_stop_reason (PyObject *self, PyObject *args)
TRY_CATCH (except, RETURN_MASK_ALL)
{
- FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
+ FRAPY_REQUIRE_VALID (self, frame);
}
GDB_PY_HANDLE_EXCEPTION (except);
@@ -195,7 +196,7 @@ frapy_pc (PyObject *self, PyObject *args)
TRY_CATCH (except, RETURN_MASK_ALL)
{
- FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
+ FRAPY_REQUIRE_VALID (self, frame);
pc = get_frame_pc (frame);
}
@@ -216,7 +217,7 @@ frapy_block (PyObject *self, PyObject *args)
TRY_CATCH (except, RETURN_MASK_ALL)
{
- FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
+ FRAPY_REQUIRE_VALID (self, frame);
block = get_frame_block (frame, NULL);
}
GDB_PY_HANDLE_EXCEPTION (except);
@@ -257,7 +258,7 @@ frapy_function (PyObject *self, PyObject *args)
TRY_CATCH (except, RETURN_MASK_ALL)
{
- FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
+ FRAPY_REQUIRE_VALID (self, frame);
sym = find_pc_function (get_frame_address_in_block (frame));
}
@@ -319,7 +320,7 @@ frapy_older (PyObject *self, PyObject *args)
TRY_CATCH (except, RETURN_MASK_ALL)
{
- FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
+ FRAPY_REQUIRE_VALID (self, frame);
prev = get_prev_frame (frame);
if (prev)
@@ -348,7 +349,7 @@ frapy_newer (PyObject *self, PyObject *args)
TRY_CATCH (except, RETURN_MASK_ALL)
{
- FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
+ FRAPY_REQUIRE_VALID (self, frame);
next = get_next_frame (frame);
if (next)
@@ -377,7 +378,7 @@ frapy_find_sal (PyObject *self, PyObject *args)
TRY_CATCH (except, RETURN_MASK_ALL)
{
- FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
+ FRAPY_REQUIRE_VALID (self, frame);
find_frame_sal (frame, &sal);
sal_obj = symtab_and_line_to_sal_object (sal);
@@ -433,7 +434,7 @@ frapy_read_var (PyObject *self, PyObject *args)
TRY_CATCH (except, RETURN_MASK_ALL)
{
- FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
+ FRAPY_REQUIRE_VALID (self, frame);
if (!block)
block = get_frame_block (frame, NULL);
@@ -461,7 +462,7 @@ frapy_read_var (PyObject *self, PyObject *args)
TRY_CATCH (except, RETURN_MASK_ALL)
{
- FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
+ FRAPY_REQUIRE_VALID (self, frame);
val = read_var_value (var, frame);
}
@@ -484,12 +485,11 @@ static PyObject *
frapy_select (PyObject *self, PyObject *args)
{
struct frame_info *fi;
- frame_object *frame = (frame_object *) self;
volatile struct gdb_exception except;
TRY_CATCH (except, RETURN_MASK_ALL)
{
- FRAPY_REQUIRE_VALID (frame, fi);
+ FRAPY_REQUIRE_VALID (self, fi);
select_frame (fi);
}
diff --git a/gdb/python/python-internal.h b/gdb/python/python-internal.h
index d3cb788..9ec1981 100644
--- a/gdb/python/python-internal.h
+++ b/gdb/python/python-internal.h
@@ -114,6 +114,7 @@ extern PyTypeObject symbol_object_type;
extern PyTypeObject event_object_type;
extern PyTypeObject events_object_type;
extern PyTypeObject stop_event_object_type;
+extern PyTypeObject breakpoint_object_type;
/* Defined in py-breakpoint.c */
typedef struct breakpoint_object breakpoint_object;
@@ -161,6 +162,7 @@ PyObject *block_to_block_object (struct block
*block, struct objfile *objfile);
PyObject *value_to_value_object (struct value *v);
PyObject *type_to_type_object (struct type *);
PyObject *frame_info_to_frame_object (struct frame_info *frame);
+struct frame_info *frame_object_to_frame_info (PyObject *frame_obj);
PyObject *pspace_to_pspace_object (struct program_space *);
PyObject *pspy_get_printers (PyObject *, void *);
@@ -194,6 +196,7 @@ void gdbpy_initialize_functions (void);
void gdbpy_initialize_pspace (void);
void gdbpy_initialize_objfile (void);
void gdbpy_initialize_breakpoints (void);
+void gdbpy_initialize_finishbreakpoints (void);
void gdbpy_initialize_lazy_string (void);
void gdbpy_initialize_parameters (void);
void gdbpy_initialize_thread (void);
diff --git a/gdb/python/python.c b/gdb/python/python.c
index 8a7bc66..d620382 100644
--- a/gdb/python/python.c
+++ b/gdb/python/python.c
@@ -1060,6 +1060,7 @@ Enables or disables printing of Python stack traces."),
gdbpy_initialize_pspace ();
gdbpy_initialize_objfile ();
gdbpy_initialize_breakpoints ();
+ gdbpy_initialize_finishbreakpoints();
gdbpy_initialize_lazy_string ();
gdbpy_initialize_thread ();
gdbpy_initialize_inferior ();
diff --git a/gdb/testsuite/gdb.python/py-breakpoint.c
b/gdb/testsuite/gdb.python/py-breakpoint.c
index 9a96681..f32ff78 100644
--- a/gdb/testsuite/gdb.python/py-breakpoint.c
+++ b/gdb/testsuite/gdb.python/py-breakpoint.c
@@ -29,18 +29,32 @@ int add (int i)
return i + i;
}
+int increase_1(int *a)
+{
+ *a += 1;
+ return -5;
+}
+
+void increase(int *a)
+{
+ increase_1(a);
+}
int main (int argc, char *argv[])
{
int foo = 5;
int bar = 42;
int i;
+ i = 0 ;
+ /* Break at increase. */
+ increase (&i) ;
+ increase (&i) ;
for (i = 0; i < 10; i++)
{
result += multiply (foo); /* Break at multiply. */
result += add (bar); /* Break at add. */
}
-
+
return 0; /* Break at end. */
}
diff --git a/gdb/testsuite/gdb.python/py-breakpoint.exp
b/gdb/testsuite/gdb.python/py-breakpoint.exp
index f0a83f1..8755888 100644
--- a/gdb/testsuite/gdb.python/py-breakpoint.exp
+++ b/gdb/testsuite/gdb.python/py-breakpoint.exp
@@ -44,7 +44,8 @@ gdb_py_test_silent_cmd "python blist =
gdb.breakpoints()" "Get Breakpoint List"
gdb_test "python print blist\[0\]" "<gdb.Breakpoint object at $hex>"
"Check obj exists"
gdb_test "python print blist\[0\].location" "main." "Check breakpoint location"
-gdb_breakpoint [gdb_get_line_number "Break at multiply."]
+set mult_line [gdb_get_line_number "Break at multiply."]
+gdb_breakpoint ${mult_line}
gdb_continue_to_breakpoint "Break at multiply."
# Check that the Python breakpoint code noted the addition of a
@@ -54,7 +55,9 @@ gdb_test "python print len(blist)" "2" "Check for
two breakpoints"
gdb_test "python print blist\[0\]" "<gdb.Breakpoint object at $hex>"
"Check obj exists"
gdb_test "python print blist\[0\].location" "main." "Check breakpoint location"
gdb_test "python print blist\[1\]" "<gdb.Breakpoint object at $hex>"
"Check obj exists"
-gdb_test "python print blist\[1\].location" "py-breakpoint\.c:41*"
"Check breakpoint location"
+
+gdb_test "python print blist\[1\].location" "py-breakpoint\.c:${mult_line}*" \
+ "Check breakpoint location"
# Check hit and ignore counts.
gdb_test "python print blist\[1\].hit_count" "1" "Check breakpoint hit count"
diff --git a/gdb/testsuite/gdb.python/py-finish-breakpoint.exp
b/gdb/testsuite/gdb.python/py-finish-breakpoint.exp
new file mode 100644
index 0000000..febef50
--- /dev/null
+++ b/gdb/testsuite/gdb.python/py-finish-breakpoint.exp
@@ -0,0 +1,63 @@
+# Copyright (C) 2010, 2011 Free Software Foundation, Inc.
+#
+# 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.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# This file is part of the GDB testsuite. It tests the mechanism
+# exposing values to Python.
+
+if $tracelevel then {
+ strace $tracelevel
+}
+
+load_lib gdb-python.exp
+
+set testfile "py-breakpoint"
+set srcfile ${testfile}.c
+set remote_python_file [remote_download host
${srcdir}/${subdir}/py-finish-breakpoint.py]
+
+if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+ return -1
+}
+
+# Skip all tests if Python scripting is not enabled.
+if { [skip_python_tests] } { continue }
+
+if ![runto_main] then {
+ fail "Cannot run to main."
+ return 0
+}
+
+gdb_test "source $remote_python_file" ".*Python script imported.*"
"import python scripts"
+
+gdb_test "python MyBreakpoint(\"increase_1\")" ".*Breakpoint 2.*"
"create Python function breakpoint"
+
+gdb_test "continue" ".*Arrived at MyBreakpoint with 0.*" "check
MyBreakpoint hit"
+gdb_test "python finishbp = MyFinishBreakpoint (gdb.parse_and_eval
(\"a\"), gdb.selected_frame ())" ".*Breakpoint 3.*" "set
FinishBreakpoint"
+gdb_test "python print finishbp.out_of_scoped" ".*False.*" "check
out_of_scoped init"
+gdb_test "python print finishbp.return_value" ".*None.*" "check return_value"
+
+gdb_test "continue" ".*MyFinishBreakpoint stop with
1.*#0.*increase.*" "check MyFinishBreakpoint hit"
+gdb_test "python print finishbp.return_value" ".*-5.*" "check return_value"
+gdb_test "python print finishbp.out_of_scoped" ".*False.*" "check
out_of_scoped after hit"
+gdb_test "finish" ".*Run til.*" "return to main()"
+gdb_test "python print finishbp.return_value" ".*None.*" "check return_value"
+
+gdb_test "continue" ".*Arrived at MyBreakpoint with 1.*" "check
MyBreakpoint second hit"
+gdb_test "up" ".*increase_1.*" "go one frame up"
+gdb_test_no_output "python finishbp.out_of_scoped = False" "re-enable
out_of_scoped"
+gdb_test_no_output "set confirm off" "disable confirmation"
+gdb_test_no_output "return" "return from the frame"
+
+gdb_test "next" ".*MyFinishBreakpoint out of scope.*" "check Finish
breakpoint discard"
+gdb_test "python print finishbp.out_of_scoped" ".*True.*" "check out_of_scoped"
\ No newline at end of file
diff --git a/gdb/testsuite/gdb.python/py-finish-breakpoint.py
b/gdb/testsuite/gdb.python/py-finish-breakpoint.py
new file mode 100644
index 0000000..ea82fe9
--- /dev/null
+++ b/gdb/testsuite/gdb.python/py-finish-breakpoint.py
@@ -0,0 +1,21 @@
+class MyBreakpoint(gdb.Breakpoint):
+ def stop(self):
+ val = gdb.parse_and_eval ("a")
+ print "Arrived at MyBreakpoint with %d" % int(val.dereference())
+ return True
+
+class MyFinishBreakpoint(gdb.FinishBreakpoint):
+ def __init__(self, val, frame):
+ super (MyFinishBreakpoint, self).__init__ (frame)
+ print "MyFinishBreakpoint init"
+ self.val = val
+
+ def stop(self):
+ print "MyFinishBreakpoint stop with %d" % int(self.val.dereference())
+ gdb.execute("where 1")
+ return True
+
+ def out_of_scope(self):
+ print "MyFinishBreakpoint out of scope..."
+
+print "Python script imported"
\ No newline at end of file
--
1.7.4.4