This is similar to Mark Gilsse's patch in the OP, except that it ensures that
the expression will fold back to a single condition.  I did include Richi's
patch from #c6 to make it more likely to trigger asap.

I'd appreciate feedback on the match.pd changes; it's my first time looking
into this new(ish) mini-language.


r~
        * gimplify.c (gimplify_expr) [VEC_COND_EXPR]: Allow the first
        argument to be is_gimple_condexpr.
        * match.pd: Simplify and + ior of vec_cond.

diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 7be6bd7..c434e55 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -10773,8 +10773,21 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, 
gimple_seq *post_p,
            goto expr_2;
          }
 
-       case FMA_EXPR:
        case VEC_COND_EXPR:
+         {
+           gimplify_status r0, r1, r2;
+           r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
+                               post_p, is_gimple_condexpr, fb_rvalue);
+           r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
+                               post_p, is_gimple_val, fb_rvalue);
+           r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
+                               post_p, is_gimple_val, fb_rvalue);
+           ret = MIN (MIN (r0, r1), r2);
+            recalculate_side_effects (*expr_p);
+           break;
+         }
+
+       case FMA_EXPR:
        case VEC_PERM_EXPR:
          /* Classified as tcc_expression.  */
          goto expr_3;
diff --git a/gcc/match.pd b/gcc/match.pd
index 5903782..4192d29 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -30,6 +30,7 @@ along with GCC; see the file COPYING3.  If not see
    real_zerop real_onep real_minus_onep
    zerop
    CONSTANT_CLASS_P
+   COMPARISON_CLASS_P
    tree_expr_nonnegative_p
    integer_valued_real_p
    integer_pow2p
@@ -2452,6 +2453,35 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
    replace if (x == 0) with tem = ~x; if (tem != 0) which is
    clearly less optimal and which we'll transform again in forwprop.  */
 
+/* Simplification of vec_cond.  */
+
+(for bcode (bit_and bit_ior)
+ (simplify
+  (bcode (vec_cond COMPARISON_CLASS_P@0 integer_all_onesp@2 integer_zerop@3)
+        (vec_cond COMPARISON_CLASS_P@1 @2 @3))
+  (with
+    {
+      tree al = TREE_OPERAND (@0, 0);
+      tree ar = TREE_OPERAND (@0, 1);
+      tree bl = TREE_OPERAND (@1, 0);
+      tree br = TREE_OPERAND (@1, 1);
+    }
+    (if (operand_equal_p (al, bl, 0) && operand_equal_p (ar, br, 0))
+      (with
+       {
+         tree_code tcode
+           = bcode == BIT_AND_EXPR ? TRUTH_AND_EXPR : TRUTH_OR_EXPR;
+         tree folded
+           = combine_comparisons (UNKNOWN_LOCATION, tcode, TREE_CODE (@0),
+                                  TREE_CODE (@1), TREE_TYPE (@0), al, ar);
+       }
+       (if (folded)
+         (switch
+           (if (integer_truep (folded)) @2)
+           (if (integer_zerop (folded)) @3)
+           (if (COMPARISON_CLASS_P (folded))
+             { build3 (VEC_COND_EXPR, TREE_TYPE (@2), folded, @2, @3); })))
+       )))))
 
 /* Simplification of math builtins.  These rules must all be optimizations
    as well as IL simplifications.  If there is a possibility that the new

Reply via email to