mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2025-01-06 12:09:26 +08:00
30ab358668
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.
105 lines
1.9 KiB
C++
105 lines
1.9 KiB
C++
/* This test script is part of GDB, the GNU debugger.
|
|
|
|
Copyright 2006-2021 Free Software Foundation, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
/* Rvalue reference parameter tests, based on ref-params.cc. */
|
|
|
|
#include <utility>
|
|
|
|
struct Parent
|
|
{
|
|
Parent (int id0) : id (id0) { }
|
|
int id;
|
|
};
|
|
|
|
struct Child : public Parent
|
|
{
|
|
Child (int id0) : Parent (id0) { }
|
|
};
|
|
|
|
int
|
|
f1 (Parent &&R)
|
|
{
|
|
return R.id; /* Set breakpoint marker3 here. */
|
|
}
|
|
|
|
int
|
|
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) { }
|
|
int other_id;
|
|
};
|
|
|
|
struct MultiChild : public Parent, OtherParent
|
|
{
|
|
MultiChild (int id0) : Parent (id0), OtherParent (id0 * 2) { }
|
|
};
|
|
|
|
int
|
|
mf1 (OtherParent &&R)
|
|
{
|
|
return R.other_id;
|
|
}
|
|
|
|
int
|
|
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 ()
|
|
{
|
|
Child Q(40);
|
|
Child &QR = Q;
|
|
|
|
/* Set breakpoint marker1 here. */
|
|
|
|
f1 (Child (41));
|
|
f2 (Child (42));
|
|
|
|
MultiChild MQ (53);
|
|
MultiChild &MQR = MQ;
|
|
|
|
mf2 (std::move (MQ)); /* Set breakpoint MQ here. */
|
|
|
|
(void) f3 (-1);
|
|
(void) f4 (3.5);
|
|
|
|
return 0;
|
|
}
|