On Dec 14, 2018, Jason Merrill <ja...@redhat.com> wrote:
>> If inh is false, we're a copy constructor, which always has a parm,
>> so this hunk seems unnecessary.
ack
>>> - int cvquals = cp_type_quals (TREE_TYPE (parm));
>>> + int cvquals = parm ? cp_type_quals (TREE_TYPE (parm)) : 0;
>>
>> This could also check !inh.
*nod*
> And in the existing code, while I'm looking at it:
> The "if (inh) continue" is odd, there's no reason to iterate through
> the fields ignoring all of them when we could skip the loop entirely.
Heh, funny, an earlier version of the patch that added an if (inh) to
print an error on zero-args had an 'else fields = NULL;'. That
improvement went away along with my course change. But look!, it's back
in the version below ;-)
Testing... Ok to install if it passes?
[PR c++/88146] do not crash synthesizing inherited ctor(...)
This patch started out from the testcase in PR88146, that attempted to
synthesize an inherited ctor without any args before a varargs
ellipsis and crashed while at that, because of the unguarded
dereferencing of the parm type list, that usually contains a
terminator. The terminator is not there for varargs functions,
however, and without any other args, we ended up dereferencing a NULL
pointer. Oops.
Guarding accesses to parm would be easy, but not necessary. In
do_build_copy_constructor, non-inherited ctors are copy-ctors, that
always have at least one parm, so parm needs not be guarded when we
know the access will only take place when we're dealing with an
inherited ctor. The only other problematic use was in the cvquals
initializer, a variable only used in a loop over fields, that we
skipped individually in inherited ctors. I've arranged to skip the
entire loop over fields for inherited ctors, and to only initialize
cvquals otherwise.
Avoiding the crash from unguarded accesses was easy, but I thought we
should still produce the sorry message we got in other testcases that
passed arguments through the ellipsis in inherited ctors. I put a
check in, and noticed the inherited ctors were synthesized with the
location assigned to the class name, although they were initially
assigned the location of the using declaration. I decided the latter
was better, and arranged for the better location to be retained.
Further investigation revealed the lack of a sorry message had to do
with the call being in a non-evaluated context, in this case, a
noexcept expression. The sorry would be correctly reported in other
contexts, so I rolled back the check I'd added, but retained the
source location improvement.
I was still concerned about issuing sorry messages while instantiating
template ctors even in non-evaluated contexts, e.g., if a template
ctor had a base initializer that used an inherited ctor with enough
arguments that they'd go through an ellipsis. I wanted to defer the
instantiation of such template ctors, but that would have been wrong
for constexpr template ctors, and already done for non-constexpr ones.
So, I just consolidated multiple test variants into a single testcase
that explores and explains various of the possibilities I thought of.
for gcc/cp/ChangeLog
PR c++/88146
* method.c (do_build_copy_constructor): Skip iteration over
fields for inherited ctors, and initialize cvquals otherwise.
(synthesize_method): Retain location of inherited ctor.
for gcc/testsuite/ChangeLog
PR c++/88146
* g++.dg/cpp0x/inh-ctor32.C: New.
---
gcc/cp/method.c | 14 +-
gcc/testsuite/g++.dg/cpp0x/inh-ctor32.C | 229 +++++++++++++++++++++++++++++++
2 files changed, 238 insertions(+), 5 deletions(-)
create mode 100644 gcc/testsuite/g++.dg/cpp0x/inh-ctor32.C
diff --git a/gcc/cp/method.c b/gcc/cp/method.c
index fd023e200538..4cbdadbe3d26 100644
--- a/gcc/cp/method.c
+++ b/gcc/cp/method.c
@@ -677,7 +677,7 @@ do_build_copy_constructor (tree fndecl)
{
tree fields = TYPE_FIELDS (current_class_type);
tree member_init_list = NULL_TREE;
- int cvquals = cp_type_quals (TREE_TYPE (parm));
+ int cvquals;
int i;
tree binfo, base_binfo;
tree init;
@@ -704,6 +704,11 @@ do_build_copy_constructor (tree fndecl)
inh, member_init_list);
}
+ if (!inh)
+ cvquals = cp_type_quals (TREE_TYPE (parm));
+ else
+ fields = NULL;
+
for (; fields; fields = DECL_CHAIN (fields))
{
tree field = fields;
@@ -711,8 +716,6 @@ do_build_copy_constructor (tree fndecl)
if (TREE_CODE (field) != FIELD_DECL)
continue;
- if (inh)
- continue;
expr_type = TREE_TYPE (field);
if (DECL_NAME (field))
@@ -891,8 +894,9 @@ synthesize_method (tree fndecl)
/* Reset the source location, we might have been previously
deferred, and thus have saved where we were first needed. */
- DECL_SOURCE_LOCATION (fndecl)
- = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
+ if (!DECL_INHERITED_CTOR (fndecl))
+ DECL_SOURCE_LOCATION (fndecl)
+ = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
/* If we've been asked to synthesize a clone, just synthesize the
cloned function instead. Doing so will automatically fill in the
diff --git a/gcc/testsuite/g++.dg/cpp0x/inh-ctor32.C
b/gcc/testsuite/g++.dg/cpp0x/inh-ctor32.C
new file mode 100644
index 000000000000..c40412fc5346
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/inh-ctor32.C
@@ -0,0 +1,229 @@
+// { dg-do compile { target c++11 } }
+// Minimized from the testcase for PR c++/88146,
+// then turned into multiple variants.
+
+// We issue an error when calling an inherited ctor with at least one
+// argument passed through a varargs ellipsis, if the call is in an
+// evaluated context. Even in nonevaluated contexts, we will
+// instantiate constexpr templates (unlike non-constexpr templates),
+// which might then issue errors that in nonevlauated contexts
+// wouldn't be issued.
+
+// In these variants, the inherited ctor is constexpr, but it's only
+// called in unevaluated contexts, so no error is issued. The
+// templateness of the ctor doesn't matter, because the only call that
+// passes args through the ellipsis is in a noexcept expr, that is not
+// evaluated. The ctors in derived classes are created and
+// instantiated, discarding arguments passed through the ellipsis when
+// calling base ctors, but that's not reported: we only report a
+// problem when *calling* ctors that behave this way.
+namespace unevaled_call {
+ namespace no_arg_before_ellipsis {
+ namespace without_template {
+ struct foo {
+ constexpr foo(...) {}
+ };
+ struct boo : foo {
+ using foo::foo;
+ };
+ struct bar : boo {
+ using boo::boo;
+ };
+ void f() noexcept(noexcept(bar{0}));
+ }
+
+ namespace with_template {
+ struct foo {
+ template <typename... T>
+ constexpr foo(...) {}
+ };
+ struct boo : foo {
+ using foo::foo;
+ };
+ struct bar : boo {
+ using boo::boo;
+ };
+ void f() noexcept(noexcept(bar{0}));
+ }
+ }
+
+ namespace one_arg_before_ellipsis {
+ namespace without_template {
+ struct foo {
+ constexpr foo(int, ...) {}
+ };
+ struct boo : foo {
+ using foo::foo;
+ };
+ struct bar : boo {
+ using boo::boo;
+ };
+ void f() noexcept(noexcept(bar{0,1}));
+ }
+
+ namespace with_template {
+ struct foo {
+ template <typename T>
+ constexpr foo(T, ...) {}
+ };
+ struct boo : foo {
+ using foo::foo;
+ };
+ struct bar : boo {
+ using boo::boo;
+ };
+ void f() noexcept(noexcept(bar{0,1}));
+ }
+ }
+}
+
+// In these variants, the inherited ctor is constexpr, and it's called
+// in unevaluated contexts in ways that would otherwise trigger the
+// sorry message. Here we check that the message is not issued at
+// those calls, nor at subsequent calls that use the same ctor without
+// passing arguments through its ellipsis. We check that it is issued
+// later, when we pass the ctor arguments through the ellipsis.
+namespace evaled_bad_call_in_u {
+ namespace one_arg_before_ellipsis {
+ namespace without_template {
+ struct foo {
+ constexpr foo(int, ...) {}
+ };
+ struct boo : foo {
+ using foo::foo;
+ };
+ struct bar : boo {
+ using boo::boo;
+ };
+ void f() noexcept(noexcept(bar{0, 1}));
+ bar t(0);
+ bar u(0, 1); // { dg-message "sorry, unimplemented: passing arguments to
ellipsis" }
+ }
+
+ namespace with_template {
+ struct foo {
+ template <typename T>
+ constexpr foo(T, ...) {}
+ };
+ struct boo : foo {
+ using foo::foo;
+ };
+ struct bar : boo {
+ using boo::boo;
+ };
+ void f() noexcept(noexcept(bar{0,1}));
+ bar t(0);
+ bar u(0,1); // { dg-message "sorry, unimplemented: passing arguments to
ellipsis" }
+ }
+ }
+
+ namespace no_arg_before_ellipsis {
+ namespace without_template {
+ struct foo {
+ constexpr foo(...) {}
+ };
+ struct boo : foo {
+ using foo::foo;
+ };
+ struct bar : boo {
+ using boo::boo;
+ };
+ void f() noexcept(noexcept(bar{0}));
+ bar u(0); // { dg-message "sorry, unimplemented: passing arguments to
ellipsis" }
+ }
+
+ namespace with_template {
+ struct foo {
+ template <typename... T>
+ constexpr foo(...) {}
+ };
+ struct boo : foo {
+ using foo::foo;
+ };
+ struct bar : boo {
+ using boo::boo;
+ };
+ void f() noexcept(noexcept(bar{0}));
+ bar u(0); // { dg-message "sorry, unimplemented: passing arguments to
ellipsis" }
+ }
+ }
+}
+
+// Now, instead of instantiating a class that uses a derived ctor, we
+// introduce another template ctor that will use the varargs ctor to
+// initialize its base class. The idea is to verify that the error
+// message is issued, even if the instantiation occurs in a
+// nonevaluated context, e.g., for constexpr templates. In the
+// inherited_derived_ctor, we check that even an inherited ctor of a
+// constexpr ctor is instantiated and have an error message issued.
+namespace derived_ctor {
+ namespace direct_derived_ctor {
+ namespace constexpr_noninherited_ctor {
+ struct foo {
+ template <typename T>
+ constexpr foo(T, ...) {}
+ };
+ struct boo : foo {
+ using foo::foo;
+ };
+ struct bar : boo {
+ template <typename ...T>
+ constexpr bar(T ... args) : boo(args...) {} // { dg-message "sorry,
unimplemented: passing arguments to ellipsis" }
+ };
+ void f() noexcept(noexcept(bar{0,1}));
+ }
+
+ namespace no_constexpr_noninherited_ctor {
+ struct foo {
+ template <typename T>
+ constexpr foo(T, ...) {}
+ };
+ struct boo : foo {
+ using foo::foo;
+ };
+ struct bar : boo {
+ template <typename ...T>
+ /* constexpr */ bar(T ... args) : boo(args...) {}
+ };
+ void f() noexcept(noexcept(bar{0,1}));
+ }
+ }
+
+ namespace inherited_derived_ctor {
+ namespace constexpr_noninherited_ctor {
+ struct foo {
+ template <typename T>
+ constexpr foo(T, ...) {}
+ };
+ struct boo : foo {
+ using foo::foo;
+ };
+ struct bor : boo {
+ template <typename ...T>
+ constexpr bor(T ... args) : boo(args...) {} // { dg-message "sorry,
unimplemented: passing arguments to ellipsis" }
+ };
+ struct bar : bor {
+ using bor::bor;
+ };
+ void f() noexcept(noexcept(bar{0,1})); // { dg-message "'constexpr'
expansion" }
+ }
+
+ namespace no_constexpr_noninherited_ctor {
+ struct foo {
+ template <typename T>
+ constexpr foo(T, ...) {}
+ };
+ struct boo : foo {
+ using foo::foo;
+ };
+ struct bor : boo {
+ template <typename ...T>
+ /* constexpr */ bor(T ... args) : boo(args...) {}
+ };
+ struct bar : bor {
+ using bor::bor;
+ };
+ void f() noexcept(noexcept(bar{0,1}));
+ }
+ }
+}
--
Alexandre Oliva, freedom fighter https://FSFLA.org/blogs/lxo
Be the change, be Free! FSF Latin America board member
GNU Toolchain Engineer Free Software Evangelist
Hay que enGNUrecerse, pero sin perder la terGNUra jamás-GNUChe
