On 10/15/20 6:18 PM, Marek Polacek wrote:
The code added in r10-6437 caused us to create a CONSTRUCTOR when we're
{}-initializing an aggregate.  Then we pass this new CONSTRUCTOR down to
cxx_eval_constant_expression which, if the CONSTRUCTOR isn't TREE_CONSTANT
or reduced_constant_expression_p, calls cxx_eval_bare_aggregate.  In
this case the CONSTRUCTOR wasn't reduced_constant_expression_p because
for r_c_e_p a CONST_DECL isn't good enough so it returns false.  So we
go to cxx_eval_bare_aggregate where we crash, because ctx->ctor wasn't
set up properly.  So my fix is to do so.  Since we're value-initializing,
I'm not setting CONSTRUCTOR_NO_CLEARING.

Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk/10?

gcc/cp/ChangeLog:

        PR c++/96241
        * constexpr.c (cxx_eval_array_reference): Set up ctx->ctor if we
        are initializing an aggregate.

gcc/testsuite/ChangeLog:

        PR c++/96241
        * g++.dg/cpp1y/constexpr-96241.C: New test.
---
  gcc/cp/constexpr.c                           |  4 ++
  gcc/testsuite/g++.dg/cpp1y/constexpr-96241.C | 47 ++++++++++++++++++++
  2 files changed, 51 insertions(+)
  create mode 100644 gcc/testsuite/g++.dg/cpp1y/constexpr-96241.C

diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c
index a118f8a810b..5193047670c 100644
--- a/gcc/cp/constexpr.c
+++ b/gcc/cp/constexpr.c
@@ -3657,10 +3657,14 @@ 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;

In the case that 'val' is reduced_constant_expression_p, this results in a garbage constructor. Let's try to free the new CONSTRUCTOR if it isn't returned from cxx_eval_constant_expression.

      }
    else
      val = build_value_init (elem_type, tf_warning_or_error);
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);

base-commit: 7dbf96e2a2a673d78a23da9155c0b4c4c36621c7


Reply via email to