c++, v4: Add support for __real__/__imag__ modifications in constant expressions [PR88174]

  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  <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.



	Jakub
  

On 7/27/22 02:09, Jakub Jelinek wrote:
> 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?

OK, thanks.

> 2022-07-27  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.
> 
> --- 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
>