From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1734) id BB1503858CDB; Fri, 7 Oct 2022 22:06:19 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org BB1503858CDB DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1665180379; bh=kWvmeLxolJX4nGS+r6dgT0D8juy8trgLhkxjkd6gj/Q=; h=From:To:Subject:Date:From; b=ORO3fBuRmfkZwsXjk1fk+ay4SX2S8hfGf58mKLx7R315LLKacSgxu8Y2e8aB8ti2n bVfK+047vE4/xqxbNGb5NuKon5F/NQandj8bTWKWZp2KLjXnYE9GrGD+AKHR1LO6Gr a81eWEe4FvnprNy8/VIB5pHQsC+PhYje8L3MF3Go= MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Marek Polacek To: gcc-cvs@gcc.gnu.org Subject: [gcc r13-3173] c++: fixes for derived-to-base reference binding [PR107085] X-Act-Checkin: gcc X-Git-Author: Marek Polacek X-Git-Refname: refs/heads/trunk X-Git-Oldrev: f30e9fd33e56a5a721346ea6140722e1b193db42 X-Git-Newrev: 895dd027d5dda51a95d242aec8a49a6dfa5db58d Message-Id: <20221007220619.BB1503858CDB@sourceware.org> Date: Fri, 7 Oct 2022 22:06:19 +0000 (GMT) List-Id: https://gcc.gnu.org/g:895dd027d5dda51a95d242aec8a49a6dfa5db58d commit r13-3173-g895dd027d5dda51a95d242aec8a49a6dfa5db58d Author: Marek Polacek Date: Wed Oct 5 15:51:30 2022 -0400 c++: fixes for derived-to-base reference binding [PR107085] This PR reports that struct Base {}; struct Derived : Base {}; static_assert(__reference_constructs_from_temporary(Base const&, Derived)); doesn't pass, which it should: it's just like const Base& b(Derived{}); where we bind 'b' to the Base subobject of a temporary object of type Derived. The ck_base conversion didn't have ->need_temporary_p set because we didn't need to create a temporary object just for the base, but the whole object is a temporary so we're still binding to a temporary. Since the Base subobject is an xvalue, a new function is introduced. PR c++/107085 gcc/cp/ChangeLog: * call.cc (conv_binds_ref_to_temporary): New. (ref_conv_binds_directly): Rename to... (ref_conv_binds_to_temporary): ...this. Use conv_binds_ref_to_temporary. * cp-tree.h (ref_conv_binds_directly): Rename to... (ref_conv_binds_to_temporary): ...this. * method.cc (ref_xes_from_temporary): Use ref_conv_binds_to_temporary. * parser.cc (warn_for_range_copy): Likewise. gcc/testsuite/ChangeLog: * g++.dg/ext/reference_constructs_from_temporary1.C: Adjust expected result. * g++.dg/ext/reference_converts_from_temporary1.C: Likewise. * g++.dg/cpp0x/elision4.C: New test. Diff: --- gcc/cp/call.cc | 44 +++++++++++++++++++--- gcc/cp/cp-tree.h | 2 +- gcc/cp/method.cc | 2 +- gcc/cp/parser.cc | 5 ++- gcc/testsuite/g++.dg/cpp0x/elision4.C | 15 ++++++++ .../ext/reference_constructs_from_temporary1.C | 2 +- .../ext/reference_converts_from_temporary1.C | 2 +- 7 files changed, 60 insertions(+), 12 deletions(-) diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc index bd04a1d309a..7771d80ff31 100644 --- a/gcc/cp/call.cc +++ b/gcc/cp/call.cc @@ -9210,15 +9210,47 @@ conv_binds_ref_to_prvalue (conversion *c) return conv_is_prvalue (next_conversion (c)); } -/* Return tristate::TS_TRUE if converting EXPR to a reference type TYPE does - not involve creating a temporary. Return tristate::TS_FALSE if converting - EXPR to a reference type TYPE binds the reference to a temporary. If the - conversion is invalid or bad, return tristate::TS_UNKNOWN. DIRECT_INIT_P +/* True iff C is a conversion that binds a reference to a temporary. + This is a superset of conv_binds_ref_to_prvalue: here we're also + interested in xvalues. */ + +static bool +conv_binds_ref_to_temporary (conversion *c) +{ + if (conv_binds_ref_to_prvalue (c)) + return true; + if (c->kind != ck_ref_bind) + return false; + c = next_conversion (c); + /* This is the case for + struct Base {}; + struct Derived : Base {}; + const Base& b(Derived{}); + where we bind 'b' to the Base subobject of a temporary object of type + Derived. The subobject is an xvalue; the whole object is a prvalue. */ + if (c->kind != ck_base) + return false; + c = next_conversion (c); + if (c->kind == ck_identity && c->u.expr) + { + tree expr = c->u.expr; + while (handled_component_p (expr)) + expr = TREE_OPERAND (expr, 0); + if (TREE_CODE (expr) == TARGET_EXPR) + return true; + } + return false; +} + +/* Return tristate::TS_TRUE if converting EXPR to a reference type TYPE binds + the reference to a temporary. Return tristate::TS_FALSE if converting + EXPR to a reference type TYPE doesn't bind the reference to a temporary. If + the conversion is invalid or bad, return tristate::TS_UNKNOWN. DIRECT_INIT_P says whether the conversion should be done in direct- or copy-initialization context. */ tristate -ref_conv_binds_directly (tree type, tree expr, bool direct_init_p /*= false*/) +ref_conv_binds_to_temporary (tree type, tree expr, bool direct_init_p/*=false*/) { gcc_assert (TYPE_REF_P (type)); @@ -9230,7 +9262,7 @@ ref_conv_binds_directly (tree type, tree expr, bool direct_init_p /*= false*/) /*c_cast_p=*/false, flags, tf_none); tristate ret (tristate::TS_UNKNOWN); if (conv && !conv->bad_p) - ret = tristate (!conv_binds_ref_to_prvalue (conv)); + ret = tristate (conv_binds_ref_to_temporary (conv)); /* Free all the conversions we allocated. */ obstack_free (&conversion_obstack, p); diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 8bc1c2dc7fd..469eb2fdb25 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -6534,7 +6534,7 @@ extern bool sufficient_parms_p (const_tree); extern tree type_decays_to (tree); extern tree extract_call_expr (tree); extern tree build_trivial_dtor_call (tree, bool = false); -extern tristate ref_conv_binds_directly (tree, tree, bool = false); +extern tristate ref_conv_binds_to_temporary (tree, tree, bool = false); extern tree build_user_type_conversion (tree, tree, int, tsubst_flags_t); extern tree build_new_function_call (tree, vec **, diff --git a/gcc/cp/method.cc b/gcc/cp/method.cc index 55af5c43c18..622e1b9802e 100644 --- a/gcc/cp/method.cc +++ b/gcc/cp/method.cc @@ -2233,7 +2233,7 @@ ref_xes_from_temporary (tree to, tree from, bool direct_init_p) tree val = build_stub_object (from); if (!TYPE_REF_P (from) && TREE_CODE (from) != FUNCTION_TYPE) val = CLASS_TYPE_P (from) ? force_rvalue (val, tf_none) : rvalue (val); - return ref_conv_binds_directly (to, val, direct_init_p).is_false (); + return ref_conv_binds_to_temporary (to, val, direct_init_p).is_true (); } /* Worker for is_{,nothrow_}convertible. Attempt to perform an implicit diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index 555476e42e7..dc3d17c416c 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -13731,7 +13731,8 @@ warn_for_range_copy (tree decl, tree expr) if (TYPE_REF_P (type)) { - if (glvalue_p (expr) && ref_conv_binds_directly (type, expr).is_false ()) + if (glvalue_p (expr) + && ref_conv_binds_to_temporary (type, expr).is_true ()) { auto_diagnostic_group d; if (warning_at (loc, OPT_Wrange_loop_construct, @@ -13762,7 +13763,7 @@ warn_for_range_copy (tree decl, tree expr) /* If we can initialize a reference directly, suggest that to avoid the copy. */ tree rtype = cp_build_reference_type (type, /*rval*/false); - if (ref_conv_binds_directly (rtype, expr).is_true ()) + if (ref_conv_binds_to_temporary (rtype, expr).is_false ()) { auto_diagnostic_group d; if (warning_at (loc, OPT_Wrange_loop_construct, diff --git a/gcc/testsuite/g++.dg/cpp0x/elision4.C b/gcc/testsuite/g++.dg/cpp0x/elision4.C new file mode 100644 index 00000000000..3cc2e3afa5d --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/elision4.C @@ -0,0 +1,15 @@ +// PR c++/107085 +// { dg-do compile { target c++11 } } + +struct X { + X(); + X(X&&); +}; +struct Z : X {}; +X x1 = Z(); +X x2 = X(Z()); + +struct B { }; +struct D : B { }; +B b1 = D(); +B b2 = B(D()); diff --git a/gcc/testsuite/g++.dg/ext/reference_constructs_from_temporary1.C b/gcc/testsuite/g++.dg/ext/reference_constructs_from_temporary1.C index 76de905a35d..5354b1dc4e6 100644 --- a/gcc/testsuite/g++.dg/ext/reference_constructs_from_temporary1.C +++ b/gcc/testsuite/g++.dg/ext/reference_constructs_from_temporary1.C @@ -201,7 +201,7 @@ SA(!__reference_constructs_from_temporary(const int&, H)); SA(!__reference_constructs_from_temporary(int&&, G2)); SA(!__reference_constructs_from_temporary(const int&, H2)); -SA(!__reference_constructs_from_temporary(const Base&, Der)); +SA(__reference_constructs_from_temporary(const Base&, Der)); // This fails because std::is_constructible_v> is false. SA(!__reference_constructs_from_temporary(int&&, id)); diff --git a/gcc/testsuite/g++.dg/ext/reference_converts_from_temporary1.C b/gcc/testsuite/g++.dg/ext/reference_converts_from_temporary1.C index 90196c38742..e6c159e9b00 100644 --- a/gcc/testsuite/g++.dg/ext/reference_converts_from_temporary1.C +++ b/gcc/testsuite/g++.dg/ext/reference_converts_from_temporary1.C @@ -201,7 +201,7 @@ SA( __reference_converts_from_temporary(const int&, H)); SA(!__reference_converts_from_temporary(int&&, G2)); SA(!__reference_converts_from_temporary(const int&, H2)); -SA(!__reference_converts_from_temporary(const Base&, Der)); +SA(__reference_converts_from_temporary(const Base&, Der)); // This fails because std::is_constructible_v> is false. SA(!__reference_converts_from_temporary(int&&, id));