* Re: [RFC/Patch] PR 16113: Allow gdb.Field objects as subscripts on gdb.Value objects
2013-12-09 1:02 [RFC/Patch] PR 16113: Allow gdb.Field objects as subscripts on gdb.Value objects Siva Chandra
@ 2013-12-09 1:04 ` Siva Chandra
2013-12-09 3:50 ` Eli Zaretskii
2013-12-09 10:30 ` Phil Muldoon
0 siblings, 2 replies; 4+ messages in thread
From: Siva Chandra @ 2013-12-09 1:04 UTC (permalink / raw)
To: gdb-patches
[-- Attachment #1: Type: text/plain, Size: 2122 bytes --]
Sorry for double posting, I missed attaching the patch with the previous post.
2013-12-08 Siva Chandra Reddy <sivachandra@google.com>
PR 16113: Allow gdb.Field objects with the subscript operator on
gdb.Value objects of struct/class values.
* NEWS (Python Scripting): Add entry for the new feature.
* python/py-type.c (gdbpy_is_field): New function
* python/py-value.c (valpy_getitem): Allow subscript value to be
a gdb.Field object.
(value_has_field): New function
(get_field_flag): New function
* python/python-internal.h (gdbpy_is_field): Add declaration.
testsuite/
* gdb.python/py-value-cc.cc: Improve test case.
* gdb.python/py-value-cc.exp: Add new tests.
doc/
* gdb.texinfo (Values From Inferior): Add a note about using
gdb.Field objects as subscripts on gdb.Value objects.
On Sun, Dec 8, 2013 at 5:02 PM, Siva Chandra <sivachandra@google.com> wrote:
> Hi,
>
> The attached patch addresses the marked PR. The doc and NEWS changes
> are incomplete as it depends on whether the route I have taken in this
> patch is acceptable. I will fill them after I get (dis/)approval.
> Other changes to the doc and NEWS are present.
>
> 2013-12-08 Siva Chandra Reddy <sivachandra@google.com>
>
> PR 16113: Allow gdb.Field objects with the subscript operator on
> gdb.Value objects of struct/class values.
> * NEWS (Python Scripting): Add entry for the new feature.
> * python/py-type.c (gdbpy_is_field): New function
> * python/py-value.c (valpy_getitem): Allow subscript value to be
> a gdb.Field object.
> (value_has_field): New function
> (get_field_flag): New function
> * python/python-internal.h (gdbpy_is_field): Add declaration.
>
> testsuite/
> * gdb.python/py-value-cc.cc: Improve test case.
> * gdb.python/py-value-cc.exp: Add new tests.
>
> doc/
> * gdb.texinfo (Values From Inferior): Add a note about using
> gdb.Field objects as subscripts on gdb.Value objects.
[-- Attachment #2: value_field_subscript_patch_v1.txt --]
[-- Type: text/plain, Size: 9958 bytes --]
diff --git a/gdb/NEWS b/gdb/NEWS
index ae84e00..38a40bc 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -40,6 +40,7 @@
** Frame filters and frame decorators have been added.
** Temporary breakpoints are now supported.
** Line tables representation has been added.
+ ** gdb.Field objects can be used as subscripts on gdb.Value objects.
* New targets
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index 87d5145..d0295b2 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -23985,7 +23985,16 @@ can access its @code{foo} element with:
bar = some_val['foo']
@end smallexample
-Again, @code{bar} will also be a @code{gdb.Value} object.
+Again, @code{bar} will also be a @code{gdb.Value} object. Structure
+elements can also be accessed by using @code{gdb.Field} objects as
+subscripts (@xref{Types In Python} for more information on
+@code{gdb.Field} objects). For example, if @code{foo_field} is a
+@code{gdb.Field} object corresponding to element @code{foo} of the above
+structure, then @code{bar} can also be accessed as follows:
+
+@smallexample
+bar = some_val[foo_field]
+@end smallexample
A @code{gdb.Value} that represents a function can be executed via
inferior function call. Any arguments provided to the call must match
diff --git a/gdb/python/py-type.c b/gdb/python/py-type.c
index 9aeb92c..4ad1e12 100644
--- a/gdb/python/py-type.c
+++ b/gdb/python/py-type.c
@@ -146,6 +146,14 @@ field_new (void)
\f
+/* Return true if OBJ is of type gdb.Field, false otherwise. */
+
+int
+gdbpy_is_field (PyObject *obj)
+{
+ return PyObject_TypeCheck (obj, &field_object_type);
+}
+
/* Return the code for this type. */
static PyObject *
typy_get_code (PyObject *self, void *closure)
@@ -167,6 +175,13 @@ convert_field (struct type *type, int field)
if (!result)
return NULL;
+ arg = type_to_type_object (type);
+ if (arg == NULL)
+ goto fail;
+ if (PyObject_SetAttrString (result, "parent_type", arg) < 0)
+ goto failarg;
+ Py_DECREF (arg);
+
if (!field_is_static (&TYPE_FIELD (type, field)))
{
const char *attrstring;
diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c
index 40254b9..a40bb7c 100644
--- a/gdb/python/py-value.c
+++ b/gdb/python/py-value.c
@@ -499,13 +499,65 @@ valpy_length (PyObject *self)
return -1;
}
-/* Given string name of an element inside structure, return its value
- object. Returns NULL on error, with a python exception set. */
+/* Return 1 if the gdb.Field object FIELD is present in the value V.
+ Returns 0 otherwise. If any Python error occurs, -1 is returned. */
+
+static int
+value_has_field (struct value *v, PyObject *field)
+{
+ struct type *parent_type, *val_type;
+ PyObject *type_object = PyObject_GetAttrString (field, "parent_type");
+
+ if (type_object == NULL)
+ return -1;
+
+ parent_type = type_object_to_type (type_object);
+ Py_DECREF (type_object);
+ if (parent_type == NULL)
+ return -1;
+
+ val_type = value_type (v);
+ val_type = check_typedef (val_type);
+ if (TYPE_CODE (val_type) == TYPE_CODE_REF
+ || TYPE_CODE (val_type) == TYPE_CODE_PTR)
+ val_type = check_typedef (TYPE_TARGET_TYPE (val_type));
+
+ if (TYPE_CODE (val_type) == TYPE_CODE_STRUCT
+ && types_equal (val_type, parent_type))
+ return 1;
+ else
+ return 0;
+}
+
+/* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
+ Returns 1 if the flag value is true, 0 if it is false, and -1 if
+ a Python error occurs. */
+
+static int
+get_field_flag (PyObject *field, const char *flag_name)
+{
+ int flag_value;
+ PyObject *flag_object = PyObject_GetAttrString (field, flag_name);
+
+ if (flag_object == NULL)
+ return -1;
+
+ flag_value = PyObject_IsTrue (flag_object);
+ Py_DECREF (flag_object);
+
+ return flag_value;
+}
+
+/* Given string name or a gdb.Field object corresponding to an element inside
+ a structure, return its value object. Returns NULL on error, with a python
+ exception set. */
+
static PyObject *
valpy_getitem (PyObject *self, PyObject *key)
{
value_object *self_value = (value_object *) self;
char *field = NULL;
+ PyObject *base_class_type_object = NULL;
volatile struct gdb_exception except;
PyObject *result = NULL;
@@ -515,6 +567,54 @@ valpy_getitem (PyObject *self, PyObject *key)
if (field == NULL)
return NULL;
}
+ else if (gdbpy_is_field (key))
+ {
+ int artificial, is_base_class, valid_field;
+
+ valid_field = value_has_field (self_value->value, key);
+ if (valid_field < 0)
+ return NULL;
+ else if (valid_field == 0)
+ {
+ PyErr_SetString (PyExc_TypeError,
+ _("Invalid lookup for a field not contained in "
+ "the value."));
+
+ return NULL;
+ }
+
+ artificial = get_field_flag (key, "artificial");
+ if (artificial < 0)
+ return NULL;
+ else if (artificial > 0)
+ {
+ PyErr_SetString (PyExc_ValueError,
+ _("Cannot lookup artificial fields."));
+ return NULL;
+ }
+
+ is_base_class = get_field_flag (key, "is_base_class");
+ if (is_base_class < 0)
+ return NULL;
+ else if (is_base_class > 0)
+ {
+ base_class_type_object = PyObject_GetAttrString (key, "type");
+ if (base_class_type_object == NULL)
+ return NULL;
+ }
+ else
+ {
+ PyObject *name_obj = PyObject_GetAttrString (key, "name");
+
+ if (name_obj == NULL)
+ return NULL;
+
+ field = python_string_to_host_string (name_obj);
+ Py_DECREF (name_obj);
+ if (field == NULL)
+ return NULL;
+ }
+ }
TRY_CATCH (except, RETURN_MASK_ALL)
{
@@ -524,6 +624,23 @@ valpy_getitem (PyObject *self, PyObject *key)
if (field)
res_val = value_struct_elt (&tmp, NULL, field, 0, NULL);
+ else if (base_class_type_object)
+ {
+ struct type *base_class_type, *val_type;
+
+ base_class_type = type_object_to_type (base_class_type_object);
+ Py_DECREF (base_class_type_object);
+ if (base_class_type == NULL)
+ return NULL;
+
+ val_type = check_typedef (value_type (tmp));
+ if (TYPE_CODE (val_type) == TYPE_CODE_PTR)
+ res_val = value_cast (lookup_pointer_type (base_class_type), tmp);
+ else if (TYPE_CODE (val_type) == TYPE_CODE_REF)
+ res_val = value_cast (lookup_reference_type (base_class_type), tmp);
+ else
+ res_val = value_cast (base_class_type, tmp);
+ }
else
{
/* Assume we are attempting an array access, and let the
diff --git a/gdb/python/python-internal.h b/gdb/python/python-internal.h
index 125670e..dade7c7 100644
--- a/gdb/python/python-internal.h
+++ b/gdb/python/python-internal.h
@@ -290,6 +290,7 @@ PyObject *gdbpy_newest_frame (PyObject *self, PyObject *args);
PyObject *gdbpy_selected_frame (PyObject *self, PyObject *args);
PyObject *gdbpy_block_for_pc (PyObject *self, PyObject *args);
PyObject *gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw);
+int gdbpy_is_field (PyObject *obj);
PyObject *gdbpy_create_lazy_string_object (CORE_ADDR address, long length,
const char *encoding,
struct type *type);
diff --git a/gdb/testsuite/gdb.python/py-value-cc.cc b/gdb/testsuite/gdb.python/py-value-cc.cc
index c010fc9..1a85bf5 100644
--- a/gdb/testsuite/gdb.python/py-value-cc.cc
+++ b/gdb/testsuite/gdb.python/py-value-cc.cc
@@ -16,8 +16,16 @@
along with this program. If not, see <http://www.gnu.org/licenses/>. */
class A {
+ public:
+ int a;
};
+class B : public A {
+ public:
+ char a;
+};
+
+typedef B Btd;
typedef int *int_ptr;
int
@@ -28,6 +36,19 @@ func (const A &a)
int_ptr ptr = &val;
int_ptr &int_ptr_ref = ptr;
+ B b;
+ B b1;
+
+ b.a = 'a';
+ b.A::a = 10;
+
+ B *b_obj = &b1;
+ b_obj->a = 'b';
+ b_obj->A::a = 100;
+
+ B &b_ref = b1;
+ Btd &b_td = b1;
+
return 0; /* Break here. */
}
@@ -35,5 +56,6 @@ int
main ()
{
A obj;
+
return func (obj);
}
diff --git a/gdb/testsuite/gdb.python/py-value-cc.exp b/gdb/testsuite/gdb.python/py-value-cc.exp
index 55c3b97..f652bad 100644
--- a/gdb/testsuite/gdb.python/py-value-cc.exp
+++ b/gdb/testsuite/gdb.python/py-value-cc.exp
@@ -44,3 +44,33 @@ gdb_test "python print (str(gdb.parse_and_eval(\"int_ptr_ref\").dereference().ty
gdb_test "python print (str(gdb.parse_and_eval(\"int_ptr_ref\").referenced_value().type))" "int_ptr"
gdb_test "python print (str(gdb.parse_and_eval(\"int_ptr_ref\").referenced_value().dereference()))" "10"
gdb_test "python print (str(gdb.parse_and_eval(\"int_ptr_ref\").referenced_value().referenced_value()))" "10"
+
+# Tests for gdb.Value[gdb.Field]
+gdb_test_no_output "python b = gdb.parse_and_eval('b')" "init b"
+gdb_test_no_output "python b_fields = b.type.fields()" "init b_fields"
+gdb_test_no_output "python b_obj = gdb.parse_and_eval('b_obj')" "init b_obj"
+gdb_test_no_output "python b_ref = gdb.parse_and_eval('b_ref')" "init b_ref"
+gdb_test_no_output "python b_td = gdb.parse_and_eval('b_td')" "init b_td"
+
+gdb_test "python print b\[b_fields\[1\]\]" "97 'a'" "b.a via field"
+gdb_test "python print b\[b_fields\[0\]\].type" "A" \
+ "type of b's base class via field"
+gdb_test "python print b\[b_fields\[0\]\]\['a'\]" "10" "b.A::a via field"
+
+gdb_test "python print b_obj\[b_fields\[1\]\]" "98 'b'" "b_obj->a via field"
+gdb_test "python print b_obj\[b_fields\[0\]\].type.target()" "A" \
+ "type of b_obj's base class via field"
+gdb_test "python print b_obj\[b_fields\[0\]\]\['a'\]" "100" \
+ "b_obj->A::a via field"
+
+gdb_test "python print b_ref\[b_fields\[1\]\]" "98 'b'" "b_ref.a via field"
+gdb_test "python print b_ref\[b_fields\[0\]\].type.target()" "A" \
+ "type of b_ref's base class via field"
+gdb_test "python print b_ref\[b_fields\[0\]\]\['a'\]" "100" \
+ "b_ref.A::a via field"
+
+gdb_test "python print b_td\[b_fields\[1\]\]" "98 'b'" "b_td.a via field"
+gdb_test "python print b_td\[b_fields\[0\]\].type.target()" "A" \
+ "type of b_td's base class via field"
+gdb_test "python print b_td\[b_fields\[0\]\]\['a'\]" "100" \
+ "b_td.A::a via field"
^ permalink raw reply [flat|nested] 4+ messages in thread