[gcc r13-7938] MATCH: Fix infinite loop between `vec_cond(vec_cond(a, b, 0), c, d)` and `a & b`

[gcc r13-7938] MATCH: Fix infinite loop between `vec_cond(vec_cond(a, b, 0), c, d)` and `a & b`

[Andrew Pinski]

https://gcc.gnu.org/g:add2afa9e25f1776fdfbeb1b99fd1efcf850f91f

commit r13-7938-gadd2afa9e25f1776fdfbeb1b99fd1efcf850f91f
Author: Andrew Pinski <pinskia@gmail.com>
Date:   Thu Oct 5 12:21:19 2023 -0700

    MATCH: Fix infinite loop between `vec_cond(vec_cond(a,b,0), c, d)` and `a & b`
    
    Match has a pattern which converts `vec_cond(vec_cond(a,b,0), c, d)`
    into `vec_cond(a & b, c, d)` but since in this case a is a comparison
    fold will change `a & b` back into `vec_cond(a,b,0)` which causes an
    infinite loop.
    The best way to fix this is to enable the patterns for vec_cond(*,vec_cond,*)
    only for GIMPLE so we don't get an infinite loop for fold any more.
    
    Note this is a latent bug since these patterns were added in r11-2577-g229752afe3156a
    and was exposed by r14-3350-g47b833a9abe1 where now able to remove a VIEW_CONVERT_EXPR.
    
    OK? Bootstrapped and tested on x86_64-linux-gnu with no regressions.
    
            PR middle-end/111699
    
    gcc/ChangeLog:
    
            * match.pd ((c ? a : b) op d, (c ? a : b) op (c ? d : e),
            (v ? w : 0) ? a : b, c1 ? c2 ? a : b : b): Enable only for GIMPLE.
    
    gcc/testsuite/ChangeLog:
    
            * gcc.c-torture/compile/pr111699-1.c: New test.
    
    (cherry picked from commit e77428a9a336f57e3efe3eff95f2b491d7e9be14)

Diff:
---
 gcc/match.pd                                     | 5 +++++
 gcc/testsuite/gcc.c-torture/compile/pr111699-1.c | 7 +++++++
 2 files changed, 12 insertions(+)

diff --git a/gcc/match.pd b/gcc/match.pd
index ae030437214..3651dd26814 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -4551,6 +4551,10 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 /* (v ? w : 0) ? a : b is just (v & w) ? a : b
    Currently disabled after pass lvec because ARM understands
    VEC_COND_EXPR<v==w,-1,0> but not a plain v==w fed to BIT_IOR_EXPR.  */
+#if GIMPLE
+/* These can only be done in gimple as fold likes to convert:
+   (CMP) & N into (CMP) ? N : 0
+   and we try to match the same pattern again and again. */
 (simplify
  (vec_cond (vec_cond:s @0 @3 integer_zerop) @1 @2)
  (if (optimize_vectors_before_lowering_p () && types_match (@0, @3))
@@ -4585,6 +4589,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
  (vec_cond @0 @3 (vec_cond:s @1 @2 @3))
  (if (optimize_vectors_before_lowering_p () && types_match (@0, @1))
   (vec_cond (bit_and (bit_not @0) @1) @2 @3)))
+#endif
 
 /* Canonicalize mask ? { 0, ... } : { -1, ...} to ~mask if the mask
    types are compatible.  */
diff --git a/gcc/testsuite/gcc.c-torture/compile/pr111699-1.c b/gcc/testsuite/gcc.c-torture/compile/pr111699-1.c
new file mode 100644
index 00000000000..87b127ed199
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/pr111699-1.c
@@ -0,0 +1,7 @@
+typedef unsigned char __attribute__((__vector_size__ (8))) V;
+
+void
+foo (V *v)
+{
+  *v =  (V) 0x107B9A7FF >= (*v <= 0);
+}