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.133.124]) by sourceware.org (Postfix) with ESMTPS id C57B83858D1E for ; Thu, 11 May 2023 18:30:12 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org C57B83858D1E 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=1683829812; 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: content-transfer-encoding:content-transfer-encoding; bh=CNKTmGGz7DbyYE73dBv1fMpHwMrwfHMrCTmlJLnLHnU=; b=VtWJeMWWb5TUcdP4qkx7BWBVfwKOPMXR+/Q9G02eGMXfqML168abnmonGVg2NUde8p5aff JNrNLP9eDypv/Iz083KJJ9fD8xxLIxJRS7NgmnHj4zhnHEWHQ7K9jA60kMqj61REEI4v9v KWio3rTFEU9cHe3SmFU5ZLGCOJ9+t9I= Received: from mail-qk1-f198.google.com (mail-qk1-f198.google.com [209.85.222.198]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-464-X16vl7C4Op-Yjw8bP_gRkQ-1; Thu, 11 May 2023 14:30:10 -0400 X-MC-Unique: X16vl7C4Op-Yjw8bP_gRkQ-1 Received: by mail-qk1-f198.google.com with SMTP id af79cd13be357-7577727a00eso1981826185a.1 for ; Thu, 11 May 2023 11:30:10 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1683829809; x=1686421809; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=CNKTmGGz7DbyYE73dBv1fMpHwMrwfHMrCTmlJLnLHnU=; b=CPV650ff5QvOC0T0m9Sr2ncldNsxay/y6pL/5gF0DGLVRVHeRU061DTFvsPAwCUTDq sK6K+EQwqkGlePW8+QKmgjbkJ58pcP01XYBuBk8p03gjFCJmpV+6om4miYWvqjGjutUF QPouihlkn98CIppSO2/x8uGyiMkysC5aVaJz3Bpohcq4JPoN+MSUX/rITlpkPlBwwPzW oddO3lED2MznEc3tfBVkbHmeJQ8WydBq1gE8jlVVcOCJIBADC8H7rmy0ZpUkWpZ/IIJP MVh9STUPwfL0xHE6b8y1e4Wf0TFTpjyWn0128t6JadOy2n3fv/lBQ1iqp/YQHU7Xy9Fa AE6g== X-Gm-Message-State: AC+VfDyqowrl3PF94gg4XMLPHBIs8c26pjN+lOFAjtsR077vAiH3009a QthyaX+XY3F5NFeR0MkzOTzEKZsIuJVH9h+FG5GxaSKmb3TRl6GbwX0Wp/wl7bYjURepSaZbeUa 3B29nyfHMNlzvzFK5ICwIu5LjA2Joj+a6GiWnZx3p5KFtmHGwcvHrs7RCQQnAZrv5qP59jBQUwN o= X-Received: by 2002:ad4:5bab:0:b0:621:5823:cf1c with SMTP id 11-20020ad45bab000000b006215823cf1cmr7958802qvq.14.1683829809243; Thu, 11 May 2023 11:30:09 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ52uqrL8OCztCG0bT6xGVcPeo96W5vJUUpAT9HywT/2kz7/7YrecqUAz6FrRJ+Sonr5f+CM2g== X-Received: by 2002:ad4:5bab:0:b0:621:5823:cf1c with SMTP id 11-20020ad45bab000000b006215823cf1cmr7958747qvq.14.1683829808764; Thu, 11 May 2023 11:30:08 -0700 (PDT) Received: from localhost.localdomain (ool-457670bb.dyn.optonline.net. [69.118.112.187]) by smtp.gmail.com with ESMTPSA id a11-20020a0ce34b000000b0061b62c1534fsm2438380qvm.23.2023.05.11.11.30.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 May 2023 11:30:08 -0700 (PDT) From: Patrick Palka To: gcc-patches@gcc.gnu.org Cc: jason@redhat.com, Patrick Palka Subject: [PATCH] c++: 'mutable' subobject of constexpr variable [PR109745] Date: Thu, 11 May 2023 14:30:06 -0400 Message-ID: <20230511183006.1565721-1-ppalka@redhat.com> X-Mailer: git-send-email 2.40.1.552.g91428f078b MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset="US-ASCII"; x-default=true X-Spam-Status: No, score=-13.7 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_H2,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: r13-2701-g7107ea6fb933f1 made us correctly accept 'mutable' member accesses during constexpr evaluation of objects constructed during that evaluation, while continuing to reject such accesses for constexpr objects constructed outside of that evaluation, by considering the CONSTRUCTOR_MUTABLE_POISON flag during cxx_eval_component_reference. However, this flag is set only for the outermost CONSTRUCTOR of a constexpr variable initializer, so if we're accessing a 'mutable' subobject within a nested CONSTRUCTOR, the flag won't be set and we'll incorrectly accept the access. This can lead to us rejecting valid code, as in the first testcase, or even wrong code due to speculative constexpr evaluation as in the second and third testcase. This patch fixes this by setting CONSTRUCTOR_MUTABLE_POISON recursively rather than only on the outermost CONSTRUCTOR. Bootstrapped and regtested on x86_64-pc-linux-gnu, does this look OK for trunk/13? PR c++/109745 gcc/cp/ChangeLog: * typeck2.cc (poison_mutable_constructors): Define. (store_init_value): Use it instead of setting CONSTRUCTOR_MUTABLE_POISON directly. gcc/testsuite/ChangeLog: * g++.dg/cpp0x/constexpr-mutable4.C: New test. * g++.dg/cpp0x/constexpr-mutable5.C: New test. * g++.dg/cpp1y/constexpr-mutable2.C: New test. --- gcc/cp/typeck2.cc | 26 +++++++++++-- .../g++.dg/cpp0x/constexpr-mutable4.C | 16 ++++++++ .../g++.dg/cpp0x/constexpr-mutable5.C | 39 +++++++++++++++++++ .../g++.dg/cpp1y/constexpr-mutable2.C | 20 ++++++++++ 4 files changed, 97 insertions(+), 4 deletions(-) create mode 100644 gcc/testsuite/g++.dg/cpp0x/constexpr-mutable4.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/constexpr-mutable5.C create mode 100644 gcc/testsuite/g++.dg/cpp1y/constexpr-mutable2.C diff --git a/gcc/cp/typeck2.cc b/gcc/cp/typeck2.cc index f5cc7c8371c..8a187708482 100644 --- a/gcc/cp/typeck2.cc +++ b/gcc/cp/typeck2.cc @@ -776,6 +776,27 @@ split_nonconstant_init (tree dest, tree init) return code; } +/* T is the initializer of a constexpr variable. Set CONSTRUCTOR_MUTABLE_POISON + for any CONSTRUCTOR within T that contains (directly or indirectly) a mutable + member, thereby poisoning it so it can't be copied to another a constexpr + variable, or read during constexpr evaluation. */ + +static void +poison_mutable_constructors (tree t) +{ + if (TREE_CODE (t) != CONSTRUCTOR) + return; + + if (cp_has_mutable_p (TREE_TYPE (t))) + { + CONSTRUCTOR_MUTABLE_POISON (t) = true; + + if (vec *elts = CONSTRUCTOR_ELTS (t)) + for (const constructor_elt &ce : *elts) + poison_mutable_constructors (ce.value); + } +} + /* Perform appropriate conversions on the initial value of a variable, store it in the declaration DECL, and print any error messages that are appropriate. @@ -886,10 +907,7 @@ store_init_value (tree decl, tree init, vec** cleanups, int flags) else value = fold_non_dependent_init (value, tf_warning_or_error, /*manifestly_const_eval=*/true, decl); - if (TREE_CODE (value) == CONSTRUCTOR && cp_has_mutable_p (type)) - /* Poison this CONSTRUCTOR so it can't be copied to another - constexpr variable. */ - CONSTRUCTOR_MUTABLE_POISON (value) = true; + poison_mutable_constructors (value); const_init = (reduced_constant_expression_p (value) || error_operand_p (value)); DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = const_init; diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-mutable4.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-mutable4.C new file mode 100644 index 00000000000..01f32dea1bd --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-mutable4.C @@ -0,0 +1,16 @@ +// PR c++/109745 +// { dg-do compile { target c++11 } } + +struct A { mutable int m = 0; }; + +struct B { A a; }; + +struct C { B b; }; + +int main() { + constexpr B b; + constexpr int bam = b.a.m; // { dg-error "mutable" } + + constexpr C c; + constexpr int cbam = c.b.a.m; // { dg-error "mutable" } +} diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-mutable5.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-mutable5.C new file mode 100644 index 00000000000..6a530e2abe6 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-mutable5.C @@ -0,0 +1,39 @@ +// PR c++/109745 +// { dg-do run { target c++11 } } +// { dg-additional-options "-O" } + +struct A { + mutable int m = 0; + void f() const { ++m; }; + constexpr int get_m() const { return m; } +}; + +struct B { A a; }; + +struct C { B b; }; + +int main() { + constexpr A a; + a.m++; + if (a.get_m() != 1 || a.m != 1) + __builtin_abort(); + a.m++; + if (a.get_m() != 2 || a.m != 2) + __builtin_abort(); + + constexpr B b; + b.a.m++; + if (b.a.get_m() != 1 || b.a.m != 1) + __builtin_abort(); + b.a.m++; + if (b.a.get_m() != 2 || b.a.m != 2) + __builtin_abort(); + + constexpr C c; + c.b.a.m++; + if (c.b.a.get_m() != 1 || c.b.a.m != 1) + __builtin_abort(); + c.b.a.m++; + if (c.b.a.get_m() != 2 || c.b.a.m != 2) + __builtin_abort(); +} diff --git a/gcc/testsuite/g++.dg/cpp1y/constexpr-mutable2.C b/gcc/testsuite/g++.dg/cpp1y/constexpr-mutable2.C new file mode 100644 index 00000000000..bb3429aea13 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1y/constexpr-mutable2.C @@ -0,0 +1,20 @@ +// PR c++/109745 +// { dg-do run { target c++14 } } +// { dg-additional-options "-O" } + +template +struct Foo { T val; }; + +struct Bar { + constexpr Bar() = default; + constexpr Bar(Bar const& other) { other.val_ = 42; } + constexpr int val() const { return val_; } + mutable int val_{}; +}; + +int main() { + constexpr Foo x{}; + Foo y{x}; + if (x.val.val() != 42 || x.val.val_ != 42) + __builtin_abort(); +} -- 2.40.1.552.g91428f078b