Toolchain/binutils-gdb
1
0
Fork 0
forked from Imagelibrary/binutils-gdb
Code Pull Requests Activity

gdb: fix overload resolution for see-through references

Browse Source 
The overload resolution mechanism assigns badness values to the
necessary conversions to be made on types to pick a champion.  A
badness value consists of a "rank" that scores the conversion and a
"subrank" to differentiate conversions of the same kind.

An auxiliary function, 'sum_ranks', is used for adding two badness
values.  In all of its uses, except two, 'sum_ranks' is used for
populating the subrank of a badness value.  The two exceptions are in
'rank_one_type':

~~~
  /* See through references, since we can almost make non-references
     references.  */

  if (TYPE_IS_REFERENCE (arg))
    return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
		       REFERENCE_CONVERSION_BADNESS));
  if (TYPE_IS_REFERENCE (parm))
    return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
		       REFERENCE_CONVERSION_BADNESS));
~~~

Here, the result of a recursive call is combined with
REFERENCE_CONVERSION_BADNESS.  This leads to the problem of
over-punishment by combining two ranks.  Consider this:

    void an_overloaded_function (const foo &);
    void an_overloaded_function (const foo &&);
    ...
    foo arg;
    an_overloaded_function(arg);

When ranking 'an_overloaded_function (const foo &)', the badness
values REFERENCE_CONVERSION_BADNESS and CV_CONVERSION_BADNESS are
combined, whereas 'rank_one_type' assigns only the
REFERENCE_CONVERSION_BADNESS value to 'an_overloaded_function (const
foo &&)' (there is a different execution flow for that).  This yields
in GDB picking the latter function as the overload champion instead of
the former.

In fact, the 'rank_one_type' function should have given
'an_overloaded_function (const foo &)' the CV_CONVERSION_BADNESS
value, with the see-through referencing increasing the subrank a
little bit.  This can be achieved by introducing a new badness value,
REFERENCE_SEE_THROUGH_BADNESS, which bumps up the subrank only, and
using it in the two "exceptional" cases of 'sum_ranks'.

gdb/ChangeLog:
2019-12-06  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>

	* gdbtypes.h: Define the REFERENCE_SEE_THROUGH_BADNESS value.
	* gdbtypes.c (rank_one_type): Use REFERENCE_SEE_THROUGH_BADNESS
	for ranking see-through reference cases.

gdb/testsuite/ChangeLog:
2019-12-06  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>

	* gdb.cp/rvalue-ref-overload.cc: Add a case that involves both
	CV and reference conversion for overload resolution.
	* gdb.cp/rvalue-ref-overload.exp: Test it.

Change-Id: I39ae6505ab85ad0bd21915368c82540ceeb3aae9
This commit is contained in:
Tankut Baris Aktemur
2019-11-12 15:12:43 +01:00
parent e0fad1eadf
commit 06acc08f0a
6 changed files with 29 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
gdb/ChangeLog
View File

@@ -1,3 +1,9 @@
2019-12-06 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
* gdbtypes.h: Define the REFERENCE_SEE_THROUGH_BADNESS value.
* gdbtypes.c (rank_one_type): Use REFERENCE_SEE_THROUGH_BADNESS
for ranking see-through reference cases.
2019-12-06 Philippe Waroquiers <philippe.waroquiers@skynet.be>
* stack.c (faas_command): Check a command is provided.
* thread.c (taas_command, tfaas_command): Likewise.

5
gdb/gdbtypes.c
View File

@@ -60,6 +60,7 @@ const struct rank VOID_PTR_CONVERSION_BADNESS = {2,0};
const struct rank BOOL_CONVERSION_BADNESS = {3,0};
const struct rank BASE_CONVERSION_BADNESS = {2,0};
const struct rank REFERENCE_CONVERSION_BADNESS = {2,0};
const struct rank REFERENCE_SEE_THROUGH_BADNESS = {0,1};
const struct rank NULL_POINTER_CONVERSION_BADNESS = {2,0};
const struct rank NS_POINTER_CONVERSION_BADNESS = {10,0};
const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS = {3,0};
@@ -4338,10 +4339,10 @@ rank_one_type (struct type *parm, struct type *arg, struct value *value)
if (TYPE_IS_REFERENCE (arg))
return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
REFERENCE_CONVERSION_BADNESS));
REFERENCE_SEE_THROUGH_BADNESS));
if (TYPE_IS_REFERENCE (parm))
return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
REFERENCE_CONVERSION_BADNESS));
REFERENCE_SEE_THROUGH_BADNESS));
if (overload_debug)
/* Debugging only. */
fprintf_filtered (gdb_stderr,

1
gdb/gdbtypes.h
View File

@@ -2105,6 +2105,7 @@ extern const struct rank BASE_CONVERSION_BADNESS;
/* * Badness of converting from non-reference to reference. Subrank
is the type of reference conversion being done. */
extern const struct rank REFERENCE_CONVERSION_BADNESS;
extern const struct rank REFERENCE_SEE_THROUGH_BADNESS;
/* * Conversion to rvalue reference. */
#define REFERENCE_CONVERSION_RVALUE 1
/* * Conversion to const lvalue reference. */

6
gdb/testsuite/ChangeLog
View File

@@ -1,3 +1,9 @@
2019-12-06 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
* gdb.cp/rvalue-ref-overload.cc: Add a case that involves both
CV and reference conversion for overload resolution.
* gdb.cp/rvalue-ref-overload.exp: Test it.
2019-12-06 Philippe Waroquiers <philippe.waroquiers@skynet.be>
* gdb.threads/pthreads.exp: Test taas and tfaas without command.

9
gdb/testsuite/gdb.cp/rvalue-ref-overload.cc
View File

@@ -35,6 +35,8 @@ public:
int overload1arg (foo_lval_ref);
int overload1arg (foo_rval_ref);
int overloadConst (const foo &);
int overloadConst (const foo &&);
};
void
@@ -71,6 +73,11 @@ main ()
// result = 1 + 2 + 3 + 3 = 9
int result = f (i) + f (ci) + f (0) + f (std::move (i));
/* Overload resolution below requires both a CV-conversion
and reference conversion. */
int test_const // = 3
= foo_rr_instance1.overloadConst (arg);
marker1 (); // marker1-returns-here
return result;
}
@@ -84,3 +91,5 @@ foo::~foo () {}
int foo::overload1arg (foo_lval_ref arg) { return 1; }
int foo::overload1arg (foo_rval_ref arg) { return 2; }
int foo::overloadConst (const foo &arg) { return 3; }
int foo::overloadConst (const foo &&arg) { return 4; }

4
gdb/testsuite/gdb.cp/rvalue-ref-overload.exp
View File

@@ -49,6 +49,8 @@ cp_test_ptype_class "foo_rr_instance1" "" "class" "foo" \
{ method public "~foo();" }
{ method public "int overload1arg(foo_lval_ref);" }
{ method public "int overload1arg(foo_rval_ref);" }
{ method public "int overloadConst(const foo &);" }
{ method public "int overloadConst(const foo &&);" }
}
gdb_test "print foo_rr_instance1.overload1arg(arg)" \
@@ -59,6 +61,8 @@ gdb_test "print foo_rr_instance1.overload1arg(static_cast<foo&&>(arg))" \
"\\$\[0-9\]+ = 2" \
"print call overloaded func foo && arg"
gdb_test "print foo_rr_instance1.overloadConst(arg)" "3"
# Test lvalue vs rvalue function overloads
gdb_test "print f (i)" "= 1" "lvalue reference overload"