From a16b0e220dfc49ed814e779d45faab84e31a4e42 Mon Sep 17 00:00:00 2001 From: Siva Chandra Date: Thu, 12 Dec 2013 15:18:27 -0800 Subject: [PATCH] 2013-12-12 Siva Chandra Reddy PR python/16113 * NEWS (Python Scripting): Add entry for the new feature and the new attribute of gdb.Field objects. * python/py-type.c (gdbpy_is_field): New function (convert_field): Add 'parent_type' attribute to gdb.Field objects. * 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 to test usage of gdb.Field objects as subscripts on gdb.Value objects. doc/ * gdb.texinfo (Values From Inferior): Add a note about using gdb.Field objects as subscripts on gdb.Value objects. (Types In Python): Add description about the new attribute "parent_type" of gdb.Field objects. --- gdb/ChangeLog | 14 +++ gdb/NEWS | 2 + gdb/doc/ChangeLog | 8 ++ gdb/doc/gdb.texinfo | 16 ++- gdb/python/py-type.c | 15 +++ gdb/python/py-value.c | 126 ++++++++++++++++++++++- gdb/python/python-internal.h | 1 + gdb/testsuite/ChangeLog | 7 ++ gdb/testsuite/gdb.python/py-value-cc.cc | 30 ++++++ gdb/testsuite/gdb.python/py-value-cc.exp | 35 +++++++ 10 files changed, 251 insertions(+), 3 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index c49895b7b5..42285b5440 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,17 @@ +2013-12-12 Siva Chandra Reddy + + PR python/16113 + * NEWS (Python Scripting): Add entry for the new feature and the + new attribute of gdb.Field objects. + * python/py-type.c (gdbpy_is_field): New function + (convert_field): Add 'parent_type' attribute to gdb.Field + objects. + * 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. + 2013-12-12 Pedro Alves * breakpoint.c (insert_bp_location): Make 'hw_bp_err_string' local diff --git a/gdb/NEWS b/gdb/NEWS index eff057f32f..e4baf503df 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -40,6 +40,8 @@ ** Frame filters and frame decorators have been added. ** Temporary breakpoints are now supported. ** Line tables representation has been added. + ** New attribute 'parent_type' for gdb.Field objects. + ** gdb.Field objects can be used as subscripts on gdb.Value objects. * New targets diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog index d1f969cbe8..7db94e7424 100644 --- a/gdb/doc/ChangeLog +++ b/gdb/doc/ChangeLog @@ -1,3 +1,11 @@ +2013-12-12 Siva Chandra Reddy + + PR python/16113 + * gdb.texinfo (Values From Inferior): Add a note about using + gdb.Field objects as subscripts on gdb.Value objects. + (Types In Python): Add description about the new attribute + "parent_type" of gdb.Field objects. + 2013-12-12 Joel Brobecker * gdb.texinfo (GDB/MI Miscellaneous Commands): Add @cindex diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index d7c90f5c18..b7551c2af1 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -23985,7 +23985,17 @@ can access its @code{foo} element with: bar = some_val['foo'] @end smallexample -Again, @code{bar} will also be a @code{gdb.Value} object. +@cindex getting structure elements using gdb.Field objects as subscripts +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 (@pxref{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 @@ -24367,6 +24377,10 @@ this will be zero; in this case the field's size is given by its type. @item type The type of the field. This is usually an instance of @code{Type}, but it can be @code{None} in some situations. + +@item parent_type +The type which contains this field. This is an instance of +@code{gdb.Type}. @end table @end defun diff --git a/gdb/python/py-type.c b/gdb/python/py-type.c index 9aeb92c18b..4ad1e12bf5 100644 --- a/gdb/python/py-type.c +++ b/gdb/python/py-type.c @@ -146,6 +146,14 @@ field_new (void) +/* 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 40254b9926..df25179c7e 100644 --- a/gdb/python/py-value.c +++ b/gdb/python/py-value.c @@ -499,13 +499,80 @@ 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; + enum type_code type_code; + PyObject *type_object = PyObject_GetAttrString (field, "parent_type"); + volatile struct gdb_exception except; + int has_field = 0; + + if (type_object == NULL) + return -1; + + parent_type = type_object_to_type (type_object); + Py_DECREF (type_object); + if (parent_type == NULL) + { + PyErr_SetString (PyExc_TypeError, + _("'parent_type' attribute of gdb.Field object is not a" + "gdb.Type object.")); + return -1; + } + + TRY_CATCH (except, RETURN_MASK_ALL) + { + 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)); + + type_code = TYPE_CODE (val_type); + if ((type_code == TYPE_CODE_STRUCT || type_code == TYPE_CODE_UNION) + && types_equal (val_type, parent_type)) + has_field = 1; + else + has_field = 0; + } + GDB_PY_SET_HANDLE_EXCEPTION (except); + + return has_field; +} + +/* 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 +582,44 @@ valpy_getitem (PyObject *self, PyObject *key) if (field == NULL) return NULL; } + else if (gdbpy_is_field (key)) + { + int 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; + } + + 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 +629,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 != NULL) + { + 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) + error (_("Field type not an instance of gdb.Type.")); + + 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 125670eb97..dade7c7f0f 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/ChangeLog b/gdb/testsuite/ChangeLog index 869c8af355..61f31d9b2a 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,10 @@ +2013-12-12 Siva Chandra Reddy + + PR python/16113 + * gdb.python/py-value-cc.cc: Improve test case. + * gdb.python/py-value-cc.exp: Add new tests to test usage of + gdb.Field objects as subscripts on gdb.Value objects. + 2013-12-10 Doug Evans PR 16286 diff --git a/gdb/testsuite/gdb.python/py-value-cc.cc b/gdb/testsuite/gdb.python/py-value-cc.cc index c010fc98d8..80094ec35b 100644 --- a/gdb/testsuite/gdb.python/py-value-cc.cc +++ b/gdb/testsuite/gdb.python/py-value-cc.cc @@ -16,8 +16,21 @@ along with this program. If not, see . */ class A { + public: + int a; }; +union U { + int a; + char c; +}; + +class B : public A { + public: + char a; +}; + +typedef B Btd; typedef int *int_ptr; int @@ -28,6 +41,22 @@ 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; + + U u; + u.a = 99; + return 0; /* Break here. */ } @@ -35,5 +64,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 55c3b970cc..eacaf2e9dd 100644 --- a/gdb/testsuite/gdb.python/py-value-cc.exp +++ b/gdb/testsuite/gdb.python/py-value-cc.exp @@ -44,3 +44,38 @@ 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_no_output "python u = gdb.parse_and_eval('u')" "init u" +gdb_test_no_output "python u_fields = u.type.fields()" "init u_fields" + +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" + +gdb_test "python print(u\[u_fields\[0\]\])" "99.*" "u's first field via field" +gdb_test "python print(u\[u_fields\[1\]\])" "99.*" "u's second field via field" -- 2.34.1