Re: [PATCH] tree-optimization/105250 - adjust fold_convertible_p PR105140 fix

[Richard Sandiford <richard.sandiford@arm.com>]

Richard Biener via Gcc-patches <gcc-patches@gcc.gnu.org> writes:
> The following reverts the original PR105140 fix and goes for instead
> applying the additional fold_convert constraint for VECTOR_TYPE
> conversions also to fold_convertible_p.  I did not try sanitizing
> all of this at this point.
>
> Bootstrapped on x86_64-unknown-linux-gnu, testing in progress.
>
> 2022-04-13  Richard Biener  <rguenther@suse.de>
>
> 	PR tree-optimization/105250
> 	* fold-const.cc (fold_convertible_p): Revert
> 	r12-7979-geaaf77dd85c333, instead check for size equality
> 	of the vector types involved.

This doesn't look right, and I think it'll break SVE.  For one
thing, the tree_int_cst_equal check is bound to fail for
variable-length vectors.

But also, the idea was to allow element-wise conversions between
different vector sizes.  For example, you can do a nop/convert
from V4SI to V4DI, which converts 4 SIs to 4 DIs.  This is used
a lot for conversions to and from “partial” SVE vectors, where smaller
elements are stored in wider containers.

Thanks,
Richard

>
> 	* gcc.dg/pr105250.c: New testcase.
> ---
>  gcc/fold-const.cc               |  7 +++----
>  gcc/testsuite/gcc.dg/pr105250.c | 29 +++++++++++++++++++++++++++++
>  2 files changed, 32 insertions(+), 4 deletions(-)
>  create mode 100644 gcc/testsuite/gcc.dg/pr105250.c
>
> diff --git a/gcc/fold-const.cc b/gcc/fold-const.cc
> index 7226bc5af01..a57ad0739fb 100644
> --- a/gcc/fold-const.cc
> +++ b/gcc/fold-const.cc
> @@ -2379,13 +2379,12 @@ build_zero_vector (tree type)
>    return build_vector_from_val (type, t);
>  }
>  
> -/* Returns true, if ARG, an operand or a type, is convertible to TYPE
> -   using a NOP_EXPR.  */
> +/* Returns true, if ARG is convertible to TYPE using a NOP_EXPR.  */
>  
>  bool
>  fold_convertible_p (const_tree type, const_tree arg)
>  {
> -  const_tree orig = TYPE_P (arg) ? arg : TREE_TYPE (arg);
> +  const_tree orig = TREE_TYPE (arg);
>  
>    if (type == orig)
>      return true;
> @@ -2417,7 +2416,7 @@ fold_convertible_p (const_tree type, const_tree arg)
>        return (VECTOR_TYPE_P (orig)
>  	      && known_eq (TYPE_VECTOR_SUBPARTS (type),
>  			   TYPE_VECTOR_SUBPARTS (orig))
> -	      && fold_convertible_p (TREE_TYPE (type), TREE_TYPE (orig)));
> +	      && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
>  
>      default:
>        return false;
> diff --git a/gcc/testsuite/gcc.dg/pr105250.c b/gcc/testsuite/gcc.dg/pr105250.c
> new file mode 100644
> index 00000000000..665dd95d8cb
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/pr105250.c
> @@ -0,0 +1,29 @@
> +/* { dg-do compile } */
> +/* { dg-options "-w -Wno-psabi -O2" } */
> +
> +typedef int __attribute__((__vector_size__(4))) T;
> +typedef int __attribute__((__vector_size__(8))) U;
> +typedef int __attribute__((__vector_size__(16))) V;
> +typedef int __attribute__((__vector_size__(32))) W;
> +typedef _Float32 __attribute__((__vector_size__(16))) F;
> +typedef _Float64 __attribute__((__vector_size__(32))) G;
> +void foo();
> +
> +foo(int, int, int, int, U, U, V, V, W, W, int,
> +     T, int, U, U, V, V, W, W, T,
> +     T, int, U, U, V, V, W, W, T,
> +     T, int, W, W, T, T, int, int, int,
> +     int, int, int, W, int, int, int, int, int, int,
> +     V, W, T, int, int, U, F, int, int, int,
> +     int, int, int, G)
> +{
> +  foo(0, 0, 0, 0, (U){}, (U){}, (V){}, (V){}, (W){},
> +       (W){}, 2, (T){}, 0, 0, 0, 0, (U){}, (U){},
> +       (V){}, (V){}, (W){}, (W){}, (T){},
> +       (T){}, 0, 0, 0, 0, (U){}, (U){}, (V){},
> +       (V){}, (W){}, (W){}, (T){}, (T){}, 0, 0, 0,
> +       0, 0, 0, (T){},
> +       (T){}, (W){},
> +       (W){}, (T){}, (T){}, 0, 0, 0, 0, 0, 0, (W){},
> +       (V){}, (W){}, (T){}, 0, 0, (U){}, (F){});
> +}