RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-25 20:23:11 +01:00
Code Issues Projects Releases Wiki Activity
7aeebb1a7c
llvm-mirror/test/Transforms/InstSimplify/and-or-icmp-min-max.ll
Sanjay Patel aa7efec9b3 [InstSimplify] peek through 'not' operand in logic-of-icmps fold 
This extends D78430 to solve cases like:
https://llvm.org/PR47858

There are still missed opportunities shown in the tests,
and as noted in the earlier patches, we have related
functionality in InstCombine, so we may want to extend
other folds in a similar way.

A semi-random sampling of test diff proofs in this patch:
https://rise4fun.com/Alive/sS4C
2020-10-25 11:13:30 -04:00

2674 lines
76 KiB
LLVM
Raw Blame History

; 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) *
; 2 (not of input operand)
; variations for a total of 192 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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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: ret i1 [[CMP]]
;
%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
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; (X == MIN) && (!X < Y) --> false
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
define i1 @slt_and_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @slt_and_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp slt i8 %notx, %y
%cmpeq = icmp eq i8 %x, 128
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define <2 x i1> @slt_and_max_commute_not_op(<2 x i8> %x, <2 x i8> %y) {
; CHECK-LABEL: @slt_and_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor <2 x i8> [[X:%.*]], <i8 -1, i8 -1>
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq <2 x i8> [[X]], <i8 -128, i8 -128>
; CHECK-NEXT: [[R:%.*]] = and <2 x i1> [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret <2 x i1> [[R]]
;
%notx = xor <2 x i8> %x, <i8 -1, i8 -1>
%cmp = icmp slt <2 x i8> %notx, %y
%cmpeq = icmp eq <2 x i8> %x, <i8 128, i8 128>
%r = and <2 x i1> %cmpeq, %cmp
ret <2 x i1> %r
}
define i1 @slt_swap_and_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @slt_swap_and_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sgt i8 %y, %notx
%cmpeq = icmp eq i8 %x, 128
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @slt_swap_and_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @slt_swap_and_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sgt i8 %y, %notx
%cmpeq = icmp eq i8 %x, 128
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ult_and_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ult_and_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ult i8 %notx, %y
%cmpeq = icmp eq i8 %x, 0
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ult_and_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ult_and_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ult i8 %notx, %y
%cmpeq = icmp eq i8 %x, 0
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ult_swap_and_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ult_swap_and_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ugt i8 %y, %notx
%cmpeq = icmp eq i8 %x, 0
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ult_swap_and_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ult_swap_and_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ugt i8 %y, %notx
%cmpeq = icmp eq i8 %x, 0
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; (X == MAX) && (!X > Y) --> false
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
define i1 @sgt_and_min_not_op(i9 %x, i9 %y) {
; CHECK-LABEL: @sgt_and_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i9 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i9 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i9 [[X]], 255
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i9 %x, -1
%cmp = icmp sgt i9 %notx, %y
%cmpeq = icmp eq i9 %x, 255
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sgt_and_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sgt_and_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sgt i8 %notx, %y
%cmpeq = icmp eq i8 %x, 127
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @sgt_swap_and_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sgt_swap_and_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp slt i8 %y, %notx
%cmpeq = icmp eq i8 %x, 127
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sgt_swap_and_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sgt_swap_and_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 127
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp slt i8 %y, %notx
%cmpeq = icmp eq i8 %x, 127
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ugt_and_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ugt_and_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ugt i8 %notx, %y
%cmpeq = icmp eq i8 %x, 255
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ugt_and_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ugt_and_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ugt i8 %notx, %y
%cmpeq = icmp eq i8 %x, 255
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ugt_swap_and_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ugt_swap_and_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ult i8 %y, %notx
%cmpeq = icmp eq i8 %x, 255
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ugt_swap_and_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ugt_swap_and_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -1
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ult i8 %y, %notx
%cmpeq = icmp eq i8 %x, 255
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; (X != MIN) || (!X >= Y) --> true
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
define i1 @sge_or_not_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sge_or_not_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sge i8 %notx, %y
%cmpeq = icmp ne i8 %x, 128
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sge_or_not_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sge_or_not_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sge i8 %notx, %y
%cmpeq = icmp ne i8 %x, 128
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @sge_swap_or_not_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sge_swap_or_not_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sle i8 %y, %notx
%cmpeq = icmp ne i8 %x, 128
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sge_swap_or_not_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sge_swap_or_not_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sle i8 %y, %notx
%cmpeq = icmp ne i8 %x, 128
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @uge_or_not_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @uge_or_not_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp uge i8 %notx, %y
%cmpeq = icmp ne i8 %x, 0
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @uge_or_not_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @uge_or_not_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp uge i8 %notx, %y
%cmpeq = icmp ne i8 %x, 0
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @uge_swap_or_not_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @uge_swap_or_not_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ule i8 %y, %notx
%cmpeq = icmp ne i8 %x, 0
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @uge_swap_or_not_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @uge_swap_or_not_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ule i8 %y, %notx
%cmpeq = icmp ne i8 %x, 0
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; (X != MAX) || (!X <= Y) --> true
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
define i1 @sle_or_not_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sle_or_not_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sle i8 %notx, %y
%cmpeq = icmp ne i8 %x, 127
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sle_or_not_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sle_or_not_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sle i8 %notx, %y
%cmpeq = icmp ne i8 %x, 127
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @sle_swap_or_not_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sle_swap_or_not_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sge i8 %y, %notx
%cmpeq = icmp ne i8 %x, 127
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sle_swap_or_not_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sle_swap_or_not_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sge i8 %y, %notx
%cmpeq = icmp ne i8 %x, 127
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ule_or_not_min_not_op(i427 %x, i427 %y) {
; CHECK-LABEL: @ule_or_not_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i427 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ule i427 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i427 [[X]], -1
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i427 %x, -1
%cmp = icmp ule i427 %notx, %y
%cmpeq = icmp ne i427 %x, -1
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ule_or_not_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ule_or_not_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ule i8 %notx, %y
%cmpeq = icmp ne i8 %x, 255
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ule_swap_or_not_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ule_swap_or_not_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp uge i8 %y, %notx
%cmpeq = icmp ne i8 %x, 255
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ule_swap_or_not_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ule_swap_or_not_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp uge i8 %y, %notx
%cmpeq = icmp ne i8 %x, 255
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; (X == MIN) && (!X >= Y) --> X == MIN
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
define i1 @sge_and_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sge_and_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sge i8 %notx, %y
%cmpeq = icmp eq i8 %x, 128
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sge_and_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sge_and_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sge i8 %notx, %y
%cmpeq = icmp eq i8 %x, 128
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @sge_swap_and_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sge_swap_and_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sle i8 %y, %notx
%cmpeq = icmp eq i8 %x, 128
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sge_swap_and_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sge_swap_and_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sle i8 %y, %notx
%cmpeq = icmp eq i8 %x, 128
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @uge_and_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @uge_and_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp uge i8 %notx, %y
%cmpeq = icmp eq i8 %x, 0
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @uge_and_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @uge_and_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp uge i8 %notx, %y
%cmpeq = icmp eq i8 %x, 0
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @uge_swap_and_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @uge_swap_and_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ule i8 %y, %notx
%cmpeq = icmp eq i8 %x, 0
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @uge_swap_and_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @uge_swap_and_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ule i8 %y, %notx
%cmpeq = icmp eq i8 %x, 0
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; (X == MIN) && (!X <= Y) --> X == MIN
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
define i1 @sle_and_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sle_and_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sle i8 %notx, %y
%cmpeq = icmp eq i8 %x, 128
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sle_and_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sle_and_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sle i8 %notx, %y
%cmpeq = icmp eq i8 %x, 128
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @sle_swap_and_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sle_swap_and_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sge i8 %y, %notx
%cmpeq = icmp eq i8 %x, 128
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sle_swap_and_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sle_swap_and_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sge i8 %y, %notx
%cmpeq = icmp eq i8 %x, 128
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ule_and_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ule_and_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ule i8 %notx, %y
%cmpeq = icmp eq i8 %x, 0
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ule_and_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ule_and_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ule i8 %notx, %y
%cmpeq = icmp eq i8 %x, 0
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ule_swap_and_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ule_swap_and_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp uge i8 %y, %notx
%cmpeq = icmp eq i8 %x, 0
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ule_swap_and_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ule_swap_and_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp eq i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = and i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp uge i8 %y, %notx
%cmpeq = icmp eq i8 %x, 0
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; (X == MIN) || (!X >= Y) --> !X >= Y
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
define i1 @sge_or_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sge_or_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp sge i8 %notx, %y
%cmpeq = icmp eq i8 %x, 128
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sge_or_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sge_or_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp sge i8 %notx, %y
%cmpeq = icmp eq i8 %x, 128
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @sge_swap_or_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sge_swap_or_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp sle i8 %y, %notx
%cmpeq = icmp eq i8 %x, 128
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sge_swap_or_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sge_swap_or_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp sle i8 %y, %notx
%cmpeq = icmp eq i8 %x, 128
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @uge_or_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @uge_or_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp uge i8 %notx, %y
%cmpeq = icmp eq i8 %x, 0
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @uge_or_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @uge_or_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp uge i8 %notx, %y
%cmpeq = icmp eq i8 %x, 0
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @uge_swap_or_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @uge_swap_or_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp ule i8 %y, %notx
%cmpeq = icmp eq i8 %x, 0
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @uge_swap_or_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @uge_swap_or_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp ule i8 %y, %notx
%cmpeq = icmp eq i8 %x, 0
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; (X == MAX) || (!X <= Y) --> !X <= Y
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
define i1 @sle_or_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sle_or_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp sle i8 %notx, %y
%cmpeq = icmp eq i8 %x, 127
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sle_or_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sle_or_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sle i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp sle i8 %notx, %y
%cmpeq = icmp eq i8 %x, 127
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @sle_swap_or_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sle_swap_or_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp sge i8 %y, %notx
%cmpeq = icmp eq i8 %x, 127
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sle_swap_or_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sle_swap_or_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp sge i8 %y, %notx
%cmpeq = icmp eq i8 %x, 127
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ule_or_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ule_or_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp ule i8 %notx, %y
%cmpeq = icmp eq i8 %x, 255
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ule_or_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ule_or_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp ule i8 %notx, %y
%cmpeq = icmp eq i8 %x, 255
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ule_swap_or_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ule_swap_or_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp uge i8 %y, %notx
%cmpeq = icmp eq i8 %x, 255
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ule_swap_or_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ule_swap_or_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp uge i8 %y, %notx
%cmpeq = icmp eq i8 %x, 255
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; (X != MIN) && (!X < Y) --> !X < Y
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
define i1 @slt_and_not_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @slt_and_not_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp slt i8 %notx, %y
%cmpeq = icmp ne i8 %x, 128
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @slt_and_not_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @slt_and_not_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp slt i8 %notx, %y
%cmpeq = icmp ne i8 %x, 128
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @slt_swap_and_not_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @slt_swap_and_not_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp sgt i8 %y, %notx
%cmpeq = icmp ne i8 %x, 128
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @slt_swap_and_not_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @slt_swap_and_not_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp sgt i8 %y, %notx
%cmpeq = icmp ne i8 %x, 128
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ult_and_not_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ult_and_not_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp ult i8 %notx, %y
%cmpeq = icmp ne i8 %x, 0
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ult_and_not_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ult_and_not_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp ult i8 %notx, %y
%cmpeq = icmp ne i8 %x, 0
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ult_swap_and_not_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ult_swap_and_not_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp ugt i8 %y, %notx
%cmpeq = icmp ne i8 %x, 0
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ult_swap_and_not_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ult_swap_and_not_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp ugt i8 %y, %notx
%cmpeq = icmp ne i8 %x, 0
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; (X != MAX) && (!X > Y) --> !X > Y
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
define i1 @sgt_and_not_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sgt_and_not_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp sgt i8 %notx, %y
%cmpeq = icmp ne i8 %x, 127
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sgt_and_not_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sgt_and_not_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp sgt i8 %notx, %y
%cmpeq = icmp ne i8 %x, 127
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @sgt_swap_and_not_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sgt_swap_and_not_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp slt i8 %y, %notx
%cmpeq = icmp ne i8 %x, 127
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sgt_swap_and_not_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sgt_swap_and_not_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp slt i8 %y, %notx
%cmpeq = icmp ne i8 %x, 127
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ugt_and_not_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ugt_and_not_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp ugt i8 %notx, %y
%cmpeq = icmp ne i8 %x, 255
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ugt_and_not_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ugt_and_not_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp ugt i8 %notx, %y
%cmpeq = icmp ne i8 %x, 255
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ugt_swap_and_not_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ugt_swap_and_not_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp ult i8 %y, %notx
%cmpeq = icmp ne i8 %x, 255
%r = and i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ugt_swap_and_not_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ugt_swap_and_not_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%notx = xor i8 %x, -1
%cmp = icmp ult i8 %y, %notx
%cmpeq = icmp ne i8 %x, 255
%r = and i1 %cmpeq, %cmp
ret i1 %r
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; (X != MIN) || (!X < Y) --> X != MIN
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
define i1 @slt_or_not_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @slt_or_not_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp slt i8 %notx, %y
%cmpeq = icmp ne i8 %x, 128
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @slt_or_not_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @slt_or_not_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp slt i8 %notx, %y
%cmpeq = icmp ne i8 %x, 128
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @slt_swap_or_not_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @slt_swap_or_not_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sgt i8 %y, %notx
%cmpeq = icmp ne i8 %x, 128
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @slt_swap_or_not_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @slt_swap_or_not_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -128
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sgt i8 %y, %notx
%cmpeq = icmp ne i8 %x, 128
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ult_or_not_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ult_or_not_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ult i8 %notx, %y
%cmpeq = icmp ne i8 %x, 0
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ult_or_not_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ult_or_not_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ult i8 %notx, %y
%cmpeq = icmp ne i8 %x, 0
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ult_swap_or_not_max_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ult_swap_or_not_max_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ugt i8 %y, %notx
%cmpeq = icmp ne i8 %x, 0
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ult_swap_or_not_max_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ult_swap_or_not_max_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 0
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ugt i8 %y, %notx
%cmpeq = icmp ne i8 %x, 0
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; (X != MAX) || (!X > Y) --> X != MAX
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
define i1 @sgt_or_not_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sgt_or_not_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sgt i8 %notx, %y
%cmpeq = icmp ne i8 %x, 127
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sgt_or_not_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sgt_or_not_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp sgt i8 %notx, %y
%cmpeq = icmp ne i8 %x, 127
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @sgt_swap_or_not_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sgt_swap_or_not_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp slt i8 %y, %notx
%cmpeq = icmp ne i8 %x, 127
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @sgt_swap_or_not_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @sgt_swap_or_not_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], 127
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp slt i8 %y, %notx
%cmpeq = icmp ne i8 %x, 127
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ugt_or_not_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ugt_or_not_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ugt i8 %notx, %y
%cmpeq = icmp ne i8 %x, 255
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ugt_or_not_min_commute_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ugt_or_not_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[NOTX]], [[Y:%.*]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ugt i8 %notx, %y
%cmpeq = icmp ne i8 %x, 255
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
define i1 @ugt_swap_or_not_min_not_op(i8 %x, i8 %y) {
; CHECK-LABEL: @ugt_swap_or_not_min_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i8 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i8 [[X]], -1
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMP]], [[CMPEQ]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i8 %x, -1
%cmp = icmp ult i8 %y, %notx
%cmpeq = icmp ne i8 %x, 255
%r = or i1 %cmp, %cmpeq
ret i1 %r
}
define i1 @ugt_swap_or_not_min_commute_not_op(i823 %x, i823 %y) {
; CHECK-LABEL: @ugt_swap_or_not_min_commute_not_op(
; CHECK-NEXT: [[NOTX:%.*]] = xor i823 [[X:%.*]], -1
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i823 [[Y:%.*]], [[NOTX]]
; CHECK-NEXT: [[CMPEQ:%.*]] = icmp ne i823 [[X]], 255
; CHECK-NEXT: [[R:%.*]] = or i1 [[CMPEQ]], [[CMP]]
; CHECK-NEXT: ret i1 [[R]]
;
%notx = xor i823 %x, -1
%cmp = icmp ult i823 %y, %notx
%cmpeq = icmp ne i823 %x, 255
%r = or i1 %cmpeq, %cmp
ret i1 %r
}
Reference in New Issue View Git Blame Copy Permalink