This is an archive of the discontinued LLVM Phabricator instance.

Differential D147596

Add baseline tests for D147597
ClosedPublic

Authored by junaire on Apr 5 2023, 1:52 AM.

Details

Reviewers
RKSimon
spatel
nikic
goldstein.w.n
bcl5980
junaire
Summary

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

Diff Detail

Event Timeline

junaire created this revision.Apr 5 2023, 1:52 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 5 2023, 1:52 AM
Herald added a subscriber: StephenFan. · View Herald Transcript
junaire requested review of this revision.Apr 5 2023, 1:52 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 5 2023, 1:52 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
junaire added a child revision: D147597: [InstCombine] icmp(X | OrC, C) --> icmp(X, 0).Apr 5 2023, 1:55 AM
Harbormaster completed remote builds in B223740: Diff 511017.Apr 5 2023, 2:35 AM
junaire updated this revision to Diff 511043.Apr 5 2023, 4:24 AM

Update the tests

junaire retitled this revision from Add baseline tests for icmp(Positive1 * X * Y + Positive2) to Add baseline tests for icmp(X * Y + Positive).Apr 5 2023, 4:24 AM
junaire updated this revision to Diff 511055.Apr 5 2023, 5:09 AM

Vector tests

Harbormaster completed remote builds in B223755: Diff 511043.Apr 5 2023, 5:09 AM
Harbormaster completed remote builds in B223764: Diff 511055.Apr 5 2023, 5:40 AM
junaire updated this revision to Diff 511308.Apr 6 2023, 1:05 AM
  • remove nsw flag
  • rename the tests
junaire retitled this revision from Add baseline tests for icmp(X * Y + Positive) to Add baseline tests for D147597.Apr 6 2023, 1:07 AM
Harbormaster completed remote builds in B223939: Diff 511308.Apr 6 2023, 1:34 AM
junaire updated this revision to Diff 511952.Apr 8 2023, 8:07 PM

Add more tests

Harbormaster completed remote builds in B224415: Diff 511952.Apr 8 2023, 8:34 PM
junaire updated this revision to Diff 512400.Apr 11 2023, 5:04 AM

Add negative tests

junaire mentioned this in D147597: [InstCombine] icmp(X | OrC, C) --> icmp(X, 0).Apr 11 2023, 5:07 AM
Harbormaster completed remote builds in B224737: Diff 512400.Apr 11 2023, 5:52 AM
junaire updated this revision to Diff 512704.Apr 12 2023, 2:17 AM

rename tests & add multiuse tests

junaire updated this revision to Diff 512720.Apr 12 2023, 2:33 AM

Add vector with poison tests

junaire updated this revision to Diff 512724.Apr 12 2023, 2:38 AM

Update the comments

Harbormaster completed remote builds in B224982: Diff 512724.Apr 12 2023, 3:42 AM
nikic added inline comments.Apr 12 2023, 1:59 PM
llvm/test/Transforms/InstCombine/icmp.ll
5125

It's usually enough to have just one multi-use test, no need to add multi-use variants of all tests.

junaire updated this revision to Diff 513012.Apr 12 2023, 4:46 PM

Address @nikic's comments, thx! -- only keep one multiuse test

junaire updated this revision to Diff 513015.Apr 12 2023, 4:48 PM

remove unused function

Harbormaster completed remote builds in B225217: Diff 513015.Apr 12 2023, 5:32 PM
junaire accepted this revision.Apr 13 2023, 2:27 AM
This revision is now accepted and ready to land.Apr 13 2023, 2:27 AM
junaire closed this revision.Apr 13 2023, 2:28 AM

https://reviews.llvm.org/rGa088beaef21badc91806329941113f097cdeb62c

Revision Contents

PathSize
llvm/
test/
Transforms/
InstCombine/
318 lines

Diff 512400

llvm/test/Transforms/InstCombine/icmp.ll

Show First 20 Lines • Show All 4,621 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[R:%.*]] = icmp ne i8 [[A]], 0 ; CHECK-NEXT: [[R:%.*]] = icmp ne i8 [[A]], 0
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
; ;
%zx = zext i2 %x to i8 %zx = zext i2 %x to i8
%a = and i8 %zx, %y %a = and i8 %zx, %y
%r = icmp ne i8 %a, 0 %r = icmp ne i8 %a, 0
ret i1 %r ret i1 %r
} }
define i1 @mul_or_positive_sgt_zero(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_or_positive_sgt_zero(
; CHECK-NEXT: [[MUL1:%.*]] = mul i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or i8 [[MUL1]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[ADD]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul1 = mul i8 %a, %b
%add = or i8 %mul1, 24
%cmp = icmp sgt i8 %add, 0
ret i1 %cmp
}
define <2 x i1> @mul_or_postive_sgt_zero_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_or_postive_sgt_zero_vec(
; CHECK-NEXT: [[MUL1:%.*]] = mul <2 x i8> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or <2 x i8> [[MUL1]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[ADD]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul1 = mul <2 x i8> %a, %b
%add = or <2 x i8> %mul1, <i8 24, i8 24>
%cmp = icmp sgt <2 x i8> %add, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @mul_or_positive_sge_zero(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_or_positive_sge_zero(
; CHECK-NEXT: [[MUL1:%.*]] = mul i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[MUL1]], -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul1 = mul i8 %a, %b
%add = or i8 %mul1, 24
%cmp = icmp sge i8 %add, 0
ret i1 %cmp
}
define <2 x i1> @mul_or_postive_sge_zero_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_or_postive_sge_zero_vec(
; CHECK-NEXT: [[MUL1:%.*]] = mul <2 x i8> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[MUL1]], <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul1 = mul <2 x i8> %a, %b
%add = or <2 x i8> %mul1, <i8 24, i8 24>
%cmp = icmp sge <2 x i8> %add, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @mul_or_positive_sge_postive(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_or_positive_sge_postive(
; CHECK-NEXT: [[MUL1:%.*]] = mul i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or i8 [[MUL1]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[ADD]], 23
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul1 = mul i8 %a, %b
%add = or i8 %mul1, 24
%cmp = icmp sge i8 %add, 24
ret i1 %cmp
}
define <2 x i1> @mul_or_postive_sge_positive_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_or_postive_sge_positive_vec(
; CHECK-NEXT: [[MUL1:%.*]] = mul <2 x i8> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or <2 x i8> [[MUL1]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[ADD]], <i8 23, i8 23>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul1 = mul <2 x i8> %a, %b
%add = or <2 x i8> %mul1, <i8 24, i8 24>
%cmp = icmp sge <2 x i8> %add, <i8 24, i8 24>
ret <2 x i1> %cmp
}
define i1 @mul_or_positive_sle_zero(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_or_positive_sle_zero(
; CHECK-NEXT: [[MUL1:%.*]] = mul i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or i8 [[MUL1]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[ADD]], 1
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul1 = mul i8 %a, %b
%add = or i8 %mul1, 24
%cmp = icmp sle i8 %add, 0
ret i1 %cmp
}
define <2 x i1> @mul_or_postive_sle_zero_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_or_postive_sle_zero_vec(
; CHECK-NEXT: [[MUL1:%.*]] = mul <2 x i8> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or <2 x i8> [[MUL1]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[ADD]], <i8 1, i8 1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul1 = mul <2 x i8> %a, %b
%add = or <2 x i8> %mul1, <i8 24, i8 24>
%cmp = icmp sle <2 x i8> %add, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @mul_or_positive_slt_zero(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_or_positive_slt_zero(
; CHECK-NEXT: [[MUL1:%.*]] = mul i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[MUL1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul1 = mul i8 %a, %b
%add = or i8 %mul1, 24
%cmp = icmp slt i8 %add, 0
ret i1 %cmp
}
define <2 x i1> @mul_or_postive_slt_zero_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_or_postive_slt_zero_vec(
; CHECK-NEXT: [[MUL1:%.*]] = mul <2 x i8> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[MUL1]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul1 = mul <2 x i8> %a, %b
%add = or <2 x i8> %mul1, <i8 24, i8 24>
%cmp = icmp slt <2 x i8> %add, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @mul_or_positive_slt_postive(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_or_positive_slt_postive(
; CHECK-NEXT: [[MUL1:%.*]] = mul i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or i8 [[MUL1]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[ADD]], 24
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul1 = mul i8 %a, %b
%add = or i8 %mul1, 24
%cmp = icmp slt i8 %add, 24
ret i1 %cmp
}
define <2 x i1> @mul_or_postive_slt_positive_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_or_postive_slt_positive_vec(
; CHECK-NEXT: [[MUL1:%.*]] = mul <2 x i8> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or <2 x i8> [[MUL1]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[ADD]], <i8 24, i8 24>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul1 = mul <2 x i8> %a, %b
%add = or <2 x i8> %mul1, <i8 24, i8 24>
%cmp = icmp slt <2 x i8> %add, <i8 24, i8 24>
ret <2 x i1> %cmp
}
; negative tests for icmp(X | LHS, C) --> icmp(X, 0)
define i1 @mul_or_positive_sgt_neg(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_or_positive_sgt_neg(
; CHECK-NEXT: [[MUL1:%.*]] = mul i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[MUL1]], -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul1 = mul i8 %a, %b
%add = or i8 %mul1, 24
%cmp = icmp sgt i8 %add, -1
ret i1 %cmp
}
define <2 x i1> @mul_or_postive_sgt_neg_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_or_postive_sgt_neg_vec(
; CHECK-NEXT: [[MUL1:%.*]] = mul <2 x i8> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[MUL1]], <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul1 = mul <2 x i8> %a, %b
%add = or <2 x i8> %mul1, <i8 24, i8 24>
%cmp = icmp sgt <2 x i8> %add, <i8 -1, i8 -1>
ret <2 x i1> %cmp
}
define i1 @mul_or_positive_sge_neg(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_or_positive_sge_neg(
; CHECK-NEXT: [[MUL1:%.*]] = mul i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or i8 [[MUL1]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[ADD]], -2
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul1 = mul i8 %a, %b
%add = or i8 %mul1, 24
%cmp = icmp sge i8 %add, -1
ret i1 %cmp
}
define <2 x i1> @mul_or_postive_sge_neg_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_or_postive_sge_neg_vec(
; CHECK-NEXT: [[MUL1:%.*]] = mul <2 x i8> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or <2 x i8> [[MUL1]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[ADD]], <i8 -2, i8 -2>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul1 = mul <2 x i8> %a, %b
%add = or <2 x i8> %mul1, <i8 24, i8 24>
%cmp = icmp sge <2 x i8> %add, <i8 -1, i8 -1>
ret <2 x i1> %cmp
}
define i1 @mul_or_small_sge_large(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_or_small_sge_large(
; CHECK-NEXT: [[MUL1:%.*]] = mul i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or i8 [[MUL1]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[ADD]], 24
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul1 = mul i8 %a, %b
%add = or i8 %mul1, 24
%cmp = icmp sge i8 %add, 25
ret i1 %cmp
}
define <2 x i1> @mul_or_small_sge_large_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_or_small_sge_large_vec(
; CHECK-NEXT: [[MUL1:%.*]] = mul <2 x i8> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or <2 x i8> [[MUL1]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[ADD]], <i8 24, i8 24>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul1 = mul <2 x i8> %a, %b
%add = or <2 x i8> %mul1, <i8 24, i8 24>
%cmp = icmp sge <2 x i8> %add, <i8 25, i8 25>
ret <2 x i1> %cmp
}
define i1 @mul_or_positive_sle_neg(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_or_positive_sle_neg(
; CHECK-NEXT: [[MUL1:%.*]] = mul i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[MUL1]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul1 = mul i8 %a, %b
%add = or i8 %mul1, 24
%cmp = icmp sle i8 %add, -1
ret i1 %cmp
}
define <2 x i1> @mul_or__sle_neg_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_or__sle_neg_vec(
; CHECK-NEXT: [[MUL1:%.*]] = mul <2 x i8> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[MUL1]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul1 = mul <2 x i8> %a, %b
%add = or <2 x i8> %mul1, <i8 24, i8 24>
%cmp = icmp sle <2 x i8> %add, <i8 -1, i8 -1>
ret <2 x i1> %cmp
}
define i1 @mul_or_positive_slt_neg(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_or_positive_slt_neg(
; CHECK-NEXT: [[MUL1:%.*]] = mul i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or i8 [[MUL1]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[ADD]], -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul1 = mul i8 %a, %b
%add = or i8 %mul1, 24
%cmp = icmp slt i8 %add, -1
ret i1 %cmp
}
define <2 x i1> @mul_or_postive_slt_neg_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_or_postive_slt_neg_vec(
; CHECK-NEXT: [[MUL1:%.*]] = mul <2 x i8> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or <2 x i8> [[MUL1]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[ADD]], <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul1 = mul <2 x i8> %a, %b
%add = or <2 x i8> %mul1, <i8 24, i8 24>
%cmp = icmp slt <2 x i8> %add, <i8 -1, i8 -1>
ret <2 x i1> %cmp
}
define i1 @mul_or_small_slt_large(i8 %a, i8 %b) {
; CHECK-LABEL: @mul_or_small_slt_large(
; CHECK-NEXT: [[MUL1:%.*]] = mul i8 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or i8 [[MUL1]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[ADD]], 25
; CHECK-NEXT: ret i1 [[CMP]]
;
%mul1 = mul i8 %a, %b
%add = or i8 %mul1, 24
%cmp = icmp slt i8 %add, 25
ret i1 %cmp
}
define <2 x i1> @mul_or_small_slt_large_vec(<2 x i8> %a, <2 x i8> %b) {
; CHECK-LABEL: @mul_or_small_slt_large_vec(
; CHECK-NEXT: [[MUL1:%.*]] = mul <2 x i8> [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[ADD:%.*]] = or <2 x i8> [[MUL1]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[ADD]], <i8 25, i8 25>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%mul1 = mul <2 x i8> %a, %b
%add = or <2 x i8> %mul1, <i8 24, i8 24>
%cmp = icmp slt <2 x i8> %add, <i8 25, i8 25>
ret <2 x i1> %cmp
}
nikicUnsubmitted
Not Done
ReplyInline Actions

It's usually enough to have just one multi-use test, no need to add multi-use variants of all tests.

nikic: It's usually enough to have just one multi-use test, no need to add multi-use variants of all…