[gcc r11-6738] match.pd: Optimize (x < 0) ^ (y < 0) to (x ^ y) < 0 etc. [PR96681]

[Jakub Jelinek]

https://gcc.gnu.org/g:5c046034e3ea61dd68965154a398f8f813daf8f2

commit r11-6738-g5c046034e3ea61dd68965154a398f8f813daf8f2
Author: Jakub Jelinek <jakub@redhat.com>
Date:   Fri Jan 15 21:10:44 2021 +0100

    match.pd: Optimize (x < 0) ^ (y < 0) to (x ^ y) < 0 etc. [PR96681]
    
    This patch simplifies comparisons that test the sign bit xored together.
    If the comparisons are both < 0 or both >= 0, then we should xor the operands
    together and compare the result to < 0, if the comparisons are different,
    we should compare to >= 0.
    
    2021-01-15  Jakub Jelinek  <jakub@redhat.com>
    
            PR tree-optimization/96681
            * match.pd ((x < 0) ^ (y < 0) to (x ^ y) < 0): New simplification.
            ((x >= 0) ^ (y >= 0) to (x ^ y) < 0): Likewise.
            ((x < 0) ^ (y >= 0) to (x ^ y) >= 0): Likewise.
            ((x >= 0) ^ (y < 0) to (x ^ y) >= 0): Likewise.
    
            * gcc.dg/tree-ssa/pr96681.c: New test.

Diff:
---
 gcc/match.pd                            | 18 +++++++++++++++++
 gcc/testsuite/gcc.dg/tree-ssa/pr96681.c | 35 +++++++++++++++++++++++++++++++++
 2 files changed, 53 insertions(+)

diff --git a/gcc/match.pd b/gcc/match.pd
index f08ab674a70..e731bdba171 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -3993,6 +3993,24 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
    (if (single_use (@2))
     (cmp @0 @1)))))
 
+/* Simplify (x < 0) ^ (y < 0) to (x ^ y) < 0 and
+   (x >= 0) ^ (y >= 0) to (x ^ y) < 0.  */
+(for cmp (lt ge)
+ (simplify
+  (bit_xor (cmp:s @0 integer_zerop) (cmp:s @1 integer_zerop))
+   (if (INTEGRAL_TYPE_P (TREE_TYPE (@0))
+	&& !TYPE_UNSIGNED (TREE_TYPE (@0))
+	&& types_match (TREE_TYPE (@0), TREE_TYPE (@1)))
+    (lt (bit_xor @0 @1) { build_zero_cst (TREE_TYPE (@0)); }))))
+/* Simplify (x < 0) ^ (y >= 0) to (x ^ y) >= 0 and
+   (x >= 0) ^ (y < 0) to (x ^ y) >= 0.  */
+(simplify
+ (bit_xor:c (lt:s @0 integer_zerop) (ge:s @1 integer_zerop))
+  (if (INTEGRAL_TYPE_P (TREE_TYPE (@0))
+       && !TYPE_UNSIGNED (TREE_TYPE (@0))
+       && types_match (TREE_TYPE (@0), TREE_TYPE (@1)))
+   (ge (bit_xor @0 @1) { build_zero_cst (TREE_TYPE (@0)); })))
+
 /* Transform comparisons of the form X * C1 CMP 0 to X CMP 0 in the
    signed arithmetic case.  That form is created by the compiler
    often enough for folding it to be of value.  One example is in
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr96681.c b/gcc/testsuite/gcc.dg/tree-ssa/pr96681.c
new file mode 100644
index 00000000000..6d72a1a3d7d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/pr96681.c
@@ -0,0 +1,35 @@
+/* PR tree-optimization/96681 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+/* { dg-final { scan-tree-dump-times " \\^ " 5 "optimized" } } */
+/* { dg-final { scan-tree-dump-times " (?:<|>=) 0" 5 "optimized" } } */
+
+int
+foo (int x, int y)
+{
+  return (x < 0) ^ (y < 0);
+}
+
+int
+bar (int x, int y)
+{
+  return (x > -1) ^ (y > -1);
+}
+
+int
+baz (int x, int y)
+{
+  return (x ^ y) < 0;
+}
+
+int
+qux (int x, int y)
+{
+  return (x ^ y) >= 0;
+}
+
+int
+corge (int x, int y)
+{
+  return (x >= 0) ^ (y < 0);
+}