[llvm] 02b070e - [InstSimplify] add tests for logic-of-icmp with min/max constant; NFC
Sanjay Patel via llvm-commits
llvm-commits at lists.llvm.org
Sun Apr 19 05:24:49 PDT 2020
Author: Sanjay Patel
Date: 2020-04-19T08:24:38-04:00
New Revision: 02b070ed497fa38fc3aca857bc2f03975ecb28a7
URL: https://github.com/llvm/llvm-project/commit/02b070ed497fa38fc3aca857bc2f03975ecb28a7
DIFF: https://github.com/llvm/llvm-project/commit/02b070ed497fa38fc3aca857bc2f03975ecb28a7.diff
LOG: [InstSimplify] add tests for logic-of-icmp with min/max constant; NFC
See PR45510:
https://bugs.llvm.org/show_bug.cgi?id=45510
We had partial coverage for some of these patterns, so removing duplicate tests
with the complete set in the new test file.
Added:
llvm/test/Transforms/InstSimplify/and-or-icmp-min-max.ll
Modified:
llvm/test/Transforms/InstSimplify/AndOrXor.ll
Removed:
llvm/test/Transforms/InstSimplify/unsigned-range-checks.ll
################################################################################
diff --git a/llvm/test/Transforms/InstSimplify/AndOrXor.ll b/llvm/test/Transforms/InstSimplify/AndOrXor.ll
index a5c8108d0a5d..8952acc2feb6 100644
--- a/llvm/test/Transforms/InstSimplify/AndOrXor.ll
+++ b/llvm/test/Transforms/InstSimplify/AndOrXor.ll
@@ -383,112 +383,6 @@ define i32 @neg_nuw(i32 %x) {
ret i32 %neg
}
-define i1 @and_icmp1(i32 %x, i32 %y) {
-; CHECK-LABEL: @and_icmp1(
-; CHECK-NEXT: [[TMP1:%.*]] = icmp ult i32 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT: ret i1 [[TMP1]]
-;
- %1 = icmp ult i32 %x, %y
- %2 = icmp ne i32 %y, 0
- %3 = and i1 %1, %2
- ret i1 %3
-}
-
-define i1 @and_icmp2(i32 %x, i32 %y) {
-; CHECK-LABEL: @and_icmp2(
-; CHECK-NEXT: [[TMP1:%.*]] = icmp ugt i32 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT: ret i1 [[TMP1]]
-;
- %1 = icmp ugt i32 %x, %y
- %2 = icmp ne i32 %x, 0
- %3 = and i1 %1, %2
- ret i1 %3
-}
-
-define i1 @and_icmp3(i32 %x, i32 %y) {
-; CHECK-LABEL: @and_icmp3(
-; CHECK-NEXT: ret i1 false
-;
- %1 = icmp ult i32 %x, %y
- %2 = icmp eq i32 %y, 0
- %3 = and i1 %1, %2
- ret i1 %3
-}
-
-define i1 @and_icmp4(i32 %x, i32 %y) {
-; CHECK-LABEL: @and_icmp4(
-; CHECK-NEXT: ret i1 false
-;
- %1 = icmp ugt i32 %x, %y
- %2 = icmp eq i32 %x, 0
- %3 = and i1 %1, %2
- ret i1 %3
-}
-
-define i1 @or_icmp1(i32 %x, i32 %y) {
-; CHECK-LABEL: @or_icmp1(
-; CHECK-NEXT: [[TMP1:%.*]] = icmp ne i32 [[Y:%.*]], 0
-; CHECK-NEXT: ret i1 [[TMP1]]
-;
- %1 = icmp ult i32 %x, %y
- %2 = icmp ne i32 %y, 0
- %3 = or i1 %1, %2
- ret i1 %3
-}
-
-define i1 @or_icmp2(i32 %x, i32 %y) {
-; CHECK-LABEL: @or_icmp2(
-; CHECK-NEXT: [[TMP1:%.*]] = icmp ne i32 [[X:%.*]], 0
-; CHECK-NEXT: ret i1 [[TMP1]]
-;
- %1 = icmp ugt i32 %x, %y
- %2 = icmp ne i32 %x, 0
- %3 = or i1 %1, %2
- ret i1 %3
-}
-
-define i1 @or_icmp3(i32 %x, i32 %y) {
-; CHECK-LABEL: @or_icmp3(
-; CHECK-NEXT: ret i1 true
-;
- %1 = icmp uge i32 %x, %y
- %2 = icmp ne i32 %y, 0
- %3 = or i1 %1, %2
- ret i1 %3
-}
-
-define i1 @or_icmp4(i32 %x, i32 %y) {
-; CHECK-LABEL: @or_icmp4(
-; CHECK-NEXT: ret i1 true
-;
- %1 = icmp ule i32 %x, %y
- %2 = icmp ne i32 %x, 0
- %3 = or i1 %1, %2
- ret i1 %3
-}
-
-define i1 @or_icmp5(i32 %x, i32 %y) {
-; CHECK-LABEL: @or_icmp5(
-; CHECK-NEXT: [[TMP1:%.*]] = icmp uge i32 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT: ret i1 [[TMP1]]
-;
- %1 = icmp uge i32 %x, %y
- %2 = icmp eq i32 %y, 0
- %3 = or i1 %1, %2
- ret i1 %3
-}
-
-define i1 @or_icmp6(i32 %x, i32 %y) {
-; CHECK-LABEL: @or_icmp6(
-; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i32 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT: ret i1 [[TMP1]]
-;
- %1 = icmp ule i32 %x, %y
- %2 = icmp eq i32 %x, 0
- %3 = or i1 %1, %2
- ret i1 %3
-}
-
; PR27869 - Look through casts to eliminate cmps and bitwise logic.
define i32 @and_of_zexted_icmps(i32 %i) {
@@ -581,6 +475,8 @@ define <2 x i3> @and_of_
diff erent_cast_icmps_vec(<2 x i8> %i, <2 x i16> %j) {
ret <2 x i3> %and
}
+; limit
+
define i32 @or_of_zexted_icmps(i32 %i) {
; CHECK-LABEL: @or_of_zexted_icmps(
; CHECK-NEXT: ret i32 1
diff --git a/llvm/test/Transforms/InstSimplify/and-or-icmp-min-max.ll b/llvm/test/Transforms/InstSimplify/and-or-icmp-min-max.ll
new file mode 100644
index 000000000000..7da2da65c6b6
--- /dev/null
+++ b/llvm/test/Transforms/InstSimplify/and-or-icmp-min-max.ll
@@ -0,0 +1,1272 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -instsimplify -S | FileCheck %s
+
+; There are 12 basic patterns (or 6 with DeMorganized equivalent) with
+; 2 (commute logic op) *
+; 2 (swap compare operands) *
+; 2 (signed/unsigned)
+; variations for a total of 96 tests.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; (X == MAX) && (X < Y) --> false
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define i1 @slt_and_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @slt_and_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp slt i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 127
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define <2 x i1> @slt_and_max_commute(<2 x i8> %x, <2 x i8> %y) {
+; CHECK-LABEL: @slt_and_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq <2 x i8> [[X]], <i8 127, i8 127>
+; CHECK-NEXT: [[R:%.*]] = and <2 x i1> [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret <2 x i1> [[R]]
+;
+ %cmp = icmp slt <2 x i8> %x, %y
+ %cmpeq = icmp eq <2 x i8> %x, <i8 127, i8 127>
+ %r = and <2 x i1> %cmpeq, %cmp
+ ret <2 x i1> %r
+}
+
+define i1 @slt_swap_and_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @slt_swap_and_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sgt i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 127
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @slt_swap_and_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @slt_swap_and_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sgt i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 127
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ult_and_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @ult_and_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ult i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 255
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ult_and_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ult_and_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ult i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 255
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ult_swap_and_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @ult_swap_and_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ugt i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 255
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ult_swap_and_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ult_swap_and_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ugt i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 255
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; (X == MIN) && (X > Y) --> false
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define i1 @sgt_and_min(i9 %x, i9 %y) {
+; CHECK-LABEL: @sgt_and_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i9 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i9 [[X]], -256
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sgt i9 %x, %y
+ %cmpeq = icmp eq i9 %x, 256
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sgt_and_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sgt_and_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sgt i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 128
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @sgt_swap_and_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @sgt_swap_and_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp slt i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 128
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sgt_swap_and_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sgt_swap_and_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp slt i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 128
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ugt_and_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @ugt_and_min(
+; CHECK-NEXT: ret i1 false
+;
+ %cmp = icmp ugt i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 0
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ugt_and_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ugt_and_min_commute(
+; CHECK-NEXT: ret i1 false
+;
+ %cmp = icmp ugt i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 0
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ugt_swap_and_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @ugt_swap_and_min(
+; CHECK-NEXT: ret i1 false
+;
+ %cmp = icmp ult i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 0
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ugt_swap_and_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ugt_swap_and_min_commute(
+; CHECK-NEXT: ret i1 false
+;
+ %cmp = icmp ult i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 0
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; (X != MAX) || (X >= Y) --> true
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define i1 @sge_or_not_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @sge_or_not_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sge i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 127
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sge_or_not_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sge_or_not_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sge i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 127
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @sge_swap_or_not_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @sge_swap_or_not_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sle i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 127
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sge_swap_or_not_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sge_swap_or_not_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sle i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 127
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @uge_or_not_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @uge_or_not_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp uge i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 255
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @uge_or_not_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @uge_or_not_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp uge i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 255
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @uge_swap_or_not_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @uge_swap_or_not_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ule i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 255
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @uge_swap_or_not_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @uge_swap_or_not_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ule i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 255
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; (X != MIN) || (X <= Y) --> true
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define i1 @sle_or_not_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @sle_or_not_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sle i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 128
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sle_or_not_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sle_or_not_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sle i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 128
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @sle_swap_or_not_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @sle_swap_or_not_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sge i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 128
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sle_swap_or_not_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sle_swap_or_not_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sge i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 128
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ule_or_not_min(i427 %x, i427 %y) {
+; CHECK-LABEL: @ule_or_not_min(
+; CHECK-NEXT: ret i1 true
+;
+ %cmp = icmp ule i427 %x, %y
+ %cmpeq = icmp ne i427 %x, 0
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ule_or_not_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ule_or_not_min_commute(
+; CHECK-NEXT: ret i1 true
+;
+ %cmp = icmp ule i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 0
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ule_swap_or_not_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @ule_swap_or_not_min(
+; CHECK-NEXT: ret i1 true
+;
+ %cmp = icmp uge i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 0
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ule_swap_or_not_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ule_swap_or_not_min_commute(
+; CHECK-NEXT: ret i1 true
+;
+ %cmp = icmp uge i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 0
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; (X == MAX) && (X >= Y) --> X == MAX
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define i1 @sge_and_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @sge_and_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sge i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 127
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sge_and_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sge_and_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sge i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 127
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @sge_swap_and_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @sge_swap_and_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sle i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 127
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sge_swap_and_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sge_swap_and_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sle i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 127
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @uge_and_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @uge_and_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp uge i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 255
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @uge_and_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @uge_and_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp uge i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 255
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @uge_swap_and_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @uge_swap_and_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ule i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 255
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @uge_swap_and_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @uge_swap_and_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ule i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 255
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; (X == MIN) && (X <= Y) --> X == MIN
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define i1 @sle_and_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @sle_and_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sle i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 128
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sle_and_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sle_and_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sle i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 128
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @sle_swap_and_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @sle_swap_and_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sge i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 128
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sle_swap_and_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sle_swap_and_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sge i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 128
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ule_and_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @ule_and_min(
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
+; CHECK-NEXT: ret i1 [[CMPEQ]]
+;
+ %cmp = icmp ule i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 0
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ule_and_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ule_and_min_commute(
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
+; CHECK-NEXT: ret i1 [[CMPEQ]]
+;
+ %cmp = icmp ule i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 0
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ule_swap_and_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @ule_swap_and_min(
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
+; CHECK-NEXT: ret i1 [[CMPEQ]]
+;
+ %cmp = icmp uge i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 0
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ule_swap_and_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ule_swap_and_min_commute(
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X:%.*]], 0
+; CHECK-NEXT: ret i1 [[CMPEQ]]
+;
+ %cmp = icmp uge i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 0
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; (X == MAX) || (X >= Y) --> X >= Y
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define i1 @sge_or_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @sge_or_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sge i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 127
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sge_or_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sge_or_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sge i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 127
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @sge_swap_or_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @sge_swap_or_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sle i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 127
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sge_swap_or_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sge_swap_or_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sle i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 127
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @uge_or_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @uge_or_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp uge i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 255
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @uge_or_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @uge_or_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp uge i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 255
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @uge_swap_or_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @uge_swap_or_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ule i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 255
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @uge_swap_or_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @uge_swap_or_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ule i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 255
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; (X == MIN) || (X <= Y) --> X <= Y
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define i1 @sle_or_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @sle_or_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sle i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 128
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sle_or_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sle_or_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sle i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 128
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @sle_swap_or_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @sle_swap_or_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sge i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 128
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sle_swap_or_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sle_swap_or_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sge i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 128
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ule_or_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @ule_or_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %cmp = icmp ule i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 0
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ule_or_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ule_or_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %cmp = icmp ule i8 %x, %y
+ %cmpeq = icmp eq i8 %x, 0
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ule_swap_or_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @ule_swap_or_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %cmp = icmp uge i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 0
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ule_swap_or_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ule_swap_or_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %cmp = icmp uge i8 %y, %x
+ %cmpeq = icmp eq i8 %x, 0
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; (X != MAX) && (X < Y) --> X < Y
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define i1 @slt_and_not_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @slt_and_not_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp slt i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 127
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @slt_and_not_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @slt_and_not_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp slt i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 127
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @slt_swap_and_not_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @slt_swap_and_not_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sgt i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 127
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @slt_swap_and_not_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @slt_swap_and_not_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sgt i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 127
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ult_and_not_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @ult_and_not_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ult i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 255
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ult_and_not_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ult_and_not_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ult i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 255
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ult_swap_and_not_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @ult_swap_and_not_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ugt i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 255
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ult_swap_and_not_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ult_swap_and_not_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ugt i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 255
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; (X != MIN) && (X > Y) --> X > Y
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define i1 @sgt_and_not_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @sgt_and_not_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sgt i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 128
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sgt_and_not_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sgt_and_not_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sgt i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 128
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @sgt_swap_and_not_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @sgt_swap_and_not_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp slt i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 128
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sgt_swap_and_not_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sgt_swap_and_not_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp slt i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 128
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ugt_and_not_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @ugt_and_not_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %cmp = icmp ugt i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 0
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ugt_and_not_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ugt_and_not_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %cmp = icmp ugt i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 0
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ugt_swap_and_not_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @ugt_swap_and_not_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %cmp = icmp ult i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 0
+ %r = and i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ugt_swap_and_not_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ugt_swap_and_not_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: ret i1 [[CMP]]
+;
+ %cmp = icmp ult i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 0
+ %r = and i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; (X != MAX) || (X < Y) --> X != MAX
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define i1 @slt_or_not_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @slt_or_not_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp slt i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 127
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @slt_or_not_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @slt_or_not_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp slt i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 127
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @slt_swap_or_not_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @slt_swap_or_not_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sgt i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 127
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @slt_swap_or_not_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @slt_swap_or_not_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sgt i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 127
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ult_or_not_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @ult_or_not_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ult i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 255
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ult_or_not_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ult_or_not_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ult i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 255
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ult_swap_or_not_max(i8 %x, i8 %y) {
+; CHECK-LABEL: @ult_swap_or_not_max(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ugt i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 255
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ult_swap_or_not_max_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ult_swap_or_not_max_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp ugt i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 255
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; (X != MIN) || (X > Y) --> X != MIN
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define i1 @sgt_or_not_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @sgt_or_not_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sgt i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 128
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sgt_or_not_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sgt_or_not_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp sgt i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 128
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @sgt_swap_or_not_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @sgt_swap_or_not_min(
+; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp slt i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 128
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @sgt_swap_or_not_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @sgt_swap_or_not_min_commute(
+; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[X:%.*]]
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
+; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %cmp = icmp slt i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 128
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ugt_or_not_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @ugt_or_not_min(
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
+; CHECK-NEXT: ret i1 [[CMPEQ]]
+;
+ %cmp = icmp ugt i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 0
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ugt_or_not_min_commute(i8 %x, i8 %y) {
+; CHECK-LABEL: @ugt_or_not_min_commute(
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
+; CHECK-NEXT: ret i1 [[CMPEQ]]
+;
+ %cmp = icmp ugt i8 %x, %y
+ %cmpeq = icmp ne i8 %x, 0
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
+
+define i1 @ugt_swap_or_not_min(i8 %x, i8 %y) {
+; CHECK-LABEL: @ugt_swap_or_not_min(
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X:%.*]], 0
+; CHECK-NEXT: ret i1 [[CMPEQ]]
+;
+ %cmp = icmp ult i8 %y, %x
+ %cmpeq = icmp ne i8 %x, 0
+ %r = or i1 %cmp, %cmpeq
+ ret i1 %r
+}
+
+define i1 @ugt_swap_or_not_min_commute(i823 %x, i823 %y) {
+; CHECK-LABEL: @ugt_swap_or_not_min_commute(
+; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i823 [[X:%.*]], 0
+; CHECK-NEXT: ret i1 [[CMPEQ]]
+;
+ %cmp = icmp ult i823 %y, %x
+ %cmpeq = icmp ne i823 %x, 0
+ %r = or i1 %cmpeq, %cmp
+ ret i1 %r
+}
diff --git a/llvm/test/Transforms/InstSimplify/unsigned-range-checks.ll b/llvm/test/Transforms/InstSimplify/unsigned-range-checks.ll
deleted file mode 100644
index e0c3a7c8d689..000000000000
--- a/llvm/test/Transforms/InstSimplify/unsigned-range-checks.ll
+++ /dev/null
@@ -1,130 +0,0 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt %s -instsimplify -S | FileCheck %s
-
-; Here we add unsigned two values, check that addition did not underflow AND
-; that the result is non-zero. This can be simplified just to a comparison
-; between the base and negated offset.
-
-; If we are checking that the result is not null or no underflow happened,
-; it is tautological (always-true).
-define i1 @t1(i8 %x, i8 %y) {
-; CHECK-LABEL: @t1(
-; CHECK-NEXT: ret i1 true
-;
- %not_null = icmp ne i8 %y, 0
- %no_underflow = icmp ule i8 %y, %x
- %r = or i1 %not_null, %no_underflow
- ret i1 %r
-}
-define i1 @t2_commutative(i8 %x, i8 %y) {
-; CHECK-LABEL: @t2_commutative(
-; CHECK-NEXT: ret i1 true
-;
- %not_null = icmp ne i8 %y, 0
- %no_underflow = icmp uge i8 %x, %y ; swapped
- %r = or i1 %not_null, %no_underflow
- ret i1 %r
-}
-
-define i1 @t3_commutative(i8 %x, i8 %y) {
-; CHECK-LABEL: @t3_commutative(
-; CHECK-NEXT: ret i1 true
-;
- %not_null = icmp ne i8 %y, 0
- %no_underflow = icmp ule i8 %y, %x
- %r = or i1 %no_underflow, %not_null ; swapped
- ret i1 %r
-}
-define i1 @t4_commutative(i8 %x, i8 %y) {
-; CHECK-LABEL: @t4_commutative(
-; CHECK-NEXT: ret i1 true
-;
- %not_null = icmp ne i8 %y, 0
- %no_underflow = icmp uge i8 %x, %y ; swapped
- %r = or i1 %no_underflow, %not_null ; swapped
- ret i1 %r
-}
-
-; If we are checking that the result is null and underflow happened,
-; it is tautological (always-false).
-define i1 @t5(i8 %x, i8 %y) {
-; CHECK-LABEL: @t5(
-; CHECK-NEXT: ret i1 false
-;
- %not_null = icmp eq i8 %y, 0
- %no_underflow = icmp ugt i8 %y, %x
- %r = and i1 %not_null, %no_underflow
- ret i1 %r
-}
-define i1 @t6_commutative(i8 %x, i8 %y) {
-; CHECK-LABEL: @t6_commutative(
-; CHECK-NEXT: ret i1 false
-;
- %not_null = icmp eq i8 %y, 0
- %no_underflow = icmp ult i8 %x, %y ; swapped
- %r = and i1 %not_null, %no_underflow
- ret i1 %r
-}
-
-; We only need to know that any of the 'add' operands is non-zero,
-; not necessarily the one used in the comparison.
-define i1 @t7(i8 %x, i8 %y) {
-; CHECK-LABEL: @t7(
-; CHECK-NEXT: ret i1 true
-;
- %cmp = icmp slt i8 %y, 0
- %not_null = icmp ne i8 %y, 0
- %no_underflow = icmp ule i8 %y, %x
- %r = or i1 %not_null, %no_underflow
- ret i1 %r
-}
-
-; If we check that no underflow happened and that the result is null,
-; we can just check for null.
-define i1 @t8(i8 %x, i8 %y) {
-; CHECK-LABEL: @t8(
-; CHECK-NEXT: [[NOT_NULL:%.*]] = icmp eq i8 [[Y:%.*]], 0
-; CHECK-NEXT: ret i1 [[NOT_NULL]]
-;
- %not_null = icmp eq i8 %y, 0
- %no_underflow = icmp ule i8 %y, %x
- %r = and i1 %not_null, %no_underflow
- ret i1 %r
-}
-; Likewise, if we check that result is non-null or underflow happened,
-; we can just check for null.
-define i1 @t9(i8 %x, i8 %y) {
-; CHECK-LABEL: @t9(
-; CHECK-NEXT: [[NOT_NULL:%.*]] = icmp ne i8 [[Y:%.*]], 0
-; CHECK-NEXT: ret i1 [[NOT_NULL]]
-;
- %not_null = icmp ne i8 %y, 0
- %no_underflow = icmp ugt i8 %y, %x
- %r = or i1 %not_null, %no_underflow
- ret i1 %r
-}
-
-; If we check that no underflow happened or that the result is not null,
-; we can just check for lack of underflow.
-define i1 @t10(i8 %x, i8 %y) {
-; CHECK-LABEL: @t10(
-; CHECK-NEXT: [[NO_UNDERFLOW:%.*]] = icmp ule i8 [[Y:%.*]], [[X:%.*]]
-; CHECK-NEXT: ret i1 [[NO_UNDERFLOW]]
-;
- %not_null = icmp eq i8 %y, 0
- %no_underflow = icmp ule i8 %y, %x
- %r = or i1 %not_null, %no_underflow
- ret i1 %r
-}
-; Likewise, if we check that underflow happened and that the result is not null,
-; we can just check for lack of underflow.
-define i1 @t11(i8 %x, i8 %y) {
-; CHECK-LABEL: @t11(
-; CHECK-NEXT: [[NO_UNDERFLOW:%.*]] = icmp ugt i8 [[Y:%.*]], [[X:%.*]]
-; CHECK-NEXT: ret i1 [[NO_UNDERFLOW]]
-;
- %not_null = icmp ne i8 %y, 0
- %no_underflow = icmp ugt i8 %y, %x
- %r = and i1 %not_null, %no_underflow
- ret i1 %r
-}
More information about the llvm-commits
mailing list