From: Alexandre Oliva Date: Wed, 19 Dec 2018 06:51:19 +0000 (+0000) Subject: [PR c++/88146] do not crash synthesizing inherited ctor(...) X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=bceca9b3f7d9cd935574652edc62a117c8736823;p=gcc.git [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 guarded the cvquals initialization and the entire loop over fields so they only run for copy-ctors. 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): Guard cvquals init and loop over fields to run for non-inherited ctors only. (synthesize_method): Retain location of inherited ctor. for gcc/testsuite/ChangeLog PR c++/88146 * g++.dg/cpp0x/inh-ctor32.C: New. From-SVN: r267250 --- diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index ed652bd8a47..0246806c9a7 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,10 @@ +2018-12-19 Alexandre Oliva + + PR c++/88146 + * method.c (do_build_copy_constructor): Guard cvquals init and + loop over fields to run for non-inherited ctors only. + (synthesize_method): Retain location of inherited ctor. + 2018-12-17 Jakub Jelinek PR c++/88410 diff --git a/gcc/cp/method.c b/gcc/cp/method.c index fd023e20053..17404a65b0f 100644 --- a/gcc/cp/method.c +++ b/gcc/cp/method.c @@ -675,12 +675,9 @@ do_build_copy_constructor (tree fndecl) } else { - tree fields = TYPE_FIELDS (current_class_type); tree member_init_list = NULL_TREE; - int cvquals = cp_type_quals (TREE_TYPE (parm)); int i; tree binfo, base_binfo; - tree init; vec *vbases; /* Initialize all the base-classes with the parameter converted @@ -704,53 +701,58 @@ do_build_copy_constructor (tree fndecl) inh, member_init_list); } - for (; fields; fields = DECL_CHAIN (fields)) + if (!inh) { - tree field = fields; - tree expr_type; - - if (TREE_CODE (field) != FIELD_DECL) - continue; - if (inh) - continue; + int cvquals = cp_type_quals (TREE_TYPE (parm)); - expr_type = TREE_TYPE (field); - if (DECL_NAME (field)) + for (tree fields = TYPE_FIELDS (current_class_type); + fields; fields = DECL_CHAIN (fields)) { - if (VFIELD_NAME_P (DECL_NAME (field))) + tree field = fields; + tree expr_type; + + if (TREE_CODE (field) != FIELD_DECL) continue; - } - else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type)) - /* Just use the field; anonymous types can't have - nontrivial copy ctors or assignment ops or this - function would be deleted. */; - else - continue; - /* Compute the type of "init->field". If the copy-constructor - parameter is, for example, "const S&", and the type of - the field is "T", then the type will usually be "const - T". (There are no cv-qualified variants of reference - types.) */ - if (!TYPE_REF_P (expr_type)) - { - int quals = cvquals; + expr_type = TREE_TYPE (field); + if (DECL_NAME (field)) + { + if (VFIELD_NAME_P (DECL_NAME (field))) + continue; + } + else if (ANON_AGGR_TYPE_P (expr_type) && TYPE_FIELDS (expr_type)) + /* Just use the field; anonymous types can't have + nontrivial copy ctors or assignment ops or this + function would be deleted. */; + else + continue; - if (DECL_MUTABLE_P (field)) - quals &= ~TYPE_QUAL_CONST; - quals |= cp_type_quals (expr_type); - expr_type = cp_build_qualified_type (expr_type, quals); - } + /* Compute the type of "init->field". If the copy-constructor + parameter is, for example, "const S&", and the type of + the field is "T", then the type will usually be "const + T". (There are no cv-qualified variants of reference + types.) */ + if (!TYPE_REF_P (expr_type)) + { + int quals = cvquals; - init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE); - if (move_p && !TYPE_REF_P (expr_type) - /* 'move' breaks bit-fields, and has no effect for scalars. */ - && !scalarish_type_p (expr_type)) - init = move (init); - init = build_tree_list (NULL_TREE, init); + if (DECL_MUTABLE_P (field)) + quals &= ~TYPE_QUAL_CONST; + quals |= cp_type_quals (expr_type); + expr_type = cp_build_qualified_type (expr_type, quals); + } + + tree init = build3 (COMPONENT_REF, expr_type, parm, field, NULL_TREE); + if (move_p && !TYPE_REF_P (expr_type) + /* 'move' breaks bit-fields, and has no effect for scalars. */ + && !scalarish_type_p (expr_type)) + init = move (init); + init = build_tree_list (NULL_TREE, init); - member_init_list = tree_cons (field, init, member_init_list); + member_init_list = tree_cons (field, init, member_init_list); + } } + finish_mem_initializers (member_init_list); } } @@ -891,8 +893,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/ChangeLog b/gcc/testsuite/ChangeLog index 188b6c5ec60..a0d8c9981bc 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2018-12-19 Alexandre Oliva + + PR c++/88146 + * g++.dg/cpp0x/inh-ctor32.C: New. + 2018-12-18 Jakub Jelinek PR rtl-optimization/87759 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 00000000000..c40412fc534 --- /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 + 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 + 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 + 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 + 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 + constexpr foo(T, ...) {} + }; + struct boo : foo { + using foo::foo; + }; + struct bar : boo { + template + 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 + constexpr foo(T, ...) {} + }; + struct boo : foo { + using foo::foo; + }; + struct bar : boo { + template + /* constexpr */ bar(T ... args) : boo(args...) {} + }; + void f() noexcept(noexcept(bar{0,1})); + } + } + + namespace inherited_derived_ctor { + namespace constexpr_noninherited_ctor { + struct foo { + template + constexpr foo(T, ...) {} + }; + struct boo : foo { + using foo::foo; + }; + struct bor : boo { + template + 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 + constexpr foo(T, ...) {} + }; + struct boo : foo { + using foo::foo; + }; + struct bor : boo { + template + /* constexpr */ bor(T ... args) : boo(args...) {} + }; + struct bar : bor { + using bor::bor; + }; + void f() noexcept(noexcept(bar{0,1})); + } + } +}