This is an archive of the discontinued LLVM Phabricator instance.

Differential D148209

Add baseline tests for D148210
Needs ReviewPublic

Authored by junaire on Apr 13 2023, 3:25 AM.

Details

Reviewers
RKSimon
spatel
nikic
goldstein.w.n
bcl5980
Summary

Signed-off-by: Jun Zhang <jun@junz.org>

Diff Detail

Unit TestsFailed

TimeTest
130 msx64 debian > LLVM.Examples/OrcV2Examples::lljit-with-thinlto-summaries.test
30 msx64 debian > LLVM.Examples/OrcV2Examples::orcv2-cbindings-add-object-file.test
40 msx64 debian > LLVM.Examples/OrcV2Examples::orcv2-cbindings-basic-usage.test
40 msx64 debian > LLVM.Examples/OrcV2Examples::orcv2-cbindings-lazy.test
30 msx64 debian > LLVM.Examples/OrcV2Examples::orcv2-cbindings-removable-code.test

Event Timeline

junaire created this revision.Apr 13 2023, 3:25 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 13 2023, 3:25 AM
Herald added a subscriber: StephenFan. · View Herald Transcript
junaire requested review of this revision.Apr 13 2023, 3:25 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 13 2023, 3:25 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
junaire added a child revision: D148210: [InstCombine] Reassociate (C * X) * Y in foldICmpMulConstant.Apr 13 2023, 3:29 AM
Harbormaster completed remote builds in B225294: Diff 513151.Apr 13 2023, 4:54 AM
junaire updated this revision to Diff 514953.Apr 19 2023, 7:45 AM

Add more tests

junaire retitled this revision from Add baseline tests for icmp(MulC * X * Y, C) --> icmp(X * Y, C) to Add baseline tests for D148210.Apr 19 2023, 7:45 AM
junaire updated this revision to Diff 514999.Apr 19 2023, 9:41 AM

fix

Harbormaster completed remote builds in B226633: Diff 514999.Apr 19 2023, 11:07 AM
junaire updated this revision to Diff 515563.Apr 20 2023, 8:12 PM

Add tests without nsw

junaire updated this revision to Diff 515576.Apr 20 2023, 8:53 PM

update

Harbormaster completed remote builds in B227056: Diff 515576.Apr 20 2023, 9:41 PM
junaire updated this revision to Diff 517849.Apr 28 2023, 2:47 AM

.

Harbormaster completed remote builds in B228774: Diff 517849.Apr 28 2023, 3:34 AM
junaire updated this revision to Diff 518286.Apr 30 2023, 2:48 AM

.

Herald added a project: Restricted Project. · View Herald TranscriptApr 30 2023, 2:48 AM
Herald added subscribers: cfe-commits, mstorsjo. · View Herald Transcript
Harbormaster completed remote builds in B229111: Diff 518286.Apr 30 2023, 2:48 AM
junaire updated this revision to Diff 518288.Apr 30 2023, 2:51 AM

.

Harbormaster completed remote builds in B229113: Diff 518288.Apr 30 2023, 3:45 AM

Revision Contents

PathSize
llvm/
test/
Transforms/
InstCombine/
444 lines

Diff 515576

llvm/test/Transforms/InstCombine/icmp.ll

Show First 20 Lines • Show All 4,959 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[A]], -1 ; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[A]], -1
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
%b = or i8 %a, 24 %b = or i8 %a, 24
call void @use_i8(i8 %b) call void @use_i8(i8 %b)
%cmp = icmp sgt i8 %b, 0 %cmp = icmp sgt i8 %b, 0
ret i1 %cmp ret i1 %cmp
} }
define i1 @mul_mul_sge_zero(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_mul_sge_zero(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw i8 [[A:%.*]], 42
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[MUL2]], -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = mul nsw i8 %a, 42
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp sge i8 %mul2, 0
ret i1 %cmp
}
define <2 x i1> @mul_mul_sge_zero_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_mul_sge_zero_vec(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw <2 x i8> [[A:%.*]], <i8 42, i8 42>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[MUL2]], <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = mul nsw <2 x i8> %a, <i8 42, i8 42>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp sge <2 x i8> %mul2, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @mul_mul_sge_one(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_mul_sge_one(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw i8 [[A:%.*]], 42
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[MUL2]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = mul nsw i8 %a, 42
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp sge i8 %mul2, 1
ret i1 %cmp
}
define <2 x i1> @mul_mul_sge_one_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_mul_sge_one_vec(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw <2 x i8> [[A:%.*]], <i8 42, i8 42>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[MUL2]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = mul nsw <2 x i8> %a, <i8 42, i8 42>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp sge <2 x i8> %mul2, <i8 1, i8 1>
ret <2 x i1> %cmp
}
define i1 @mul_mul_slt_zero(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_mul_slt_zero(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw i8 [[A:%.*]], 42
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[MUL2]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = mul nsw i8 %a, 42
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp slt i8 %mul2, 0
ret i1 %cmp
}
define <2 x i1> @mul_mul_slt_zero_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_mul_slt_zero_vec(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw <2 x i8> [[A:%.*]], <i8 42, i8 42>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[MUL2]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = mul nsw <2 x i8> %a, <i8 42, i8 42>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp slt <2 x i8> %mul2, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @mul_mul_slt_one(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_mul_slt_one(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw i8 [[A:%.*]], 42
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[MUL2]], 1
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = mul nsw i8 %a, 42
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp slt i8 %mul2, 1
ret i1 %cmp
}
define <2 x i1> @mul_mul_slt_one_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_mul_slt_one_vec(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw <2 x i8> [[A:%.*]], <i8 42, i8 42>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[MUL2]], <i8 1, i8 1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = mul nsw <2 x i8> %a, <i8 42, i8 42>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp slt <2 x i8> %mul2, <i8 1, i8 1>
ret <2 x i1> %cmp
}
define i1 @mul_mul_sle_zero(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_mul_sle_zero(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw i8 [[A:%.*]], 42
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[MUL2]], 1
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = mul nsw i8 %a, 42
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp sle i8 %mul2, 0
ret i1 %cmp
}
define <2 x i1> @mul_mul_sle_zero_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_mul_sle_zero_vec(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw <2 x i8> [[A:%.*]], <i8 42, i8 42>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[MUL2]], <i8 1, i8 1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = mul nsw <2 x i8> %a, <i8 42, i8 42>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp sle <2 x i8> %mul2, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @mul_mul_sle_negone(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_mul_sle_negone(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw i8 [[A:%.*]], 42
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[MUL2]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = mul nsw i8 %a, 42
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp sle i8 %mul2, -1
ret i1 %cmp
}
define <2 x i1> @mul_mul_sle_negone_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_mul_sle_negone_vec(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw <2 x i8> [[A:%.*]], <i8 42, i8 42>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[MUL2]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = mul nsw <2 x i8> %a, <i8 42, i8 42>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp sle <2 x i8> %mul2, <i8 -1, i8 -1>
ret <2 x i1> %cmp
}
define i1 @mul_mul_sgt_zero(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_mul_sgt_zero(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw i8 [[A:%.*]], 42
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[MUL2]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = mul nsw i8 %a, 42
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp sgt i8 %mul2, 0
ret i1 %cmp
}
define <2 x i1> @mul_mul_sgt_zero_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_mul_sgt_zero_vec(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw <2 x i8> [[A:%.*]], <i8 42, i8 42>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[MUL2]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = mul nsw <2 x i8> %a, <i8 42, i8 42>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp sgt <2 x i8> %mul2, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @mul_mul_sgt_negone(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_mul_sgt_negone(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw i8 [[A:%.*]], 42
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[MUL2]], -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = mul nsw i8 %a, 42
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp sgt i8 %mul2, -1
ret i1 %cmp
}
define <2 x i1> @mul_mul_sgt_negone_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_mul_sgt_negone_vec(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw <2 x i8> [[A:%.*]], <i8 42, i8 42>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[MUL2]], <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = mul nsw <2 x i8> %a, <i8 42, i8 42>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp sgt <2 x i8> %mul2, <i8 -1, i8 -1>
ret <2 x i1> %cmp
}
define i1 @shl_mul_sge_zero(i8 %a, i8 %b) {
; CHECK-LABEL: @shl_mul_sge_zero(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw i8 [[A:%.*]], 1
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[MUL2]], -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = shl nsw i8 %a, 1
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp sge i8 %mul2, 0
ret i1 %cmp
}
define <2 x i1> @shl_mul_sge_zero_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @shl_mul_sge_zero_vec(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw <2 x i8> [[A:%.*]], <i8 1, i8 1>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[MUL2]], <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = shl nsw <2 x i8> %a, <i8 1, i8 1>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp sge <2 x i8> %mul2, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @shl_mul_sge_one(i8 %a, i8 %b) {
; CHECK-LABEL: @shl_mul_sge_one(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw i8 [[A:%.*]], 1
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[MUL2]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = shl nsw i8 %a, 1
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp sge i8 %mul2, 1
ret i1 %cmp
}
define <2 x i1> @shl_mul_sge_one_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @shl_mul_sge_one_vec(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw <2 x i8> [[A:%.*]], <i8 1, i8 1>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[MUL2]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = shl nsw <2 x i8> %a, <i8 1, i8 1>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp sge <2 x i8> %mul2, <i8 1, i8 1>
ret <2 x i1> %cmp
}
define i1 @shl_mul_slt_zero(i8 %a, i8 %b) {
; CHECK-LABEL: @shl_mul_slt_zero(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw i8 [[A:%.*]], 1
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[MUL2]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = shl nsw i8 %a, 1
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp slt i8 %mul2, 0
ret i1 %cmp
}
define <2 x i1> @shl_mul_slt_zero_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @shl_mul_slt_zero_vec(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw <2 x i8> [[A:%.*]], <i8 1, i8 1>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[MUL2]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = shl nsw <2 x i8> %a, <i8 1, i8 1>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp slt <2 x i8> %mul2, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @shl_mul_slt_one(i8 %a, i8 %b) {
; CHECK-LABEL: @shl_mul_slt_one(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw i8 [[A:%.*]], 1
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[MUL2]], 1
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = shl nsw i8 %a, 1
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp slt i8 %mul2, 1
ret i1 %cmp
}
define <2 x i1> @shl_mul_slt_one_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @shl_mul_slt_one_vec(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw <2 x i8> [[A:%.*]], <i8 1, i8 1>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[MUL2]], <i8 1, i8 1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = shl nsw <2 x i8> %a, <i8 1, i8 1>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp slt <2 x i8> %mul2, <i8 1, i8 1>
ret <2 x i1> %cmp
}
define i1 @shl_mul_sle_zero(i8 %a, i8 %b) {
; CHECK-LABEL: @shl_mul_sle_zero(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw i8 [[A:%.*]], 1
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[MUL2]], 1
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = shl nsw i8 %a, 1
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp sle i8 %mul2, 0
ret i1 %cmp
}
define <2 x i1> @shl_mul_sle_zero_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @shl_mul_sle_zero_vec(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw <2 x i8> [[A:%.*]], <i8 1, i8 1>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[MUL2]], <i8 1, i8 1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = shl nsw <2 x i8> %a, <i8 1, i8 1>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp sle <2 x i8> %mul2, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @shl_mul_sle_negone(i8 %a, i8 %b) {
; CHECK-LABEL: @shl_mul_sle_negone(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw i8 [[A:%.*]], 1
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[MUL2]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = shl nsw i8 %a, 1
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp sle i8 %mul2, -1
ret i1 %cmp
}
define <2 x i1> @shl_mul_sle_negone_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @shl_mul_sle_negone_vec(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw <2 x i8> [[A:%.*]], <i8 1, i8 1>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[MUL2]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = shl nsw <2 x i8> %a, <i8 1, i8 1>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp sle <2 x i8> %mul2, <i8 -1, i8 -1>
ret <2 x i1> %cmp
}
define i1 @shl_mul_sgt_zero(i8 %a, i8 %b) {
; CHECK-LABEL: @shl_mul_sgt_zero(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw i8 [[A:%.*]], 1
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[MUL2]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = shl nsw i8 %a, 1
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp sgt i8 %mul2, 0
ret i1 %cmp
}
define <2 x i1> @shl_mul_sgt_zero_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @shl_mul_sgt_zero_vec(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw <2 x i8> [[A:%.*]], <i8 1, i8 1>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[MUL2]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = shl nsw <2 x i8> %a, <i8 1, i8 1>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp sgt <2 x i8> %mul2, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @shl_mul_sgt_negone(i8 %a, i8 %b) {
; CHECK-LABEL: @shl_mul_sgt_negone(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw i8 [[A:%.*]], 1
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[MUL2]], -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = shl nsw i8 %a, 1
%mul2 = mul nsw i8 %b, %mul
%cmp = icmp sgt i8 %mul2, -1
ret i1 %cmp
}
define <2 x i1> @shl_mul_sgt_negone_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @shl_mul_sgt_negone_vec(
; CHECK-NEXT: [[MUL:%.*]] = shl nsw <2 x i8> [[A:%.*]], <i8 1, i8 1>
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw <2 x i8> [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[MUL2]], <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul = shl nsw <2 x i8> %a, <i8 1, i8 1>
%mul2 = mul nsw <2 x i8> %b, %mul
%cmp = icmp sgt <2 x i8> %mul2, <i8 -1, i8 -1>
ret <2 x i1> %cmp
}
define i1 @mul_mul_sge_zero_multiuse(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_mul_sge_zero_multiuse(
; CHECK-NEXT: [[MUL:%.*]] = mul nsw i8 [[A:%.*]], 42
; CHECK-NEXT: [[MUL2:%.*]] = mul nsw i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: call void @use_i8(i8 [[MUL2]])
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[MUL2]], -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = mul nsw i8 %a, 42
%mul2 = mul nsw i8 %b, %mul
call void @use_i8(i8 %mul2)
%cmp = icmp sge i8 %mul2, 0
ret i1 %cmp
}
define i1 @mul_mul_sge_zero_nonsw(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_mul_sge_zero_nonsw(
; CHECK-NEXT: [[MUL:%.*]] = mul i8 [[A:%.*]], 42
; CHECK-NEXT: [[MUL2:%.*]] = mul i8 [[MUL]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[MUL2]], -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul = mul i8 %a, 42
%mul2 = mul i8 %b, %mul
%cmp = icmp sge i8 %mul2, 0
ret i1 %cmp
}