Hi Jason. I’ve been reminded in the PR that folks are waiting for a fix thanks Iain
> On 21 Oct 2026, at 17:01, Iain Sandoe <[email protected]> wrote: > > gentle ping, apparently folks are interested in getting a solution landed. > thanks > Iain > >> On 6 Oct 2026, at 23:02, Iain Sandoe <[email protected]> wrote: >> >> Tested on x86_64-linux, darwin, OK for trunk, and eventual backports >> to fix the 126811 regression on open branches? >> thanks >> Iain >> >> --- 8< --- >> >> The initial solution proposed and landed for 126811 was to avoid calling >> tsubst on constructors (motivated by a similar scheme used for constructor >> elements). The intent was to avoid recursing into these where they have >> NSDMIs (or other content that contains expressions that tsubst does not >> expect). The concern at the time was that to handle an arbitrary set of >> such conditions in tsubst would be open-ended and hard to prove complete. >> >> However, the solution landed has just pushed that problem onto constexpr >> handling and resulted in a number of reported regressions. Rather than >> trying to fix these issues in constexpr, a rework of the patch for the >> original (126811) problem deals with the cases in which tsubst is expected >> to be visited by expressions already lowered. >> >> One specific expected case is when tsubst is called with NULL_TREE args >> and is used explicitly to rewrite the tree. We also handle cases now >> where the constructor tree contains a mixture of sub-trees that still >> require substitution. >> >> In the final analysis the penalty for doing this in tsubst is small - >> firstly the current set of excluded trees are (presumably) never reached >> in current code (an absence of reports). The case that is reached is >> actually guarded by 'checking' and therefore only enabled for trunk. We >> can also short-circuit for the special case that the substitution is called >> with null args - so that the original concern about complexity in tsubst >> turned out to be somewhat unfounded. >> >> The patch reverts the change previously applied for 126811 so that we do >> not reopen that regression at the same time. The combination of gating >> on checking and that the current reporting conditions are not reached >> should make this reasonable for fixing the 126811 regression on open >> branches. >> >> My original testsuite additions were augmented with the assistance of an >> LLM given the guidance that we should intend comprehensive coverage, >> therefore they are partially LLM-generated. >> >> PR c++/126811 >> PR c++/127395 >> PR c++/127439 >> PR c++/127573 >> >> gcc/cp/ChangeLog: >> >> * pt.cc (tsubst_expr): Allow for CONSTRUCTORS that may have a >> mixture of lowered and to-be-substituted sub-trees. >> * typeck2.cc (store_init_value): Revert the gating of tsubst >> for CONSTRUCTOR trees. >> >> gcc/testsuite/ChangeLog: >> >> * g++.dg/cpp0x/constexpr-scalar-init1.C: New test. >> * g++.dg/cpp0x/nsdmi-template28.C: New test. >> >> Signed-off-by: Iain Sandoe <[email protected]> >> Assisted-by: Claude Opus 5 <[email protected]> >> --- >> gcc/cp/pt.cc | 25 +++- >> gcc/cp/typeck2.cc | 9 +- >> .../g++.dg/cpp0x/constexpr-scalar-init1.C | 131 ++++++++++++++++++ >> gcc/testsuite/g++.dg/cpp0x/nsdmi-template28.C | 82 +++++++++++ >> 4 files changed, 236 insertions(+), 11 deletions(-) >> create mode 100644 gcc/testsuite/g++.dg/cpp0x/constexpr-scalar-init1.C >> create mode 100644 gcc/testsuite/g++.dg/cpp0x/nsdmi-template28.C >> >> diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc >> index 2b68ceb0cd2..1953a579a20 100644 >> --- a/gcc/cp/pt.cc >> +++ b/gcc/cp/pt.cc >> @@ -21945,7 +21945,13 @@ tsubst_expr (tree t, tree args, tsubst_flags_t >> complain, tree in_decl) >> } >> >> case FIX_TRUNC_EXPR: >> - /* convert_like should have created an IMPLICIT_CONV_EXPR. */ >> + /* convert_like should have created an IMPLICIT_CONV_EXPR, unless we >> + are on the fold path (ARGS == NULL_TREE), where we can get elements >> + that were folded outside any template (e.g an NSDMI). In those cases >> + there is nothing to substitute into them, but seeing one is not an >> + error. */ >> + if (args == NULL_TREE || !instantiation_dependent_expression_p (t)) >> + RETURN (t); >> gcc_unreachable (); >> >> case ADDR_EXPR: >> @@ -23379,12 +23385,17 @@ tsubst_expr (tree t, tree args, tsubst_flags_t >> complain, tree in_decl) >> case CLEANUP_POINT_EXPR: >> /* We shouldn't have built any of these during initial template >> generation. Instead, they should be built during instantiation >> - in response to the saved STMT_IS_FULL_EXPR_P setting. */ >> + in response to the saved STMT_IS_FULL_EXPR_P setting - unless we >> + are on the fold path; see FIX_TRUNC_EXPR above. */ >> + if (args == NULL_TREE || !instantiation_dependent_expression_p (t)) >> + RETURN (t); >> gcc_unreachable (); >> >> case TARGET_EXPR: >> /* TARGET_EXPR represents temporary objects and should not appear in >> - templated trees. */ >> + templated trees -- but see CLEANUP_POINT_EXPR above. */ >> + if (args == NULL_TREE || !instantiation_dependent_expression_p (t)) >> + RETURN (t); >> gcc_unreachable (); >> >> case OFFSET_REF: >> @@ -23663,8 +23674,12 @@ tsubst_expr (tree t, tree args, tsubst_flags_t >> complain, tree in_decl) >> if (tree subst = objcp_tsubst_expr (t, args, complain, in_decl)) >> RETURN (subst); >> >> - /* We shouldn't get here, but keep going if !flag_checking. */ >> - if (flag_checking) >> + /* We shouldn't get here, but keep going if !flag_checking. On the >> fold >> + path (ARGS == NULL_TREE) an already-folded tree has nothing to >> + substitute; see FIX_TRUNC_EXPR above. */ >> + if (flag_checking >> + && args != NULL_TREE >> + && instantiation_dependent_expression_p (t)) >> gcc_unreachable (); >> RETURN (t); >> } >> diff --git a/gcc/cp/typeck2.cc b/gcc/cp/typeck2.cc >> index c7ebd080edc..08ba3da53d6 100644 >> --- a/gcc/cp/typeck2.cc >> +++ b/gcc/cp/typeck2.cc >> @@ -1072,12 +1072,9 @@ store_init_value (tree decl, tree init, vec<tree, >> va_gc>** cleanups, int flags) >> || (DECL_IN_AGGR_P (decl) >> && DECL_INITIALIZED_IN_CLASS_P (decl))) >> { >> - /* As in massage_init_elt, do not fold a CONSTRUCTOR in a template >> - it has already been folded c++/126811. */ >> - if (!(processing_template_decl && TREE_CODE (value) == CONSTRUCTOR)) >> - value = fold_non_dependent_expr (value, tf_warning_or_error, >> - /*manifestly_const_eval=*/true, >> - decl); >> + value = fold_non_dependent_expr (value, tf_warning_or_error, >> + /*manifestly_const_eval=*/true, >> + decl); >> if (value == error_mark_node) >> ; >> /* Diagnose a non-constant initializer for constexpr variable or >> diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-scalar-init1.C >> b/gcc/testsuite/g++.dg/cpp0x/constexpr-scalar-init1.C >> new file mode 100644 >> index 00000000000..5a58c6b1642 >> --- /dev/null >> +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-scalar-init1.C >> @@ -0,0 +1,131 @@ >> +// PR c++/126811 c++/127395 >> +// { dg-do compile { target c++11 } } >> + >> +// The static_asserts ensure that we actually test the pathway. >> + >> +enum E { e0 = 0, e7 = 7 }; >> +struct C { int m; int n; void mf (); }; >> +using P = int *; >> +using PM = int C::*; // scalar: takes the failing path >> +using PMF = void (C::*) (); // RECORD_TYPE, so a different path >> +using CD = _Complex double; // SCALAR_TYPE_P via ARITHMETIC_TYPE_P >> +typedef int V __attribute__((vector_size (16))); >> +typedef float VF __attribute__((vector_size (16))); >> + >> +template <int> void scalars () >> +{ >> + constexpr int i0 = int{}; >> + constexpr int i7 = int{7}; >> + constexpr char c0 = char{}; >> + constexpr bool b0 = bool{}; >> + constexpr bool b1 = bool{true}; >> + constexpr float f0 = float{}; >> + constexpr float f2 = float{2}; >> + constexpr double d0 = double{}; >> + constexpr double d1 = double{1}; >> + constexpr E ee = E{}; >> + constexpr P pp = P{}; >> + constexpr PM pm = PM{}; >> + constexpr CD cd = CD{}; >> + >> + static_assert (i0 == 0, "int{}"); >> + static_assert (i7 == 7, "int{7}"); >> + static_assert (c0 == 0, "char{}"); >> + static_assert (b0 == false, "bool{}"); >> + static_assert (b1 == true, "bool{true}"); >> + static_assert (f0 == 0.0f, "float{}"); >> + static_assert (f2 == 2.0f, "float{2}"); >> + static_assert (d0 == 0.0, "double{}"); >> + static_assert (d1 == 1.0, "double{1}"); >> + static_assert (ee == e0, "E{}"); >> + static_assert (pp == nullptr, "P{}"); >> + static_assert (pm == nullptr, "PM{}"); >> + static_assert (__real cd == 0.0 && __imag cd == 0.0, "_Complex double{}"); >> +} >> + >> +template <int> void ptrmem () >> +{ >> + constexpr PM null = PM{}; // empty: needs build_value_init, >> + constexpr PM nullp = PM{nullptr}; // not build_zero_cst >> + // one element: needs the C++ >> + // conversion, not fold_convert >> + constexpr PM first = &C::m; >> + constexpr PM second = PM{&C::n}; >> + >> + static_assert (null == nullptr, "PM{}"); >> + static_assert (nullp == nullptr, "PM{nullptr}"); >> + static_assert (null != first, "null PM is not offset 0"); >> + static_assert (second == &C::n, "PM{&C::n}"); >> +} >> + >> +template <int> void vectors () >> +{ >> + constexpr V v0 = V{}; >> + constexpr V v4 = V{1,2,3,4}; >> + constexpr VF vf0 = VF{}; >> + static_assert (v0[0] == 0, "V{}"); >> + static_assert (v4[0] == 1 && v4[3] == 4, "V{1,2,3,4}"); >> + static_assert (vf0[2] == 0.0f, "VF{}"); >> +} >> + >> +template <int> void ptrmemfunc () >> +{ >> + constexpr PMF p = PMF{}; >> + static_assert (p == nullptr, "PMF{}"); >> +} >> + >> +struct S { int x; double y; }; >> + >> +template <int> void aggregates () >> +{ >> + constexpr int a4[4] = {1,2,3,4}; >> + constexpr int a0[4] = {}; >> + constexpr S s = S{1,2.0}; >> + constexpr S sz = S{}; >> + static_assert (a4[0] == 1 && a4[3] == 4, "int[4] = {1,2,3,4}"); >> + static_assert (a0[0] == 0 && a0[3] == 0, "int[4] = {}"); >> + static_assert (s.x == 1 && s.y == 2.0, "S{1,2.0}"); >> + static_assert (sz.x == 0 && sz.y == 0.0, "S{}"); >> +} >> + >> +// The fix should not touch this. >> +template <int N> void dependent () >> +{ >> + constexpr int i = int{N}; >> + constexpr double d = double{N}; >> + static_assert (i == 3, "int{N}"); >> + static_assert (d == 3.0, "double{N}"); >> +} >> + >> +// or this... >> +template <int> void not_constexpr () >> +{ >> + int i = int{5}; >> + double d = double{}; >> + V v = V{1,2,3,4}; >> + (void) i; (void) d; (void) v; >> +} >> + >> +// CONSTRUCTOR should not reach the effected path. >> +void nontemplate () >> +{ >> + constexpr int i7 = int{7}; >> + constexpr double d1 = double{1}; >> + constexpr PM pm = PM{}; >> + constexpr V v4 = V{1,2,3,4}; >> + static_assert (i7 == 7, "int{7} outside a template"); >> + static_assert (d1 == 1.0, "double{1} outside a template"); >> + static_assert (pm == nullptr, "PM{} outside a template"); >> + static_assert (v4[3] == 4, "V{1,2,3,4} outside a template"); >> +} >> + >> +void use () >> +{ >> + scalars<0> (); >> + ptrmem<0> (); >> + vectors<0> (); >> + ptrmemfunc<0> (); >> + aggregates<0> (); >> + dependent<3> (); >> + not_constexpr<0> (); >> +} >> diff --git a/gcc/testsuite/g++.dg/cpp0x/nsdmi-template28.C >> b/gcc/testsuite/g++.dg/cpp0x/nsdmi-template28.C >> new file mode 100644 >> index 00000000000..3c74947376d >> --- /dev/null >> +++ b/gcc/testsuite/g++.dg/cpp0x/nsdmi-template28.C >> @@ -0,0 +1,82 @@ >> +// PR c++/126811 c++/127439 c++/127593 >> +// { dg-do compile { target c++11 } } >> + >> +// This covers a CONSTRUCTOR holding both >> +// * an already-folded NSDMI sub-tree >> +// * an undigested IMPLICIT_CONV_EXPR >> + >> +struct A { double m = 1; }; // NSDMI -> FLOAT_EXPR once digested >> + >> +// The constructor is deliberately DECLARED BUT NOT DEFINED: that is what >> +// leaves the conversion from "" >> + >> +struct a { constexpr a (const char *); }; // { dg-warning {inline function >> 'constexpr a::a.const char..' used but never defined} } >> + >> +struct Mix { A x; a y; }; >> + >> +template <typename> void copy_list_init () >> +{ >> + constexpr Mix m = { {}, "" }; >> + (void) m; >> +} >> + >> +template <typename> void direct_list_init () >> +{ >> + constexpr Mix m{ {}, "" }; >> + (void) m; >> +} >> + >> +// Nested case. >> +template <typename> void nested () >> +{ >> + constexpr A x[]{ {} }; >> + (void) x; >> +} >> + >> +// opposite requirement in the same syntax. >> +template <typename> void array_of_class () >> +{ >> + constexpr a c[] = { "" }; >> + (void) c; >> +} >> + >> +#if __cplusplus >= 202002L >> +// Designated initializers put the two halves at the SAME level with nothing >> +// nested: `m` comes from the NSDMI, `y` from the conversion. >> +struct Mix2 { double m = 1; a y; }; >> + >> +template <typename> void designated () >> +{ >> + constexpr Mix2 v{ .y = "" }; >> + (void) v; >> +} >> +#endif >> + >> +// Value coverage for the same shape with a DEFINED constructor, so the >> +// initializer really is constant-evaluated and the result can be checked. >> +// This is the case a fix must not silently break while stopping the ICEs. >> +struct b { constexpr b (const char *s) : p (s) {} const char *p; }; >> +struct MixDef { A x; b y; }; >> + >> +template <typename> void values () >> +{ >> + constexpr MixDef m{ {}, "" }; >> + static_assert (m.x.m == 1.0, "NSDMI half"); >> + static_assert (m.y.p[0] == 0, "converted half"); >> +} >> + >> +// The same mixture reached through a real instantiation takes a different >> route >> +// inside tsubst (non-null ARGS), and used to ICE there too rather than >> give this >> +// diagnostic. >> +template <typename> void instantiated () >> +{ >> + constexpr Mix m = { {}, "" }; // { dg-error "used before its definition" } >> + (void) m; >> +} >> + >> +void use () >> +{ >> + nested<int> (); >> + instantiated<int> (); >> + values<int> (); >> +} >> -- >> 2.50.1 (Apple Git-155) >> >
