This is an archive of the discontinued LLVM Phabricator instance.

Differential D149408

[ValueTracking] Add more tests for `isKnownNonZero` cases; NFC
ClosedPublic

Authored by goldstein.w.n on Apr 27 2023, 11:19 PM.

Details

Reviewers
StephenFan
nikic
spatel
Commits
rGf7bf984ed3ac: [ValueTracking] Add more tests for `isKnownNonZero` cases; NFC

Diff Detail

Event Timeline

goldstein.w.n created this revision.Apr 27 2023, 11:19 PM
Herald added a project: Restricted Project. · View Herald TranscriptApr 27 2023, 11:19 PM
goldstein.w.n requested review of this revision.Apr 27 2023, 11:19 PM
Herald added a project: Restricted Project. · View Herald TranscriptApr 27 2023, 11:19 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B228728: Diff 517792.Apr 27 2023, 11:19 PM
goldstein.w.n added a parent revision: D149407: [ValueTracking] Pull out logic for detecting if `(add X, Y)` is non-zero; NFC.Apr 27 2023, 11:25 PM
goldstein.w.n added a child revision: D149409: [ValueTracking] Handle bitcasts between vec-int-ptr in `isKnownNonZero`.
nikic accepted this revision.Apr 28 2023, 1:56 AM

LGTM (haven't looked this over in detail)

This revision is now accepted and ready to land.Apr 28 2023, 1:56 AM
goldstein.w.n updated this revision to Diff 518172.Apr 29 2023, 9:12 AM

Add more tests for bittest case

Harbormaster completed remote builds in B229013: Diff 518172.Apr 29 2023, 10:05 AM
goldstein.w.n updated this revision to Diff 518203.Apr 29 2023, 11:41 AM

Add tests for bitcast of smaller size but not multiple

Harbormaster completed remote builds in B229039: Diff 518203.Apr 29 2023, 1:09 PM
goldstein.w.n updated this revision to Diff 518242.Apr 29 2023, 3:06 PM

Rebase

Harbormaster completed remote builds in B229074: Diff 518242.Apr 29 2023, 4:03 PM
Closed by commit rGf7bf984ed3ac: [ValueTracking] Add more tests for `isKnownNonZero` cases; NFC (authored by goldstein.w.n). · Explain WhyApr 30 2023, 8:07 AM
This revision was automatically updated to reflect the committed changes.
goldstein.w.n added a commit: rGf7bf984ed3ac: [ValueTracking] Add more tests for `isKnownNonZero` cases; NFC.

Revision Contents

PathSize
llvm/
test/
Analysis/
ValueTracking/
599 lines

Diff 518318

llvm/test/Analysis/ValueTracking/known-non-zero.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 -passes=instsimplify < %s -S | FileCheck %s ; RUN: opt -passes=instsimplify < %s -S | FileCheck %s
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
declare i8 @llvm.abs.i8(i8, i1) declare i8 @llvm.abs.i8(i8, i1)
declare i8 @llvm.bitreverse.i8(i8) declare i8 @llvm.bitreverse.i8(i8)
declare i16 @llvm.bswap.i16(i16) declare i16 @llvm.bswap.i16(i16)
declare i8 @llvm.ctpop.i8(i8) declare i8 @llvm.ctpop.i8(i8)
declare <2 x i8> @llvm.uadd.sat.2xi8(<2 x i8>, <2 x i8>) declare <2 x i8> @llvm.uadd.sat.2xi8(<2 x i8>, <2 x i8>)
declare i8 @llvm.uadd.sat.i8(i8, i8) declare i8 @llvm.uadd.sat.i8(i8, i8)
declare i8 @llvm.fshr.i8(i8, i8, i8) declare i8 @llvm.fshr.i8(i8, i8, i8)
declare i8 @llvm.fshl.i8(i8, i8, i8) declare i8 @llvm.fshl.i8(i8, i8, i8)
declare i8 @llvm.ctlz.i8(i8, i1)
declare i8 @llvm.cttz.i8(i8, i1)
declare i8 @llvm.sadd.sat.i8(i8, i8)
declare i8 @llvm.smax.i8(i8, i8)
declare i8 @llvm.smin.i8(i8, i8)
declare i8 @llvm.sshl.sat.i8(i8, i8)
declare i8 @llvm.ssub.sat.i8(i8, i8)
declare i8 @llvm.umax.i8(i8, i8)
declare i8 @llvm.umin.i8(i8, i8)
declare i8 @llvm.ushl.sat.i8(i8, i8)
declare i8 @llvm.usub.sat.i8(i8, i8)
declare float @llvm.maximum.f32(float, float)
;; Throughout use: X > Y || Y == 0 which folds to X > Y iff X known ;; Throughout use: X > Y || Y == 0 which folds to X > Y iff X known
;; non-zero. Do this because many of the expressions already have ;; non-zero. Do this because many of the expressions already have
;; hardcoded cases for folding Foo(X) == 0 -> X == 0 and we want to ;; hardcoded cases for folding Foo(X) == 0 -> X == 0 and we want to
;; test explicitly that `isKnownNonZero` works. ;; test explicitly that `isKnownNonZero` works.
define i1 @check_neg(i8 %x, i8 %y) { define i1 @check_neg(i8 %x, i8 %y) {
; CHECK-LABEL: @check_neg( ; CHECK-LABEL: @check_neg(
▲ Show 20 Lines • Show All 258 Lines • ▼ Show 20 Lines
; ;
%cnt = and <2 x i32> %x, <i32 16, i32 24> %cnt = and <2 x i32> %x, <i32 16, i32 24>
%val = or <2 x i32> %y, <i32 402784272, i32 268697601> %val = or <2 x i32> %y, <i32 402784272, i32 268697601>
%shl = ashr <2 x i32> %val, %cnt %shl = ashr <2 x i32> %val, %cnt
%r = icmp eq <2 x i32> %shl, zeroinitializer %r = icmp eq <2 x i32> %shl, zeroinitializer
ret <2 x i1> %r ret <2 x i1> %r
} }
define i1 @lshr_nz_bounded_cnt_fail(i32 %cnt, i32 %y) { define i1 @lshr_nz_bounded_cnt_fail(i32 %cnt, i32 %y) {
; CHECK-LABEL: @lshr_nz_bounded_cnt_fail( ; CHECK-LABEL: @lshr_nz_bounded_cnt_fail(
; CHECK-NEXT: [[CNT_ULT:%.*]] = icmp ult i32 [[CNT:%.*]], 20 ; CHECK-NEXT: [[CNT_ULT:%.*]] = icmp ult i32 [[CNT:%.*]], 20
; CHECK-NEXT: call void @llvm.assume(i1 [[CNT_ULT]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[CNT_ULT]])
; CHECK-NEXT: [[VAL:%.*]] = or i32 [[Y:%.*]], 131072 ; CHECK-NEXT: [[VAL:%.*]] = or i32 [[Y:%.*]], 131072
; CHECK-NEXT: [[SHL:%.*]] = lshr i32 [[VAL]], [[CNT]] ; CHECK-NEXT: [[SHL:%.*]] = lshr i32 [[VAL]], [[CNT]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i32 [[SHL]], 0 ; CHECK-NEXT: [[R:%.*]] = icmp eq i32 [[SHL]], 0
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
Show All 16 Lines
; ;
%cnt = and <2 x i32> %x, <i32 24, i32 24> %cnt = and <2 x i32> %x, <i32 24, i32 24>
%val = or <2 x i32> %y, <i32 131088, i32 268697601> %val = or <2 x i32> %y, <i32 131088, i32 268697601>
%shl = ashr <2 x i32> %val, %cnt %shl = ashr <2 x i32> %val, %cnt
%r = icmp eq <2 x i32> %shl, zeroinitializer %r = icmp eq <2 x i32> %shl, zeroinitializer
ret <2 x i1> %r ret <2 x i1> %r
} }
define i1 @lshr_nonzero_and_shift_out_zeros(i32 %cnt, i32 %y) { define i1 @lshr_nonzero_and_shift_out_zeros(i32 %cnt, i32 %y) {
; CHECK-LABEL: @lshr_nonzero_and_shift_out_zeros( ; CHECK-LABEL: @lshr_nonzero_and_shift_out_zeros(
; CHECK-NEXT: [[CNT_ULT:%.*]] = icmp ult i32 [[CNT:%.*]], 4 ; CHECK-NEXT: [[CNT_ULT:%.*]] = icmp ult i32 [[CNT:%.*]], 4
; CHECK-NEXT: call void @llvm.assume(i1 [[CNT_ULT]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[CNT_ULT]])
; CHECK-NEXT: [[VAL:%.*]] = and i32 [[Y:%.*]], -131072 ; CHECK-NEXT: [[VAL:%.*]] = and i32 [[Y:%.*]], -131072
; CHECK-NEXT: [[VAL_NZ:%.*]] = icmp ne i32 [[VAL]], 0 ; CHECK-NEXT: [[VAL_NZ:%.*]] = icmp ne i32 [[VAL]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[VAL_NZ]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[VAL_NZ]])
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
%cnt_ult = icmp ult i32 %cnt, 4 %cnt_ult = icmp ult i32 %cnt, 4
call void @llvm.assume(i1 %cnt_ult) call void @llvm.assume(i1 %cnt_ult)
%val = and i32 %y, -131072 %val = and i32 %y, -131072
%val_nz = icmp ne i32 %val, 0 %val_nz = icmp ne i32 %val, 0
call void @llvm.assume(i1 %val_nz) call void @llvm.assume(i1 %val_nz)
%shl = lshr i32 %val, %cnt %shl = lshr i32 %val, %cnt
%r = icmp eq i32 %shl, 0 %r = icmp eq i32 %shl, 0
ret i1 %r ret i1 %r
} }
define i1 @ashr_nonzero_and_shift_out_zeros(i32 %ccnt, i32 %y) { define i1 @ashr_nonzero_and_shift_out_zeros(i32 %ccnt, i32 %y) {
; CHECK-LABEL: @ashr_nonzero_and_shift_out_zeros( ; CHECK-LABEL: @ashr_nonzero_and_shift_out_zeros(
; CHECK-NEXT: [[VAL:%.*]] = and i32 [[Y:%.*]], -131072 ; CHECK-NEXT: [[VAL:%.*]] = and i32 [[Y:%.*]], -131072
; CHECK-NEXT: [[VAL_NZ:%.*]] = icmp ne i32 [[VAL]], 0 ; CHECK-NEXT: [[VAL_NZ:%.*]] = icmp ne i32 [[VAL]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[VAL_NZ]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[VAL_NZ]])
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
%cnt = and i32 %ccnt, 7 %cnt = and i32 %ccnt, 7
%val = and i32 %y, -131072 %val = and i32 %y, -131072
%val_nz = icmp ne i32 %val, 0 %val_nz = icmp ne i32 %val, 0
call void @llvm.assume(i1 %val_nz) call void @llvm.assume(i1 %val_nz)
%shl = ashr i32 %val, %cnt %shl = ashr i32 %val, %cnt
%r = icmp eq i32 %shl, 0 %r = icmp eq i32 %shl, 0
ret i1 %r ret i1 %r
} }
define i1 @shl_nonzero_and_shift_out_zeros(i32 %ccnt, i32 %y) { define i1 @shl_nonzero_and_shift_out_zeros(i32 %ccnt, i32 %y) {
; CHECK-LABEL: @shl_nonzero_and_shift_out_zeros( ; CHECK-LABEL: @shl_nonzero_and_shift_out_zeros(
; CHECK-NEXT: [[VAL:%.*]] = and i32 [[Y:%.*]], 131071 ; CHECK-NEXT: [[VAL:%.*]] = and i32 [[Y:%.*]], 131071
; CHECK-NEXT: [[VAL_NZ:%.*]] = icmp ne i32 [[VAL]], 0 ; CHECK-NEXT: [[VAL_NZ:%.*]] = icmp ne i32 [[VAL]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[VAL_NZ]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[VAL_NZ]])
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
%cnt = and i32 %ccnt, 6 %cnt = and i32 %ccnt, 6
%val = and i32 %y, 131071 %val = and i32 %y, 131071
%val_nz = icmp ne i32 %val, 0 %val_nz = icmp ne i32 %val, 0
call void @llvm.assume(i1 %val_nz) call void @llvm.assume(i1 %val_nz)
%shl = shl i32 %val, %cnt %shl = shl i32 %val, %cnt
%r = icmp eq i32 %shl, 0 %r = icmp eq i32 %shl, 0
ret i1 %r ret i1 %r
} }
define i1 @lshr_nonzero_and_shift_out_zeros_fail(i32 %cnt, i32 %y) { define i1 @lshr_nonzero_and_shift_out_zeros_fail(i32 %cnt, i32 %y) {
; CHECK-LABEL: @lshr_nonzero_and_shift_out_zeros_fail( ; CHECK-LABEL: @lshr_nonzero_and_shift_out_zeros_fail(
; CHECK-NEXT: [[CNT_ULT:%.*]] = icmp ult i32 [[CNT:%.*]], 19 ; CHECK-NEXT: [[CNT_ULT:%.*]] = icmp ult i32 [[CNT:%.*]], 19
; CHECK-NEXT: call void @llvm.assume(i1 [[CNT_ULT]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[CNT_ULT]])
; CHECK-NEXT: [[VAL:%.*]] = and i32 [[Y:%.*]], -131072 ; CHECK-NEXT: [[VAL:%.*]] = and i32 [[Y:%.*]], -131072
; CHECK-NEXT: [[VAL_NZ:%.*]] = icmp ne i32 [[VAL]], 0 ; CHECK-NEXT: [[VAL_NZ:%.*]] = icmp ne i32 [[VAL]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[VAL_NZ]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[VAL_NZ]])
; CHECK-NEXT: [[SHL:%.*]] = lshr i32 [[VAL]], [[CNT]] ; CHECK-NEXT: [[SHL:%.*]] = lshr i32 [[VAL]], [[CNT]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i32 [[SHL]], 0 ; CHECK-NEXT: [[R:%.*]] = icmp eq i32 [[SHL]], 0
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
; ;
%cnt_ult = icmp ult i32 %cnt, 19 %cnt_ult = icmp ult i32 %cnt, 19
call void @llvm.assume(i1 %cnt_ult) call void @llvm.assume(i1 %cnt_ult)
%val = and i32 %y, -131072 %val = and i32 %y, -131072
%val_nz = icmp ne i32 %val, 0 %val_nz = icmp ne i32 %val, 0
call void @llvm.assume(i1 %val_nz) call void @llvm.assume(i1 %val_nz)
%shl = lshr i32 %val, %cnt %shl = lshr i32 %val, %cnt
%r = icmp eq i32 %shl, 0 %r = icmp eq i32 %shl, 0
ret i1 %r ret i1 %r
} }
define i1 @ashr_nonzero_and_shift_out_zeros_fail(i32 %ccnt, i32 %y) { define i1 @ashr_nonzero_and_shift_out_zeros_fail(i32 %ccnt, i32 %y) {
; CHECK-LABEL: @ashr_nonzero_and_shift_out_zeros_fail( ; CHECK-LABEL: @ashr_nonzero_and_shift_out_zeros_fail(
; CHECK-NEXT: [[CNT:%.*]] = and i32 [[CCNT:%.*]], 18 ; CHECK-NEXT: [[CNT:%.*]] = and i32 [[CCNT:%.*]], 18
; CHECK-NEXT: [[VAL:%.*]] = and i32 [[Y:%.*]], -131072 ; CHECK-NEXT: [[VAL:%.*]] = and i32 [[Y:%.*]], -131072
; CHECK-NEXT: [[VAL_NZ:%.*]] = icmp ne i32 [[VAL]], 0 ; CHECK-NEXT: [[VAL_NZ:%.*]] = icmp ne i32 [[VAL]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[VAL_NZ]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[VAL_NZ]])
; CHECK-NEXT: [[SHL:%.*]] = ashr i32 [[VAL]], [[CNT]] ; CHECK-NEXT: [[SHL:%.*]] = ashr i32 [[VAL]], [[CNT]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i32 [[SHL]], 0 ; CHECK-NEXT: [[R:%.*]] = icmp eq i32 [[SHL]], 0
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
; ;
%cnt = and i32 %ccnt, 18 %cnt = and i32 %ccnt, 18
%val = and i32 %y, -131072 %val = and i32 %y, -131072
%val_nz = icmp ne i32 %val, 0 %val_nz = icmp ne i32 %val, 0
call void @llvm.assume(i1 %val_nz) call void @llvm.assume(i1 %val_nz)
%shl = ashr i32 %val, %cnt %shl = ashr i32 %val, %cnt
%r = icmp eq i32 %shl, 0 %r = icmp eq i32 %shl, 0
ret i1 %r ret i1 %r
} }
define i1 @shl_nonzero_and_shift_out_zeros_fail(i32 %ccnt, i32 %y) { define i1 @shl_nonzero_and_shift_out_zeros_fail(i32 %ccnt, i32 %y) {
; CHECK-LABEL: @shl_nonzero_and_shift_out_zeros_fail( ; CHECK-LABEL: @shl_nonzero_and_shift_out_zeros_fail(
; CHECK-NEXT: [[CNT:%.*]] = and i32 [[CCNT:%.*]], 6 ; CHECK-NEXT: [[CNT:%.*]] = and i32 [[CCNT:%.*]], 6
; CHECK-NEXT: [[VAL:%.*]] = and i32 [[Y:%.*]], 268435455 ; CHECK-NEXT: [[VAL:%.*]] = and i32 [[Y:%.*]], 268435455
; CHECK-NEXT: [[VAL_NZ:%.*]] = icmp ne i32 [[VAL]], 0 ; CHECK-NEXT: [[VAL_NZ:%.*]] = icmp ne i32 [[VAL]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[VAL_NZ]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[VAL_NZ]])
; CHECK-NEXT: [[SHL:%.*]] = shl i32 [[VAL]], [[CNT]] ; CHECK-NEXT: [[SHL:%.*]] = shl i32 [[VAL]], [[CNT]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i32 [[SHL]], 0 ; CHECK-NEXT: [[R:%.*]] = icmp eq i32 [[SHL]], 0
; CHECK-NEXT: ret i1 [[R]] ; CHECK-NEXT: ret i1 [[R]]
; ;
%cnt = and i32 %ccnt, 6 %cnt = and i32 %ccnt, 6
%val = and i32 %y, 268435455 %val = and i32 %y, 268435455
%val_nz = icmp ne i32 %val, 0 %val_nz = icmp ne i32 %val, 0
call void @llvm.assume(i1 %val_nz) call void @llvm.assume(i1 %val_nz)
%shl = shl i32 %val, %cnt %shl = shl i32 %val, %cnt
%r = icmp eq i32 %shl, 0 %r = icmp eq i32 %shl, 0
ret i1 %r ret i1 %r
} }
define i1 @sub_nonzero_ops_ne(i8 %xx, i8 %yy, i8 %z) { define i1 @sub_nonzero_ops_ne(i8 %xx, i8 %yy, i8 %z) {
; CHECK-LABEL: @sub_nonzero_ops_ne( ; CHECK-LABEL: @sub_nonzero_ops_ne(
▲ Show 20 Lines • Show All 145 Lines • ▼ Show 20 Lines;
call void @llvm.assume(i1 %pred0) call void @llvm.assume(i1 %pred0)
%pred1 = icmp ne i8 %w, 0 %pred1 = icmp ne i8 %w, 0
call void @llvm.assume(i1 %pred1) call void @llvm.assume(i1 %pred1)
%v = tail call i8 @llvm.fshl.i8(i8 %x, i8 %w, i8 %y) %v = tail call i8 @llvm.fshl.i8(i8 %x, i8 %w, i8 %y)
%or = or i8 %v, %z %or = or i8 %v, %z
%r = icmp eq i8 %or, 0 %r = icmp eq i8 %or, 0
ret i1 %r ret i1 %r
} }
define i1 @bitcast_nonzero(<2 x i8> %xx, i16 %ind) {
; CHECK-LABEL: @bitcast_nonzero(
; CHECK-NEXT: [[XA:%.*]] = add nuw nsw <2 x i8> [[XX:%.*]], <i8 1, i8 1>
; CHECK-NEXT: [[X:%.*]] = bitcast <2 x i8> [[XA]] to i16
; CHECK-NEXT: [[Z:%.*]] = or i16 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i16 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%xa = add nuw nsw <2 x i8> %xx, <i8 1, i8 1>
%x = bitcast <2 x i8> %xa to i16
%z = or i16 %x, %ind
%r = icmp eq i16 %z, 0
ret i1 %r
}
define i1 @bitcast_todo_partial_nonzero_vec_to_int(<2 x i8> %xx, i16 %ind) {
; CHECK-LABEL: @bitcast_todo_partial_nonzero_vec_to_int(
; CHECK-NEXT: [[XA:%.*]] = add nuw nsw <2 x i8> [[XX:%.*]], <i8 1, i8 0>
; CHECK-NEXT: [[X:%.*]] = bitcast <2 x i8> [[XA]] to i16
; CHECK-NEXT: [[Z:%.*]] = or i16 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i16 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%xa = add nuw nsw <2 x i8> %xx, <i8 1, i8 0>
%x = bitcast <2 x i8> %xa to i16
%z = or i16 %x, %ind
%r = icmp eq i16 %z, 0
ret i1 %r
}
define <2 x i1> @bitcast_fail_nonzero_int_to_vec(i16 %xx, <2 x i8> %ind) {
; CHECK-LABEL: @bitcast_fail_nonzero_int_to_vec(
; CHECK-NEXT: [[XA:%.*]] = add nuw nsw i16 [[XX:%.*]], 1
; CHECK-NEXT: [[X:%.*]] = bitcast i16 [[XA]] to <2 x i8>
; CHECK-NEXT: [[Z:%.*]] = or <2 x i8> [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq <2 x i8> [[Z]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[R]]
;
%xa = add nuw nsw i16 %xx, 1
%x = bitcast i16 %xa to <2 x i8>
%z = or <2 x i8> %x, %ind
%r = icmp eq <2 x i8> %z, zeroinitializer
ret <2 x i1> %r
}
define <2 x i1> @bitcast_veci8_to_veci16(<4 x i8> %xx, <2 x i16> %ind) {
; CHECK-LABEL: @bitcast_veci8_to_veci16(
; CHECK-NEXT: [[XA:%.*]] = add nuw nsw <4 x i8> [[XX:%.*]], <i8 1, i8 1, i8 1, i8 1>
; CHECK-NEXT: [[X:%.*]] = bitcast <4 x i8> [[XA]] to <2 x i16>
; CHECK-NEXT: [[Z:%.*]] = or <2 x i16> [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq <2 x i16> [[Z]], zeroinitializer
; CHECK-NEXT: ret <2 x i1> [[R]]
;
%xa = add nuw nsw <4 x i8> %xx, <i8 1, i8 1, i8 1, i8 1>
%x = bitcast <4 x i8> %xa to <2 x i16>
%z = or <2 x i16> %x, %ind
%r = icmp eq <2 x i16> %z, zeroinitializer
ret <2 x i1> %r
}
define <3 x i1> @bitcast_veci3_to_veci4_fail_not_multiple(<4 x i3> %xx, <3 x i4> %ind) {
; CHECK-LABEL: @bitcast_veci3_to_veci4_fail_not_multiple(
; CHECK-NEXT: [[XA:%.*]] = add nuw nsw <4 x i3> [[XX:%.*]], <i3 1, i3 1, i3 1, i3 1>
; CHECK-NEXT: [[X:%.*]] = bitcast <4 x i3> [[XA]] to <3 x i4>
; CHECK-NEXT: [[Z:%.*]] = or <3 x i4> [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq <3 x i4> [[Z]], zeroinitializer
; CHECK-NEXT: ret <3 x i1> [[R]]
;
%xa = add nuw nsw <4 x i3> %xx, <i3 1, i3 1, i3 1, i3 1>
%x = bitcast <4 x i3> %xa to <3 x i4>
%z = or <3 x i4> %x, %ind
%r = icmp eq <3 x i4> %z, zeroinitializer
ret <3 x i1> %r
}
define <4 x i1> @bitcast_fail_veci16_to_veci8(<2 x i16> %xx, <4 x i8> %ind) {
; CHECK-LABEL: @bitcast_fail_veci16_to_veci8(
; CHECK-NEXT: [[XA:%.*]] = add nuw nsw <2 x i16> [[XX:%.*]], <i16 1, i16 1>
; CHECK-NEXT: [[X:%.*]] = bitcast <2 x i16> [[XA]] to <4 x i8>
; CHECK-NEXT: [[Z:%.*]] = or <4 x i8> [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq <4 x i8> [[Z]], zeroinitializer
; CHECK-NEXT: ret <4 x i1> [[R]]
;
%xa = add nuw nsw <2 x i16> %xx, <i16 1, i16 1>
%x = bitcast <2 x i16> %xa to <4 x i8>
%z = or <4 x i8> %x, %ind
%r = icmp eq <4 x i8> %z, zeroinitializer
ret <4 x i1> %r
}
define i1 @bitcast_nonzero_fail_dont_check_float(float %xx, i32 %ind) {
; CHECK-LABEL: @bitcast_nonzero_fail_dont_check_float(
; CHECK-NEXT: [[XA:%.*]] = call float @llvm.maximum.f32(float [[XX:%.*]], float 1.000000e+00)
; CHECK-NEXT: [[X:%.*]] = bitcast float [[XA]] to i32
; CHECK-NEXT: [[Z:%.*]] = or i32 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i32 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%xa = call float @llvm.maximum.f32(float %xx, float 1.000000e+00)
%x = bitcast float %xa to i32
%z = or i32 %x, %ind
%r = icmp eq i32 %z, 0
ret i1 %r
}
define i1 @ctlz_true_nonzero(i8 %xx, i8 %ind) {
; CHECK-LABEL: @ctlz_true_nonzero(
; CHECK-NEXT: [[XS:%.*]] = lshr i8 [[XX:%.*]], 1
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.ctlz.i8(i8 [[XS]], i1 true)
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%xs = lshr i8 %xx, 1
%x = call i8 @llvm.ctlz.i8(i8 %xs, i1 true)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @ctlz_false_nonzero(i8 %xx, i8 %ind) {
; CHECK-LABEL: @ctlz_false_nonzero(
; CHECK-NEXT: [[XA:%.*]] = and i8 [[XX:%.*]], 127
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.ctlz.i8(i8 [[XA]], i1 true)
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%xa = and i8 %xx, 127
%x = call i8 @llvm.ctlz.i8(i8 %xa, i1 true)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @ctlz_nonzero_fail_maybe_neg(i8 %xx, i8 %ind) {
; CHECK-LABEL: @ctlz_nonzero_fail_maybe_neg(
; CHECK-NEXT: [[XS:%.*]] = ashr i8 [[XX:%.*]], 1
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.ctlz.i8(i8 [[XS]], i1 true)
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%xs = ashr i8 %xx, 1
%x = call i8 @llvm.ctlz.i8(i8 %xs, i1 true)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @cttz_true_nonzero(i8 %xx, i8 %ind) {
; CHECK-LABEL: @cttz_true_nonzero(
; CHECK-NEXT: [[XS:%.*]] = shl i8 [[XX:%.*]], 1
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.cttz.i8(i8 [[XS]], i1 true)
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%xs = shl i8 %xx, 1
%x = call i8 @llvm.cttz.i8(i8 %xs, i1 true)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @cttz_false_nonzero(i8 %xx, i8 %ind) {
; CHECK-LABEL: @cttz_false_nonzero(
; CHECK-NEXT: [[XA:%.*]] = and i8 [[XX:%.*]], -2
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.cttz.i8(i8 [[XA]], i1 true)
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%xa = and i8 %xx, -2
%x = call i8 @llvm.cttz.i8(i8 %xa, i1 true)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @cttz_nonzero_fail_maybe_odd(i8 %xx, i8 %cnt, i8 %ind) {
; CHECK-LABEL: @cttz_nonzero_fail_maybe_odd(
; CHECK-NEXT: [[XS:%.*]] = shl i8 [[XX:%.*]], [[CNT:%.*]]
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.cttz.i8(i8 [[XS]], i1 true)
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%xs = shl i8 %xx, %cnt
%x = call i8 @llvm.cttz.i8(i8 %xs, i1 true)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @mul_nonzero_odd(i8 %xx, i8 %y, i8 %ind) {
; CHECK-LABEL: @mul_nonzero_odd(
; CHECK-NEXT: [[XO:%.*]] = or i8 [[XX:%.*]], 1
; CHECK-NEXT: [[Y_NZ:%.*]] = icmp ne i8 [[Y:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[Y_NZ]])
; CHECK-NEXT: [[X:%.*]] = mul i8 [[XO]], [[Y]]
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%xo = or i8 %xx, 1
%y_nz = icmp ne i8 %y, 0
call void @llvm.assume(i1 %y_nz)
%x = mul i8 %xo, %y
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @mul_nonzero_odd_fail_y_maybe_zero(i8 %xx, i8 %y, i8 %ind) {
; CHECK-LABEL: @mul_nonzero_odd_fail_y_maybe_zero(
; CHECK-NEXT: [[XO:%.*]] = or i8 [[XX:%.*]], 1
; CHECK-NEXT: [[X:%.*]] = mul i8 [[XO]], [[Y:%.*]]
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%xo = or i8 %xx, 1
%x = mul i8 %xo, %y
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @sshl_nonzero(i8 %xx, i8 %y, i8 %ind) {
; CHECK-LABEL: @sshl_nonzero(
; CHECK-NEXT: [[X_NZ:%.*]] = icmp ne i8 [[XX:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[X_NZ]])
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.sshl.sat.i8(i8 [[XX]], i8 [[Y:%.*]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%x_nz = icmp ne i8 %xx, 0
call void @llvm.assume(i1 %x_nz)
%x = call i8 @llvm.sshl.sat.i8(i8 %xx, i8 %y)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @sshl_nonzero_fail_x_maybe_z(i8 %xx, i8 %y, i8 %ind) {
; CHECK-LABEL: @sshl_nonzero_fail_x_maybe_z(
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.sshl.sat.i8(i8 [[XX:%.*]], i8 [[Y:%.*]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%x = call i8 @llvm.sshl.sat.i8(i8 %xx, i8 %y)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @ushl_nonzero(i8 %xx, i8 %y, i8 %ind) {
; CHECK-LABEL: @ushl_nonzero(
; CHECK-NEXT: [[X_NZ:%.*]] = icmp ne i8 [[XX:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[X_NZ]])
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.ushl.sat.i8(i8 [[XX]], i8 [[Y:%.*]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%x_nz = icmp ne i8 %xx, 0
call void @llvm.assume(i1 %x_nz)
%x = call i8 @llvm.ushl.sat.i8(i8 %xx, i8 %y)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @ushl_nonzero_fail_x_maybe_z(i8 %xx, i8 %y, i8 %ind) {
; CHECK-LABEL: @ushl_nonzero_fail_x_maybe_z(
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.ushl.sat.i8(i8 [[XX:%.*]], i8 [[Y:%.*]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%x = call i8 @llvm.ushl.sat.i8(i8 %xx, i8 %y)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @ssub_sat_nonzero(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @ssub_sat_nonzero(
; CHECK-NEXT: [[XA:%.*]] = and i8 [[XX:%.*]], -65
; CHECK-NEXT: [[YO:%.*]] = or i8 [[YY:%.*]], 64
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[XA]], i8 [[YO]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%xa = and i8 %xx, 191
%yo = or i8 %yy, 64
%x = call i8 @llvm.ssub.sat.i8(i8 %xa, i8 %yo)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @ssub_sat_nonzero_ne_known_bits_fail_overlap(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @ssub_sat_nonzero_ne_known_bits_fail_overlap(
; CHECK-NEXT: [[XA:%.*]] = and i8 [[XX:%.*]], -64
; CHECK-NEXT: [[YO:%.*]] = or i8 [[YY:%.*]], 64
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.ssub.sat.i8(i8 [[XA]], i8 [[YO]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%xa = and i8 %xx, 192
%yo = or i8 %yy, 64
%x = call i8 @llvm.ssub.sat.i8(i8 %xa, i8 %yo)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @usub_sat_nonzero(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @usub_sat_nonzero(
; CHECK-NEXT: [[Y_ULT_31:%.*]] = icmp ult i8 [[YY:%.*]], 31
; CHECK-NEXT: call void @llvm.assume(i1 [[Y_ULT_31]])
; CHECK-NEXT: [[XO:%.*]] = or i8 [[XX:%.*]], 34
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[XO]], i8 [[YY]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%y_ult_31 = icmp ult i8 %yy, 31
call void @llvm.assume(i1 %y_ult_31)
%xo = or i8 %xx, 34
%x = call i8 @llvm.usub.sat.i8(i8 %xo, i8 %yy)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @usub_sat_nonzero_fail(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @usub_sat_nonzero_fail(
; CHECK-NEXT: [[XA:%.*]] = and i8 [[XX:%.*]], 16
; CHECK-NEXT: [[YO:%.*]] = or i8 [[YY:%.*]], 7
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.usub.sat.i8(i8 [[XA]], i8 [[YO]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%xa = and i8 %xx, 16
%yo = or i8 %yy, 7
%x = call i8 @llvm.usub.sat.i8(i8 %xa, i8 %yo)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @sadd_sat_nonzero(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @sadd_sat_nonzero(
; CHECK-NEXT: [[X_STRICT_POS:%.*]] = icmp sgt i8 [[XX:%.*]], 0
; CHECK-NEXT: [[Y_POS:%.*]] = icmp sge i8 [[YY:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[X_STRICT_POS]])
; CHECK-NEXT: call void @llvm.assume(i1 [[Y_POS]])
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[XX]], i8 [[YY]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%x_strict_pos = icmp sgt i8 %xx, 0
%y_pos = icmp sge i8 %yy, 0
call void @llvm.assume(i1 %x_strict_pos)
call void @llvm.assume(i1 %y_pos)
%x = call i8 @llvm.sadd.sat.i8(i8 %xx, i8 %yy)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @sadd_sat_nonzero_fail_maybe_zz(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @sadd_sat_nonzero_fail_maybe_zz(
; CHECK-NEXT: [[X_POS:%.*]] = icmp sge i8 [[XX:%.*]], 0
; CHECK-NEXT: [[Y_POS:%.*]] = icmp sge i8 [[YY:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[X_POS]])
; CHECK-NEXT: call void @llvm.assume(i1 [[Y_POS]])
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.sadd.sat.i8(i8 [[XX]], i8 [[YY]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%x_pos = icmp sge i8 %xx, 0
%y_pos = icmp sge i8 %yy, 0
call void @llvm.assume(i1 %x_pos)
call void @llvm.assume(i1 %y_pos)
%x = call i8 @llvm.sadd.sat.i8(i8 %xx, i8 %yy)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @umax_nonzero(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @umax_nonzero(
; CHECK-NEXT: [[X_NZ:%.*]] = icmp ne i8 [[XX:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[X_NZ]])
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.umax.i8(i8 [[XX]], i8 [[YY:%.*]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%x_nz = icmp ne i8 %xx, 0
call void @llvm.assume(i1 %x_nz)
%x = call i8 @llvm.umax.i8(i8 %xx, i8 %yy)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @umax_nonzero_fail_x_maybe_z(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @umax_nonzero_fail_x_maybe_z(
; CHECK-NEXT: [[X_NZ:%.*]] = icmp sge i8 [[XX:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[X_NZ]])
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.umax.i8(i8 [[XX]], i8 [[YY:%.*]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%x_nz = icmp sge i8 %xx, 0
call void @llvm.assume(i1 %x_nz)
%x = call i8 @llvm.umax.i8(i8 %xx, i8 %yy)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @umin_nonzero(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @umin_nonzero(
; CHECK-NEXT: [[X_NZ:%.*]] = icmp ne i8 [[XX:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[X_NZ]])
; CHECK-NEXT: [[Y_NZ:%.*]] = icmp ne i8 [[YY:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[Y_NZ]])
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.umin.i8(i8 [[XX]], i8 [[YY]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%x_nz = icmp ne i8 %xx, 0
call void @llvm.assume(i1 %x_nz)
%y_nz = icmp ne i8 %yy, 0
call void @llvm.assume(i1 %y_nz)
%x = call i8 @llvm.umin.i8(i8 %xx, i8 %yy)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @umin_nonzero_fail_y_maybe_z(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @umin_nonzero_fail_y_maybe_z(
; CHECK-NEXT: [[X_NZ:%.*]] = icmp ne i8 [[XX:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[X_NZ]])
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.umin.i8(i8 [[XX]], i8 [[YY:%.*]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%x_nz = icmp ne i8 %xx, 0
call void @llvm.assume(i1 %x_nz)
%x = call i8 @llvm.umin.i8(i8 %xx, i8 %yy)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @smin_nonzero(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @smin_nonzero(
; CHECK-NEXT: [[X_NZ:%.*]] = icmp ne i8 [[XX:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[X_NZ]])
; CHECK-NEXT: [[Y_NZ:%.*]] = icmp ne i8 [[YY:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[Y_NZ]])
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.umin.i8(i8 [[XX]], i8 [[YY]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%x_nz = icmp ne i8 %xx, 0
call void @llvm.assume(i1 %x_nz)
%y_nz = icmp ne i8 %yy, 0
call void @llvm.assume(i1 %y_nz)
%x = call i8 @llvm.umin.i8(i8 %xx, i8 %yy)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @smin_nonzero_neg_arg(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @smin_nonzero_neg_arg(
; CHECK-NEXT: [[X_NEG:%.*]] = icmp slt i8 [[XX:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[X_NEG]])
; CHECK-NEXT: ret i1 false
;
%x_neg = icmp slt i8 %xx, 0
call void @llvm.assume(i1 %x_neg)
%x = call i8 @llvm.smin.i8(i8 %xx, i8 %yy)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @smin_nonzero_fail_y_maybe_z(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @smin_nonzero_fail_y_maybe_z(
; CHECK-NEXT: [[X_NZ:%.*]] = icmp sle i8 [[XX:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[X_NZ]])
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.smin.i8(i8 [[XX]], i8 [[YY:%.*]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%x_nz = icmp sle i8 %xx, 0
call void @llvm.assume(i1 %x_nz)
%x = call i8 @llvm.smin.i8(i8 %xx, i8 %yy)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @smax_nonzero_pos_arg(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @smax_nonzero_pos_arg(
; CHECK-NEXT: [[YA:%.*]] = and i8 [[YY:%.*]], 127
; CHECK-NEXT: [[YO:%.*]] = or i8 [[YA]], 1
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.smax.i8(i8 [[XX:%.*]], i8 [[YO]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%ya = and i8 %yy, 127
%yo = or i8 %ya, 1
%x = call i8 @llvm.smax.i8(i8 %xx, i8 %yo)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}
define i1 @smax_nonzero_pos_arg_fail_nonstrict_pos(i8 %xx, i8 %yy, i8 %ind) {
; CHECK-LABEL: @smax_nonzero_pos_arg_fail_nonstrict_pos(
; CHECK-NEXT: [[Y_POS:%.*]] = icmp sge i8 [[YY:%.*]], 0
; CHECK-NEXT: call void @llvm.assume(i1 [[Y_POS]])
; CHECK-NEXT: [[X:%.*]] = call i8 @llvm.smax.i8(i8 [[XX:%.*]], i8 [[YY]])
; CHECK-NEXT: [[Z:%.*]] = or i8 [[X]], [[IND:%.*]]
; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[Z]], 0
; CHECK-NEXT: ret i1 [[R]]
;
%y_pos = icmp sge i8 %yy, 0
call void @llvm.assume(i1 %y_pos)
%x = call i8 @llvm.smax.i8(i8 %xx, i8 %yy)
%z = or i8 %x, %ind
%r = icmp eq i8 %z, 0
ret i1 %r
}