diff --git a/gdb/NEWS b/gdb/NEWS index 5062e02..c669fd4 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -51,6 +51,12 @@ qXfer:btrace:read's annex The qXfer:btrace:read packet supports a new annex 'delta' to read branch trace incrementally. +* Python Scripting + + ** Valid Python operations on gdb.Value objects representing + structs/classes invoke the corresponding overloaded operators if + available. + *** Changes in GDB 7.7 * Improved support for process record-replay and reverse debugging on diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index af14286..dbeac6a 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -24038,7 +24038,26 @@ 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. In general, overloaded operators are invoked for the +following operators: @code{+} (binary addition), @code{-} (binary +subtraction), @code{*} (multiplication), @code{/}, @code{%}, @code{<<}, +@code{>>}, @code{|}, @code{&}, @code{^}. 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 67e6c4e..f382ec5 100644 --- a/gdb/python/py-value.c +++ b/gdb/python/py-value.c @@ -934,6 +934,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 @@ -965,6 +967,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)); @@ -972,7 +975,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: @@ -985,6 +991,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. */ @@ -994,38 +1001,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 ace957a..7ea4f5d 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; @@ -88,5 +97,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 e6351f6..949f04f 100644 --- a/gdb/testsuite/gdb.python/py-value-cc.exp +++ b/gdb/testsuite/gdb.python/py-value-cc.exp @@ -99,3 +99,7 @@ gdb_test "python print xtd\[x_fields\[1\]\]\['a'\]" "102" "xtd->a via field" gdb_test "python print len(uu_fields)" "2" "number of fields in uu" gdb_test "python print uu\[uu_fields\[0\]\]\['x'\]" "1000" "uu.x via field" gdb_test "python print uu\[uu_fields\[1\]\]\['a'\]" "1000" "uu.a 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"