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
5127

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/
498 lines

Diff 512724

llvm/test/Transforms/InstCombine/icmp.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=instcombine -S | FileCheck %s ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-p1:16:16:16-p2:32:32:32-p3:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-p1:16:16:16-p2:32:32:32-p3:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
declare i8 @llvm.abs.i8(i8, i1) declare i8 @llvm.abs.i8(i8, i1)
declare void @use_i1(i1) declare void @use_i1(i1)
declare void @use_i8(i8)
declare void @use_v2i8(<2 x i8>)
declare void @use_i32(i32) declare void @use_i32(i32)
declare void @use_i64(i64) declare void @use_i64(i64)
define i32 @test1(i32 %X) { define i32 @test1(i32 %X) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[X_LOBIT:%.*]] = lshr i32 [[X:%.*]], 31 ; CHECK-NEXT: [[X_LOBIT:%.*]] = lshr i32 [[X:%.*]], 31
; CHECK-NEXT: ret i32 [[X_LOBIT]] ; CHECK-NEXT: ret i32 [[X_LOBIT]]
; ;
▲ Show 20 Lines • Show All 4,605 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
} }
; fold icmp(X | OrC, C) --> icmp(X, 0)
define i1 @or_positive_sgt_zero(i8 %a) {
; CHECK-LABEL: @or_positive_sgt_zero(
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[B]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
%cmp = icmp sgt i8 %b, 0
ret i1 %cmp
}
define <2 x i1> @or_postive_sgt_zero_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_sgt_zero_vec(
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[B]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
%cmp = icmp sgt <2 x i8> %b, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define <2 x i1> @or_poison_vec_sgt_zero_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_poison_vec_sgt_zero_vec(
; CHECK-NEXT: ret <2 x i1> poison
;
%b = or <2 x i8> %a, <i8 poison, i8 poison>
%cmp = icmp sgt <2 x i8> %b, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @or_positive_sge_zero(i8 %a) {
; CHECK-LABEL: @or_positive_sge_zero(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[A:%.*]], -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
%cmp = icmp sge i8 %b, 0
ret i1 %cmp
}
define <2 x i1> @or_postive_sge_zero_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_sge_zero_vec(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[A:%.*]], <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
%cmp = icmp sge <2 x i8> %b, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define <2 x i1> @or_poison_vec_sge_zero_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_poison_vec_sge_zero_vec(
; CHECK-NEXT: ret <2 x i1> poison
;
%b = or <2 x i8> %a, <i8 poison, i8 poison>
%cmp = icmp sge <2 x i8> %b, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @or_positive_sge_postive(i8 %a) {
; CHECK-LABEL: @or_positive_sge_postive(
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[B]], 23
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
%cmp = icmp sge i8 %b, 24
ret i1 %cmp
}
define <2 x i1> @or_postive_sge_positive_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_sge_positive_vec(
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[B]], <i8 23, i8 23>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
%cmp = icmp sge <2 x i8> %b, <i8 24, i8 24>
ret <2 x i1> %cmp
}
define <2 x i1> @or_poison_vec_sge_positive_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_poison_vec_sge_positive_vec(
; CHECK-NEXT: ret <2 x i1> poison
;
%b = or <2 x i8> %a, <i8 poison, i8 poison>
%cmp = icmp sge <2 x i8> %b, <i8 24, i8 24>
ret <2 x i1> %cmp
}
define i1 @or_positive_sle_zero(i8 %a) {
; CHECK-LABEL: @or_positive_sle_zero(
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[B]], 1
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
%cmp = icmp sle i8 %b, 0
ret i1 %cmp
}
define <2 x i1> @or_postive_sle_zero_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_sle_zero_vec(
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[B]], <i8 1, i8 1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
%cmp = icmp sle <2 x i8> %b, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define <2 x i1> @or_poison_vec_sle_zero_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_poison_vec_sle_zero_vec(
; CHECK-NEXT: ret <2 x i1> poison
;
%b = or <2 x i8> %a, <i8 poison, i8 poison>
%cmp = icmp sle <2 x i8> %b, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @or_positive_slt_zero(i8 %a) {
; CHECK-LABEL: @or_positive_slt_zero(
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[A:%.*]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
%cmp = icmp slt i8 %b, 0
ret i1 %cmp
}
define <2 x i1> @or_postive_slt_zero_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_slt_zero_vec(
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[A:%.*]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
%cmp = icmp slt <2 x i8> %b, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define <2 x i1> @or_poison_vec_slt_zero_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_poison_vec_slt_zero_vec(
; CHECK-NEXT: ret <2 x i1> poison
;
%b = or <2 x i8> %a, <i8 poison, i8 poison>
%cmp = icmp slt <2 x i8> %b, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @or_positive_slt_postive(i8 %a) {
; CHECK-LABEL: @or_positive_slt_postive(
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[B]], 24
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
%cmp = icmp slt i8 %b, 24
ret i1 %cmp
}
define <2 x i1> @or_postive_slt_positive_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_slt_positive_vec(
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[B]], <i8 24, i8 24>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
%cmp = icmp slt <2 x i8> %b, <i8 24, i8 24>
ret <2 x i1> %cmp
}
define <2 x i1> @or_poison_vec_slt_positive_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_poison_vec_slt_positive_vec(
; CHECK-NEXT: ret <2 x i1> poison
;
%b = or <2 x i8> %a, <i8 poison, i8 poison>
%cmp = icmp slt <2 x i8> %b, <i8 24, i8 24>
ret <2 x i1> %cmp
}
; negative tests for icmp(X | OrC, C) --> icmp(X, 0)
define i1 @or_positive_sgt_neg(i8 %a) {
; CHECK-LABEL: @or_positive_sgt_neg(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[A:%.*]], -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
%cmp = icmp sgt i8 %b, -1
ret i1 %cmp
}
define <2 x i1> @or_postive_sgt_neg_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_sgt_neg_vec(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[A:%.*]], <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
%cmp = icmp sgt <2 x i8> %b, <i8 -1, i8 -1>
ret <2 x i1> %cmp
}
define i1 @mul_or_positive_sge_neg(i8 %a) {
; CHECK-LABEL: @mul_or_positive_sge_neg(
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[B]], -2
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
%cmp = icmp sge i8 %b, -1
ret i1 %cmp
}
define <2 x i1> @or_postive_sge_neg_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_sge_neg_vec(
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[B]], <i8 -2, i8 -2>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
%cmp = icmp sge <2 x i8> %b, <i8 -1, i8 -1>
ret <2 x i1> %cmp
}
define i1 @mul_or_small_sge_large(i8 %a) {
; CHECK-LABEL: @mul_or_small_sge_large(
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[B]], 24
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
%cmp = icmp sge i8 %b, 25
ret i1 %cmp
}
define <2 x i1> @or_small_sge_large_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_small_sge_large_vec(
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[B]], <i8 24, i8 24>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
%cmp = icmp sge <2 x i8> %b, <i8 25, i8 25>
ret <2 x i1> %cmp
}
define i1 @or_positive_sle_neg(i8 %a) {
; CHECK-LABEL: @or_positive_sle_neg(
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[A:%.*]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
%cmp = icmp sle i8 %b, -1
ret i1 %cmp
}
define <2 x i1> @or_sle_neg_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_sle_neg_vec(
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[A:%.*]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
%cmp = icmp sle <2 x i8> %b, <i8 -1, i8 -1>
ret <2 x i1> %cmp
}
define i1 @or_positive_slt_neg(i8 %a) {
; CHECK-LABEL: @or_positive_slt_neg(
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[B]], -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
%cmp = icmp slt i8 %b, -1
ret i1 %cmp
}
define <2 x i1> @or_postive_slt_neg_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_slt_neg_vec(
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[B]], <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
%cmp = icmp slt <2 x i8> %b, <i8 -1, i8 -1>
ret <2 x i1> %cmp
}
define i1 @or_small_slt_large(i8 %a) {
; CHECK-LABEL: @or_small_slt_large(
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], 24
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[B]], 25
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
%cmp = icmp slt i8 %b, 25
ret i1 %cmp
}
define <2 x i1> @or_small_slt_large_vec(<2 x i8> %a) {
; CHECK-LABEL: @or_small_slt_large_vec(
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 24, i8 24>
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[B]], <i8 25, i8 25>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
%cmp = icmp slt <2 x i8> %b, <i8 25, i8 25>
ret <2 x i1> %cmp
}
; negative tests -- extra use
define i1 @or_positive_sgt_zero_multi_use(i8 %a) {
; CHECK-LABEL: @or_positive_sgt_zero_multi_use(
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], 24
; CHECK-NEXT: call void @use_i8(i8 [[B]])
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[B]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
call void @use_i8(i8 %b)
%cmp = icmp sgt i8 %b, 0
ret i1 %cmp
}
define <2 x i1> @or_postive_sgt_zero_vec_multi_use(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_sgt_zero_vec_multi_use(
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 24, i8 24>
; CHECK-NEXT: call void @use_v2i8(<2 x i8> [[B]])
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[B]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
call void @use_v2i8(<2 x i8> %b)
%cmp = icmp sgt <2 x i8> %b, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @or_positive_sge_zero_multi_use(i8 %a) {
; CHECK-LABEL: @or_positive_sge_zero_multi_use(
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], 24
; CHECK-NEXT: call void @use_i8(i8 [[B]])
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[B]], -1
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
call void @use_i8(i8 %b)
%cmp = icmp sge i8 %b, 0
ret i1 %cmp
}
define <2 x i1> @or_postive_sge_zero_vec_multi_use(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_sge_zero_vec_multi_use(
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 24, i8 24>
; CHECK-NEXT: call void @use_v2i8(<2 x i8> [[B]])
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[B]], <i8 -1, i8 -1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
call void @use_v2i8(<2 x i8> %b)
%cmp = icmp sge <2 x i8> %b, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @or_positive_sge_postive_multi_use(i8 %a) {
; CHECK-LABEL: @or_positive_sge_postive_multi_use(
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], 24
; CHECK-NEXT: call void @use_i8(i8 [[B]])
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i8 [[B]], 23
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
call void @use_i8(i8 %b)
%cmp = icmp sge i8 %b, 24
ret i1 %cmp
}
define <2 x i1> @or_postive_sge_positive_vec_multi_use(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_sge_positive_vec_multi_use(
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 24, i8 24>
; CHECK-NEXT: call void @use_v2i8(<2 x i8> [[B]])
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt <2 x i8> [[B]], <i8 23, i8 23>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
call void @use_v2i8(<2 x i8> %b)
%cmp = icmp sge <2 x i8> %b, <i8 24, i8 24>
ret <2 x i1> %cmp
}
define i1 @or_positive_sle_zero_multi_use(i8 %a) {
; CHECK-LABEL: @or_positive_sle_zero_multi_use(
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], 24
; CHECK-NEXT: call void @use_i8(i8 [[B]])
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[B]], 1
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
call void @use_i8(i8 %b)
%cmp = icmp sle i8 %b, 0
ret i1 %cmp
}
define <2 x i1> @or_postive_sle_zero_vec_multi_use(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_sle_zero_vec_multi_use(
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 24, i8 24>
; CHECK-NEXT: call void @use_v2i8(<2 x i8> [[B]])
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[B]], <i8 1, i8 1>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
call void @use_v2i8(<2 x i8> %b)
%cmp = icmp sle <2 x i8> %b, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @or_positive_slt_zero_multi_use(i8 %a) {
; CHECK-LABEL: @or_positive_slt_zero_multi_use(
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], 24
; CHECK-NEXT: call void @use_i8(i8 [[B]])
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[B]], 0
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
call void @use_i8(i8 %b)
%cmp = icmp slt i8 %b, 0
ret i1 %cmp
}
define <2 x i1> @or_postive_slt_zero_vec_multi_use(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_slt_zero_vec_multi_use(
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 24, i8 24>
; CHECK-NEXT: call void @use_v2i8(<2 x i8> [[B]])
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[B]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
call void @use_v2i8(<2 x i8> %b)
%cmp = icmp slt <2 x i8> %b, <i8 0, i8 0>
ret <2 x i1> %cmp
}
define i1 @or_positive_slt_postive_multi_use(i8 %a) {
; CHECK-LABEL: @or_positive_slt_postive_multi_use(
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], 24
; CHECK-NEXT: call void @use_i8(i8 [[B]])
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[B]], 24
; CHECK-NEXT: ret i1 [[CMP]]
;
%b = or i8 %a, 24
call void @use_i8(i8 %b)
%cmp = icmp slt i8 %b, 24
ret i1 %cmp
}
define <2 x i1> @or_postive_slt_positive_vec_multi_use(<2 x i8> %a) {
; CHECK-LABEL: @or_postive_slt_positive_vec_multi_use(
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 24, i8 24>
; CHECK-NEXT: call void @use_v2i8(<2 x i8> [[B]])
; CHECK-NEXT: [[CMP:%.*]] = icmp slt <2 x i8> [[B]], <i8 24, i8 24>
; CHECK-NEXT: ret <2 x i1> [[CMP]]
;
%b = or <2 x i8> %a, <i8 24, i8 24>
call void @use_v2i8(<2 x i8> %b)
%cmp = icmp slt <2 x i8> %b, <i8 24, i8 24>
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…