From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 74303 invoked by alias); 14 Dec 2018 22:34:10 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 74277 invoked by uid 89); 14 Dec 2018 22:34:09 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-26.9 required=5.0 tests=BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,SPF_HELO_PASS autolearn=ham version=3.3.2 spammy=TYPE_NAME, type_name X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 14 Dec 2018 22:34:03 +0000 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 7EC3B2CD801 for ; Fri, 14 Dec 2018 22:34:02 +0000 (UTC) Received: from free.home (ovpn04.gateway.prod.ext.phx2.redhat.com [10.5.9.4]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 975D75FCD0; Fri, 14 Dec 2018 22:33:57 +0000 (UTC) Received: from livre (livre.home [172.31.160.2]) by free.home (8.15.2/8.15.2) with ESMTP id wBEMXlDF360376; Fri, 14 Dec 2018 20:33:47 -0200 From: Alexandre Oliva To: Jason Merrill Cc: gcc-patches@gcc.gnu.org Subject: Re: [C++ Patch] [PR c++/88146] do not crash synthesizing inherited ctor(...) References: <81ac6c22-8907-a166-b8df-80e06d2850da@redhat.com> Date: Fri, 14 Dec 2018 22:34:00 -0000 In-Reply-To: (Jason Merrill's message of "Fri, 14 Dec 2018 16:40:59 -0500") Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/26.1 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable X-SW-Source: 2018-12/txt/msg01117.txt.bz2 On Dec 14, 2018, Jason Merrill wrote: >> If inh is false, we're a copy constructor, which always has a parm, >> so this hunk seems unnecessary. ack >>> -=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0 int cvquals =3D cp_type_quals (TREE_TYP= E (parm)); >>> +=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0 int cvquals =3D parm ? cp_type_quals (T= REE_TYPE (parm)) : 0; >>=20 >> 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 =3D 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 =3D TYPE_FIELDS (current_class_type); tree member_init_list =3D NULL_TREE; - int cvquals =3D 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); } =20 + if (!inh) + cvquals =3D cp_type_quals (TREE_TYPE (parm)); + else + fields =3D NULL; + for (; fields; fields =3D DECL_CHAIN (fields)) { tree field =3D fields; @@ -711,8 +716,6 @@ do_build_copy_constructor (tree fndecl) =20 if (TREE_CODE (field) !=3D FIELD_DECL) continue; - if (inh) - continue; =20 expr_type =3D TREE_TYPE (field); if (DECL_NAME (field)) @@ -891,8 +894,9 @@ synthesize_method (tree fndecl) =20 /* Reset the source location, we might have been previously deferred, and thus have saved where we were first needed. */ - DECL_SOURCE_LOCATION (fndecl) - =3D DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl))); + if (!DECL_INHERITED_CTOR (fndecl)) + DECL_SOURCE_LOCATION (fndecl) + =3D DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl))); =20 /* 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.=20 + +// 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 argument= s 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 t= o 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 t= o 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, unimp= lemented: 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, unimp= lemented: 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})); + } + } +} --=20 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=C3=A1s-GNUChe