gdb: call value_ind for pointers to dynamic types in UNOP_IND evaluation

When evaluating and expression containing UNOP_IND in mode
EVAL_AVOID_SIDE_EFFECTS, GDB currently (mostly) returns the result of
a call to value_zero meaning we get back an object with the correct
type, but its contents are all zero.

If the target type contains fields with dynamic type then in order to
resolve these dynamic fields GDB will need to read the value of the
field from within the parent object.  In this case the field value
will be zero as a result of the call to value_zero mentioned above.

The idea behind EVAL_AVOID_SIDE_EFFECTS is to avoid the chance that
doing something like `ptype` will modify state within the target, for
example consider: ptype i++.

However, there is already precedence within GDB that sometimes, in
order to get accurate type results, we can't avoid reading from the
target, even when EVAL_AVOID_SIDE_EFFECTS is in effect.  For example I
would point to eval.c:evaluate_var_value, the handling of OP_REGISTER,
the handling of value_x_unop in many places.  I believe the Ada
expression evaluator also ignore EVAL_AVOID_SIDE_EFFECTS in some
cases.

I am therefor proposing that, in the case where a pointer points at a
dynamic type, we allow UNOP_IND to perform the actual indirection.
This allows accurate types to be displayed in more cases.

gdb/ChangeLog:

	* eval.c (evaluate_subexp_standard): Call value_ind for points to
	dynamic types in UNOP_IND.

gdb/testsuite/ChangeLog:

	* gdb.fortran/pointer-to-pointer.exp: Additional tests.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index d189a0919b277a8d96cfc3ce4975f79ebf116630..b50a48ca1e535c6f7a726339f816a64fea0620f5 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,8 @@
+2021-02-24  Andrew Burgess  <andrew.burgess@embecosm.com>
+
+       * eval.c (evaluate_subexp_standard): Call value_ind for points to
+       dynamic types in UNOP_IND.
+
 2021-02-23  Simon Marchi  <simon.marchi@polymtl.ca>
 
        PR gdb/26828

diff --git a/gdb/eval.c b/gdb/eval.c
index 8256fdea148995f7d17dd4034f120aa170d18432..7ba3ee59522fc4d627f85315eba77835547a6b5b 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -2425,19 +2425,29 @@ evaluate_subexp_standard (struct type *expect_type,
       else if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {
          type = check_typedef (value_type (arg1));
-         if (type->code () == TYPE_CODE_PTR
-             || TYPE_IS_REFERENCE (type)
-         /* In C you can dereference an array to get the 1st elt.  */
-             || type->code () == TYPE_CODE_ARRAY
-           )
-           return value_zero (TYPE_TARGET_TYPE (type),
-                              lval_memory);
-         else if (type->code () == TYPE_CODE_INT)
-           /* GDB allows dereferencing an int.  */
-           return value_zero (builtin_type (exp->gdbarch)->builtin_int,
-                              lval_memory);
-         else
-           error (_("Attempt to take contents of a non-pointer value."));
+
+         /* If the type pointed to is dynamic then in order to resolve the
+            dynamic properties we must actually dereference the pointer.
+            There is a risk that this dereference will have side-effects
+            in the inferior, but being able to print accurate type
+            information seems worth the risk. */
+         if ((type->code () != TYPE_CODE_PTR
+              && !TYPE_IS_REFERENCE (type))
+             || !is_dynamic_type (TYPE_TARGET_TYPE (type)))
+           {
+             if (type->code () == TYPE_CODE_PTR
+                 || TYPE_IS_REFERENCE (type)
+                 /* In C you can dereference an array to get the 1st elt.  */
+                 || type->code () == TYPE_CODE_ARRAY)
+               return value_zero (TYPE_TARGET_TYPE (type),
+                                  lval_memory);
+             else if (type->code () == TYPE_CODE_INT)
+               /* GDB allows dereferencing an int.  */
+               return value_zero (builtin_type (exp->gdbarch)->builtin_int,
+                                  lval_memory);
+             else
+               error (_("Attempt to take contents of a non-pointer value."));
+           }
        }
 
       /* Allow * on an integer so we can cast it to whatever we want.

diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 70b836b8c2f408312c740572f1bf36302e55faf2..6f1cb0a85268b5adc0fe683f7ec9f63ca8da5db1 100644 (file)
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,7 @@
+2021-02-24  Andrew Burgess  <andrew.burgess@embecosm.com>
+
+       * gdb.fortran/pointer-to-pointer.exp: Additional tests.
+
 2021-02-18  Andrew Burgess  <andrew.burgess@embecosm.com>
 
        * gdb.arch/i386-biarch-core.exp: Add target check.

diff --git a/gdb/testsuite/gdb.fortran/pointer-to-pointer.exp b/gdb/testsuite/gdb.fortran/pointer-to-pointer.exp
index 27739cc6cf3a8b29c7ae5b39b673d4f2f55d8e93..306168b28769181c9360774243e6341a51defdb7 100644 (file)
--- a/gdb/testsuite/gdb.fortran/pointer-to-pointer.exp
+++ b/gdb/testsuite/gdb.fortran/pointer-to-pointer.exp
@@ -30,20 +30,29 @@ if ![fortran_runto_main] {
     return -1
 }
 
-# Depending on the compiler being used, the type names can be printed differently.
+# Depending on the compiler being used, the type names can be printed
+# differently.
 set real4 [fortran_real4]
 
 gdb_breakpoint [gdb_get_line_number "Break Here"]
 gdb_continue_to_breakpoint "Break Here"
 
+gdb_test "print buffer" \
+    " = \\(PTR TO -> \\( Type l_buffer \\)\\) $hex"
+gdb_test "ptype buffer" \
+    [multi_line \
+        "type = PTR TO -> \\( Type l_buffer" \
+        "    $real4 :: alpha\\(:\\)" \
+        "End Type l_buffer \\)" ]
+gdb_test "ptype buffer%alpha" "type = $real4 \\(5\\)"
+
+# GDB allows pointer types to be dereferenced using '*'.  This is not
+# real Fortran syntax, just something extra that GDB supports.
 gdb_test "print *buffer" \
     " = \\( alpha = \\(1\\.5, 2\\.5, 3\\.5, 4\\.5, 5\\.5\\) \\)"
-
-set l_buffer_type [multi_line \
-                      "Type l_buffer" \
-                      "    $real4 :: alpha\\(:\\)" \
-                      "End Type l_buffer" ]
-
-gdb_test "ptype buffer" "type = PTR TO -> \\( ${l_buffer_type} \\)"
-gdb_test "ptype *buffer" "type = ${l_buffer_type}"
-gdb_test "ptype buffer%alpha" "type = $real4 \\(5\\)"
+gdb_test "ptype *buffer" \
+    [multi_line \
+        "type = Type l_buffer" \
+        "    $real4 :: alpha\\(5\\)" \
+        "End Type l_buffer" ]
+gdb_test "ptype (*buffer)%alpha" "type = $real4 \\(5\\)"