On Tue, Jul 05, 2022 at 04:44:41PM -0400, Jason Merrill wrote:
> But preeval should always be true, so we'd never reach the new handling in
> the if (!preeval) block. Certainly the new testcase doesn't exercise this
> code.
Ok, changed now.
I had to keep the ctors[i] = valp; statement in the !preeval block, because
otherwise e.g. 20_util/optional/monadic/transform.cc test fails randomly.
It was wrong already before the patch, it would adjust
TREE_CONSTANT/TREE_SIDE_EFFECTS sometimes on no longer used trees,
but with the vector holding pointers to trees rather than trees it is even
more severe.
Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?
2022-07-27 Jakub Jelinek <ja...@redhat.com>
PR c++/88174
* constexpr.cc (cxx_eval_store_expression): Handle REALPART_EXPR
and IMAGPART_EXPR. Change ctors from releasing_vec to
auto_vec<tree *>, adjust all uses. For !preeval, update ctors
vector.
* g++.dg/cpp1y/constexpr-complex1.C: New test.
--- gcc/cp/constexpr.cc.jj 2022-07-04 12:26:18.147053851 +0200
+++ gcc/cp/constexpr.cc 2022-07-26 17:35:53.100556949 +0200
@@ -5726,6 +5726,20 @@ cxx_eval_store_expression (const constex
}
break;
+ case REALPART_EXPR:
+ gcc_assert (probe == target);
+ vec_safe_push (refs, probe);
+ vec_safe_push (refs, TREE_TYPE (probe));
+ probe = TREE_OPERAND (probe, 0);
+ break;
+
+ case IMAGPART_EXPR:
+ gcc_assert (probe == target);
+ vec_safe_push (refs, probe);
+ vec_safe_push (refs, TREE_TYPE (probe));
+ probe = TREE_OPERAND (probe, 0);
+ break;
+
default:
if (evaluated)
object = probe;
@@ -5764,7 +5778,8 @@ cxx_eval_store_expression (const constex
type = TREE_TYPE (object);
bool no_zero_init = true;
- releasing_vec ctors, indexes;
+ auto_vec<tree *> ctors;
+ releasing_vec indexes;
auto_vec<int> index_pos_hints;
bool activated_union_member_p = false;
bool empty_base = false;
@@ -5804,14 +5819,36 @@ cxx_eval_store_expression (const constex
*valp = ary_ctor;
}
- /* If the value of object is already zero-initialized, any new ctors for
- subobjects will also be zero-initialized. */
- no_zero_init = CONSTRUCTOR_NO_CLEARING (*valp);
-
enum tree_code code = TREE_CODE (type);
tree reftype = refs->pop();
tree index = refs->pop();
+ if (code == COMPLEX_TYPE)
+ {
+ if (TREE_CODE (*valp) == COMPLEX_CST)
+ *valp = build2 (COMPLEX_EXPR, type, TREE_REALPART (*valp),
+ TREE_IMAGPART (*valp));
+ else if (TREE_CODE (*valp) == CONSTRUCTOR
+ && CONSTRUCTOR_NELTS (*valp) == 0
+ && CONSTRUCTOR_NO_CLEARING (*valp))
+ {
+ tree r = build_constructor (reftype, NULL);
+ CONSTRUCTOR_NO_CLEARING (r) = 1;
+ *valp = build2 (COMPLEX_EXPR, type, r, r);
+ }
+ gcc_assert (TREE_CODE (*valp) == COMPLEX_EXPR);
+ ctors.safe_push (valp);
+ vec_safe_push (indexes, index);
+ valp = &TREE_OPERAND (*valp, TREE_CODE (index) == IMAGPART_EXPR);
+ gcc_checking_assert (refs->is_empty ());
+ type = reftype;
+ break;
+ }
+
+ /* If the value of object is already zero-initialized, any new ctors for
+ subobjects will also be zero-initialized. */
+ no_zero_init = CONSTRUCTOR_NO_CLEARING (*valp);
+
if (code == RECORD_TYPE && is_empty_field (index))
/* Don't build a sub-CONSTRUCTOR for an empty base or field, as they
have no data and might have an offset lower than previously declared
@@ -5854,7 +5891,7 @@ cxx_eval_store_expression (const constex
no_zero_init = true;
}
- vec_safe_push (ctors, *valp);
+ ctors.safe_push (valp);
vec_safe_push (indexes, index);
constructor_elt *cep
@@ -5916,11 +5953,11 @@ cxx_eval_store_expression (const constex
semantics are not applied on an object under construction.
They come into effect when the constructor for the most
derived object ends." */
- for (tree elt : *ctors)
+ for (tree *elt : ctors)
if (same_type_ignoring_top_level_qualifiers_p
- (TREE_TYPE (const_object_being_modified), TREE_TYPE (elt)))
+ (TREE_TYPE (const_object_being_modified), TREE_TYPE (*elt)))
{
- fail = TREE_READONLY (elt);
+ fail = TREE_READONLY (*elt);
break;
}
}
@@ -5961,6 +5998,7 @@ cxx_eval_store_expression (const constex
valp = ctx->global->values.get (object);
for (unsigned i = 0; i < vec_safe_length (indexes); i++)
{
+ ctors[i] = valp;
constructor_elt *cep
= get_or_insert_ctor_field (*valp, indexes[i], index_pos_hints[i]);
valp = &cep->value;
@@ -6023,17 +6061,45 @@ cxx_eval_store_expression (const constex
CONSTRUCTORs, if any. */
bool c = TREE_CONSTANT (init);
bool s = TREE_SIDE_EFFECTS (init);
+ if (!indexes->is_empty ())
+ {
+ tree last = indexes->last ();
+ if (TREE_CODE (last) == REALPART_EXPR
+ || TREE_CODE (last) == IMAGPART_EXPR)
+ {
+ /* And canonicalize COMPLEX_EXPR into COMPLEX_CST if
+ possible. */
+ tree *cexpr = ctors.last ();
+ if (tree c = const_binop (COMPLEX_EXPR, TREE_TYPE (*cexpr),
+ TREE_OPERAND (*cexpr, 0),
+ TREE_OPERAND (*cexpr, 1)))
+ *cexpr = c;
+ else
+ {
+ TREE_CONSTANT (*cexpr)
+ = (TREE_CONSTANT (TREE_OPERAND (*cexpr, 0))
+ & TREE_CONSTANT (TREE_OPERAND (*cexpr, 1)));
+ TREE_SIDE_EFFECTS (*cexpr)
+ = (TREE_SIDE_EFFECTS (TREE_OPERAND (*cexpr, 0))
+ | TREE_SIDE_EFFECTS (TREE_OPERAND (*cexpr, 1)));
+ }
+ c = TREE_CONSTANT (*cexpr);
+ s = TREE_SIDE_EFFECTS (*cexpr);
+ }
+ }
if (!c || s || activated_union_member_p)
- for (tree elt : *ctors)
+ for (tree *elt : ctors)
{
+ if (TREE_CODE (*elt) != CONSTRUCTOR)
+ continue;
if (!c)
- TREE_CONSTANT (elt) = false;
+ TREE_CONSTANT (*elt) = false;
if (s)
- TREE_SIDE_EFFECTS (elt) = true;
+ TREE_SIDE_EFFECTS (*elt) = true;
/* Clear CONSTRUCTOR_NO_CLEARING since we've activated a member of
this union. */
- if (TREE_CODE (TREE_TYPE (elt)) == UNION_TYPE)
- CONSTRUCTOR_NO_CLEARING (elt) = false;
+ if (TREE_CODE (TREE_TYPE (*elt)) == UNION_TYPE)
+ CONSTRUCTOR_NO_CLEARING (*elt) = false;
}
if (lval)
--- gcc/testsuite/g++.dg/cpp1y/constexpr-complex1.C.jj 2022-07-04
17:30:47.884580998 +0200
+++ gcc/testsuite/g++.dg/cpp1y/constexpr-complex1.C 2022-07-04
17:30:47.884580998 +0200
@@ -0,0 +1,24 @@
+// PR c++/88174
+// { dg-do compile { target c++14 } }
+
+constexpr bool
+foo (double x, double y, double z, double w)
+{
+ __complex__ double a = 0;
+ __real__ a = x;
+ __imag__ a = y;
+#if __cpp_constexpr >= 201907L
+ __complex__ double b;
+ __real__ b = z;
+#else
+ __complex__ double b = z;
+#endif
+ __imag__ b = w;
+ a += b;
+ a -= b;
+ a *= b;
+ a /= b;
+ return __real__ a == x && __imag__ a == y;
+}
+
+static_assert (foo (1.0, 2.0, 3.0, 4.0), "");
Jakub
