[2/2] gdb: allow casting to rvalue reference in more cases

Message ID 77ce5f417886a9d74198b18bd9ad565ac346c633.1616667144.git.andrew.burgess@embecosm.com
State New
Headers show
Series
  • Value casting changes
Related show

Commit Message

Andrew Burgess March 25, 2021, 10:16 a.m.
It is not currently possible to cast some values to an rvaule
reference.  This happens when simple scalar values are cast to an
rvalue reference of the same type, e.g.:

  int global_var;

Then in GDB:

  (gdb) p static_cast<int&&> (global_var)
  Attempt to take address of value not located in memory.

Which is clearly silly.

The problem is that as part of the cast an intermediate value is
created within GDB that becomes an lval_none rather than the original
lval_memory.  The casting logic basically goes like this:

The call tree that leads to the error looks like this:

  value_cast
    value_cast
    value_ref
      value_addr
        error

The first value_cast call is casting the value for 'global_var' to
type 'int&&'.  GDB spots that the target type is a reference, and so
calls value_cast again, this time casting 'global_var' to type 'int'.
We then call value_ref to convert the result of the second value_cast
into a reference.

Unfortunately, the second cast results in the value (for global_var)
changing from an lval_memory to an lval_none.  This is because int to
int casting calls extract_unsigned_integer and then
value_from_longest.

In theory value_cast has a check at its head that should help in this
case, the code is:

  if (value_type (arg2) == type)
    return arg2;

However, this only works in some cases.  In our case
'value_type (arg2)' will be an objfile owned type, while the type from
the expression parser 'int&&' will be gdbarch owned.  The pointers
will not be equal, but the meaning of the type will be equal.

I did consider making the int to int casting case smarter, but this
obviously is only one example.  We must also consider things like
float to float, or pointer to pointer....

So, I instead decided to try and make the initial check smarter.
Instead of a straight pointer comparison, I now propose that we use
types_deeply_equal.  If this is true then we are casting something
back to its current type, in which case we can preserve the lval
setting by using value_copy.

gdb/ChangeLog:

	* valops.c (value_cast): Call value_deeply_equal before performing
	any cast.

gdb/testsuite/ChangeLog:

	* gdb.cp/rvalue-ref-params.cc (f3): New function.
	(f4): New function.
	(global_int): New global variable.
	(global_float): Likeiwse.
	(main): Call both new functions.
	* gdb.cp/rvalue-ref-params.exp: Add new tests.
---
 gdb/ChangeLog                              |  5 +++++
 gdb/testsuite/ChangeLog                    |  9 +++++++++
 gdb/testsuite/gdb.cp/rvalue-ref-params.cc  | 19 +++++++++++++++++++
 gdb/testsuite/gdb.cp/rvalue-ref-params.exp |  9 +++++++++
 gdb/valops.c                               | 21 +++++++++++++++++++--
 5 files changed, 61 insertions(+), 2 deletions(-)

-- 
2.25.4

Comments

Tom Tromey April 1, 2021, 7:29 p.m. | #1
>>>>> "Andrew" == Andrew Burgess <andrew.burgess@embecosm.com> writes:


Andrew> gdb/ChangeLog:

Andrew> 	* valops.c (value_cast): Call value_deeply_equal before performing
Andrew> 	any cast.

This looks reasonable to me.  Thank you.

Tom

Patch

diff --git a/gdb/testsuite/gdb.cp/rvalue-ref-params.cc b/gdb/testsuite/gdb.cp/rvalue-ref-params.cc
index d38c96cd7a1..d6340fa32e8 100644
--- a/gdb/testsuite/gdb.cp/rvalue-ref-params.cc
+++ b/gdb/testsuite/gdb.cp/rvalue-ref-params.cc
@@ -42,6 +42,18 @@  f2 (Child &&C)
   return f1 (std::move (C));                 /* Set breakpoint marker2 here.  */
 }
 
+int
+f3 (int &&var_i)
+{
+  return var_i + 1;
+}
+
+int
+f4 (float &&var_f)
+{
+  return static_cast <int> (var_f);
+}
+
 struct OtherParent
 {
   OtherParent (int other_id0) : other_id (other_id0) { }
@@ -65,6 +77,10 @@  mf2 (MultiChild &&C)
   return mf1 (std::move (C));
 }
 
+/* These are used from within GDB.  */
+int global_int = 7;
+float global_float = 3.5f;
+
 int
 main ()
 {
@@ -81,5 +97,8 @@  main ()
 
   mf2 (std::move (MQ));			/* Set breakpoint MQ here.  */
 
+  (void) f3 (-1);
+  (void) f4 (3.5);
+
   return 0;
 }
diff --git a/gdb/testsuite/gdb.cp/rvalue-ref-params.exp b/gdb/testsuite/gdb.cp/rvalue-ref-params.exp
index 53bd065d88b..1fd3edb0584 100644
--- a/gdb/testsuite/gdb.cp/rvalue-ref-params.exp
+++ b/gdb/testsuite/gdb.cp/rvalue-ref-params.exp
@@ -40,6 +40,15 @@  set t "print value of f1 on (Child&&) in main"
 gdb_start_again "marker1 here" $t
 gdb_test "print f1(static_cast<Child&&>(Q))" ".* = 40.*" $t
 
+gdb_test "print f3(static_cast<int&&> (global_int))" " = 8"
+gdb_test "print f4(static_cast<float&&> (global_float))" " = 3"
+
+gdb_test "print static_cast<int&> (global_int)" " = \\(int &\\) @$hex: 7"
+gdb_test "print static_cast<int&&> (global_int)" " = \\(int &&\\) @$hex: 7"
+
+gdb_test "print static_cast<float&> (global_float)" " = \\(float &\\) @$hex: 3\\.$decimal"
+gdb_test "print static_cast<float&&> (global_float)" " = \\(float &&\\) @$hex: 3\\.$decimal"
+
 set t "print value of f2 on (Child&&) in main" 
 gdb_start_again "marker1 here" $t
 gdb_test "print f2(static_cast<Child&&>(Q))" ".* = 40.*" $t
diff --git a/gdb/valops.c b/gdb/valops.c
index fec821ad932..76e1feb8a87 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -415,8 +415,25 @@  value_cast (struct type *type, struct value *arg2)
 
   int convert_to_boolean = 0;
 
-  if (value_type (arg2) == type)
-    return arg2;
+  /* TYPE might be equal in meaning to the existing type of ARG2, but for
+     many reasons, might be a different type object (e.g. TYPE might be a
+     gdbarch owned type, while VALUE_TYPE (ARG2) could be an objfile owned
+     type).
+
+     In this case we want to preserve the LVAL of ARG2 as this allows the
+     resulting value to be used in more places.  We do this by calling
+     VALUE_COPY if appropriate.  */
+  if (types_deeply_equal (value_type (arg2), type))
+    {
+      /* If the types are exactly equal then we can avoid creating a new
+	 value completely.  */
+      if (value_type (arg2) != type)
+	{
+	  arg2 = value_copy (arg2);
+	  deprecated_set_value_type (arg2, type);
+	}
+      return arg2;
+    }
 
   if (is_fixed_point_type (type))
     return value_cast_to_fixed_point (type, arg2);