diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c index 4707d29f3bc..7ebdd308dcd 100644 --- a/gcc/cp/constexpr.c +++ b/gcc/cp/constexpr.c @@ -3657,15 +3657,22 @@ cxx_eval_array_reference (const constexpr_ctx *ctx, tree t, initializer, it's initialized from {}. But use build_value_init directly for non-aggregates to avoid creating a garbage CONSTRUCTOR. */ tree val; + constexpr_ctx new_ctx; if (CP_AGGREGATE_TYPE_P (elem_type)) { tree empty_ctor = build_constructor (init_list_type_node, NULL); val = digest_init (elem_type, empty_ctor, tf_warning_or_error); + new_ctx = *ctx; + new_ctx.ctor = build_constructor (elem_type, NULL); + ctx = &new_ctx; } else val = build_value_init (elem_type, tf_warning_or_error); - return cxx_eval_constant_expression (ctx, val, lval, non_constant_p, - overflow_p); + t = cxx_eval_constant_expression (ctx, val, lval, non_constant_p, + overflow_p); + if (CP_AGGREGATE_TYPE_P (elem_type) && t != ctx->ctor) + free_constructor (ctx->ctor); + return t; } /* Subroutine of cxx_eval_constant_expression. diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-96241.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-96241.C new file mode 100644 index 00000000000..599405302cb --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-96241.C @@ -0,0 +1,18 @@ +// PR c++/96241 +// { dg-do compile { target c++11 } } + +template struct S {}; +template using U = S; +template using f = S; +template using V = U; +template struct A { typedef int type[N]; }; +template struct B { typename A::type k; }; +template +constexpr B bar(T (&arr)[N], f) { + return {arr[P]...}; +} +template constexpr B foo(T (&arr)[N]) { + return bar(arr, V{}); +} +constexpr char arr[2]{}; +B<2> b = foo(arr); diff --git a/gcc/testsuite/g++.dg/cpp1y/constexpr-96241.C b/gcc/testsuite/g++.dg/cpp1y/constexpr-96241.C new file mode 100644 index 00000000000..107f2b09de9 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1y/constexpr-96241.C @@ -0,0 +1,47 @@ +// PR c++/96241 +// { dg-do compile { target c++14 } } + +#define assert(expr) static_assert (expr, #expr) + +enum E { o }; + +struct S { + int e = o; +}; + +using T = S[3]; + +constexpr struct S s[1][1][1] = { }; +assert (0 == s[0][0][0].e); + +constexpr int +fn0 () +{ + return T{}[0].e; +} +assert(fn0 () == 0); + +constexpr int +fn1 () +{ + S d[1]; + int x = d[0].e; + return x; +} +assert(fn1 () == 0); + +constexpr int +fn2 () +{ + S d[1]; + return d[0].e; +} +assert(fn2 () == 0); + +constexpr int +fn3 () +{ + struct X { int e = o; } d[1]{}; + return d[0].e; +} +assert(fn3 () == 0);