shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
llvm-project/llvm/test/Transforms/InstCombine/sub-minmax.ll
Nikita Popov a105877646
[InstCombine] Remove some of the complexity-based canonicalization (#91185) 
The idea behind this canonicalization is that it allows us to handle less
patterns, because we know that some will be canonicalized away. This is
indeed very useful to e.g. know that constants are always on the right.

However, this is only useful if the canonicalization is actually
reliable. This is the case for constants, but not for arguments: Moving
these to the right makes it look like the "more complex" expression is
guaranteed to be on the left, but this is not actually the case in
practice. It fails as soon as you replace the argument with another
instruction.

The end result is that it looks like things correctly work in tests,
while they actually don't. We use the "thwart complexity-based
canonicalization" trick to handle this in tests, but it's often a
challenge for new contributors to get this right, and based on the
regressions this PR originally exposed, we clearly don't get this right
in many cases.

For this reason, I think that it's better to remove this complexity
canonicalization. It will make it much easier to write tests for
commuted cases and make sure that they are handled.
2024-08-21 12:02:54 +02:00

1147 lines
38 KiB
LLVM
Raw Permalink Blame History

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
; RUN: opt < %s -passes=instcombine -S | FileCheck %s
declare i5 @llvm.umin.i5(i5, i5)
declare <2 x i8> @llvm.smin.v2i8(<2 x i8>, <2 x i8>)
declare <2 x i8> @llvm.smax.v2i8(<2 x i8>, <2 x i8>)
declare <2 x i8> @llvm.umin.v2i8(<2 x i8>, <2 x i8>)
declare <2 x i8> @llvm.umax.v2i8(<2 x i8>, <2 x i8>)
declare i8 @llvm.smax.i8(i8, i8)
declare i8 @llvm.smin.i8(i8, i8)
declare i8 @llvm.umax.i8(i8, i8)
declare i8 @llvm.umin.i8(i8, i8)
define i32 @max_na_b_minux_na(i32 %A, i32 %B) {
; CHECK-LABEL: define {{[^@]+}}@max_na_b_minux_na
; CHECK-SAME: (i32 [[A:%.*]], i32 [[B:%.*]]) {
; CHECK-NEXT: [[NOT:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.usub.sat.i32(i32 [[NOT]], i32 [[B]])
; CHECK-NEXT: [[X:%.*]] = sub i32 0, [[TMP1]]
; CHECK-NEXT: ret i32 [[X]]
;
%not = xor i32 %A, -1
%l0 = icmp ult i32 %not, %B
%l1 = select i1 %l0, i32 %not, i32 %B
%x = sub i32 %l1, %not
ret i32 %x
}
define i32 @na_minus_max_na_b(i32 %A, i32 %B) {
; CHECK-LABEL: define {{[^@]+}}@na_minus_max_na_b
; CHECK-SAME: (i32 [[A:%.*]], i32 [[B:%.*]]) {
; CHECK-NEXT: [[NOT:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[X:%.*]] = call i32 @llvm.usub.sat.i32(i32 [[NOT]], i32 [[B]])
; CHECK-NEXT: ret i32 [[X]]
;
%not = xor i32 %A, -1
%l0 = icmp ult i32 %not, %B
%l1 = select i1 %l0, i32 %not, i32 %B
%x = sub i32 %not, %l1
ret i32 %x
}
define i5 @sub_umin(i5 %a, i5 %b) {
; CHECK-LABEL: define {{[^@]+}}@sub_umin
; CHECK-SAME: (i5 [[A:%.*]], i5 [[B:%.*]]) {
; CHECK-NEXT: [[R:%.*]] = call i5 @llvm.usub.sat.i5(i5 [[A]], i5 [[B]])
; CHECK-NEXT: ret i5 [[R]]
;
%umin = call i5 @llvm.umin.i5(i5 %a, i5 %b)
%r = sub i5 %a, %umin
ret i5 %r
}
define <2 x i8> @sub_umin_commute_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: define {{[^@]+}}@sub_umin_commute_vec
; CHECK-SAME: (<2 x i8> [[A:%.*]], <2 x i8> [[B:%.*]]) {
; CHECK-NEXT: [[R:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[B]], <2 x i8> [[A]])
; CHECK-NEXT: ret <2 x i8> [[R]]
;
%umin = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %b, <2 x i8> %a)
%r = sub <2 x i8> %b, %umin
ret <2 x i8> %r
}
define i5 @sub_umin_uses(i5 %a, i5 %b, ptr %p) {
; CHECK-LABEL: define {{[^@]+}}@sub_umin_uses
; CHECK-SAME: (i5 [[A:%.*]], i5 [[B:%.*]], ptr [[P:%.*]]) {
; CHECK-NEXT: [[UMIN:%.*]] = call i5 @llvm.umin.i5(i5 [[A]], i5 [[B]])
; CHECK-NEXT: store i5 [[UMIN]], ptr [[P]], align 1
; CHECK-NEXT: [[R:%.*]] = sub i5 [[A]], [[UMIN]]
; CHECK-NEXT: ret i5 [[R]]
;
%umin = call i5 @llvm.umin.i5(i5 %a, i5 %b)
store i5 %umin, ptr %p
%r = sub i5 %a, %umin
ret i5 %r
}
define i5 @sub_umin_no_common_op(i5 %a, i5 %b, i5 %c) {
; CHECK-LABEL: define {{[^@]+}}@sub_umin_no_common_op
; CHECK-SAME: (i5 [[A:%.*]], i5 [[B:%.*]], i5 [[C:%.*]]) {
; CHECK-NEXT: [[UMIN:%.*]] = call i5 @llvm.umin.i5(i5 [[A]], i5 [[B]])
; CHECK-NEXT: [[R:%.*]] = sub i5 [[C]], [[UMIN]]
; CHECK-NEXT: ret i5 [[R]]
;
%umin = call i5 @llvm.umin.i5(i5 %a, i5 %b)
%r = sub i5 %c, %umin
ret i5 %r
}
define i32 @max_b_na_minus_na(i32 %A, i32 %B) {
; CHECK-LABEL: define {{[^@]+}}@max_b_na_minus_na
; CHECK-SAME: (i32 [[A:%.*]], i32 [[B:%.*]]) {
; CHECK-NEXT: [[NOT:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.usub.sat.i32(i32 [[NOT]], i32 [[B]])
; CHECK-NEXT: [[X:%.*]] = sub i32 0, [[TMP1]]
; CHECK-NEXT: ret i32 [[X]]
;
%not = xor i32 %A, -1
%l0 = icmp ugt i32 %not, %B
%l1 = select i1 %l0, i32 %B, i32 %not
%x = sub i32 %l1, %not
ret i32 %x
}
define i32 @na_minus_max_b_na(i32 %A, i32 %B) {
; CHECK-LABEL: define {{[^@]+}}@na_minus_max_b_na
; CHECK-SAME: (i32 [[A:%.*]], i32 [[B:%.*]]) {
; CHECK-NEXT: [[NOT:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[X:%.*]] = call i32 @llvm.usub.sat.i32(i32 [[NOT]], i32 [[B]])
; CHECK-NEXT: ret i32 [[X]]
;
%not = xor i32 %A, -1
%l0 = icmp ugt i32 %not, %B
%l1 = select i1 %l0, i32 %B, i32 %not
%x = sub i32 %not, %l1
ret i32 %x
}
define i32 @max_na_bi_minux_na(i32 %A, i32 %Bi) {
; CHECK-LABEL: define {{[^@]+}}@max_na_bi_minux_na
; CHECK-SAME: (i32 [[A:%.*]], i32 [[BI:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.usub.sat.i32(i32 [[BI]], i32 [[A]])
; CHECK-NEXT: [[X:%.*]] = sub i32 0, [[TMP1]]
; CHECK-NEXT: ret i32 [[X]]
;
%B = xor i32 %Bi, -1
%not = xor i32 %A, -1
%l0 = icmp ult i32 %not, %B
%l1 = select i1 %l0, i32 %not, i32 %B
%x = sub i32 %l1, %not
ret i32 %x
}
define i32 @na_minus_max_na_bi(i32 %A, i32 %Bi) {
; CHECK-LABEL: define {{[^@]+}}@na_minus_max_na_bi
; CHECK-SAME: (i32 [[A:%.*]], i32 [[BI:%.*]]) {
; CHECK-NEXT: [[X:%.*]] = call i32 @llvm.usub.sat.i32(i32 [[BI]], i32 [[A]])
; CHECK-NEXT: ret i32 [[X]]
;
%B = xor i32 %Bi, -1
%not = xor i32 %A, -1
%l0 = icmp ult i32 %not, %B
%l1 = select i1 %l0, i32 %not, i32 %B
%x = sub i32 %not, %l1
ret i32 %x
}
define i32 @max_bi_na_minus_na(i32 %A, i32 %Bi) {
; CHECK-LABEL: define {{[^@]+}}@max_bi_na_minus_na
; CHECK-SAME: (i32 [[A:%.*]], i32 [[BI:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.usub.sat.i32(i32 [[BI]], i32 [[A]])
; CHECK-NEXT: [[X:%.*]] = sub i32 0, [[TMP1]]
; CHECK-NEXT: ret i32 [[X]]
;
%B = xor i32 %Bi, -1
%not = xor i32 %A, -1
%l0 = icmp ugt i32 %not, %B
%l1 = select i1 %l0, i32 %B, i32 %not
%x = sub i32 %l1, %not
ret i32 %x
}
define i32 @na_minus_max_bi_na(i32 %A, i32 %Bi) {
; CHECK-LABEL: define {{[^@]+}}@na_minus_max_bi_na
; CHECK-SAME: (i32 [[A:%.*]], i32 [[BI:%.*]]) {
; CHECK-NEXT: [[X:%.*]] = call i32 @llvm.usub.sat.i32(i32 [[BI]], i32 [[A]])
; CHECK-NEXT: ret i32 [[X]]
;
%B = xor i32 %Bi, -1
%not = xor i32 %A, -1
%l0 = icmp ugt i32 %not, %B
%l1 = select i1 %l0, i32 %B, i32 %not
%x = sub i32 %not, %l1
ret i32 %x
}
define i32 @max_na_bi_minux_na_use(i32 %A, i32 %Bi) {
; CHECK-LABEL: define {{[^@]+}}@max_na_bi_minux_na_use
; CHECK-SAME: (i32 [[A:%.*]], i32 [[BI:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.umax.i32(i32 [[A]], i32 -32)
; CHECK-NEXT: [[L1:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[X:%.*]] = sub i32 [[A]], [[TMP1]]
; CHECK-NEXT: call void @use32(i32 [[L1]])
; CHECK-NEXT: ret i32 [[X]]
;
%not = xor i32 %A, -1
%l0 = icmp ult i32 %not, 31
%l1 = select i1 %l0, i32 %not, i32 31
%x = sub i32 %l1, %not
call void @use32(i32 %l1)
ret i32 %x
}
define i32 @na_minus_max_na_bi_use(i32 %A, i32 %Bi) {
; CHECK-LABEL: define {{[^@]+}}@na_minus_max_na_bi_use
; CHECK-SAME: (i32 [[A:%.*]], i32 [[BI:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.umax.i32(i32 [[A]], i32 -32)
; CHECK-NEXT: [[L1:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[X:%.*]] = sub i32 [[TMP1]], [[A]]
; CHECK-NEXT: call void @use32(i32 [[L1]])
; CHECK-NEXT: ret i32 [[X]]
;
%not = xor i32 %A, -1
%l0 = icmp ult i32 %not, 31
%l1 = select i1 %l0, i32 %not, i32 31
%x = sub i32 %not, %l1
call void @use32(i32 %l1)
ret i32 %x
}
define i32 @max_bi_na_minus_na_use(i32 %A, i32 %Bi) {
; CHECK-LABEL: define {{[^@]+}}@max_bi_na_minus_na_use
; CHECK-SAME: (i32 [[A:%.*]], i32 [[BI:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.umax.i32(i32 [[BI]], i32 [[A]])
; CHECK-NEXT: [[L1:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[X:%.*]] = sub i32 [[A]], [[TMP1]]
; CHECK-NEXT: call void @use32(i32 [[L1]])
; CHECK-NEXT: ret i32 [[X]]
;
%not = xor i32 %A, -1
%B = xor i32 %Bi, -1
%l0 = icmp ult i32 %B, %not
%l1 = select i1 %l0, i32 %B, i32 %not
%x = sub i32 %l1, %not
call void @use32(i32 %l1)
ret i32 %x
}
define i32 @na_minus_max_bi_na_use(i32 %A, i32 %Bi) {
; CHECK-LABEL: define {{[^@]+}}@na_minus_max_bi_na_use
; CHECK-SAME: (i32 [[A:%.*]], i32 [[BI:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.umax.i32(i32 [[BI]], i32 [[A]])
; CHECK-NEXT: [[L1:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[X:%.*]] = sub i32 [[TMP1]], [[A]]
; CHECK-NEXT: call void @use32(i32 [[L1]])
; CHECK-NEXT: ret i32 [[X]]
;
%not = xor i32 %A, -1
%B = xor i32 %Bi, -1
%l0 = icmp ult i32 %B, %not
%l1 = select i1 %l0, i32 %B, i32 %not
%x = sub i32 %not, %l1
call void @use32(i32 %l1)
ret i32 %x
}
define i32 @max_na_bi_minux_na_use2(i32 %A, i32 %Bi) {
; CHECK-LABEL: define {{[^@]+}}@max_na_bi_minux_na_use2
; CHECK-SAME: (i32 [[A:%.*]], i32 [[BI:%.*]]) {
; CHECK-NEXT: [[NOT:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[L1:%.*]] = call i32 @llvm.umin.i32(i32 [[NOT]], i32 31)
; CHECK-NEXT: [[X:%.*]] = sub i32 [[L1]], [[NOT]]
; CHECK-NEXT: call void @use32(i32 [[L1]])
; CHECK-NEXT: call void @use32(i32 [[NOT]])
; CHECK-NEXT: ret i32 [[X]]
;
%not = xor i32 %A, -1
%l0 = icmp ult i32 %not, 31
%l1 = select i1 %l0, i32 %not, i32 31
%x = sub i32 %l1, %not
call void @use32(i32 %l1)
call void @use32(i32 %not)
ret i32 %x
}
define i32 @na_minus_max_na_bi_use2(i32 %A, i32 %Bi) {
; CHECK-LABEL: define {{[^@]+}}@na_minus_max_na_bi_use2
; CHECK-SAME: (i32 [[A:%.*]], i32 [[BI:%.*]]) {
; CHECK-NEXT: [[NOT:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[L1:%.*]] = call i32 @llvm.umin.i32(i32 [[NOT]], i32 31)
; CHECK-NEXT: [[X:%.*]] = sub i32 [[NOT]], [[L1]]
; CHECK-NEXT: call void @use32(i32 [[L1]])
; CHECK-NEXT: call void @use32(i32 [[NOT]])
; CHECK-NEXT: ret i32 [[X]]
;
%not = xor i32 %A, -1
%l0 = icmp ult i32 %not, 31
%l1 = select i1 %l0, i32 %not, i32 31
%x = sub i32 %not, %l1
call void @use32(i32 %l1)
call void @use32(i32 %not)
ret i32 %x
}
define i32 @max_bi_na_minus_na_use2(i32 %A, i32 %Bi) {
; CHECK-LABEL: define {{[^@]+}}@max_bi_na_minus_na_use2
; CHECK-SAME: (i32 [[A:%.*]], i32 [[BI:%.*]]) {
; CHECK-NEXT: [[NOT:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.umax.i32(i32 [[BI]], i32 [[A]])
; CHECK-NEXT: [[L1:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[X:%.*]] = sub i32 [[A]], [[TMP1]]
; CHECK-NEXT: call void @use32(i32 [[L1]])
; CHECK-NEXT: call void @use32(i32 [[NOT]])
; CHECK-NEXT: ret i32 [[X]]
;
%not = xor i32 %A, -1
%B = xor i32 %Bi, -1
%l0 = icmp ult i32 %B, %not
%l1 = select i1 %l0, i32 %B, i32 %not
%x = sub i32 %l1, %not
call void @use32(i32 %l1)
call void @use32(i32 %not)
ret i32 %x
}
define i32 @na_minus_max_bi_na_use2(i32 %A, i32 %Bi) {
; CHECK-LABEL: define {{[^@]+}}@na_minus_max_bi_na_use2
; CHECK-SAME: (i32 [[A:%.*]], i32 [[BI:%.*]]) {
; CHECK-NEXT: [[NOT:%.*]] = xor i32 [[A]], -1
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.umax.i32(i32 [[BI]], i32 [[A]])
; CHECK-NEXT: [[L1:%.*]] = xor i32 [[TMP1]], -1
; CHECK-NEXT: [[X:%.*]] = sub i32 [[TMP1]], [[A]]
; CHECK-NEXT: call void @use32(i32 [[L1]])
; CHECK-NEXT: call void @use32(i32 [[NOT]])
; CHECK-NEXT: ret i32 [[X]]
;
%not = xor i32 %A, -1
%B = xor i32 %Bi, -1
%l0 = icmp ult i32 %B, %not
%l1 = select i1 %l0, i32 %B, i32 %not
%x = sub i32 %not, %l1
call void @use32(i32 %l1)
call void @use32(i32 %not)
ret i32 %x
}
define i8 @umin_not_sub(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umin_not_sub
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: [[MINXY:%.*]] = xor i8 [[TMP1]], -1
; CHECK-NEXT: [[SUBX:%.*]] = sub i8 [[TMP1]], [[X]]
; CHECK-NEXT: [[SUBY:%.*]] = sub i8 [[TMP1]], [[Y]]
; CHECK-NEXT: call void @use8(i8 [[SUBX]])
; CHECK-NEXT: call void @use8(i8 [[SUBY]])
; CHECK-NEXT: ret i8 [[MINXY]]
;
%nx = xor i8 %x, -1
%ny = xor i8 %y, -1
%cmpxy = icmp ult i8 %nx, %ny
%minxy = select i1 %cmpxy, i8 %nx, i8 %ny
%subx = sub i8 %nx, %minxy
%suby = sub i8 %ny, %minxy
call void @use8(i8 %subx)
call void @use8(i8 %suby)
ret i8 %minxy
}
define i8 @umin_not_sub_rev(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umin_not_sub_rev
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: [[MINXY:%.*]] = xor i8 [[TMP1]], -1
; CHECK-NEXT: [[SUBX:%.*]] = sub i8 [[X]], [[TMP1]]
; CHECK-NEXT: [[SUBY:%.*]] = sub i8 [[Y]], [[TMP1]]
; CHECK-NEXT: call void @use8(i8 [[SUBX]])
; CHECK-NEXT: call void @use8(i8 [[SUBY]])
; CHECK-NEXT: ret i8 [[MINXY]]
;
%nx = xor i8 %x, -1
%ny = xor i8 %y, -1
%cmpxy = icmp ult i8 %nx, %ny
%minxy = select i1 %cmpxy, i8 %nx, i8 %ny
%subx = sub i8 %minxy, %nx
%suby = sub i8 %minxy, %ny
call void @use8(i8 %subx)
call void @use8(i8 %suby)
ret i8 %minxy
}
define void @umin3_not_all_ops_extra_uses_invert_subs(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: define {{[^@]+}}@umin3_not_all_ops_extra_uses_invert_subs
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]], i8 [[Z:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Z]])
; CHECK-NEXT: [[TMP2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[TMP1]])
; CHECK-NEXT: [[MINXYZ:%.*]] = xor i8 [[TMP2]], -1
; CHECK-NEXT: [[XMIN:%.*]] = sub i8 [[TMP2]], [[X]]
; CHECK-NEXT: [[YMIN:%.*]] = sub i8 [[TMP2]], [[Y]]
; CHECK-NEXT: [[ZMIN:%.*]] = sub i8 [[TMP2]], [[Z]]
; CHECK-NEXT: call void @use8(i8 [[MINXYZ]])
; CHECK-NEXT: call void @use8(i8 [[XMIN]])
; CHECK-NEXT: call void @use8(i8 [[YMIN]])
; CHECK-NEXT: call void @use8(i8 [[ZMIN]])
; CHECK-NEXT: ret void
;
%xn = xor i8 %x, -1
%yn = xor i8 %y, -1
%zn = xor i8 %z, -1
%cmpxz = icmp ult i8 %xn, %zn
%minxz = select i1 %cmpxz, i8 %xn, i8 %zn
%cmpxyz = icmp ult i8 %minxz, %yn
%minxyz = select i1 %cmpxyz, i8 %minxz, i8 %yn
%xmin = sub i8 %xn, %minxyz
%ymin = sub i8 %yn, %minxyz
%zmin = sub i8 %zn, %minxyz
call void @use8(i8 %minxyz)
call void @use8(i8 %xmin)
call void @use8(i8 %ymin)
call void @use8(i8 %zmin)
ret void
}
; Handle this pattern with extra uses because it shows up in benchmarks.
; ~X - Min/Max(~X, Y) -> ~Min/Max(X, ~Y) - X
; ~X - Min/Max(Y, ~X) -> ~Min/Max(X, ~Y) - X
; Min/Max(~X, Y) - ~X -> X - ~Min/Max(X, ~Y)
; Min/Max(Y, ~X) - ~X -> X - ~Min/Max(X, ~Y)
define i8 @umin_not_sub_intrinsic_commute0(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umin_not_sub_intrinsic_commute0
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[NY:%.*]] = xor i8 [[Y]], -1
; CHECK-NEXT: call void @use8(i8 [[NY]])
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: [[M:%.*]] = xor i8 [[TMP1]], -1
; CHECK-NEXT: call void @use8(i8 [[M]])
; CHECK-NEXT: [[SUBX:%.*]] = sub i8 [[TMP1]], [[X]]
; CHECK-NEXT: ret i8 [[SUBX]]
;
%nx = xor i8 %x, -1
%ny = xor i8 %y, -1
call void @use8(i8 %ny)
%m = call i8 @llvm.umin.i8(i8 %nx, i8 %ny)
call void @use8(i8 %m)
%subx = sub i8 %nx, %m
ret i8 %subx
}
define i8 @umax_not_sub_intrinsic_commute1(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umax_not_sub_intrinsic_commute1
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[NY:%.*]] = xor i8 [[Y]], -1
; CHECK-NEXT: call void @use8(i8 [[NY]])
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.umin.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: [[M:%.*]] = xor i8 [[TMP1]], -1
; CHECK-NEXT: call void @use8(i8 [[M]])
; CHECK-NEXT: [[SUBX:%.*]] = sub i8 [[TMP1]], [[X]]
; CHECK-NEXT: ret i8 [[SUBX]]
;
%nx = xor i8 %x, -1
%ny = xor i8 %y, -1
call void @use8(i8 %ny)
%m = call i8 @llvm.umax.i8(i8 %ny, i8 %nx)
call void @use8(i8 %m)
%subx = sub i8 %nx, %m
ret i8 %subx
}
define i8 @smin_not_sub_intrinsic_commute2(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@smin_not_sub_intrinsic_commute2
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[NY:%.*]] = xor i8 [[Y]], -1
; CHECK-NEXT: call void @use8(i8 [[NY]])
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.smax.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: [[M:%.*]] = xor i8 [[TMP1]], -1
; CHECK-NEXT: call void @use8(i8 [[M]])
; CHECK-NEXT: [[SUBX:%.*]] = sub i8 [[X]], [[TMP1]]
; CHECK-NEXT: ret i8 [[SUBX]]
;
%nx = xor i8 %x, -1
%ny = xor i8 %y, -1
call void @use8(i8 %ny)
%m = call i8 @llvm.smin.i8(i8 %nx, i8 %ny)
call void @use8(i8 %m)
%subx = sub i8 %m, %nx
ret i8 %subx
}
define i8 @smax_not_sub_intrinsic_commute3(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@smax_not_sub_intrinsic_commute3
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[NY:%.*]] = xor i8 [[Y]], -1
; CHECK-NEXT: call void @use8(i8 [[NY]])
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.smin.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: [[M:%.*]] = xor i8 [[TMP1]], -1
; CHECK-NEXT: call void @use8(i8 [[M]])
; CHECK-NEXT: [[SUBX:%.*]] = sub i8 [[X]], [[TMP1]]
; CHECK-NEXT: ret i8 [[SUBX]]
;
%nx = xor i8 %x, -1
%ny = xor i8 %y, -1
call void @use8(i8 %ny)
%m = call i8 @llvm.smax.i8(i8 %ny, i8 %nx)
call void @use8(i8 %m)
%subx = sub i8 %m, %nx
ret i8 %subx
}
; negative test - don't increase instruction count
define i8 @umin_not_sub_intrinsic_uses(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umin_not_sub_intrinsic_uses
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[NX:%.*]] = xor i8 [[X]], -1
; CHECK-NEXT: call void @use8(i8 [[NX]])
; CHECK-NEXT: [[NY:%.*]] = xor i8 [[Y]], -1
; CHECK-NEXT: call void @use8(i8 [[NY]])
; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[NX]], i8 [[NY]])
; CHECK-NEXT: call void @use8(i8 [[M]])
; CHECK-NEXT: [[SUBX:%.*]] = sub i8 [[NX]], [[M]]
; CHECK-NEXT: ret i8 [[SUBX]]
;
%nx = xor i8 %x, -1
call void @use8(i8 %nx)
%ny = xor i8 %y, -1
call void @use8(i8 %ny)
%m = call i8 @llvm.umin.i8(i8 %nx, i8 %ny)
call void @use8(i8 %m)
%subx = sub i8 %nx, %m
ret i8 %subx
}
define i8 @umax_sub_op0(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umax_sub_op0
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: ret i8 [[R]]
;
%u = call i8 @llvm.umax.i8(i8 %y, i8 %x)
%r = sub i8 %u, %y
ret i8 %r
}
define <2 x i8> @umax_sub_op0_vec_commute(<2 x i8> %x, <2 x i8> %y) {
; CHECK-LABEL: define {{[^@]+}}@umax_sub_op0_vec_commute
; CHECK-SAME: (<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]]) {
; CHECK-NEXT: [[R:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[X]], <2 x i8> [[Y]])
; CHECK-NEXT: ret <2 x i8> [[R]]
;
%u = call <2 x i8> @llvm.umax.v2i8(<2 x i8> %x, <2 x i8> %y)
%r = sub <2 x i8> %u, %y
ret <2 x i8> %r
}
define i8 @umax_sub_op0_use(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umax_sub_op0_use
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[U:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: call void @use8(i8 [[U]])
; CHECK-NEXT: [[R:%.*]] = sub i8 [[U]], [[Y]]
; CHECK-NEXT: ret i8 [[R]]
;
%u = call i8 @llvm.umax.i8(i8 %x, i8 %y)
call void @use8(i8 %u)
%r = sub i8 %u, %y
ret i8 %r
}
define i8 @umax_sub_op1(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umax_sub_op1
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: [[R:%.*]] = sub i8 0, [[TMP1]]
; CHECK-NEXT: ret i8 [[R]]
;
%u = call i8 @llvm.umax.i8(i8 %x, i8 %y)
%r = sub i8 %y, %u
ret i8 %r
}
define <2 x i8> @umax_sub_op1_vec_commute(<2 x i8> %x, <2 x i8> %y) {
; CHECK-LABEL: define {{[^@]+}}@umax_sub_op1_vec_commute
; CHECK-SAME: (<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[X]], <2 x i8> [[Y]])
; CHECK-NEXT: [[R:%.*]] = sub <2 x i8> zeroinitializer, [[TMP1]]
; CHECK-NEXT: ret <2 x i8> [[R]]
;
%u = call <2 x i8> @llvm.umax.v2i8(<2 x i8> %y, <2 x i8> %x)
%r = sub <2 x i8> %y, %u
ret <2 x i8> %r
}
define i8 @umax_sub_op1_use(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umax_sub_op1_use
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[U:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: call void @use8(i8 [[U]])
; CHECK-NEXT: [[R:%.*]] = sub i8 [[Y]], [[U]]
; CHECK-NEXT: ret i8 [[R]]
;
%u = call i8 @llvm.umax.i8(i8 %x, i8 %y)
call void @use8(i8 %u)
%r = sub i8 %y, %u
ret i8 %r
}
define i8 @umin_sub_op1(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umin_sub_op1
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[Y]], i8 [[X]])
; CHECK-NEXT: ret i8 [[R]]
;
%u = call i8 @llvm.umin.i8(i8 %y, i8 %x)
%r = sub i8 %y, %u
ret i8 %r
}
define i8 @umin_sub_op1_commute(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umin_sub_op1_commute
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[Y]], i8 [[X]])
; CHECK-NEXT: ret i8 [[R]]
;
%u = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%r = sub i8 %y, %u
ret i8 %r
}
define i8 @umin_sub_op0(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umin_sub_op0
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[Y]], i8 [[X]])
; CHECK-NEXT: [[R:%.*]] = sub i8 0, [[TMP1]]
; CHECK-NEXT: ret i8 [[R]]
;
%u = call i8 @llvm.umin.i8(i8 %y, i8 %x)
%r = sub i8 %u, %y
ret i8 %r
}
define i8 @umin_sub_op0_commute(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umin_sub_op0_commute
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[Y]], i8 [[X]])
; CHECK-NEXT: [[R:%.*]] = sub i8 0, [[TMP1]]
; CHECK-NEXT: ret i8 [[R]]
;
%u = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%r = sub i8 %u, %y
ret i8 %r
}
define i8 @umin_sub_op1_use(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umin_sub_op1_use
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[U:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
; CHECK-NEXT: call void @use8(i8 [[U]])
; CHECK-NEXT: [[R:%.*]] = sub i8 [[Y]], [[U]]
; CHECK-NEXT: ret i8 [[R]]
;
%u = call i8 @llvm.umin.i8(i8 %y, i8 %x)
call void @use8(i8 %u)
%r = sub i8 %y, %u
ret i8 %r
}
define i8 @umin_sub_op0_use(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@umin_sub_op0_use
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[U:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
; CHECK-NEXT: call void @use8(i8 [[U]])
; CHECK-NEXT: [[R:%.*]] = sub i8 [[U]], [[Y]]
; CHECK-NEXT: ret i8 [[R]]
;
%u = call i8 @llvm.umin.i8(i8 %y, i8 %x)
call void @use8(i8 %u)
%r = sub i8 %u, %y
ret i8 %r
}
;
; sub(add(X,Y), s/umin(X,Y)) --> s/umax(X,Y)
; sub(add(X,Y), s/umax(X,Y)) --> s/umin(X,Y)
;
define i8 @diff_add_smin(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@diff_add_smin
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[S:%.*]] = call i8 @llvm.smax.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: ret i8 [[S]]
;
%a = add i8 %x, %y
%m = call i8 @llvm.smin.i8(i8 %x, i8 %y)
%s = sub i8 %a, %m
ret i8 %s
}
define i8 @diff_add_smax(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@diff_add_smax
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[S:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]])
; CHECK-NEXT: ret i8 [[S]]
;
%a = add i8 %x, %y
%m = call i8 @llvm.smax.i8(i8 %y, i8 %x)
%s = sub i8 %a, %m
ret i8 %s
}
define i8 @diff_add_umin(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@diff_add_umin
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[S:%.*]] = call i8 @llvm.umax.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: ret i8 [[S]]
;
%a = add i8 %x, %y
%m = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%s = sub i8 %a, %m
ret i8 %s
}
define i8 @diff_add_umax(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@diff_add_umax
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[S:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]])
; CHECK-NEXT: ret i8 [[S]]
;
%a = add i8 %x, %y
%m = call i8 @llvm.umax.i8(i8 %y, i8 %x)
%s = sub i8 %a, %m
ret i8 %s
}
define i8 @diff_add_smin_use(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@diff_add_smin_use
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: [[S:%.*]] = call i8 @llvm.smax.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: call void @use8(i8 [[M]])
; CHECK-NEXT: ret i8 [[S]]
;
%a = add i8 %x, %y
%m = call i8 @llvm.smin.i8(i8 %x, i8 %y)
%s = sub i8 %a, %m
call void @use8(i8 %m)
ret i8 %s
}
define i8 @diff_add_use_smax(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@diff_add_use_smax
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[A:%.*]] = add i8 [[X]], [[Y]]
; CHECK-NEXT: [[S:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]])
; CHECK-NEXT: call void @use8(i8 [[A]])
; CHECK-NEXT: ret i8 [[S]]
;
%a = add i8 %x, %y
%m = call i8 @llvm.smax.i8(i8 %y, i8 %x)
%s = sub i8 %a, %m
call void @use8(i8 %a)
ret i8 %s
}
define i8 @diff_add_use_umin_use(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@diff_add_use_umin_use
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[A:%.*]] = add i8 [[X]], [[Y]]
; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: [[S:%.*]] = sub i8 [[A]], [[M]]
; CHECK-NEXT: call void @use8(i8 [[A]])
; CHECK-NEXT: call void @use8(i8 [[M]])
; CHECK-NEXT: ret i8 [[S]]
;
%a = add i8 %x, %y
%m = call i8 @llvm.umin.i8(i8 %x, i8 %y)
%s = sub i8 %a, %m
call void @use8(i8 %a)
call void @use8(i8 %m)
ret i8 %s
}
; sub(add(X,Y),umin(Y,Z)) --> add(X,usubsat(Y,Z))
define i8 @sub_add_umin(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: define {{[^@]+}}@sub_add_umin
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]], i8 [[Z:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[Y]], i8 [[Z]])
; CHECK-NEXT: [[S:%.*]] = add i8 [[X]], [[TMP1]]
; CHECK-NEXT: ret i8 [[S]]
;
%a = add i8 %x, %y
%m = call i8 @llvm.umin.i8(i8 %y, i8 %z)
%s = sub i8 %a, %m
ret i8 %s
}
define i8 @sub_add_umin_commute_umin(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: define {{[^@]+}}@sub_add_umin_commute_umin
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]], i8 [[Z:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[Y]], i8 [[Z]])
; CHECK-NEXT: [[S:%.*]] = add i8 [[X]], [[TMP1]]
; CHECK-NEXT: ret i8 [[S]]
;
%a = add i8 %x, %y
%m = call i8 @llvm.umin.i8(i8 %z, i8 %y)
%s = sub i8 %a, %m
ret i8 %s
}
define i8 @sub_add_umin_commute_add(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: define {{[^@]+}}@sub_add_umin_commute_add
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]], i8 [[Z:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[Y]], i8 [[Z]])
; CHECK-NEXT: [[S:%.*]] = add i8 [[X]], [[TMP1]]
; CHECK-NEXT: ret i8 [[S]]
;
%a = add i8 %y, %x
%m = call i8 @llvm.umin.i8(i8 %y, i8 %z)
%s = sub i8 %a, %m
ret i8 %s
}
define i8 @sub_add_umin_commute_add_umin(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: define {{[^@]+}}@sub_add_umin_commute_add_umin
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]], i8 [[Z:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[Y]], i8 [[Z]])
; CHECK-NEXT: [[S:%.*]] = add i8 [[X]], [[TMP1]]
; CHECK-NEXT: ret i8 [[S]]
;
%a = add i8 %y, %x
%m = call i8 @llvm.umin.i8(i8 %z, i8 %y)
%s = sub i8 %a, %m
ret i8 %s
}
define <2 x i8> @sub_add_umin_vec(<2 x i8> %x, <2 x i8> %y, <2 x i8> %z) {
; CHECK-LABEL: define {{[^@]+}}@sub_add_umin_vec
; CHECK-SAME: (<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]], <2 x i8> [[Z:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> [[Y]], <2 x i8> [[Z]])
; CHECK-NEXT: [[S:%.*]] = add <2 x i8> [[X]], [[TMP1]]
; CHECK-NEXT: ret <2 x i8> [[S]]
;
%a = add <2 x i8> %x, %y
%m = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %y, <2 x i8> %z)
%s = sub <2 x i8> %a, %m
ret <2 x i8> %s
}
; negative test
define i8 @sub_add_umin_mismatch(i8 %x, i8 %y, i8 %z, i8 %t) {
; CHECK-LABEL: define {{[^@]+}}@sub_add_umin_mismatch
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]], i8 [[Z:%.*]], i8 [[T:%.*]]) {
; CHECK-NEXT: [[A:%.*]] = add i8 [[X]], [[Y]]
; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[T]], i8 [[Z]])
; CHECK-NEXT: [[S:%.*]] = sub i8 [[A]], [[M]]
; CHECK-NEXT: ret i8 [[S]]
;
%a = add i8 %x, %y
%m = call i8 @llvm.umin.i8(i8 %t, i8 %z)
%s = sub i8 %a, %m
ret i8 %s
}
define i8 @sub_add_umin_use_a(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: define {{[^@]+}}@sub_add_umin_use_a
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]], i8 [[Z:%.*]]) {
; CHECK-NEXT: [[A:%.*]] = add i8 [[X]], [[Y]]
; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[Z]])
; CHECK-NEXT: [[S:%.*]] = sub i8 [[A]], [[M]]
; CHECK-NEXT: call void @use8(i8 [[A]])
; CHECK-NEXT: ret i8 [[S]]
;
%a = add i8 %x, %y
%m = call i8 @llvm.umin.i8(i8 %y, i8 %z)
%s = sub i8 %a, %m
call void @use8(i8 %a)
ret i8 %s
}
define i8 @sub_add_umin_use_m(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: define {{[^@]+}}@sub_add_umin_use_m
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]], i8 [[Z:%.*]]) {
; CHECK-NEXT: [[A:%.*]] = add i8 [[X]], [[Y]]
; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[Z]])
; CHECK-NEXT: [[S:%.*]] = sub i8 [[A]], [[M]]
; CHECK-NEXT: call void @use8(i8 [[M]])
; CHECK-NEXT: ret i8 [[S]]
;
%a = add i8 %x, %y
%m = call i8 @llvm.umin.i8(i8 %y, i8 %z)
%s = sub i8 %a, %m
call void @use8(i8 %m)
ret i8 %s
}
define <2 x i8> @sub_smax0_sub_nsw(<2 x i8> %x, <2 x i8> %y) {
; CHECK-LABEL: define {{[^@]+}}@sub_smax0_sub_nsw
; CHECK-SAME: (<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]]) {
; CHECK-NEXT: [[R:%.*]] = call <2 x i8> @llvm.smin.v2i8(<2 x i8> [[X]], <2 x i8> [[Y]])
; CHECK-NEXT: ret <2 x i8> [[R]]
;
%sub = sub nsw <2 x i8> %x, %y
%m = call <2 x i8> @llvm.smax.v2i8(<2 x i8> %sub, <2 x i8> <i8 0, i8 poison>)
%r = sub <2 x i8> %x, %m
ret <2 x i8> %r
}
define i8 @sub_smax0_sub_nsw_use(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@sub_smax0_sub_nsw_use
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = sub nsw i8 [[X]], [[Y]]
; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[SUB]], i8 0)
; CHECK-NEXT: call void @use8(i8 [[M]])
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: ret i8 [[R]]
;
%sub = sub nsw i8 %x, %y
%m = call i8 @llvm.smax.i8(i8 %sub, i8 0)
call void @use8(i8 %m)
%r = sub i8 %x, %m
ret i8 %r
}
; negative test - must have nsw
define i8 @sub_smax0_sub(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@sub_smax0_sub
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = sub i8 [[X]], [[Y]]
; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[SUB]], i8 0)
; CHECK-NEXT: [[R:%.*]] = sub i8 [[X]], [[M]]
; CHECK-NEXT: ret i8 [[R]]
;
%sub = sub i8 %x, %y
%m = call i8 @llvm.smax.i8(i8 %sub, i8 0)
%r = sub i8 %x, %m
ret i8 %r
}
; negative test - wrong op
define i8 @sub_smax0_sub_commute(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@sub_smax0_sub_commute
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = sub nsw i8 [[X]], [[Y]]
; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[SUB]], i8 0)
; CHECK-NEXT: [[R:%.*]] = sub i8 [[M]], [[X]]
; CHECK-NEXT: ret i8 [[R]]
;
%sub = sub nsw i8 %x, %y
%m = call i8 @llvm.smax.i8(i8 %sub, i8 0)
%r = sub i8 %m, %x
ret i8 %r
}
define i8 @sub_smin0_sub_nsw_use(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@sub_smin0_sub_nsw_use
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = sub nsw i8 [[X]], [[Y]]
; CHECK-NEXT: call void @use8(i8 [[SUB]])
; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[X]], i8 [[Y]])
; CHECK-NEXT: ret i8 [[R]]
;
%sub = sub nsw i8 %x, %y
call void @use8(i8 %sub)
%m = call i8 @llvm.smin.i8(i8 %sub, i8 0)
%r = sub i8 %x, %m
ret i8 %r
}
define <2 x i8> @sub_smin0_sub_nsw(<2 x i8> %x, <2 x i8> %y) {
; CHECK-LABEL: define {{[^@]+}}@sub_smin0_sub_nsw
; CHECK-SAME: (<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]]) {
; CHECK-NEXT: [[R:%.*]] = call <2 x i8> @llvm.smax.v2i8(<2 x i8> [[X]], <2 x i8> [[Y]])
; CHECK-NEXT: ret <2 x i8> [[R]]
;
%sub = sub nsw <2 x i8> %x, %y
%m = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %sub, <2 x i8> zeroinitializer)
%r = sub <2 x i8> %x, %m
ret <2 x i8> %r
}
; negative test - must have nsw
define i8 @sub_smin0_sub(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@sub_smin0_sub
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = sub i8 [[X]], [[Y]]
; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[SUB]], i8 0)
; CHECK-NEXT: [[R:%.*]] = sub i8 [[X]], [[M]]
; CHECK-NEXT: ret i8 [[R]]
;
%sub = sub i8 %x, %y
%m = call i8 @llvm.smin.i8(i8 %sub, i8 0)
%r = sub i8 %x, %m
ret i8 %r
}
; negative test - wrong op
define i8 @sub_smin0_sub_nsw_commute(i8 %x, i8 %y) {
; CHECK-LABEL: define {{[^@]+}}@sub_smin0_sub_nsw_commute
; CHECK-SAME: (i8 [[X:%.*]], i8 [[Y:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = sub nsw i8 [[Y]], [[X]]
; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[SUB]], i8 0)
; CHECK-NEXT: [[R:%.*]] = sub i8 [[X]], [[M]]
; CHECK-NEXT: ret i8 [[R]]
;
%sub = sub nsw i8 %y, %x
%m = call i8 @llvm.smin.i8(i8 %sub, i8 0)
%r = sub i8 %x, %m
ret i8 %r
}
define i8 @sub_max_min_nsw(i8 %a, i8 %b) {
; CHECK-LABEL: define {{[^@]+}}@sub_max_min_nsw
; CHECK-SAME: (i8 [[A:%.*]], i8 [[B:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = sub nsw i8 [[A]], [[B]]
; CHECK-NEXT: [[AB:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB]], i1 true)
; CHECK-NEXT: ret i8 [[AB]]
;
%min = call i8 @llvm.smin.i8(i8 %a, i8 %b)
%max = call i8 @llvm.smax.i8(i8 %a, i8 %b)
%ab = sub nsw i8 %max, %min
ret i8 %ab
}
define i8 @sub_max_min_nuw(i8 %a, i8 %b) {
; CHECK-LABEL: define {{[^@]+}}@sub_max_min_nuw
; CHECK-SAME: (i8 [[A:%.*]], i8 [[B:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = sub nsw i8 [[A]], [[B]]
; CHECK-NEXT: [[AB:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB]], i1 true)
; CHECK-NEXT: ret i8 [[AB]]
;
%min = call i8 @llvm.smin.i8(i8 %a, i8 %b)
%max = call i8 @llvm.smax.i8(i8 %a, i8 %b)
%ab = sub nuw i8 %max, %min
ret i8 %ab
}
define i8 @sub_max_min_nsw_commute(i8 %a, i8 %b) {
; CHECK-LABEL: define {{[^@]+}}@sub_max_min_nsw_commute
; CHECK-SAME: (i8 [[A:%.*]], i8 [[B:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = sub nsw i8 [[A]], [[B]]
; CHECK-NEXT: [[AB:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB]], i1 true)
; CHECK-NEXT: ret i8 [[AB]]
;
%min = call i8 @llvm.smin.i8(i8 %b, i8 %a)
%max = call i8 @llvm.smax.i8(i8 %a, i8 %b)
%ab = sub nsw i8 %max, %min
ret i8 %ab
}
define i8 @sub_max_min_nuw_commute(i8 %a, i8 %b) {
; CHECK-LABEL: define {{[^@]+}}@sub_max_min_nuw_commute
; CHECK-SAME: (i8 [[A:%.*]], i8 [[B:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = sub nsw i8 [[A]], [[B]]
; CHECK-NEXT: [[AB:%.*]] = call i8 @llvm.abs.i8(i8 [[SUB]], i1 true)
; CHECK-NEXT: ret i8 [[AB]]
;
%min = call i8 @llvm.smin.i8(i8 %b, i8 %a)
%max = call i8 @llvm.smax.i8(i8 %a, i8 %b)
%ab = sub nuw i8 %max, %min
ret i8 %ab
}
define <2 x i8> @sub_max_min_vec_nsw(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: define {{[^@]+}}@sub_max_min_vec_nsw
; CHECK-SAME: (<2 x i8> [[A:%.*]], <2 x i8> [[B:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = sub nsw <2 x i8> [[A]], [[B]]
; CHECK-NEXT: [[AB:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[SUB]], i1 true)
; CHECK-NEXT: ret <2 x i8> [[AB]]
;
%min = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %a, <2 x i8> %b)
%max = call <2 x i8> @llvm.smax.v2i8(<2 x i8> %a, <2 x i8> %b)
%ab = sub nsw <2 x i8> %max, %min
ret <2 x i8> %ab
}
define <2 x i8> @sub_max_min_vec_nuw(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: define {{[^@]+}}@sub_max_min_vec_nuw
; CHECK-SAME: (<2 x i8> [[A:%.*]], <2 x i8> [[B:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = sub nsw <2 x i8> [[A]], [[B]]
; CHECK-NEXT: [[AB:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[SUB]], i1 true)
; CHECK-NEXT: ret <2 x i8> [[AB]]
;
%min = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %a, <2 x i8> %b)
%max = call <2 x i8> @llvm.smax.v2i8(<2 x i8> %a, <2 x i8> %b)
%ab = sub nuw <2 x i8> %max, %min
ret <2 x i8> %ab
}
define <2 x i8> @sub_max_min_vec_nsw_commute(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: define {{[^@]+}}@sub_max_min_vec_nsw_commute
; CHECK-SAME: (<2 x i8> [[A:%.*]], <2 x i8> [[B:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = sub nsw <2 x i8> [[A]], [[B]]
; CHECK-NEXT: [[AB:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[SUB]], i1 true)
; CHECK-NEXT: ret <2 x i8> [[AB]]
;
%min = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %b, <2 x i8> %a)
%max = call <2 x i8> @llvm.smax.v2i8(<2 x i8> %a, <2 x i8> %b)
%ab = sub nsw <2 x i8> %max, %min
ret <2 x i8> %ab
}
define <2 x i8> @sub_max_min_vec_nuw_commute(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: define {{[^@]+}}@sub_max_min_vec_nuw_commute
; CHECK-SAME: (<2 x i8> [[A:%.*]], <2 x i8> [[B:%.*]]) {
; CHECK-NEXT: [[SUB:%.*]] = sub nsw <2 x i8> [[A]], [[B]]
; CHECK-NEXT: [[AB:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[SUB]], i1 true)
; CHECK-NEXT: ret <2 x i8> [[AB]]
;
%min = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %b, <2 x i8> %a)
%max = call <2 x i8> @llvm.smax.v2i8(<2 x i8> %a, <2 x i8> %b)
%ab = sub nuw <2 x i8> %max, %min
ret <2 x i8> %ab
}
; negative test - multiple use
define i8 @sub_max_min_multi_use(i8 %a, i8 %b) {
; CHECK-LABEL: define {{[^@]+}}@sub_max_min_multi_use
; CHECK-SAME: (i8 [[A:%.*]], i8 [[B:%.*]]) {
; CHECK-NEXT: [[MIN:%.*]] = call i8 @llvm.smin.i8(i8 [[A]], i8 [[B]])
; CHECK-NEXT: call void @use8(i8 [[MIN]])
; CHECK-NEXT: [[MAX:%.*]] = call i8 @llvm.smax.i8(i8 [[A]], i8 [[B]])
; CHECK-NEXT: call void @use8(i8 [[MAX]])
; CHECK-NEXT: [[AB:%.*]] = sub nsw i8 [[MAX]], [[MIN]]
; CHECK-NEXT: ret i8 [[AB]]
;
%min = call i8 @llvm.smin.i8(i8 %a, i8 %b)
call void @use8(i8 %min)
%max = call i8 @llvm.smax.i8(i8 %a, i8 %b)
call void @use8(i8 %max)
%ab = sub nsw i8 %max, %min
ret i8 %ab
}
define <2 x i8> @sub_max_min_vec_multi_use(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: define {{[^@]+}}@sub_max_min_vec_multi_use
; CHECK-SAME: (<2 x i8> [[A:%.*]], <2 x i8> [[B:%.*]]) {
; CHECK-NEXT: [[MIN:%.*]] = call <2 x i8> @llvm.smin.v2i8(<2 x i8> [[A]], <2 x i8> [[B]])
; CHECK-NEXT: call void @use8v2(<2 x i8> [[MIN]])
; CHECK-NEXT: [[MAX:%.*]] = call <2 x i8> @llvm.smax.v2i8(<2 x i8> [[A]], <2 x i8> [[B]])
; CHECK-NEXT: call void @use8v2(<2 x i8> [[MAX]])
; CHECK-NEXT: [[AB:%.*]] = sub nsw <2 x i8> [[MAX]], [[MIN]]
; CHECK-NEXT: ret <2 x i8> [[AB]]
;
%min = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %a, <2 x i8> %b)
call void @use8v2(<2 x i8> %min)
%max = call <2 x i8> @llvm.smax.v2i8(<2 x i8> %a, <2 x i8> %b)
call void @use8v2(<2 x i8> %max)
%ab = sub nsw <2 x i8> %max, %min
ret <2 x i8> %ab
}
declare void @use8(i8)
declare void @use32(i32 %u)
declare void @use8v2(i8)
Reference in New Issue View Git Blame Copy Permalink