* [PATCH] c++: wrong error with static constexpr var in tmpl [PR109876] @ 2023-05-26 23:18 Marek Polacek 2023-05-27 1:47 ` Jason Merrill 0 siblings, 1 reply; 4+ messages in thread From: Marek Polacek @ 2023-05-26 23:18 UTC (permalink / raw) To: Jason Merrill, GCC Patches Since r8-509, we'll no longer create a static temporary var for the initializer '{ 1, 2 }' for num in the attached test because the code in finish_compound_literal is now guarded by '&& fcl_context == fcl_c99' but it's fcl_functional here. This causes us to reject num as non-constant when evaluating it in a template. Jason's idea was to treat num as value-dependent even though it actually isn't. This patch implements that suggestion. The is_really_empty_class check is sort of non-obvious but the comment should explain why I added it. Co-authored-by: Jason Merrill <jason@redhat.com> Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? PR c++/109876 gcc/cp/ChangeLog: * pt.cc (value_dependent_expression_p) <case VAR_DECL>: Treat a constexpr-declared non-constant variable as value-dependent. gcc/testsuite/ChangeLog: * g++.dg/cpp0x/constexpr-template12.C: New test. * g++.dg/cpp1z/constexpr-template1.C: New test. --- gcc/cp/pt.cc | 12 ++++++ .../g++.dg/cpp0x/constexpr-template12.C | 38 +++++++++++++++++++ .../g++.dg/cpp1z/constexpr-template1.C | 25 ++++++++++++ 3 files changed, 75 insertions(+) create mode 100644 gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C create mode 100644 gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index 7fb3e75bceb..38fd8070705 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -27969,6 +27969,18 @@ value_dependent_expression_p (tree expression) else if (TYPE_REF_P (TREE_TYPE (expression))) /* FIXME cp_finish_decl doesn't fold reference initializers. */ return true; + /* We have a constexpr variable and we're processing a template. When + there's lifetime extension involved (for which finish_compound_literal + used to create a temporary), we'll not be able to evaluate the + variable until instantiating, so pretend it's value-dependent. */ + else if (DECL_DECLARED_CONSTEXPR_P (expression) + && !TREE_CONSTANT (expression) + /* When there's nothing to initialize, we'll never mark the + VAR_DECL TREE_CONSTANT, therefore it would remain + value-dependent and we wouldn't instantiate. */ + && !is_really_empty_class (TREE_TYPE (expression), + /*ignore_vptr*/false)) + return true; return false; case DYNAMIC_CAST_EXPR: diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C new file mode 100644 index 00000000000..a9e065320c8 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C @@ -0,0 +1,38 @@ +// PR c++/109876 +// { dg-do compile { target c++11 } } + +using size_t = decltype(sizeof 0); + +namespace std { +template <class> struct initializer_list { + const int *_M_array; + size_t _M_len; + constexpr size_t size() const { return _M_len; } +}; +} // namespace std + +constexpr std::initializer_list<int> gnum{2}; + +template <int> struct Array {}; +template <int> void g() +{ + static constexpr std::initializer_list<int> num{2}; + static_assert(num.size(), ""); + Array<num.size()> ctx; + + constexpr Array<1> num1{}; +} + +template <int N> +struct Foo +{ + static constexpr std::initializer_list<int> num = { 1, 2 }; + static_assert(num.size(), ""); + Array<num.size()> ctx; +}; + +void +f (Foo<5>) +{ + g<0>(); +} diff --git a/gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C b/gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C new file mode 100644 index 00000000000..58be046fd36 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C @@ -0,0 +1,25 @@ +// PR c++/109876 +// { dg-do compile { target c++17 } } + +struct Foo {}; +template <const Foo&> struct X {}; + +void g() +{ + static constexpr Foo foo; + X<foo> x; +} + +template<int> +void f() +{ + static constexpr Foo foo; + X<foo> x; +} + +void +h () +{ + f<0>(); + f<1>(); +} base-commit: 8d6bd830f5f9c939e8565c0341a0c6c588834484 -- 2.40.1 ^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [PATCH] c++: wrong error with static constexpr var in tmpl [PR109876] 2023-05-26 23:18 [PATCH] c++: wrong error with static constexpr var in tmpl [PR109876] Marek Polacek @ 2023-05-27 1:47 ` Jason Merrill 2023-07-13 18:54 ` [PATCH v2] " Marek Polacek 0 siblings, 1 reply; 4+ messages in thread From: Jason Merrill @ 2023-05-27 1:47 UTC (permalink / raw) To: Marek Polacek, GCC Patches On 5/26/23 19:18, Marek Polacek wrote: > Since r8-509, we'll no longer create a static temporary var for > the initializer '{ 1, 2 }' for num in the attached test because > the code in finish_compound_literal is now guarded by > '&& fcl_context == fcl_c99' but it's fcl_functional here. This > causes us to reject num as non-constant when evaluating it in > a template. > > Jason's idea was to treat num as value-dependent even though it > actually isn't. This patch implements that suggestion. > > The is_really_empty_class check is sort of non-obvious but the > comment should explain why I added it. > > Co-authored-by: Jason Merrill <jason@redhat.com> > > Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? > > PR c++/109876 > > gcc/cp/ChangeLog: > > * pt.cc (value_dependent_expression_p) <case VAR_DECL>: Treat a > constexpr-declared non-constant variable as value-dependent. > > gcc/testsuite/ChangeLog: > > * g++.dg/cpp0x/constexpr-template12.C: New test. > * g++.dg/cpp1z/constexpr-template1.C: New test. > --- > gcc/cp/pt.cc | 12 ++++++ > .../g++.dg/cpp0x/constexpr-template12.C | 38 +++++++++++++++++++ > .../g++.dg/cpp1z/constexpr-template1.C | 25 ++++++++++++ > 3 files changed, 75 insertions(+) > create mode 100644 gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C > create mode 100644 gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C > > diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc > index 7fb3e75bceb..38fd8070705 100644 > --- a/gcc/cp/pt.cc > +++ b/gcc/cp/pt.cc > @@ -27969,6 +27969,18 @@ value_dependent_expression_p (tree expression) > else if (TYPE_REF_P (TREE_TYPE (expression))) > /* FIXME cp_finish_decl doesn't fold reference initializers. */ > return true; > + /* We have a constexpr variable and we're processing a template. When > + there's lifetime extension involved (for which finish_compound_literal > + used to create a temporary), we'll not be able to evaluate the > + variable until instantiating, so pretend it's value-dependent. */ > + else if (DECL_DECLARED_CONSTEXPR_P (expression) > + && !TREE_CONSTANT (expression) > + /* When there's nothing to initialize, we'll never mark the > + VAR_DECL TREE_CONSTANT, therefore it would remain > + value-dependent and we wouldn't instantiate. */ Interesting. Can we change that (i.e. mark it TREE_CONSTANT) rather than work around it here? > + && !is_really_empty_class (TREE_TYPE (expression), > + /*ignore_vptr*/false)) > + return true; > return false; > > case DYNAMIC_CAST_EXPR: > diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C > new file mode 100644 > index 00000000000..a9e065320c8 > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C > @@ -0,0 +1,38 @@ > +// PR c++/109876 > +// { dg-do compile { target c++11 } } > + > +using size_t = decltype(sizeof 0); > + > +namespace std { > +template <class> struct initializer_list { > + const int *_M_array; > + size_t _M_len; > + constexpr size_t size() const { return _M_len; } > +}; > +} // namespace std > + > +constexpr std::initializer_list<int> gnum{2}; > + > +template <int> struct Array {}; > +template <int> void g() > +{ > + static constexpr std::initializer_list<int> num{2}; > + static_assert(num.size(), ""); > + Array<num.size()> ctx; > + > + constexpr Array<1> num1{}; > +} > + > +template <int N> > +struct Foo > +{ > + static constexpr std::initializer_list<int> num = { 1, 2 }; > + static_assert(num.size(), ""); > + Array<num.size()> ctx; > +}; > + > +void > +f (Foo<5>) > +{ > + g<0>(); > +} > diff --git a/gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C b/gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C > new file mode 100644 > index 00000000000..58be046fd36 > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C > @@ -0,0 +1,25 @@ > +// PR c++/109876 > +// { dg-do compile { target c++17 } } > + > +struct Foo {}; > +template <const Foo&> struct X {}; > + > +void g() > +{ > + static constexpr Foo foo; > + X<foo> x; > +} > + > +template<int> > +void f() > +{ > + static constexpr Foo foo; > + X<foo> x; > +} > + > +void > +h () > +{ > + f<0>(); > + f<1>(); > +} > > base-commit: 8d6bd830f5f9c939e8565c0341a0c6c588834484 ^ permalink raw reply [flat|nested] 4+ messages in thread
* [PATCH v2] c++: wrong error with static constexpr var in tmpl [PR109876] 2023-05-27 1:47 ` Jason Merrill @ 2023-07-13 18:54 ` Marek Polacek 2023-07-14 17:07 ` Jason Merrill 0 siblings, 1 reply; 4+ messages in thread From: Marek Polacek @ 2023-07-13 18:54 UTC (permalink / raw) To: Jason Merrill; +Cc: GCC Patches On Fri, May 26, 2023 at 09:47:10PM -0400, Jason Merrill wrote: > On 5/26/23 19:18, Marek Polacek wrote: > > Since r8-509, we'll no longer create a static temporary var for > > the initializer '{ 1, 2 }' for num in the attached test because > > the code in finish_compound_literal is now guarded by > > '&& fcl_context == fcl_c99' but it's fcl_functional here. This > > causes us to reject num as non-constant when evaluating it in > > a template. > > > > Jason's idea was to treat num as value-dependent even though it > > actually isn't. This patch implements that suggestion. > > > > The is_really_empty_class check is sort of non-obvious but the > > comment should explain why I added it. > > > > Co-authored-by: Jason Merrill <jason@redhat.com> > > > > Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? > > > > PR c++/109876 > > > > gcc/cp/ChangeLog: > > > > * pt.cc (value_dependent_expression_p) <case VAR_DECL>: Treat a > > constexpr-declared non-constant variable as value-dependent. > > > > gcc/testsuite/ChangeLog: > > > > * g++.dg/cpp0x/constexpr-template12.C: New test. > > * g++.dg/cpp1z/constexpr-template1.C: New test. > > --- > > gcc/cp/pt.cc | 12 ++++++ > > .../g++.dg/cpp0x/constexpr-template12.C | 38 +++++++++++++++++++ > > .../g++.dg/cpp1z/constexpr-template1.C | 25 ++++++++++++ > > 3 files changed, 75 insertions(+) > > create mode 100644 gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C > > create mode 100644 gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C > > > > diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc > > index 7fb3e75bceb..38fd8070705 100644 > > --- a/gcc/cp/pt.cc > > +++ b/gcc/cp/pt.cc > > @@ -27969,6 +27969,18 @@ value_dependent_expression_p (tree expression) > > else if (TYPE_REF_P (TREE_TYPE (expression))) > > /* FIXME cp_finish_decl doesn't fold reference initializers. */ > > return true; > > + /* We have a constexpr variable and we're processing a template. When > > + there's lifetime extension involved (for which finish_compound_literal > > + used to create a temporary), we'll not be able to evaluate the > > + variable until instantiating, so pretend it's value-dependent. */ > > + else if (DECL_DECLARED_CONSTEXPR_P (expression) > > + && !TREE_CONSTANT (expression) > > + /* When there's nothing to initialize, we'll never mark the > > + VAR_DECL TREE_CONSTANT, therefore it would remain > > + value-dependent and we wouldn't instantiate. */ Sorry it's taken so long to get back to this. > Interesting. Can we change that (i.e. mark it TREE_CONSTANT) rather than > work around it here? I think we can. Maybe as in the below: -- >8 -- Since r8-509, we'll no longer create a static temporary var for the initializer '{ 1, 2 }' for num in the attached test because the code in finish_compound_literal is now guarded by '&& fcl_context == fcl_c99' but it's fcl_functional here. This causes us to reject num as non-constant when evaluating it in a template. Jason's idea was to treat num as value-dependent even though it actually isn't. This patch implements that suggestion. We weren't marking objects whose type is an empty class type constant. This patch changes that so that v_d_e_p doesn't need to check is_really_empty_class. Co-authored-by: Jason Merrill <jason@redhat.com> Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? PR c++/109876 gcc/cp/ChangeLog: * decl.cc (cp_finish_decl): Set TREE_CONSTANT when initializing an object of empty class type. * pt.cc (value_dependent_expression_p) <case VAR_DECL>: Treat a constexpr-declared non-constant variable as value-dependent. gcc/testsuite/ChangeLog: * g++.dg/cpp0x/constexpr-template12.C: New test. * g++.dg/cpp1z/constexpr-template1.C: New test. * g++.dg/cpp1z/constexpr-template2.C: New test. --- gcc/cp/decl.cc | 13 +++++-- gcc/cp/pt.cc | 7 ++++ .../g++.dg/cpp0x/constexpr-template12.C | 38 +++++++++++++++++++ .../g++.dg/cpp1z/constexpr-template1.C | 25 ++++++++++++ .../g++.dg/cpp1z/constexpr-template2.C | 25 ++++++++++++ 5 files changed, 105 insertions(+), 3 deletions(-) create mode 100644 gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C create mode 100644 gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C create mode 100644 gcc/testsuite/g++.dg/cpp1z/constexpr-template2.C diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc index 60f107d50c4..792ab330dd0 100644 --- a/gcc/cp/decl.cc +++ b/gcc/cp/decl.cc @@ -8200,7 +8200,6 @@ void cp_finish_decl (tree decl, tree init, bool init_const_expr_p, tree asmspec_tree, int flags) { - tree type; vec<tree, va_gc> *cleanups = NULL; const char *asmspec = NULL; int was_readonly = 0; @@ -8220,7 +8219,7 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p, /* Parameters are handled by store_parm_decls, not cp_finish_decl. */ gcc_assert (TREE_CODE (decl) != PARM_DECL); - type = TREE_TYPE (decl); + tree type = TREE_TYPE (decl); if (type == error_mark_node) return; @@ -8410,7 +8409,7 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p, if (decl_maybe_constant_var_p (decl) /* FIXME setting TREE_CONSTANT on refs breaks the back end. */ && !TYPE_REF_P (type)) - TREE_CONSTANT (decl) = 1; + TREE_CONSTANT (decl) = true; } /* This is handled mostly by gimplify.cc, but we have to deal with not warning about int x = x; as it is a GCC extension to turn off @@ -8421,6 +8420,14 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p, && !warning_enabled_at (DECL_SOURCE_LOCATION (decl), OPT_Winit_self)) suppress_warning (decl, OPT_Winit_self); } + else if (VAR_P (decl) + && COMPLETE_TYPE_P (type) + && !TYPE_REF_P (type) + && !dependent_type_p (type) + && is_really_empty_class (type, /*ignore_vptr*/false)) + /* We have no initializer but there's nothing to initialize anyway. + Treat DECL as constant due to c++/109876. */ + TREE_CONSTANT (decl) = true; if (flag_openmp && TREE_CODE (decl) == FUNCTION_DECL diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index fa15b75b9c5..255d18b9539 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -27983,6 +27983,13 @@ value_dependent_expression_p (tree expression) else if (TYPE_REF_P (TREE_TYPE (expression))) /* FIXME cp_finish_decl doesn't fold reference initializers. */ return true; + /* We have a constexpr variable and we're processing a template. When + there's lifetime extension involved (for which finish_compound_literal + used to create a temporary), we'll not be able to evaluate the + variable until instantiating, so pretend it's value-dependent. */ + else if (DECL_DECLARED_CONSTEXPR_P (expression) + && !TREE_CONSTANT (expression)) + return true; return false; case DYNAMIC_CAST_EXPR: diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C new file mode 100644 index 00000000000..a9e065320c8 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C @@ -0,0 +1,38 @@ +// PR c++/109876 +// { dg-do compile { target c++11 } } + +using size_t = decltype(sizeof 0); + +namespace std { +template <class> struct initializer_list { + const int *_M_array; + size_t _M_len; + constexpr size_t size() const { return _M_len; } +}; +} // namespace std + +constexpr std::initializer_list<int> gnum{2}; + +template <int> struct Array {}; +template <int> void g() +{ + static constexpr std::initializer_list<int> num{2}; + static_assert(num.size(), ""); + Array<num.size()> ctx; + + constexpr Array<1> num1{}; +} + +template <int N> +struct Foo +{ + static constexpr std::initializer_list<int> num = { 1, 2 }; + static_assert(num.size(), ""); + Array<num.size()> ctx; +}; + +void +f (Foo<5>) +{ + g<0>(); +} diff --git a/gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C b/gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C new file mode 100644 index 00000000000..58be046fd36 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C @@ -0,0 +1,25 @@ +// PR c++/109876 +// { dg-do compile { target c++17 } } + +struct Foo {}; +template <const Foo&> struct X {}; + +void g() +{ + static constexpr Foo foo; + X<foo> x; +} + +template<int> +void f() +{ + static constexpr Foo foo; + X<foo> x; +} + +void +h () +{ + f<0>(); + f<1>(); +} diff --git a/gcc/testsuite/g++.dg/cpp1z/constexpr-template2.C b/gcc/testsuite/g++.dg/cpp1z/constexpr-template2.C new file mode 100644 index 00000000000..5a9a96ba60a --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/constexpr-template2.C @@ -0,0 +1,25 @@ +// PR c++/109876 +// { dg-do compile { target c++17 } } + +struct Foo {}; +template <const Foo&> struct X {}; + +void g() +{ + static constexpr Foo foo{}; + X<foo> x; +} + +template<int> +void f() +{ + static constexpr Foo foo{}; + X<foo> x; +} + +void +h () +{ + f<0>(); + f<1>(); +} base-commit: 834f34947b20b18696487fc5d2bccab5ea720351 -- 2.41.0 ^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [PATCH v2] c++: wrong error with static constexpr var in tmpl [PR109876] 2023-07-13 18:54 ` [PATCH v2] " Marek Polacek @ 2023-07-14 17:07 ` Jason Merrill 0 siblings, 0 replies; 4+ messages in thread From: Jason Merrill @ 2023-07-14 17:07 UTC (permalink / raw) To: Marek Polacek; +Cc: GCC Patches On 7/13/23 14:54, Marek Polacek wrote: > On Fri, May 26, 2023 at 09:47:10PM -0400, Jason Merrill wrote: >> On 5/26/23 19:18, Marek Polacek wrote: >>> The is_really_empty_class check is sort of non-obvious but the >>> comment should explain why I added it. >>> >>> + /* When there's nothing to initialize, we'll never mark the >>> + VAR_DECL TREE_CONSTANT, therefore it would remain >>> + value-dependent and we wouldn't instantiate. */ > > Sorry it's taken so long to get back to this. > >> Interesting. Can we change that (i.e. mark it TREE_CONSTANT) rather than >> work around it here? > > I think we can. Maybe as in the below: > > -- >8 -- > Since r8-509, we'll no longer create a static temporary var for > the initializer '{ 1, 2 }' for num in the attached test because > the code in finish_compound_literal is now guarded by > '&& fcl_context == fcl_c99' but it's fcl_functional here. This > causes us to reject num as non-constant when evaluating it in > a template. > > Jason's idea was to treat num as value-dependent even though it > actually isn't. This patch implements that suggestion. > > We weren't marking objects whose type is an empty class type > constant. This patch changes that so that v_d_e_p doesn't need > to check is_really_empty_class. > > Co-authored-by: Jason Merrill <jason@redhat.com> > > Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk? OK, thanks. Incidentally, I prefer to put the "ok?" line above the scissors line since it isn't intended to be part of the commit message. > PR c++/109876 > > gcc/cp/ChangeLog: > > * decl.cc (cp_finish_decl): Set TREE_CONSTANT when initializing > an object of empty class type. > * pt.cc (value_dependent_expression_p) <case VAR_DECL>: Treat a > constexpr-declared non-constant variable as value-dependent. > > gcc/testsuite/ChangeLog: > > * g++.dg/cpp0x/constexpr-template12.C: New test. > * g++.dg/cpp1z/constexpr-template1.C: New test. > * g++.dg/cpp1z/constexpr-template2.C: New test. > --- > gcc/cp/decl.cc | 13 +++++-- > gcc/cp/pt.cc | 7 ++++ > .../g++.dg/cpp0x/constexpr-template12.C | 38 +++++++++++++++++++ > .../g++.dg/cpp1z/constexpr-template1.C | 25 ++++++++++++ > .../g++.dg/cpp1z/constexpr-template2.C | 25 ++++++++++++ > 5 files changed, 105 insertions(+), 3 deletions(-) > create mode 100644 gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C > create mode 100644 gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C > create mode 100644 gcc/testsuite/g++.dg/cpp1z/constexpr-template2.C > > diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc > index 60f107d50c4..792ab330dd0 100644 > --- a/gcc/cp/decl.cc > +++ b/gcc/cp/decl.cc > @@ -8200,7 +8200,6 @@ void > cp_finish_decl (tree decl, tree init, bool init_const_expr_p, > tree asmspec_tree, int flags) > { > - tree type; > vec<tree, va_gc> *cleanups = NULL; > const char *asmspec = NULL; > int was_readonly = 0; > @@ -8220,7 +8219,7 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p, > /* Parameters are handled by store_parm_decls, not cp_finish_decl. */ > gcc_assert (TREE_CODE (decl) != PARM_DECL); > > - type = TREE_TYPE (decl); > + tree type = TREE_TYPE (decl); > if (type == error_mark_node) > return; > > @@ -8410,7 +8409,7 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p, > if (decl_maybe_constant_var_p (decl) > /* FIXME setting TREE_CONSTANT on refs breaks the back end. */ > && !TYPE_REF_P (type)) > - TREE_CONSTANT (decl) = 1; > + TREE_CONSTANT (decl) = true; > } > /* This is handled mostly by gimplify.cc, but we have to deal with > not warning about int x = x; as it is a GCC extension to turn off > @@ -8421,6 +8420,14 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p, > && !warning_enabled_at (DECL_SOURCE_LOCATION (decl), OPT_Winit_self)) > suppress_warning (decl, OPT_Winit_self); > } > + else if (VAR_P (decl) > + && COMPLETE_TYPE_P (type) > + && !TYPE_REF_P (type) > + && !dependent_type_p (type) > + && is_really_empty_class (type, /*ignore_vptr*/false)) > + /* We have no initializer but there's nothing to initialize anyway. > + Treat DECL as constant due to c++/109876. */ > + TREE_CONSTANT (decl) = true; > > if (flag_openmp > && TREE_CODE (decl) == FUNCTION_DECL > diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc > index fa15b75b9c5..255d18b9539 100644 > --- a/gcc/cp/pt.cc > +++ b/gcc/cp/pt.cc > @@ -27983,6 +27983,13 @@ value_dependent_expression_p (tree expression) > else if (TYPE_REF_P (TREE_TYPE (expression))) > /* FIXME cp_finish_decl doesn't fold reference initializers. */ > return true; > + /* We have a constexpr variable and we're processing a template. When > + there's lifetime extension involved (for which finish_compound_literal > + used to create a temporary), we'll not be able to evaluate the > + variable until instantiating, so pretend it's value-dependent. */ > + else if (DECL_DECLARED_CONSTEXPR_P (expression) > + && !TREE_CONSTANT (expression)) > + return true; > return false; > > case DYNAMIC_CAST_EXPR: > diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C > new file mode 100644 > index 00000000000..a9e065320c8 > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-template12.C > @@ -0,0 +1,38 @@ > +// PR c++/109876 > +// { dg-do compile { target c++11 } } > + > +using size_t = decltype(sizeof 0); > + > +namespace std { > +template <class> struct initializer_list { > + const int *_M_array; > + size_t _M_len; > + constexpr size_t size() const { return _M_len; } > +}; > +} // namespace std > + > +constexpr std::initializer_list<int> gnum{2}; > + > +template <int> struct Array {}; > +template <int> void g() > +{ > + static constexpr std::initializer_list<int> num{2}; > + static_assert(num.size(), ""); > + Array<num.size()> ctx; > + > + constexpr Array<1> num1{}; > +} > + > +template <int N> > +struct Foo > +{ > + static constexpr std::initializer_list<int> num = { 1, 2 }; > + static_assert(num.size(), ""); > + Array<num.size()> ctx; > +}; > + > +void > +f (Foo<5>) > +{ > + g<0>(); > +} > diff --git a/gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C b/gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C > new file mode 100644 > index 00000000000..58be046fd36 > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp1z/constexpr-template1.C > @@ -0,0 +1,25 @@ > +// PR c++/109876 > +// { dg-do compile { target c++17 } } > + > +struct Foo {}; > +template <const Foo&> struct X {}; > + > +void g() > +{ > + static constexpr Foo foo; > + X<foo> x; > +} > + > +template<int> > +void f() > +{ > + static constexpr Foo foo; > + X<foo> x; > +} > + > +void > +h () > +{ > + f<0>(); > + f<1>(); > +} > diff --git a/gcc/testsuite/g++.dg/cpp1z/constexpr-template2.C b/gcc/testsuite/g++.dg/cpp1z/constexpr-template2.C > new file mode 100644 > index 00000000000..5a9a96ba60a > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp1z/constexpr-template2.C > @@ -0,0 +1,25 @@ > +// PR c++/109876 > +// { dg-do compile { target c++17 } } > + > +struct Foo {}; > +template <const Foo&> struct X {}; > + > +void g() > +{ > + static constexpr Foo foo{}; > + X<foo> x; > +} > + > +template<int> > +void f() > +{ > + static constexpr Foo foo{}; > + X<foo> x; > +} > + > +void > +h () > +{ > + f<0>(); > + f<1>(); > +} > > base-commit: 834f34947b20b18696487fc5d2bccab5ea720351 ^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2023-07-14 17:07 UTC | newest] Thread overview: 4+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2023-05-26 23:18 [PATCH] c++: wrong error with static constexpr var in tmpl [PR109876] Marek Polacek 2023-05-27 1:47 ` Jason Merrill 2023-07-13 18:54 ` [PATCH v2] " Marek Polacek 2023-07-14 17:07 ` Jason Merrill
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).