* python/python-internal.h (frame_object_type): Declare.
* python/py-symbol.c (sympy_needs_frame): New function.
(sympy_value): New function.
(symbol_object_getset): Add "needs_frame".
(symbol_object_methods): Add "value".
* python/py-frame.c (frame_object_type): No longer static.
gdb/doc
* gdb.texinfo (Symbols In Python): Document Symbol.needs_frame and
Symbol.value.
gdb/testsuite
* gdb.python/py-symbol.exp: Test Symbol.needs_frame and
Symbol.value.
* gdb.python/py-symbol.c (qq): Set default value.
2012-02-07 Tom Tromey <tromey@redhat.com>
+ PR python/12027:
+ * python/python-internal.h (frame_object_type): Declare.
+ * python/py-symbol.c (sympy_needs_frame): New function.
+ (sympy_value): New function.
+ (symbol_object_getset): Add "needs_frame".
+ (symbol_object_methods): Add "value".
+ * python/py-frame.c (frame_object_type): No longer static.
+
+2012-02-07 Tom Tromey <tromey@redhat.com>
+
PR python/13599:
* python/py-symbol.c (sympy_line): New function.
(symbol_object_getset): Add "line".
** gdb.Symbol now has a 'line' attribute, holding the line number in
the source at which the symbol was defined.
+ ** gdb.Symbol now has the new attribute 'needs_frame' and the new
+ method 'value'. The former indicates whether the symbol needs a
+ frame in order to compute its value, and the latter computes the
+ symbol's value.
+
* GDBserver now supports stdio connections.
E.g. (gdb) target remote | ssh myhost gdbserver - hello
2012-02-07 Tom Tromey <tromey@redhat.com>
+ * gdb.texinfo (Symbols In Python): Document Symbol.needs_frame and
+ Symbol.value.
+
+2012-02-07 Tom Tromey <tromey@redhat.com>
+
* gdb.texinfo (Symbols In Python): Document Symbol.line.
2012-01-27 Thomas Schwinge <thomas@codesourcery.com>
@code{gdb} module and described later in this chapter.
@end defvar
+@defvar Symbol.needs_frame
+This is @code{True} if evaluating this symbol's value requires a frame
+(@pxref{Frames In Python}) and @code{False} otherwise. Typically,
+local variables will require a frame, but other symbols will not.
+
@defvar Symbol.is_argument
@code{True} if the symbol is an argument of a function.
@end defvar
All other @code{gdb.Symbol} methods will throw an exception if it is
invalid at the time the method is called.
@end defun
+
+@defun Symbol.value (@r{[}frame@r{]})
+Compute the value of the symbol, as a @code{gdb.Value}. For
+functions, this computes the address of the function, cast to the
+appropriate type. If the symbol requires a frame in order to compute
+its value, then @var{frame} must be given. If @var{frame} is not
+given, or if @var{frame} is invalid, then this method will throw an
+exception.
+@end defun
@end table
The available domain categories in @code{gdb.Symbol} are represented
error (_("Frame is invalid.")); \
} while (0)
-static PyTypeObject frame_object_type;
-
/* Returns the frame_info object corresponding to the given Python Frame
object. If the frame doesn't exist anymore (the frame id doesn't
correspond to any frame in the inferior), returns NULL. */
{NULL} /* Sentinel */
};
-static PyTypeObject frame_object_type = {
+PyTypeObject frame_object_type = {
PyObject_HEAD_INIT (NULL)
0, /* ob_size */
"gdb.Frame", /* tp_name */
|| class == LOC_OPTIMIZED_OUT));
}
+/* Implementation of gdb.Symbol.needs_frame -> Boolean.
+ Returns true iff the symbol needs a frame for evaluation. */
+
+static PyObject *
+sympy_needs_frame (PyObject *self, void *closure)
+{
+ struct symbol *symbol = NULL;
+ volatile struct gdb_exception except;
+ int result = 0;
+
+ SYMPY_REQUIRE_VALID (self, symbol);
+
+ TRY_CATCH (except, RETURN_MASK_ALL)
+ {
+ result = symbol_read_needs_frame (symbol);
+ }
+ GDB_PY_HANDLE_EXCEPTION (except);
+
+ if (result)
+ Py_RETURN_TRUE;
+ Py_RETURN_FALSE;
+}
+
/* Implementation of gdb.Symbol.line -> int.
Returns the line number at which the symbol was defined. */
Py_RETURN_TRUE;
}
+/* Implementation of gdb.Symbol.value (self[, frame]) -> gdb.Value. Returns
+ the value of the symbol, or an error in various circumstances. */
+
+static PyObject *
+sympy_value (PyObject *self, PyObject *args)
+{
+ struct symbol *symbol = NULL;
+ struct frame_info *frame_info = NULL;
+ PyObject *frame_obj = NULL;
+ struct value *value = NULL;
+ volatile struct gdb_exception except;
+
+ if (!PyArg_ParseTuple (args, "|O", &frame_obj))
+ return NULL;
+
+ if (frame_obj != NULL && !PyObject_TypeCheck (frame_obj, &frame_object_type))
+ {
+ PyErr_SetString (PyExc_TypeError, "argument is not a frame");
+ return NULL;
+ }
+
+ SYMPY_REQUIRE_VALID (self, symbol);
+ if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
+ {
+ PyErr_SetString (PyExc_TypeError, "cannot get the value of a typedef");
+ return NULL;
+ }
+
+ TRY_CATCH (except, RETURN_MASK_ALL)
+ {
+ if (frame_obj != NULL)
+ {
+ frame_info = frame_object_to_frame_info (frame_obj);
+ if (frame_info == NULL)
+ error ("invalid frame");
+ }
+
+ if (symbol_read_needs_frame (symbol) && frame_info == NULL)
+ error ("symbol requires a frame to compute its value");
+
+ value = read_var_value (symbol, frame_info);
+ }
+ GDB_PY_HANDLE_EXCEPTION (except);
+
+ return value_to_value_object (value);
+}
+
/* Given a symbol, and a symbol_object that has previously been
allocated and initialized, populate the symbol_object with the
struct symbol data. Also, register the symbol_object life-cycle
"True if the symbol is a function or method." },
{ "is_variable", sympy_is_variable, NULL,
"True if the symbol is a variable." },
+ { "needs_frame", sympy_needs_frame, NULL,
+ "True if the symbol requires a frame for evaluation." },
{ "line", sympy_line, NULL,
"The source line number at which the symbol was defined." },
{ NULL } /* Sentinel */
{ "is_valid", sympy_is_valid, METH_NOARGS,
"is_valid () -> Boolean.\n\
Return true if this symbol is valid, false if not." },
+ { "value", sympy_value, METH_VARARGS,
+ "value ([frame]) -> gdb.Value\n\
+Return the value of the symbol." },
{NULL} /* Sentinel */
};
extern PyTypeObject events_object_type;
extern PyTypeObject stop_event_object_type;
extern PyTypeObject breakpoint_object_type;
+extern PyTypeObject frame_object_type;
typedef struct breakpoint_object
{
-2012-01-31 Tom Tromey <tromey@redhat.com>
+2012-02-07 Tom Tromey <tromey@redhat.com>
+
+ * gdb.python/py-symbol.exp: Test Symbol.needs_frame and
+ Symbol.value.
+ * gdb.python/py-symbol.c (qq): Set default value.
+
+2012-02-07 Tom Tromey <tromey@redhat.com>
* gdb.python/py-symbol.c (qq): New global.
* gdb.python/py-symbol.exp: Add test for frame-less
};
#endif
-int qq; /* line of qq */
+int qq = 72; /* line of qq */
int func (int arg)
{
gdb_test "python print main_func.is_function" "True" "Test main_func.is_function"
gdb_test "python print gdb.lookup_global_symbol(\"junk\")" "None" "Test lookup_global_symbol(\"junk\")"
+gdb_test "python print gdb.lookup_symbol('main')\[0\].value()" "$hex .main." \
+ "print value of main"
+
set qq_line [gdb_get_line_number "line of qq"]
gdb_test "python print gdb.lookup_symbol('qq')\[0\].line" "$qq_line" \
"print line number of qq"
+gdb_test "python print gdb.lookup_symbol('qq')\[0\].value()" "72" \
+ "print value of qq"
+
+gdb_test "python print gdb.lookup_symbol('qq')\[0\].needs_frame" "False" \
+ "print whether qq needs a frame"
+
+
if ![runto_main] then {
fail "Can't run to main"
return 0
gdb_test "python print a\[0\].is_function" "False" "Test a.is_function"
gdb_test "python print a\[0\].addr_class == gdb.SYMBOL_LOC_COMPUTED" "True" "Test a.addr_class"
+gdb_test "python print a\[0\].value()" \
+ "symbol requires a frame to compute its value.*"\
+ "try to print value of a without a frame"
+gdb_test "python print a\[0\].value(frame)" "0" \
+ "print value of a"
+gdb_test "python print a\[0\].needs_frame" "True" \
+ "print whether a needs a frame"
+
# Test is_constant attribute
gdb_py_test_silent_cmd "python t = gdb.lookup_symbol(\"one\")" "Get variable a" 0
gdb_test "python print t\[0\].is_variable" "False" "Test t.is_variable"
projects / external / binutils.git / commitdiff