c++: Add support for __real__/__imag__ modifications in constant expressions [PR88174]
We claim we support P0415R1 (constexpr complex), but e.g. #include <complex> constexpr bool foo () { std::complex<double> a (1.0, 2.0); a += 3.0; a.real (6.0); return a.real () == 6.0 && a.imag () == 2.0; } static_assert (foo ()); fails with test.C:12:20: error: non-constant condition for static assertion 12 | static_assert (foo ()); | ~~~~^~ test.C:12:20: in ‘constexpr’ expansion of ‘foo()’ test.C:8:10: in ‘constexpr’ expansion of ‘a.std::complex<double>::real(6.0e+0)’ test.C:12:20: error: modification of ‘__real__ a.std::complex<double>::_M_value’ is not a constant expression The problem is we don't handle REALPART_EXPR and IMAGPART_EXPR in cxx_eval_store_expression. The following patch attempts to support it (with a requirement that those are the outermost expressions, ARRAY_REF/COMPONENT_REF etc. are just not possible on the result of these, BIT_FIELD_REF would be theoretically possible if trying to extract some bits from one part of a complex int, but I don't see how it could appear in the FE trees. For these references, the code handles value being COMPLEX_CST, COMPLEX_EXPR or CONSTRUCTOR_NO_CLEARING empty CONSTRUCTOR (what we use to represent uninitialized values for C++20 and later) and the code starts by rewriting it to COMPLEX_EXPR, so that we can freely adjust the individual parts and later on possibly optimize it back to COMPLEX_CST if both halves are constant. 2022-08-07 Jakub Jelinek <jakub@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.
This commit is contained in:
parent
a46bca36b7
commit
1907767735
|
@ -5732,6 +5732,20 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
|
|||
}
|
||||
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;
|
||||
|
@ -5770,7 +5784,8 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
|
|||
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;
|
||||
|
@ -5810,14 +5825,36 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
|
|||
*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
|
||||
|
@ -5860,7 +5897,7 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
|
|||
no_zero_init = true;
|
||||
}
|
||||
|
||||
vec_safe_push (ctors, *valp);
|
||||
ctors.safe_push (valp);
|
||||
vec_safe_push (indexes, index);
|
||||
|
||||
constructor_elt *cep
|
||||
|
@ -5922,11 +5959,11 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
|
|||
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;
|
||||
}
|
||||
}
|
||||
|
@ -5967,6 +6004,7 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
|
|||
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;
|
||||
|
@ -6029,17 +6067,45 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
|
|||
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)
|
||||
|
|
|
@ -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), "");
|
Loading…
Reference in New Issue