[RFC/Patch] Call overloaded operators to perform valid Python operations on struct/class values.
Siva Chandra
sivachandra@google.com
Mon Dec 30 14:40:00 GMT 2013
As I said in my previous post on this thread, I do not think there was
a yes or a no decision made about this feature. Hence, I am continuing
to respond to comments. Attached is the latest version which addresses
Eli'c comments.
2013-12-30 Siva Chandra Reddy <sivachandra@google.com>
Call overloaded operators to perform valid Python operations on
struct/class values.
* NEWS (Python Scripting): Add entry for this new feature.
* python/py-value.c (valpy_binop): Call value_x_binop for struct
and class values.
testsuite/
* gdb.python/py-value-cc.cc: Improve test case to enable testing
operations on gdb.Value objects.
* gdb.python/py-value-cc.exp: Add new test to test operations on
gdb.Value objects.
doc/
* gdb.texinfo (Values From Inferior): Add description about
performing valid Python operations on gdb.Value objects.
-------------- next part --------------
diff --git a/gdb/NEWS b/gdb/NEWS
index b64967e..11fb5dd 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -44,6 +44,9 @@
** 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.
+ ** Valid Python operations on gdb.Value objects representing
+ structs/classes invoke the corresponding overloaded operators if
+ available.
* New targets
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index a60e6cf..1a4a1de 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -23961,7 +23961,23 @@ bar = some_val + 2
@noindent
As result of this, @code{bar} will also be a @code{gdb.Value} object
-whose values are of the same type as those of @code{some_val}.
+whose values are of the same type as those of @code{some_val}. Valid
+Python operations can also be performed on @code{gdb.Value} objects
+representing a @code{struct} or @code{class} object. For such cases,
+the overloaded operator (if present), is used to perform the operation.
+For example, if @code{val1}and @code{val2} are @code{gdb.Value} objects
+representing instances of a @code{class} which overloads the @code{+}
+operator, then one can use the @code{+} operator in their Python script
+as follows:
+
+@smallexample
+val3 = val1 + val2
+@end smallexample
+
+@noindent
+The result of the operation @code{val3} is also a @code{gdb.Value}
+object corresponding to the value returned by the overloaded @code{+}
+operator.
Inferior values that are structures or instances of some class can
be accessed using the Python @dfn{dictionary syntax}. For example, if
diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c
index df25179..6c2458c 100644
--- a/gdb/python/py-value.c
+++ b/gdb/python/py-value.c
@@ -884,6 +884,8 @@ valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
struct value *arg1, *arg2;
struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
struct value *res_val = NULL;
+ enum exp_opcode op = OP_NULL;
+ int handled = 0;
/* If the gdb.Value object is the second operand, then it will be passed
to us as the OTHER argument, and SELF will be an entirely different
@@ -915,6 +917,7 @@ valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
CHECK_TYPEDEF (rtype);
rtype = STRIP_REFERENCE (rtype);
+ handled = 1;
if (TYPE_CODE (ltype) == TYPE_CODE_PTR
&& is_integral_type (rtype))
res_val = value_ptradd (arg1, value_as_long (arg2));
@@ -922,7 +925,10 @@ valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
&& is_integral_type (ltype))
res_val = value_ptradd (arg2, value_as_long (arg1));
else
- res_val = value_binop (arg1, arg2, BINOP_ADD);
+ {
+ handled = 0;
+ op = BINOP_ADD;
+ }
}
break;
case VALPY_SUB:
@@ -935,6 +941,7 @@ valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
CHECK_TYPEDEF (rtype);
rtype = STRIP_REFERENCE (rtype);
+ handled = 1;
if (TYPE_CODE (ltype) == TYPE_CODE_PTR
&& TYPE_CODE (rtype) == TYPE_CODE_PTR)
/* A ptrdiff_t for the target would be preferable here. */
@@ -944,38 +951,49 @@ valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
&& is_integral_type (rtype))
res_val = value_ptradd (arg1, - value_as_long (arg2));
else
- res_val = value_binop (arg1, arg2, BINOP_SUB);
+ {
+ handled = 0;
+ op = BINOP_SUB;
+ }
}
break;
case VALPY_MUL:
- res_val = value_binop (arg1, arg2, BINOP_MUL);
+ op = BINOP_MUL;
break;
case VALPY_DIV:
- res_val = value_binop (arg1, arg2, BINOP_DIV);
+ op = BINOP_DIV;
break;
case VALPY_REM:
- res_val = value_binop (arg1, arg2, BINOP_REM);
+ op = BINOP_REM;
break;
case VALPY_POW:
- res_val = value_binop (arg1, arg2, BINOP_EXP);
+ op = BINOP_EXP;
break;
case VALPY_LSH:
- res_val = value_binop (arg1, arg2, BINOP_LSH);
+ op = BINOP_LSH;
break;
case VALPY_RSH:
- res_val = value_binop (arg1, arg2, BINOP_RSH);
+ op = BINOP_RSH;
break;
case VALPY_BITAND:
- res_val = value_binop (arg1, arg2, BINOP_BITWISE_AND);
+ op = BINOP_BITWISE_AND;
break;
case VALPY_BITOR:
- res_val = value_binop (arg1, arg2, BINOP_BITWISE_IOR);
+ op = BINOP_BITWISE_IOR;
break;
case VALPY_BITXOR:
- res_val = value_binop (arg1, arg2, BINOP_BITWISE_XOR);
+ op = BINOP_BITWISE_XOR;
break;
}
+ if (!handled)
+ {
+ if (binop_user_defined_p (op, arg1, arg2))
+ res_val = value_x_binop (arg1, arg2, op, OP_NULL, EVAL_NORMAL);
+ else
+ res_val = value_binop (arg1, arg2, op);
+ }
+
if (res_val)
result = value_to_value_object (res_val);
diff --git a/gdb/testsuite/gdb.python/py-value-cc.cc b/gdb/testsuite/gdb.python/py-value-cc.cc
index 80094ec..60c2182 100644
--- a/gdb/testsuite/gdb.python/py-value-cc.cc
+++ b/gdb/testsuite/gdb.python/py-value-cc.cc
@@ -17,9 +17,18 @@
class A {
public:
+ int operator+ (const int a1);
+
+ public:
int a;
};
+int
+A::operator+ (const int a1)
+{
+ return a + a1;
+}
+
union U {
int a;
char c;
@@ -65,5 +74,7 @@ main ()
{
A obj;
+ obj.a = 5;
+
return func (obj);
}
diff --git a/gdb/testsuite/gdb.python/py-value-cc.exp b/gdb/testsuite/gdb.python/py-value-cc.exp
index eacaf2e..fb1176d 100644
--- a/gdb/testsuite/gdb.python/py-value-cc.exp
+++ b/gdb/testsuite/gdb.python/py-value-cc.exp
@@ -79,3 +79,7 @@ gdb_test "python print(b_td\[b_fields\[0\]\]\['a'\])" "100" \
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"
+
+# Test overloaded operators.
+gdb_test_no_output "python a = gdb.parse_and_eval('a')" "init a"
+gdb_test "python print a + 5" "10" "a + 5"
More information about the Gdb-patches
mailing list