On Tue, Mar 05, 2019 at 09:26:19AM +0000, Richard Sandiford wrote:
> LGTM, thanks.  Given the discussion, I think it would also be worth having
> a comment explaining why we're doing this, something like:
> 
>   /* Avoid speculatively generating a stand-alone vector comparison
>      on targets that might not support them.  Any target implementing
>      conditional internal functions must support the same comparisons
>      inside and outside a VEC_COND_EXPR.  */

Ok, here is the patch updated with your comment.

Can you please test it on aarch64 SVE?  I'll test it on x86_64/i686 later
today (maybe powerpc64{,le} too).

2019-03-05  Jakub Jelinek  <ja...@redhat.com>
            Richard Sandiford  <richard.sandif...@arm.com>

        PR tree-optimization/89570
        * match.pd (vec_cond into cond_op simplification): Don't use
        get_conditional_internal_fn, use as_internal_fn (cond_op).

--- gcc/match.pd.jj     2019-03-05 09:43:46.555727525 +0100
+++ gcc/match.pd        2019-03-05 10:05:20.089630138 +0100
@@ -5176,24 +5176,26 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 
    if the target can do it in one go.  This makes the operation conditional
    on c, so could drop potentially-trapping arithmetic, but that's a valid
-   simplification if the result of the operation isn't needed.  */
+   simplification if the result of the operation isn't needed.
+
+   Avoid speculatively generating a stand-alone vector comparison              
                                                                  
+   on targets that might not support them.  Any target implementing            
                                                                  
+   conditional internal functions must support the same comparisons            
                                                                  
+   inside and outside a VEC_COND_EXPR.  */                                     
                                                                  
+
 #if GIMPLE
 (for uncond_op (UNCOND_BINARY)
      cond_op (COND_BINARY)
  (simplify
   (vec_cond @0 (view_convert? (uncond_op@4 @1 @2)) @3)
-  (with { tree op_type = TREE_TYPE (@4); 
-         internal_fn cond_fn = get_conditional_internal_fn (uncond_op); }
-   (if (cond_fn != IFN_LAST
-       && vectorized_internal_fn_supported_p (cond_fn, op_type)
+  (with { tree op_type = TREE_TYPE (@4); }
+   (if (vectorized_internal_fn_supported_p (as_internal_fn (cond_op), op_type)
        && element_precision (type) == element_precision (op_type))
     (view_convert (cond_op @0 @1 @2 (view_convert:op_type @3))))))
  (simplify
   (vec_cond @0 @1 (view_convert? (uncond_op@4 @2 @3)))
-  (with { tree op_type = TREE_TYPE (@4);
-         internal_fn cond_fn = get_conditional_internal_fn (uncond_op); }
-   (if (cond_fn != IFN_LAST
-       && vectorized_internal_fn_supported_p (cond_fn, op_type)
+  (with { tree op_type = TREE_TYPE (@4); }
+   (if (vectorized_internal_fn_supported_p (as_internal_fn (cond_op), op_type)
        && element_precision (type) == element_precision (op_type))
     (view_convert (cond_op (bit_not @0) @2 @3 (view_convert:op_type @1)))))))
 
@@ -5202,20 +5204,14 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
      cond_op (COND_TERNARY)
  (simplify
   (vec_cond @0 (view_convert? (uncond_op@5 @1 @2 @3)) @4)
-  (with { tree op_type = TREE_TYPE (@5);
-         internal_fn cond_fn
-           = get_conditional_internal_fn (as_internal_fn (uncond_op)); }
-   (if (cond_fn != IFN_LAST
-       && vectorized_internal_fn_supported_p (cond_fn, op_type)
+  (with { tree op_type = TREE_TYPE (@5); }
+   (if (vectorized_internal_fn_supported_p (as_internal_fn (cond_op), op_type)
        && element_precision (type) == element_precision (op_type))
     (view_convert (cond_op @0 @1 @2 @3 (view_convert:op_type @4))))))
  (simplify
   (vec_cond @0 @1 (view_convert? (uncond_op@5 @2 @3 @4)))
-  (with { tree op_type = TREE_TYPE (@5);
-         internal_fn cond_fn
-           = get_conditional_internal_fn (as_internal_fn (uncond_op)); }
-   (if (cond_fn != IFN_LAST
-       && vectorized_internal_fn_supported_p (cond_fn, op_type)
+  (with { tree op_type = TREE_TYPE (@5); }
+   (if (vectorized_internal_fn_supported_p (as_internal_fn (cond_op), op_type)
        && element_precision (type) == element_precision (op_type))
     (view_convert (cond_op (bit_not @0) @2 @3 @4
                  (view_convert:op_type @1)))))))


        Jakub

Reply via email to