On 9/5/19 3:17 PM, Richard Biener wrote:
> On Tue, 16 Jul 2019, Li Jia He wrote:
>
>> Hi,
>>
>> I made some changes based on the recommendations. Would you like to
>> help me to see it again ? Sorry, it took so long time to provide the
>> patch.
>>
>> Note: 1. I keep the code for and_comparisons_1 and or_comparisons_1.
>> The reason is that I did not found a good way to handle the
>> optimization of '((x CODE1 y) AND (x CODE2 y))' in match.pd.
>> Maybe I missing some important information about match.pd.
>> 2. The gimple_resimplify2 function is not used. Since stmt1,
>> stmt2, lhs1 and lhs2 are allocated on the stack, Is there a
>> question with the value on the stack as the return value ?
>> I may have misunderstood Richard's intention.
>
> And now for the match.pd patch.
>
> +/* x > y && x != XXX_MIN --> x > y */
> +(for and (truth_and bit_and)
> + (simplify
> + (and:c (gt:c@3 @0 @1) (ne @0 INTEGER_CST@2))
> + (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)) && INTEGRAL_TYPE_P
> (TREE_TYPE(@1))
> + && (wi::eq_p (wi::to_wide (@2), wi::min_value (TREE_TYPE (@2)))))
> + @3)))
> +
> +/* x > y && x == XXX_MIN --> false */
> +(for and (truth_and bit_and)
> + (simplify
> + (and:c (gt:c @0 @1) (eq @0 INTEGER_CST@2))
> + (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)) && INTEGRAL_TYPE_P
> (TREE_TYPE(@1))
> + && (wi::eq_p (wi::to_wide (@2), wi::min_value (TREE_TYPE (@2)))))
> + { boolean_false_node; })))
>
> you could merge those two via
>
> (for eqne (eq ne)
> (for and (....
> (simplify
> (and:c (gt:c @0 @1) (eqne @0 INTEGER_CST@2))
> (if (...)
> (switch
> (if (eqne == NE_EXPR)
> @3)
> (if (eqne == EQ_EXPR)
> { constant_boolean_node (false, type); }))))
>
> notice using constant_boolean_node (false, type); instead of
> boolean_false_node. I suspect more unification is possible.
>
> Also you could do
>
> (match min_value
> INTEGER_CST
> (if (INTEGRAL_TYPE_P (type)
> && wi::eq_p (wi::to_wide (t), wi::min_value (type)))))
>
> and then write
>
> (simplify
> (and:c (gt:c @0 @1) (eq @0 min_value))
> (...
>
> Your
>
> (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)) && INTEGRAL_TYPE_P
> (TREE_TYPE(@1))
>
> is redundant, it's enough to check either @0 or @1 given they
> have to be compatible for the gt operation. Note you probably
> want to use
>
> (and:c (gt:c @0 @1) (eq @@0 min_value))
>
> and verify that types_match (@1, @0) because when @0 are a constant
> (and (eq @0 min_value) is not folded which can happen) then they
> might have different types and thus you could have
> (SHORT_MAX > intvar) && (SHORT_MAX == SHORT_MAX)
>
> That said, the patterns can be quite a bit simplified I think.
>
> Richard.
>
Likewise, I applied the suggested simplification.
Patch can bootstrap on x86_64-linux-gnu and survives regression tests.
Ready to be installed?
Thanks,
Martin
>From 1006e2cf69e97692e09e845eaadf55098d48f0e2 Mon Sep 17 00:00:00 2001
From: Li Jia He <heli...@linux.ibm.com>
Date: Mon, 15 Jul 2019 03:50:34 -0500
Subject: [PATCH 2/2] Fix PR88784, middle end is missing some optimizations
about unsigned
Hi,
According to the optimizable case described by Qi Feng on
issue 88784, we can combine the cases into the following:
1. x > y && x != XXX_MIN --> x > y
2. x > y && x == XXX_MIN --> false
3. x <= y && x == XXX_MIN --> x == XXX_MIN
4. x < y && x != XXX_MAX --> x < y
5. x < y && x == XXX_MAX --> false
6. x >= y && x == XXX_MAX --> x == XXX_MAX
7. x > y || x != XXX_MIN --> x != XXX_MIN
8. x <= y || x != XXX_MIN --> true
9. x <= y || x == XXX_MIN --> x <= y
10. x < y || x != XXX_MAX --> x != UXXX_MAX
11. x >= y || x != XXX_MAX --> true
12. x >= y || x == XXX_MAX --> x >= y
Note: XXX_MIN represents the minimum value of type x.
XXX_MAX represents the maximum value of type x.
Here we don't need to care about whether the operation is
signed or unsigned. For example, in the below equation:
'x > y && x != XXX_MIN --> x > y'
If the x type is signed int and XXX_MIN is INT_MIN, we can
optimize it to 'x > y'. However, if the type of x is unsigned
int and XXX_MIN is 0, we can still optimize it to 'x > y'.
The regression testing for the patch was done on GCC mainline on
powerpc64le-unknown-linux-gnu (Power 9 LE)
with no regressions. Is it OK for trunk ?
Thanks,
Lijia He
gcc/ChangeLog
2019-07-16 Li Jia He <heli...@linux.ibm.com>
Qi Feng <ffen...@linux.ibm.com>
PR middle-end/88784
* match.pd (x > y && x != XXX_MIN): Optimize into 'x > y'.
(x > y && x == XXX_MIN): Optimize into 'false'.
(x <= y && x == XXX_MIN): Optimize into 'x == XXX_MIN'.
(x < y && x != XXX_MAX): Optimize into 'x < y'.
(x < y && x == XXX_MAX): Optimize into 'false'.
(x >= y && x == XXX_MAX): Optimize into 'x == XXX_MAX'.
(x > y || x != XXX_MIN): Optimize into 'x != XXX_MIN'.
(x <= y || x != XXX_MIN): Optimize into 'true'.
(x <= y || x == XXX_MIN): Optimize into 'x <= y'.
(x < y || x != XXX_MAX): Optimize into 'x != XXX_MAX'.
(x >= y || x != XXX_MAX): Optimize into 'true'.
(x >= y || x == XXX_MAX): Optimize into 'x >= y'.
gcc/testsuite/ChangeLog
2019-07-16 Li Jia He <heli...@linux.ibm.com>
Qi Feng <ffen...@linux.ibm.com>
PR middle-end/88784
* gcc.dg/pr88784-1.c: New testcase.
* gcc.dg/pr88784-2.c: New testcase.
* gcc.dg/pr88784-3.c: New testcase.
* gcc.dg/pr88784-4.c: New testcase.
* gcc.dg/pr88784-5.c: New testcase.
* gcc.dg/pr88784-6.c: New testcase.
* gcc.dg/pr88784-7.c: New testcase.
* gcc.dg/pr88784-8.c: New testcase.
* gcc.dg/pr88784-9.c: New testcase.
* gcc.dg/pr88784-10.c: New testcase.
* gcc.dg/pr88784-11.c: New testcase.
* gcc.dg/pr88784-12.c: New testcase.
---
gcc/match.pd | 91 +++++++++++++++++++++++++++++--
gcc/testsuite/gcc.dg/pr88784-1.c | 30 ++++++++++
gcc/testsuite/gcc.dg/pr88784-10.c | 32 +++++++++++
gcc/testsuite/gcc.dg/pr88784-11.c | 30 ++++++++++
gcc/testsuite/gcc.dg/pr88784-12.c | 30 ++++++++++
gcc/testsuite/gcc.dg/pr88784-2.c | 30 ++++++++++
gcc/testsuite/gcc.dg/pr88784-3.c | 32 +++++++++++
gcc/testsuite/gcc.dg/pr88784-4.c | 32 +++++++++++
gcc/testsuite/gcc.dg/pr88784-5.c | 31 +++++++++++
gcc/testsuite/gcc.dg/pr88784-6.c | 31 +++++++++++
gcc/testsuite/gcc.dg/pr88784-7.c | 31 +++++++++++
gcc/testsuite/gcc.dg/pr88784-8.c | 31 +++++++++++
gcc/testsuite/gcc.dg/pr88784-9.c | 32 +++++++++++
13 files changed, 459 insertions(+), 4 deletions(-)
create mode 100644 gcc/testsuite/gcc.dg/pr88784-1.c
create mode 100644 gcc/testsuite/gcc.dg/pr88784-10.c
create mode 100644 gcc/testsuite/gcc.dg/pr88784-11.c
create mode 100644 gcc/testsuite/gcc.dg/pr88784-12.c
create mode 100644 gcc/testsuite/gcc.dg/pr88784-2.c
create mode 100644 gcc/testsuite/gcc.dg/pr88784-3.c
create mode 100644 gcc/testsuite/gcc.dg/pr88784-4.c
create mode 100644 gcc/testsuite/gcc.dg/pr88784-5.c
create mode 100644 gcc/testsuite/gcc.dg/pr88784-6.c
create mode 100644 gcc/testsuite/gcc.dg/pr88784-7.c
create mode 100644 gcc/testsuite/gcc.dg/pr88784-8.c
create mode 100644 gcc/testsuite/gcc.dg/pr88784-9.c
diff --git a/gcc/match.pd b/gcc/match.pd
index cd75dacd9cd..aa65cb63ca2 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -1860,6 +1860,89 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
{ wide_int_to_tree (type, (wi::to_wide (@1)
& (bitpos / BITS_PER_UNIT))); }))))
+(match min_value
+ INTEGER_CST
+ (if (INTEGRAL_TYPE_P (type)
+ && wi::eq_p (wi::to_wide (t), wi::min_value (type)))))
+
+(match max_value
+ INTEGER_CST
+ (if (INTEGRAL_TYPE_P (type)
+ && wi::eq_p (wi::to_wide (t), wi::max_value (type)))))
+
+/* x > y && x != XXX_MIN --> x > y
+ x > y && x == XXX_MIN --> false . */
+(for eqne (eq ne)
+ (for and (truth_and bit_and)
+ (simplify
+ (and:c (gt:c@2 @0 @1) (eqne @0 min_value))
+ (switch
+ (if (eqne == EQ_EXPR)
+ { constant_boolean_node (false, type); })
+ (if (eqne == NE_EXPR)
+ @2)
+ ))))
+
+/* x < y && x != XXX_MAX --> x < y
+ x < y && x == XXX_MAX --> false. */
+(for eqne (eq ne)
+ (for and (truth_and bit_and)
+ (simplify
+ (and:c (lt:c@2 @0 @1) (eqne @0 max_value))
+ (switch
+ (if (eqne == EQ_EXPR)
+ { constant_boolean_node (false, type); })
+ (if (eqne == NE_EXPR)
+ @2)
+ ))))
+
+/* x <= y && x == XXX_MIN --> x == XXX_MIN. */
+(for and (truth_and bit_and)
+ (simplify
+ (and:c (le:c @0 @1) (eq@2 @0 min_value))
+ @2))
+
+/* x >= y && x == XXX_MAX --> x == XXX_MAX. */
+(for and (truth_and bit_and)
+ (simplify
+ (and:c (ge:c @0 @1) (eq@2 @0 max_value))
+ @2))
+
+/* x > y || x != XXX_MIN --> x != XXX_MIN. */
+(for or (truth_or bit_ior)
+ (simplify
+ (or:c (gt:c @0 @1) (ne@2 @0 min_value))
+ @2))
+
+/* x <= y || x != XXX_MIN --> true. */
+(for or (truth_or bit_ior)
+ (simplify
+ (or:c (le:c @0 @1) (ne @0 min_value))
+ { constant_boolean_node (true, type); }))
+
+/* x <= y || x == XXX_MIN --> x <= y. */
+(for or (truth_or bit_ior)
+ (simplify
+ (or:c (le:c@2 @0 @1) (eq @0 min_value))
+ @2))
+
+/* x < y || x != XXX_MAX --> x != XXX_MAX. */
+(for or (truth_or bit_ior)
+ (simplify
+ (or:c (lt:c @0 @1) (ne@2 @0 max_value))
+ @2))
+
+/* x >= y || x != XXX_MAX --> true
+ x >= y || x == XXX_MAX --> x >= y. */
+(for eqne (eq ne)
+ (for or (truth_or bit_ior)
+ (simplify
+ (or:c (ge:c@2 @0 @1) (eqne @0 max_value))
+ (switch
+ (if (eqne == EQ_EXPR)
+ @2)
+ (if (eqne == NE_EXPR)
+ { constant_boolean_node (true, type); })))))
/* We can't reassociate at all for saturating types. */
(if (!TYPE_SATURATING (type))
@@ -5402,10 +5485,10 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
on c, so could drop potentially-trapping arithmetic, but that's a valid
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. */
+ 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)
diff --git a/gcc/testsuite/gcc.dg/pr88784-1.c b/gcc/testsuite/gcc.dg/pr88784-1.c
new file mode 100644
index 00000000000..067d40d0739
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr88784-1.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-ifcombine --param logical-op-non-short-circuit=0" } */
+
+#include <limits.h>
+
+_Bool and1(unsigned x, unsigned y)
+{
+ /* x > y && x != 0 --> x > y */
+ return x > y && x != 0;
+}
+
+_Bool and2(unsigned x, unsigned y)
+{
+ /* x < y && x != UINT_MAX --> x < y */
+ return x < y && x != UINT_MAX;
+}
+
+_Bool and3(signed x, signed y)
+{
+ /* x > y && x != INT_MIN --> x > y */
+ return x > y && x != INT_MIN;
+}
+
+_Bool and4(signed x, signed y)
+{
+ /* x < y && x != INT_MAX --> x < y */
+ return x < y && x != INT_MAX;
+}
+
+/* { dg-final { scan-tree-dump-not " != " "ifcombine" } } */
diff --git a/gcc/testsuite/gcc.dg/pr88784-10.c b/gcc/testsuite/gcc.dg/pr88784-10.c
new file mode 100644
index 00000000000..2218faa3b7c
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr88784-10.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple --param logical-op-non-short-circuit=1" } */
+
+#include <limits.h>
+
+_Bool or1(unsigned x, unsigned y)
+{
+ /* x <= y || x != 0 --> true */
+ return x <= y || x != 0;
+}
+
+_Bool or2(unsigned x, unsigned y)
+{
+ /* x >= y || x != UINT_MAX --> true */
+ return x >= y || x != UINT_MAX;
+}
+
+_Bool or3(signed x, signed y)
+{
+ /* x <= y || x != INT_MIN --> true */
+ return x <= y || x != INT_MIN;
+}
+
+_Bool or4(signed x, signed y)
+{
+ /* x >= y || x != INT_MAX --> true */
+ return x >= y || x != INT_MAX;
+}
+
+/* { dg-final { scan-tree-dump-not " != " "gimple" } } */
+/* { dg-final { scan-tree-dump-not " <= " "gimple" } } */
+/* { dg-final { scan-tree-dump-not " >= " "gimple" } } */
diff --git a/gcc/testsuite/gcc.dg/pr88784-11.c b/gcc/testsuite/gcc.dg/pr88784-11.c
new file mode 100644
index 00000000000..4465910efbb
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr88784-11.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-ifcombine --param logical-op-non-short-circuit=0" } */
+
+#include <limits.h>
+
+_Bool or1(unsigned x, unsigned y)
+{
+ /* x <= y || x == 0 --> x <= y */
+ return x <= y || x == 0;
+}
+
+_Bool or2(unsigned x, unsigned y)
+{
+ /* x >= y || x == UINT_MAX --> x >= y */
+ return x >= y || x == UINT_MAX;
+}
+
+_Bool or3(signed x, signed y)
+{
+ /* x <= y || x == INT_MIN --> x <= y */
+ return x <= y || x == INT_MIN;
+}
+
+_Bool or4(signed x, signed y)
+{
+ /* x >= y || x == INT_MAX --> x >= y */
+ return x >= y || x == INT_MAX;
+}
+
+/* { dg-final { scan-tree-dump-not " == " "ifcombine" } } */
diff --git a/gcc/testsuite/gcc.dg/pr88784-12.c b/gcc/testsuite/gcc.dg/pr88784-12.c
new file mode 100644
index 00000000000..477bba07821
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr88784-12.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dce3 --param logical-op-non-short-circuit=1" } */
+
+#include <limits.h>
+
+_Bool or1(unsigned x, unsigned y)
+{
+ /* x <= y || x == 0 --> x <= y */
+ return x <= y || x == 0;
+}
+
+_Bool or2(unsigned x, unsigned y)
+{
+ /* x >= y || x == UINT_MAX --> x >= y */
+ return x >= y || x == UINT_MAX;
+}
+
+_Bool or3(signed x, signed y)
+{
+ /* x <= y || x == INT_MIN --> x <= y */
+ return x <= y || x == INT_MIN;
+}
+
+_Bool or4(signed x, signed y)
+{
+ /* x >= y || x == INT_MAX --> x >= y */
+ return x >= y || x == INT_MAX;
+}
+
+/* { dg-final { scan-tree-dump-not " == " "dce3" } } */
diff --git a/gcc/testsuite/gcc.dg/pr88784-2.c b/gcc/testsuite/gcc.dg/pr88784-2.c
new file mode 100644
index 00000000000..02647204726
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr88784-2.c
@@ -0,0 +1,30 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple --param logical-op-non-short-circuit=1" } */
+
+#include <limits.h>
+
+_Bool and1(unsigned x, unsigned y)
+{
+ /* x > y && x != 0 --> x > y */
+ return x > y && x != 0;
+}
+
+_Bool and2(unsigned x, unsigned y)
+{
+ /* x < y && x != UINT_MAX --> x < y */
+ return x < y && x != UINT_MAX;
+}
+
+_Bool and3(signed x, signed y)
+{
+ /* x > y && x != INT_MIN --> x > y */
+ return x > y && x != INT_MIN;
+}
+
+_Bool and4(signed x, signed y)
+{
+ /* x < y && x != INT_MAX --> x < y */
+ return x < y && x != INT_MAX;
+}
+
+/* { dg-final { scan-tree-dump-not " != " "gimple" } } */
diff --git a/gcc/testsuite/gcc.dg/pr88784-3.c b/gcc/testsuite/gcc.dg/pr88784-3.c
new file mode 100644
index 00000000000..be2ce315e60
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr88784-3.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-ifcombine --param logical-op-non-short-circuit=0" } */
+
+#include <limits.h>
+
+_Bool and1(unsigned x, unsigned y)
+{
+ /* x > y && x == 0 --> false */
+ return x > y && x == 0;
+}
+
+_Bool and2(unsigned x, unsigned y)
+{
+ /* x < y && x == UINT_MAX --> false */
+ return x < y && x == UINT_MAX;
+}
+
+_Bool and3(signed x, signed y)
+{
+ /* x > y && x == INT_MIN --> false */
+ return x > y && x == INT_MIN;
+}
+
+_Bool and4(signed x, signed y)
+{
+ /* x < y && x == INT_MAX --> false */
+ return x < y && x == INT_MAX;
+}
+
+/* { dg-final { scan-tree-dump-not " == " "ifcombine" } } */
+/* { dg-final { scan-tree-dump-not " > " "ifcombine" } } */
+/* { dg-final { scan-tree-dump-not " < " "ifcombine" } } */
diff --git a/gcc/testsuite/gcc.dg/pr88784-4.c b/gcc/testsuite/gcc.dg/pr88784-4.c
new file mode 100644
index 00000000000..d1363659f40
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr88784-4.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple --param logical-op-non-short-circuit=1" } */
+
+#include <limits.h>
+
+_Bool and1(unsigned x, unsigned y)
+{
+ /* x > y && x == 0 --> false */
+ return x > y && x == 0;
+}
+
+_Bool and2(unsigned x, unsigned y)
+{
+ /* x < y && x == UINT_MAX --> false */
+ return x < y && x == UINT_MAX;
+}
+
+_Bool and3(signed x, signed y)
+{
+ /* x > y && x == INT_MIN --> false */
+ return x > y && x == INT_MIN;
+}
+
+_Bool and4(signed x, signed y)
+{
+ /* x < y && x == INT_MAX --> false */
+ return x < y && x == INT_MAX;
+}
+
+/* { dg-final { scan-tree-dump-not " == " "gimple" } } */
+/* { dg-final { scan-tree-dump-not " > " "gimple" } } */
+/* { dg-final { scan-tree-dump-not " < " "gimple" } } */
diff --git a/gcc/testsuite/gcc.dg/pr88784-5.c b/gcc/testsuite/gcc.dg/pr88784-5.c
new file mode 100644
index 00000000000..c6a349d7c75
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr88784-5.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-ifcombine --param logical-op-non-short-circuit=0" } */
+
+#include <limits.h>
+
+_Bool and1(unsigned x, unsigned y)
+{
+ /* x <= y && x == 0 --> x == 0 */
+ return x <= y && x == 0;
+}
+
+_Bool and2(unsigned x, unsigned y)
+{
+ /* x >= y && x == UINT_MAX --> x == UINT_MAX */
+ return x >= y && x == UINT_MAX;
+}
+
+_Bool and3(signed x, signed y)
+{
+ /* x <= y && x == INT_MIN --> x == INT_MIN */
+ return x <= y && x == INT_MIN;
+}
+
+_Bool and4(signed x, signed y)
+{
+ /* x >= y && x == INT_MAX --> x == INT_MAX */
+ return x >= y && x == INT_MAX;
+}
+
+/* { dg-final { scan-tree-dump-not " <= " "ifcombine" } } */
+/* { dg-final { scan-tree-dump-not " >= " "ifcombine" } } */
diff --git a/gcc/testsuite/gcc.dg/pr88784-6.c b/gcc/testsuite/gcc.dg/pr88784-6.c
new file mode 100644
index 00000000000..b0e81e0165e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr88784-6.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple --param logical-op-non-short-circuit=1" } */
+
+#include <limits.h>
+
+_Bool and1(unsigned x, unsigned y)
+{
+ /* x <= y && x == 0 --> x == 0 */
+ return x <= y && x == 0;
+}
+
+_Bool and2(unsigned x, unsigned y)
+{
+ /* x >= y && x == UINT_MAX --> x == UINT_MAX */
+ return x >= y && x == UINT_MAX;
+}
+
+_Bool and3(signed x, signed y)
+{
+ /* x <= y && x == INT_MIN --> x == INT_MIN */
+ return x <= y && x == INT_MIN;
+}
+
+_Bool and4(signed x, signed y)
+{
+ /* x >= y && x == INT_MAX --> x == INT_MAX */
+ return x >= y && x == INT_MAX;
+}
+
+/* { dg-final { scan-tree-dump-not " <= " "gimple" } } */
+/* { dg-final { scan-tree-dump-not " >= " "gimple" } } */
diff --git a/gcc/testsuite/gcc.dg/pr88784-7.c b/gcc/testsuite/gcc.dg/pr88784-7.c
new file mode 100644
index 00000000000..937d2d26593
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr88784-7.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-ifcombine --param logical-op-non-short-circuit=0" } */
+
+#include <limits.h>
+
+_Bool or1(unsigned x, unsigned y)
+{
+ /* x > y || x != 0 --> x != 0 */
+ return x > y || x != 0;
+}
+
+_Bool or2(unsigned x, unsigned y)
+{
+ /* x < y || x != UINT_MAX --> x != UINT_MAX */
+ return x < y || x != UINT_MAX;
+}
+
+_Bool or3(signed x, signed y)
+{
+ /* x > y || x != INT_MIN --> x != INT_MIN */
+ return x > y || x != INT_MIN;
+}
+
+_Bool or4(signed x, signed y)
+{
+ /* x < y || x != INT_MAX --> x != INT_MAX */
+ return x < y || x != INT_MAX;
+}
+
+/* { dg-final { scan-tree-dump-not " > " "ifcombine" } } */
+/* { dg-final { scan-tree-dump-not " < " "ifcombine" } } */
diff --git a/gcc/testsuite/gcc.dg/pr88784-8.c b/gcc/testsuite/gcc.dg/pr88784-8.c
new file mode 100644
index 00000000000..aa384c305b1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr88784-8.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-gimple --param logical-op-non-short-circuit=1" } */
+
+#include <limits.h>
+
+_Bool or1(unsigned x, unsigned y)
+{
+ /* x > y || x != 0 --> x != 0 */
+ return x > y || x != 0;
+}
+
+_Bool or2(unsigned x, unsigned y)
+{
+ /* x < y || x != UINT_MAX --> x != UINT_MAX */
+ return x < y || x != UINT_MAX;
+}
+
+_Bool or3(signed x, signed y)
+{
+ /* x > y || x != INT_MIN --> x != INT_MIN */
+ return x > y || x != INT_MIN;
+}
+
+_Bool or4(signed x, signed y)
+{
+ /* x < y || x != INT_MAX --> x != INT_MAX */
+ return x < y || x != INT_MAX;
+}
+
+/* { dg-final { scan-tree-dump-not " > " "gimple" } } */
+/* { dg-final { scan-tree-dump-not " < " "gimple" } } */
diff --git a/gcc/testsuite/gcc.dg/pr88784-9.c b/gcc/testsuite/gcc.dg/pr88784-9.c
new file mode 100644
index 00000000000..94f62d94ede
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr88784-9.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-ifcombine --param logical-op-non-short-circuit=0" } */
+
+#include <limits.h>
+
+_Bool or1(unsigned x, unsigned y)
+{
+ /* x <= y || x != 0 --> true */
+ return x <= y || x != 0;
+}
+
+_Bool or2(unsigned x, unsigned y)
+{
+ /* x >= y || x != UINT_MAX --> true */
+ return x >= y || x != UINT_MAX;
+}
+
+_Bool or3(signed x, signed y)
+{
+ /* x <= y || x != INT_MIN --> true */
+ return x <= y || x != INT_MIN;
+}
+
+_Bool or4(signed x, signed y)
+{
+ /* x >= y || x != INT_MAX --> true */
+ return x >= y || x != INT_MAX;
+}
+
+/* { dg-final { scan-tree-dump-not " != " "ifcombine" } } */
+/* { dg-final { scan-tree-dump-not " <= " "ifcombine" } } */
+/* { dg-final { scan-tree-dump-not " >= " "ifcombine" } } */
--
2.23.0
