From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id C194F385AFA6 for ; Tue, 25 Jul 2023 17:00:18 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org C194F385AFA6 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1690304417; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: in-reply-to:in-reply-to:references:references; bh=9tP9g1d2w89VElleHxuP54XoT3AUC9V3UYy4e76BVrE=; b=jOaFvY9KB6/yYUgPq4QPaVKayrQXxLZtC2Bz2p5WxRcurBbmuQyMbDG57myhD8xk1njKdA LxAZ/Y7j72wcvr+on0zONqCAZ1nNUIhjzb3/K+wLkEipjdI76eNMYGx5UTZZAQR8wi9A6F KGiDCPNaGRlnoTJmoR/tfF+GUOHhyU4= Received: from mail-ua1-f71.google.com (mail-ua1-f71.google.com [209.85.222.71]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-341-m9E7mJiKNS-4mxdvg70VTA-1; Tue, 25 Jul 2023 13:00:02 -0400 X-MC-Unique: m9E7mJiKNS-4mxdvg70VTA-1 Received: by mail-ua1-f71.google.com with SMTP id a1e0cc1a2514c-794d03cb207so1074345241.2 for ; Tue, 25 Jul 2023 10:00:01 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1690304401; x=1690909201; h=user-agent:in-reply-to:content-disposition:mime-version:references :message-id:subject:cc:to:from:date:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=9tP9g1d2w89VElleHxuP54XoT3AUC9V3UYy4e76BVrE=; b=ju6nD9e9pO4BC/BGO1EOdXWy9qb/blRp+mj7QugdpyuUB7Kb/3vke544TRBRKVD9Hv ws5j6KvldAf0Quze8AgIfTJZIlwxMI/bmYkM3WXO4usXaR2+69fTsvlwOddhokaYq1Id Ns+GT80AJZiFqDmnmmQcowAvqJo09jV4/hujA/qdqY6NoxEOWylypt/5SObgOmZ82LeI QkaOUcSKBDuH+yj8zN1iLQH24yhgiKpllkJNcP00bKSzPcs9sqtspzczRTI+Io0fWBx2 9YlUwfUgix9UKREEavTsMtadaNAaRgl98RgF7JaP+4OCIv+h5KpUu9a9Pyw3aBO9Bz2c 2L4g== X-Gm-Message-State: ABy/qLbVx1v9SWiGbUUie96xJhl/MpVN/1Me9B5lkxE0r7FQSdlqla+E W7rUFA7pig5/peaU+oL/K49jVydASgMByLovDxJmd1MVVi5J21nZ0IJGkhKdAWImfoU+xIdVPUW i3k+EcIlYTfyZLyHHiQ== X-Received: by 2002:a67:f7d1:0:b0:443:8a7b:f76d with SMTP id a17-20020a67f7d1000000b004438a7bf76dmr4745713vsp.28.1690304401081; Tue, 25 Jul 2023 10:00:01 -0700 (PDT) X-Google-Smtp-Source: APBJJlFsiUNAhX2g5hd/azQ9HgAny3IpS/NvSCha0WAo5oTchUOueg/+e19od94bm12+OrKizqfmGg== X-Received: by 2002:a67:f7d1:0:b0:443:8a7b:f76d with SMTP id a17-20020a67f7d1000000b004438a7bf76dmr4745692vsp.28.1690304400722; Tue, 25 Jul 2023 10:00:00 -0700 (PDT) Received: from redhat.com (2603-7000-9500-34a5-0000-0000-0000-1db4.res6.spectrum.com. [2603:7000:9500:34a5::1db4]) by smtp.gmail.com with ESMTPSA id o11-20020a05620a110b00b00767da9b6ae9sm3799936qkk.11.2023.07.25.10.00.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 25 Jul 2023 10:00:00 -0700 (PDT) Date: Tue, 25 Jul 2023 12:59:58 -0400 From: Marek Polacek To: Jason Merrill Cc: GCC Patches , Patrick Palka Subject: [PATCH v3] c++: fix ICE with constexpr ARRAY_REF [PR110382] Message-ID: References: <20230721223835.630543-1-polacek@redhat.com> <77708a9e-b677-e655-a3cc-a9af6d0b1321@redhat.com> <006e3a0f-07a3-c99c-647b-11271ab2adec@redhat.com> MIME-Version: 1.0 In-Reply-To: <006e3a0f-07a3-c99c-647b-11271ab2adec@redhat.com> User-Agent: Mutt/2.2.9 (2022-11-12) X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset=us-ascii Content-Disposition: inline X-Spam-Status: No, score=-12.5 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H4,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE,TXREP,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: On Tue, Jul 25, 2023 at 11:15:07AM -0400, Jason Merrill wrote: > On 7/24/23 18:37, Marek Polacek wrote: > > On Sat, Jul 22, 2023 at 12:28:59AM -0400, Jason Merrill wrote: > > > On 7/21/23 18:38, Marek Polacek wrote: > > > > Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk/13? > > > > > > > > -- >8 -- > > > > > > > > This code in cxx_eval_array_reference has been hard to get right. > > > > In r12-2304 I added some code; in r13-5693 I removed some of it. > > > > > > > > Here the problematic line is "S s = arr[0];" which causes a crash > > > > on the assert in verify_ctor_sanity: > > > > > > > > gcc_assert (!ctx->object || !DECL_P (ctx->object) > > > > || ctx->global->get_value (ctx->object) == ctx->ctor); > > > > > > > > ctx->object is the VAR_DECL 's', which is correct here. The second > > > > line points to the problem: we replaced ctx->ctor in > > > > cxx_eval_array_reference: > > > > > > > > new_ctx.ctor = build_constructor (elem_type, NULL); // #1 > > > > > > ...and this code doesn't also clear(/set) new_ctx.object like everywhere > > > else in constexpr.cc that sets new_ctx.ctor. Fixing that should make the > > > testcase work. > > > > Right, but then we'd be back pre-r12-2304 or r13-5693... > > > > ...except it should work to always clear the object, like below. > > > > which I think we shouldn't have; the CONSTRUCTOR we created in > > > > cxx_eval_constant_expression/DECL_EXPR > > > > > > > > new_ctx.ctor = build_constructor (TREE_TYPE (r), NULL); > > > > > > > > had the right type. > > > > > > Indeed, and using it rather than building a new one seems like a valid > > > optimization for trunk. > > Agreed, I kept it. > > > > > I also notice that the DECL_EXPR code calls unshare_constructor, which > > > should be unnecessary if init == ctx->ctor? > > > > It looks like init == ctx->ctor only happens only with this new testcase. > > I'm not sure it's worth it adding code for such a rare case? > > > > We still need #1 though. E.g., in constexpr-96241.C, we never > > > > set ctx.ctor/object before calling cxx_eval_array_reference, so > > > > we have to build a CONSTRUCTOR there. And in constexpr-101371-2.C > > > > we have a ctx.ctor, but it has the wrong type, so we need a new one. > > > > > > > > PR c++/110382 > > > > > > > > gcc/cp/ChangeLog: > > > > > > > > * constexpr.cc (cxx_eval_array_reference): Create a new constructor > > > > only when we don't already have a matching one. > > > > > > > > gcc/testsuite/ChangeLog: > > > > > > > > * g++.dg/cpp1y/constexpr-110382.C: New test. > > > > --- > > > > gcc/cp/constexpr.cc | 5 ++++- > > > > gcc/testsuite/g++.dg/cpp1y/constexpr-110382.C | 17 +++++++++++++++++ > > > > 2 files changed, 21 insertions(+), 1 deletion(-) > > > > create mode 100644 gcc/testsuite/g++.dg/cpp1y/constexpr-110382.C > > > > > > > > diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc > > > > index fb94f3cefcb..518b7c7a2d5 100644 > > > > --- a/gcc/cp/constexpr.cc > > > > +++ b/gcc/cp/constexpr.cc > > > > @@ -4291,7 +4291,10 @@ cxx_eval_array_reference (const constexpr_ctx *ctx, tree t, > > > > else > > > > val = build_value_init (elem_type, tf_warning_or_error); > > > > - if (!SCALAR_TYPE_P (elem_type)) > > > > + if (!SCALAR_TYPE_P (elem_type) > > > > + /* Create a new constructor only if we don't already have one that > > > > + is suitable. */ > > > > + && !(ctx->ctor && same_type_p (elem_type, TREE_TYPE (ctx->ctor)))) > > > > > > We generally use same_type_ignoring_top_level_qualifiers_p in the constexpr > > > code. > > > > True, changed. > > > > Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? > > > > For 13, I guess I should only clear the object and leave out the > > same_type_ bit. > > > > -- >8 -- > > This code in cxx_eval_array_reference has been hard to get right. > > In r12-2304 I added some code; in r13-5693 I removed some of it. > > > > Here the problematic line is "S s = arr[0];" which causes a crash > > on the assert in verify_ctor_sanity: > > > > gcc_assert (!ctx->object || !DECL_P (ctx->object) > > || ctx->global->get_value (ctx->object) == ctx->ctor); > > > > ctx->object is the VAR_DECL 's', which is correct here. The second > > line points to the problem: we replaced ctx->ctor in > > cxx_eval_array_reference: > > > > new_ctx.ctor = build_constructor (elem_type, NULL); // #1 > > > > which I think we shouldn't have; the CONSTRUCTOR we created in > > cxx_eval_constant_expression/DECL_EXPR > > > > new_ctx.ctor = build_constructor (TREE_TYPE (r), NULL); > > > > had the right type. > > > > We still need #1 though. E.g., in constexpr-96241.C, we never > > set ctx.ctor/object before calling cxx_eval_array_reference, so > > we have to build a CONSTRUCTOR there. And in constexpr-101371-2.C > > we have a ctx.ctor, but it has the wrong type, so we need a new one. > > > > We can fix the problem by always clearing the object, and, as an > > optimization, only create/free a new ctor when actually needed. > > > > PR c++/110382 > > > > gcc/cp/ChangeLog: > > > > * constexpr.cc (cxx_eval_array_reference): Create a new constructor > > only when we don't already have a matching one. Clear the object > > when the type is non-scalar. > > > > gcc/testsuite/ChangeLog: > > > > * g++.dg/cpp1y/constexpr-110382.C: New test. > > --- > > gcc/cp/constexpr.cc | 17 +++++++++++++++-- > > gcc/testsuite/g++.dg/cpp1y/constexpr-110382.C | 17 +++++++++++++++++ > > 2 files changed, 32 insertions(+), 2 deletions(-) > > create mode 100644 gcc/testsuite/g++.dg/cpp1y/constexpr-110382.C > > > > diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc > > index fb94f3cefcb..054812bcb72 100644 > > --- a/gcc/cp/constexpr.cc > > +++ b/gcc/cp/constexpr.cc > > @@ -4291,15 +4291,28 @@ cxx_eval_array_reference (const constexpr_ctx *ctx, tree t, > > else > > val = build_value_init (elem_type, tf_warning_or_error); > > + bool new_ctor; > > if (!SCALAR_TYPE_P (elem_type)) > > { > > new_ctx = *ctx; > > - new_ctx.ctor = build_constructor (elem_type, NULL); > > + /* We clear the object here. We used to replace it with T, but that > > + caused problems (101371, 108158); and anyway, T is the initializer, > > + not the target object. */ > > + new_ctx.object = NULL_TREE; > > + /* Create a new constructor only if we don't already have a suitable > > + one. */ > > + new_ctor = (!ctx->ctor > > + || !same_type_ignoring_top_level_qualifiers_p > > + (elem_type, TREE_TYPE (ctx->ctor))); > > + if (new_ctor) > > + new_ctx.ctor = build_constructor (elem_type, NULL); > > I think clearing .object should (only) happen along with changing .ctor; if > we leave .ctor alone, we should also leave the matching .object alone. Ah, true. Thus: Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? -- >8 -- This code in cxx_eval_array_reference has been hard to get right. In r12-2304 I added some code; in r13-5693 I removed some of it. Here the problematic line is "S s = arr[0];" which causes a crash on the assert in verify_ctor_sanity: gcc_assert (!ctx->object || !DECL_P (ctx->object) || ctx->global->get_value (ctx->object) == ctx->ctor); ctx->object is the VAR_DECL 's', which is correct here. The second line points to the problem: we replaced ctx->ctor in cxx_eval_array_reference: new_ctx.ctor = build_constructor (elem_type, NULL); // #1 which I think we shouldn't have; the CONSTRUCTOR we created in cxx_eval_constant_expression/DECL_EXPR new_ctx.ctor = build_constructor (TREE_TYPE (r), NULL); had the right type. We still need #1 though. E.g., in constexpr-96241.C, we never set ctx.ctor/object before calling cxx_eval_array_reference, so we have to build a CONSTRUCTOR there. And in constexpr-101371-2.C we have a ctx.ctor, but it has the wrong type, so we need a new one. We can fix the problem by always clearing the object, and, as an optimization, only create/free a new ctor when actually needed. PR c++/110382 gcc/cp/ChangeLog: * constexpr.cc (cxx_eval_array_reference): Create a new constructor only when we don't already have a matching one. Clear the object when the type is non-scalar. gcc/testsuite/ChangeLog: * g++.dg/cpp1y/constexpr-110382.C: New test. --- gcc/cp/constexpr.cc | 13 +++++++++++-- gcc/testsuite/g++.dg/cpp1y/constexpr-110382.C | 17 +++++++++++++++++ 2 files changed, 28 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/g++.dg/cpp1y/constexpr-110382.C diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc index fb94f3cefcb..5e0fe93ebc0 100644 --- a/gcc/cp/constexpr.cc +++ b/gcc/cp/constexpr.cc @@ -4291,15 +4291,24 @@ cxx_eval_array_reference (const constexpr_ctx *ctx, tree t, else val = build_value_init (elem_type, tf_warning_or_error); - if (!SCALAR_TYPE_P (elem_type)) + /* Create a new constructor only if we don't already have a suitable one. */ + const bool new_ctor = (!SCALAR_TYPE_P (elem_type) + && (!ctx->ctor + || !same_type_ignoring_top_level_qualifiers_p + (elem_type, TREE_TYPE (ctx->ctor)))); + if (new_ctor) { new_ctx = *ctx; + /* We clear the object here. We used to replace it with T, but that + caused problems (101371, 108158); and anyway, T is the initializer, + not the target object. */ + new_ctx.object = NULL_TREE; new_ctx.ctor = build_constructor (elem_type, NULL); ctx = &new_ctx; } t = cxx_eval_constant_expression (ctx, val, lval, non_constant_p, overflow_p); - if (!SCALAR_TYPE_P (elem_type) && t != ctx->ctor) + if (new_ctor && t != ctx->ctor) free_constructor (ctx->ctor); return t; } diff --git a/gcc/testsuite/g++.dg/cpp1y/constexpr-110382.C b/gcc/testsuite/g++.dg/cpp1y/constexpr-110382.C new file mode 100644 index 00000000000..317c5ecfcd5 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1y/constexpr-110382.C @@ -0,0 +1,17 @@ +// PR c++/110382 +// { dg-do compile { target c++14 } } + +struct S { + double a = 0; +}; + +constexpr double +g () +{ + S arr[1]; + S s = arr[0]; + (void) arr[0]; + return s.a; +} + +int main() { return g (); } base-commit: 09dda270380fe13e7b4722305cb1122df1f779a0 -- 2.41.0