This is an archive of the discontinued LLVM Phabricator instance.

Differential D74685

[InstCombine] Fix multi-use handling in cttz transform
ClosedPublic

Authored by nikic on Feb 16 2020, 2:03 AM.

Details

Reviewers
spatel
lebedev.ri
Commits
rGc9540fe59bbf: [InstCombine] Fix multi-use handling in cttz transform
Summary

The select-of-cttz transform can currently duplicate cttz intrinsics and zext/trunc ops. The cause is that it unnecessarily duplicates the intrinsic and the zext/trunc when setting the "undef_on_zero" flag to false. However, it's always legal to set the flag from true to false, so we can make this replacement even if there are extra users.

Diff Detail

Event Timeline

nikic created this revision.Feb 16 2020, 2:03 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 16 2020, 2:03 AM
Herald added subscribers: llvm-commits, hiraditya. · View Herald Transcript
spatel accepted this revision.Feb 17 2020, 2:05 PM

LGTM

This revision is now accepted and ready to land.Feb 17 2020, 2:05 PM
Closed by commit rGc9540fe59bbf: [InstCombine] Fix multi-use handling in cttz transform (authored by nikic). · Explain WhyFeb 18 2020, 9:03 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
lib/
Transforms/
InstCombine/
21 lines
test/
Transforms/
InstCombine/
173 lines

Diff 244859

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

Show First 20 Lines • Show All 851 Lines • ▼ Show 20 Linesstatic Value *foldSelectCttzCtlz(ICmpInst *ICI, Value *TrueVal, Value *FalseVal,
ICmpInst::Predicate Pred = ICI->getPredicate(); ICmpInst::Predicate Pred = ICI->getPredicate();
Value *CmpLHS = ICI->getOperand(0); Value *CmpLHS = ICI->getOperand(0);
Value *CmpRHS = ICI->getOperand(1); Value *CmpRHS = ICI->getOperand(1);
// Check if the condition value compares a value for equality against zero. // Check if the condition value compares a value for equality against zero.
if (!ICI->isEquality() || !match(CmpRHS, m_Zero())) if (!ICI->isEquality() || !match(CmpRHS, m_Zero()))
return nullptr; return nullptr;
Value *Count = FalseVal; Value *SelectArg = FalseVal;
Value *ValueOnZero = TrueVal; Value *ValueOnZero = TrueVal;
if (Pred == ICmpInst::ICMP_NE) if (Pred == ICmpInst::ICMP_NE)
std::swap(Count, ValueOnZero); std::swap(SelectArg, ValueOnZero);
// Skip zero extend/truncate. // Skip zero extend/truncate.
Value *V = nullptr; Value *Count = nullptr;
if (match(Count, m_ZExt(m_Value(V))) || if (!match(SelectArg, m_ZExt(m_Value(Count))) &&
match(Count, m_Trunc(m_Value(V)))) !match(SelectArg, m_Trunc(m_Value(Count))))
Count = V; Count = SelectArg;
// Check that 'Count' is a call to intrinsic cttz/ctlz. Also check that the // Check that 'Count' is a call to intrinsic cttz/ctlz. Also check that the
// input to the cttz/ctlz is used as LHS for the compare instruction. // input to the cttz/ctlz is used as LHS for the compare instruction.
if (!match(Count, m_Intrinsic<Intrinsic::cttz>(m_Specific(CmpLHS))) && if (!match(Count, m_Intrinsic<Intrinsic::cttz>(m_Specific(CmpLHS))) &&
!match(Count, m_Intrinsic<Intrinsic::ctlz>(m_Specific(CmpLHS)))) !match(Count, m_Intrinsic<Intrinsic::ctlz>(m_Specific(CmpLHS))))
return nullptr; return nullptr;
IntrinsicInst *II = cast<IntrinsicInst>(Count); IntrinsicInst *II = cast<IntrinsicInst>(Count);
// Check if the value propagated on zero is a constant number equal to the // Check if the value propagated on zero is a constant number equal to the
// sizeof in bits of 'Count'. // sizeof in bits of 'Count'.
unsigned SizeOfInBits = Count->getType()->getScalarSizeInBits(); unsigned SizeOfInBits = Count->getType()->getScalarSizeInBits();
if (match(ValueOnZero, m_SpecificInt(SizeOfInBits))) { if (match(ValueOnZero, m_SpecificInt(SizeOfInBits))) {
// Explicitly clear the 'undef_on_zero' flag. // Explicitly clear the 'undef_on_zero' flag. It's always valid to go from
IntrinsicInst *NewI = cast<IntrinsicInst>(II->clone()); // true to false on this flag, so we can replace it for all users.
NewI->setArgOperand(1, ConstantInt::getFalse(NewI->getContext())); II->setArgOperand(1, ConstantInt::getFalse(II->getContext()));
Builder.Insert(NewI); return SelectArg;
return Builder.CreateZExtOrTrunc(NewI, ValueOnZero->getType());
} }
// If the ValueOnZero is not the bitwidth, we can at least make use of the // If the ValueOnZero is not the bitwidth, we can at least make use of the
// fact that the cttz/ctlz result will not be used if the input is zero, so // fact that the cttz/ctlz result will not be used if the input is zero, so
// it's okay to relax it to undef for that case. // it's okay to relax it to undef for that case.
if (II->hasOneUse() && !match(II->getArgOperand(1), m_One())) if (II->hasOneUse() && !match(II->getArgOperand(1), m_One()))
II->setArgOperand(1, ConstantInt::getTrue(II->getContext())); II->setArgOperand(1, ConstantInt::getTrue(II->getContext()));
▲ Show 20 Lines • Show All 1,940 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/select-cmp-cttz-ctlz.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 -instcombine -S < %s | FileCheck %s ; RUN: opt -instcombine -S < %s | FileCheck %s
; This test is to verify that the instruction combiner is able to fold ; This test is to verify that the instruction combiner is able to fold
; a cttz/ctlz followed by a icmp + select into a single cttz/ctlz with ; a cttz/ctlz followed by a icmp + select into a single cttz/ctlz with
; the 'is_zero_undef' flag cleared. ; the 'is_zero_undef' flag cleared.
define i16 @test1(i16 %x) { define i16 @test1(i16 %x) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i16 @llvm.ctlz.i16(i16 [[X:%.*]], i1 false), !range !0 ; CHECK-NEXT: [[CT:%.*]] = tail call i16 @llvm.ctlz.i16(i16 [[X:%.*]], i1 false), !range !0
; CHECK-NEXT: ret i16 [[TMP1]] ; CHECK-NEXT: ret i16 [[CT]]
; ;
%ct = tail call i16 @llvm.ctlz.i16(i16 %x, i1 true) %ct = tail call i16 @llvm.ctlz.i16(i16 %x, i1 true)
%tobool = icmp ne i16 %x, 0 %tobool = icmp ne i16 %x, 0
%cond = select i1 %tobool, i16 %ct, i16 16 %cond = select i1 %tobool, i16 %ct, i16 16
ret i16 %cond ret i16 %cond
} }
define i32 @test2(i32 %x) { define i32 @test2(i32 %x) {
; CHECK-LABEL: @test2( ; CHECK-LABEL: @test2(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @llvm.ctlz.i32(i32 [[X:%.*]], i1 false), !range !1 ; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.ctlz.i32(i32 [[X:%.*]], i1 false), !range !1
; CHECK-NEXT: ret i32 [[TMP1]] ; CHECK-NEXT: ret i32 [[CT]]
; ;
%ct = tail call i32 @llvm.ctlz.i32(i32 %x, i1 true) %ct = tail call i32 @llvm.ctlz.i32(i32 %x, i1 true)
%tobool = icmp ne i32 %x, 0 %tobool = icmp ne i32 %x, 0
%cond = select i1 %tobool, i32 %ct, i32 32 %cond = select i1 %tobool, i32 %ct, i32 32
ret i32 %cond ret i32 %cond
} }
define i64 @test3(i64 %x) { define i64 @test3(i64 %x) {
; CHECK-LABEL: @test3( ; CHECK-LABEL: @test3(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.ctlz.i64(i64 [[X:%.*]], i1 false), !range !2 ; CHECK-NEXT: [[CT:%.*]] = tail call i64 @llvm.ctlz.i64(i64 [[X:%.*]], i1 false), !range !2
; CHECK-NEXT: ret i64 [[TMP1]] ; CHECK-NEXT: ret i64 [[CT]]
; ;
%ct = tail call i64 @llvm.ctlz.i64(i64 %x, i1 true) %ct = tail call i64 @llvm.ctlz.i64(i64 %x, i1 true)
%tobool = icmp ne i64 %x, 0 %tobool = icmp ne i64 %x, 0
%cond = select i1 %tobool, i64 %ct, i64 64 %cond = select i1 %tobool, i64 %ct, i64 64
ret i64 %cond ret i64 %cond
} }
define i16 @test4(i16 %x) { define i16 @test4(i16 %x) {
; CHECK-LABEL: @test4( ; CHECK-LABEL: @test4(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i16 @llvm.ctlz.i16(i16 [[X:%.*]], i1 false), !range !0 ; CHECK-NEXT: [[CT:%.*]] = tail call i16 @llvm.ctlz.i16(i16 [[X:%.*]], i1 false), !range !0
; CHECK-NEXT: ret i16 [[TMP1]] ; CHECK-NEXT: ret i16 [[CT]]
; ;
%ct = tail call i16 @llvm.ctlz.i16(i16 %x, i1 true) %ct = tail call i16 @llvm.ctlz.i16(i16 %x, i1 true)
%tobool = icmp eq i16 %x, 0 %tobool = icmp eq i16 %x, 0
%cond = select i1 %tobool, i16 16, i16 %ct %cond = select i1 %tobool, i16 16, i16 %ct
ret i16 %cond ret i16 %cond
} }
define i32 @test5(i32 %x) { define i32 @test5(i32 %x) {
; CHECK-LABEL: @test5( ; CHECK-LABEL: @test5(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @llvm.ctlz.i32(i32 [[X:%.*]], i1 false), !range !1 ; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.ctlz.i32(i32 [[X:%.*]], i1 false), !range !1
; CHECK-NEXT: ret i32 [[TMP1]] ; CHECK-NEXT: ret i32 [[CT]]
; ;
%ct = tail call i32 @llvm.ctlz.i32(i32 %x, i1 true) %ct = tail call i32 @llvm.ctlz.i32(i32 %x, i1 true)
%tobool = icmp eq i32 %x, 0 %tobool = icmp eq i32 %x, 0
%cond = select i1 %tobool, i32 32, i32 %ct %cond = select i1 %tobool, i32 32, i32 %ct
ret i32 %cond ret i32 %cond
} }
define i64 @test6(i64 %x) { define i64 @test6(i64 %x) {
; CHECK-LABEL: @test6( ; CHECK-LABEL: @test6(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.ctlz.i64(i64 [[X:%.*]], i1 false), !range !2 ; CHECK-NEXT: [[CT:%.*]] = tail call i64 @llvm.ctlz.i64(i64 [[X:%.*]], i1 false), !range !2
; CHECK-NEXT: ret i64 [[TMP1]] ; CHECK-NEXT: ret i64 [[CT]]
; ;
%ct = tail call i64 @llvm.ctlz.i64(i64 %x, i1 true) %ct = tail call i64 @llvm.ctlz.i64(i64 %x, i1 true)
%tobool = icmp eq i64 %x, 0 %tobool = icmp eq i64 %x, 0
%cond = select i1 %tobool, i64 64, i64 %ct %cond = select i1 %tobool, i64 64, i64 %ct
ret i64 %cond ret i64 %cond
} }
define i16 @test1b(i16 %x) { define i16 @test1b(i16 %x) {
; CHECK-LABEL: @test1b( ; CHECK-LABEL: @test1b(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i16 @llvm.cttz.i16(i16 [[X:%.*]], i1 false), !range !0 ; CHECK-NEXT: [[CT:%.*]] = tail call i16 @llvm.cttz.i16(i16 [[X:%.*]], i1 false), !range !0
; CHECK-NEXT: ret i16 [[TMP1]] ; CHECK-NEXT: ret i16 [[CT]]
; ;
%ct = tail call i16 @llvm.cttz.i16(i16 %x, i1 true) %ct = tail call i16 @llvm.cttz.i16(i16 %x, i1 true)
%tobool = icmp ne i16 %x, 0 %tobool = icmp ne i16 %x, 0
%cond = select i1 %tobool, i16 %ct, i16 16 %cond = select i1 %tobool, i16 %ct, i16 16
ret i16 %cond ret i16 %cond
} }
define i32 @test2b(i32 %x) { define i32 @test2b(i32 %x) {
; CHECK-LABEL: @test2b( ; CHECK-LABEL: @test2b(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1 ; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1
; CHECK-NEXT: ret i32 [[TMP1]] ; CHECK-NEXT: ret i32 [[CT]]
; ;
%ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 true) %ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 true)
%tobool = icmp ne i32 %x, 0 %tobool = icmp ne i32 %x, 0
%cond = select i1 %tobool, i32 %ct, i32 32 %cond = select i1 %tobool, i32 %ct, i32 32
ret i32 %cond ret i32 %cond
} }
define i64 @test3b(i64 %x) { define i64 @test3b(i64 %x) {
; CHECK-LABEL: @test3b( ; CHECK-LABEL: @test3b(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.cttz.i64(i64 [[X:%.*]], i1 false), !range !2 ; CHECK-NEXT: [[CT:%.*]] = tail call i64 @llvm.cttz.i64(i64 [[X:%.*]], i1 false), !range !2
; CHECK-NEXT: ret i64 [[TMP1]] ; CHECK-NEXT: ret i64 [[CT]]
; ;
%ct = tail call i64 @llvm.cttz.i64(i64 %x, i1 true) %ct = tail call i64 @llvm.cttz.i64(i64 %x, i1 true)
%tobool = icmp ne i64 %x, 0 %tobool = icmp ne i64 %x, 0
%cond = select i1 %tobool, i64 %ct, i64 64 %cond = select i1 %tobool, i64 %ct, i64 64
ret i64 %cond ret i64 %cond
} }
define i16 @test4b(i16 %x) { define i16 @test4b(i16 %x) {
; CHECK-LABEL: @test4b( ; CHECK-LABEL: @test4b(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i16 @llvm.cttz.i16(i16 [[X:%.*]], i1 false), !range !0 ; CHECK-NEXT: [[CT:%.*]] = tail call i16 @llvm.cttz.i16(i16 [[X:%.*]], i1 false), !range !0
; CHECK-NEXT: ret i16 [[TMP1]] ; CHECK-NEXT: ret i16 [[CT]]
; ;
%ct = tail call i16 @llvm.cttz.i16(i16 %x, i1 true) %ct = tail call i16 @llvm.cttz.i16(i16 %x, i1 true)
%tobool = icmp eq i16 %x, 0 %tobool = icmp eq i16 %x, 0
%cond = select i1 %tobool, i16 16, i16 %ct %cond = select i1 %tobool, i16 16, i16 %ct
ret i16 %cond ret i16 %cond
} }
define i32 @test5b(i32 %x) { define i32 @test5b(i32 %x) {
; CHECK-LABEL: @test5b( ; CHECK-LABEL: @test5b(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1 ; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1
; CHECK-NEXT: ret i32 [[TMP0]] ; CHECK-NEXT: ret i32 [[CT]]
; ;
entry: entry:
%ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 true) %ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 true)
%tobool = icmp eq i32 %x, 0 %tobool = icmp eq i32 %x, 0
%cond = select i1 %tobool, i32 32, i32 %ct %cond = select i1 %tobool, i32 32, i32 %ct
ret i32 %cond ret i32 %cond
} }
define i64 @test6b(i64 %x) { define i64 @test6b(i64 %x) {
; CHECK-LABEL: @test6b( ; CHECK-LABEL: @test6b(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.cttz.i64(i64 [[X:%.*]], i1 false), !range !2 ; CHECK-NEXT: [[CT:%.*]] = tail call i64 @llvm.cttz.i64(i64 [[X:%.*]], i1 false), !range !2
; CHECK-NEXT: ret i64 [[TMP1]] ; CHECK-NEXT: ret i64 [[CT]]
; ;
%ct = tail call i64 @llvm.cttz.i64(i64 %x, i1 true) %ct = tail call i64 @llvm.cttz.i64(i64 %x, i1 true)
%tobool = icmp eq i64 %x, 0 %tobool = icmp eq i64 %x, 0
%cond = select i1 %tobool, i64 64, i64 %ct %cond = select i1 %tobool, i64 64, i64 %ct
ret i64 %cond ret i64 %cond
} }
define i32 @test1c(i16 %x) { define i32 @test1c(i16 %x) {
; CHECK-LABEL: @test1c( ; CHECK-LABEL: @test1c(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i16 @llvm.cttz.i16(i16 [[X:%.*]], i1 false), !range !0 ; CHECK-NEXT: [[CT:%.*]] = tail call i16 @llvm.cttz.i16(i16 [[X:%.*]], i1 false), !range !0
; CHECK-NEXT: [[TMP2:%.*]] = zext i16 [[TMP1]] to i32 ; CHECK-NEXT: [[CAST2:%.*]] = zext i16 [[CT]] to i32
; CHECK-NEXT: ret i32 [[TMP2]] ; CHECK-NEXT: ret i32 [[CAST2]]
; ;
%ct = tail call i16 @llvm.cttz.i16(i16 %x, i1 true) %ct = tail call i16 @llvm.cttz.i16(i16 %x, i1 true)
%cast2 = zext i16 %ct to i32 %cast2 = zext i16 %ct to i32
%tobool = icmp ne i16 %x, 0 %tobool = icmp ne i16 %x, 0
%cond = select i1 %tobool, i32 %cast2, i32 16 %cond = select i1 %tobool, i32 %cast2, i32 16
ret i32 %cond ret i32 %cond
} }
define i64 @test2c(i16 %x) { define i64 @test2c(i16 %x) {
; CHECK-LABEL: @test2c( ; CHECK-LABEL: @test2c(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i16 @llvm.cttz.i16(i16 [[X:%.*]], i1 false), !range !0 ; CHECK-NEXT: [[CT:%.*]] = tail call i16 @llvm.cttz.i16(i16 [[X:%.*]], i1 false), !range !0
; CHECK-NEXT: [[TMP2:%.*]] = zext i16 [[TMP1]] to i64 ; CHECK-NEXT: [[CONV:%.*]] = zext i16 [[CT]] to i64
; CHECK-NEXT: ret i64 [[TMP2]] ; CHECK-NEXT: ret i64 [[CONV]]
; ;
%ct = tail call i16 @llvm.cttz.i16(i16 %x, i1 true) %ct = tail call i16 @llvm.cttz.i16(i16 %x, i1 true)
%conv = zext i16 %ct to i64 %conv = zext i16 %ct to i64
%tobool = icmp ne i16 %x, 0 %tobool = icmp ne i16 %x, 0
%cond = select i1 %tobool, i64 %conv, i64 16 %cond = select i1 %tobool, i64 %conv, i64 16
ret i64 %cond ret i64 %cond
} }
define i64 @test3c(i32 %x) { define i64 @test3c(i32 %x) {
; CHECK-LABEL: @test3c( ; CHECK-LABEL: @test3c(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1 ; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1
; CHECK-NEXT: [[TMP2:%.*]] = zext i32 [[TMP1]] to i64 ; CHECK-NEXT: [[CONV:%.*]] = zext i32 [[CT]] to i64
; CHECK-NEXT: ret i64 [[TMP2]] ; CHECK-NEXT: ret i64 [[CONV]]
; ;
%ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 true) %ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 true)
%conv = zext i32 %ct to i64 %conv = zext i32 %ct to i64
%tobool = icmp ne i32 %x, 0 %tobool = icmp ne i32 %x, 0
%cond = select i1 %tobool, i64 %conv, i64 32 %cond = select i1 %tobool, i64 %conv, i64 32
ret i64 %cond ret i64 %cond
} }
define i32 @test4c(i16 %x) { define i32 @test4c(i16 %x) {
; CHECK-LABEL: @test4c( ; CHECK-LABEL: @test4c(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i16 @llvm.ctlz.i16(i16 [[X:%.*]], i1 false), !range !0 ; CHECK-NEXT: [[CT:%.*]] = tail call i16 @llvm.ctlz.i16(i16 [[X:%.*]], i1 false), !range !0
; CHECK-NEXT: [[TMP2:%.*]] = zext i16 [[TMP1]] to i32 ; CHECK-NEXT: [[CAST:%.*]] = zext i16 [[CT]] to i32
; CHECK-NEXT: ret i32 [[TMP2]] ; CHECK-NEXT: ret i32 [[CAST]]
; ;
%ct = tail call i16 @llvm.ctlz.i16(i16 %x, i1 true) %ct = tail call i16 @llvm.ctlz.i16(i16 %x, i1 true)
%cast = zext i16 %ct to i32 %cast = zext i16 %ct to i32
%tobool = icmp ne i16 %x, 0 %tobool = icmp ne i16 %x, 0
%cond = select i1 %tobool, i32 %cast, i32 16 %cond = select i1 %tobool, i32 %cast, i32 16
ret i32 %cond ret i32 %cond
} }
define i64 @test5c(i16 %x) { define i64 @test5c(i16 %x) {
; CHECK-LABEL: @test5c( ; CHECK-LABEL: @test5c(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i16 @llvm.ctlz.i16(i16 [[X:%.*]], i1 false), !range !0 ; CHECK-NEXT: [[CT:%.*]] = tail call i16 @llvm.ctlz.i16(i16 [[X:%.*]], i1 false), !range !0
; CHECK-NEXT: [[TMP2:%.*]] = zext i16 [[TMP1]] to i64 ; CHECK-NEXT: [[CAST:%.*]] = zext i16 [[CT]] to i64
; CHECK-NEXT: ret i64 [[TMP2]] ; CHECK-NEXT: ret i64 [[CAST]]
; ;
%ct = tail call i16 @llvm.ctlz.i16(i16 %x, i1 true) %ct = tail call i16 @llvm.ctlz.i16(i16 %x, i1 true)
%cast = zext i16 %ct to i64 %cast = zext i16 %ct to i64
%tobool = icmp ne i16 %x, 0 %tobool = icmp ne i16 %x, 0
%cond = select i1 %tobool, i64 %cast, i64 16 %cond = select i1 %tobool, i64 %cast, i64 16
ret i64 %cond ret i64 %cond
} }
define i64 @test6c(i32 %x) { define i64 @test6c(i32 %x) {
; CHECK-LABEL: @test6c( ; CHECK-LABEL: @test6c(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @llvm.ctlz.i32(i32 [[X:%.*]], i1 false), !range !1 ; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.ctlz.i32(i32 [[X:%.*]], i1 false), !range !1
; CHECK-NEXT: [[TMP2:%.*]] = zext i32 [[TMP1]] to i64 ; CHECK-NEXT: [[CAST:%.*]] = zext i32 [[CT]] to i64
; CHECK-NEXT: ret i64 [[TMP2]] ; CHECK-NEXT: ret i64 [[CAST]]
; ;
%ct = tail call i32 @llvm.ctlz.i32(i32 %x, i1 true) %ct = tail call i32 @llvm.ctlz.i32(i32 %x, i1 true)
%cast = zext i32 %ct to i64 %cast = zext i32 %ct to i64
%tobool = icmp ne i32 %x, 0 %tobool = icmp ne i32 %x, 0
%cond = select i1 %tobool, i64 %cast, i64 32 %cond = select i1 %tobool, i64 %cast, i64 32
ret i64 %cond ret i64 %cond
} }
define i16 @test1d(i64 %x) { define i16 @test1d(i64 %x) {
; CHECK-LABEL: @test1d( ; CHECK-LABEL: @test1d(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.cttz.i64(i64 [[X:%.*]], i1 false), !range !2 ; CHECK-NEXT: [[CT:%.*]] = tail call i64 @llvm.cttz.i64(i64 [[X:%.*]], i1 false), !range !2
; CHECK-NEXT: [[TMP2:%.*]] = trunc i64 [[TMP1]] to i16 ; CHECK-NEXT: [[CONV:%.*]] = trunc i64 [[CT]] to i16
; CHECK-NEXT: ret i16 [[TMP2]] ; CHECK-NEXT: ret i16 [[CONV]]
; ;
%ct = tail call i64 @llvm.cttz.i64(i64 %x, i1 true) %ct = tail call i64 @llvm.cttz.i64(i64 %x, i1 true)
%conv = trunc i64 %ct to i16 %conv = trunc i64 %ct to i16
%tobool = icmp ne i64 %x, 0 %tobool = icmp ne i64 %x, 0
%cond = select i1 %tobool, i16 %conv, i16 64 %cond = select i1 %tobool, i16 %conv, i16 64
ret i16 %cond ret i16 %cond
} }
define i32 @test2d(i64 %x) { define i32 @test2d(i64 %x) {
; CHECK-LABEL: @test2d( ; CHECK-LABEL: @test2d(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.cttz.i64(i64 [[X:%.*]], i1 false), !range !2 ; CHECK-NEXT: [[CT:%.*]] = tail call i64 @llvm.cttz.i64(i64 [[X:%.*]], i1 false), !range !2
; CHECK-NEXT: [[TMP2:%.*]] = trunc i64 [[TMP1]] to i32 ; CHECK-NEXT: [[CAST:%.*]] = trunc i64 [[CT]] to i32
; CHECK-NEXT: ret i32 [[TMP2]] ; CHECK-NEXT: ret i32 [[CAST]]
; ;
%ct = tail call i64 @llvm.cttz.i64(i64 %x, i1 true) %ct = tail call i64 @llvm.cttz.i64(i64 %x, i1 true)
%cast = trunc i64 %ct to i32 %cast = trunc i64 %ct to i32
%tobool = icmp ne i64 %x, 0 %tobool = icmp ne i64 %x, 0
%cond = select i1 %tobool, i32 %cast, i32 64 %cond = select i1 %tobool, i32 %cast, i32 64
ret i32 %cond ret i32 %cond
} }
define i16 @test3d(i32 %x) { define i16 @test3d(i32 %x) {
; CHECK-LABEL: @test3d( ; CHECK-LABEL: @test3d(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1 ; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1
; CHECK-NEXT: [[TMP2:%.*]] = trunc i32 [[TMP1]] to i16 ; CHECK-NEXT: [[CAST:%.*]] = trunc i32 [[CT]] to i16
; CHECK-NEXT: ret i16 [[TMP2]] ; CHECK-NEXT: ret i16 [[CAST]]
; ;
%ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 true) %ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 true)
%cast = trunc i32 %ct to i16 %cast = trunc i32 %ct to i16
%tobool = icmp ne i32 %x, 0 %tobool = icmp ne i32 %x, 0
%cond = select i1 %tobool, i16 %cast, i16 32 %cond = select i1 %tobool, i16 %cast, i16 32
ret i16 %cond ret i16 %cond
} }
define i16 @test4d(i64 %x) { define i16 @test4d(i64 %x) {
; CHECK-LABEL: @test4d( ; CHECK-LABEL: @test4d(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.ctlz.i64(i64 [[X:%.*]], i1 false), !range !2 ; CHECK-NEXT: [[CT:%.*]] = tail call i64 @llvm.ctlz.i64(i64 [[X:%.*]], i1 false), !range !2
; CHECK-NEXT: [[TMP2:%.*]] = trunc i64 [[TMP1]] to i16 ; CHECK-NEXT: [[CAST:%.*]] = trunc i64 [[CT]] to i16
; CHECK-NEXT: ret i16 [[TMP2]] ; CHECK-NEXT: ret i16 [[CAST]]
; ;
%ct = tail call i64 @llvm.ctlz.i64(i64 %x, i1 true) %ct = tail call i64 @llvm.ctlz.i64(i64 %x, i1 true)
%cast = trunc i64 %ct to i16 %cast = trunc i64 %ct to i16
%tobool = icmp ne i64 %x, 0 %tobool = icmp ne i64 %x, 0
%cond = select i1 %tobool, i16 %cast, i16 64 %cond = select i1 %tobool, i16 %cast, i16 64
ret i16 %cond ret i16 %cond
} }
define i32 @test5d(i64 %x) { define i32 @test5d(i64 %x) {
; CHECK-LABEL: @test5d( ; CHECK-LABEL: @test5d(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.ctlz.i64(i64 [[X:%.*]], i1 false), !range !2 ; CHECK-NEXT: [[CT:%.*]] = tail call i64 @llvm.ctlz.i64(i64 [[X:%.*]], i1 false), !range !2
; CHECK-NEXT: [[TMP2:%.*]] = trunc i64 [[TMP1]] to i32 ; CHECK-NEXT: [[CAST:%.*]] = trunc i64 [[CT]] to i32
; CHECK-NEXT: ret i32 [[TMP2]] ; CHECK-NEXT: ret i32 [[CAST]]
; ;
%ct = tail call i64 @llvm.ctlz.i64(i64 %x, i1 true) %ct = tail call i64 @llvm.ctlz.i64(i64 %x, i1 true)
%cast = trunc i64 %ct to i32 %cast = trunc i64 %ct to i32
%tobool = icmp ne i64 %x, 0 %tobool = icmp ne i64 %x, 0
%cond = select i1 %tobool, i32 %cast, i32 64 %cond = select i1 %tobool, i32 %cast, i32 64
ret i32 %cond ret i32 %cond
} }
define i16 @test6d(i32 %x) { define i16 @test6d(i32 %x) {
; CHECK-LABEL: @test6d( ; CHECK-LABEL: @test6d(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @llvm.ctlz.i32(i32 [[X:%.*]], i1 false), !range !1 ; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.ctlz.i32(i32 [[X:%.*]], i1 false), !range !1
; CHECK-NEXT: [[TMP2:%.*]] = trunc i32 [[TMP1]] to i16 ; CHECK-NEXT: [[CAST:%.*]] = trunc i32 [[CT]] to i16
; CHECK-NEXT: ret i16 [[TMP2]] ; CHECK-NEXT: ret i16 [[CAST]]
; ;
%ct = tail call i32 @llvm.ctlz.i32(i32 %x, i1 true) %ct = tail call i32 @llvm.ctlz.i32(i32 %x, i1 true)
%cast = trunc i32 %ct to i16 %cast = trunc i32 %ct to i16
%tobool = icmp ne i32 %x, 0 %tobool = icmp ne i32 %x, 0
%cond = select i1 %tobool, i16 %cast, i16 32 %cond = select i1 %tobool, i16 %cast, i16 32
ret i16 %cond ret i16 %cond
} }
define i64 @select_bug1(i32 %x) { define i64 @select_bug1(i32 %x) {
; CHECK-LABEL: @select_bug1( ; CHECK-LABEL: @select_bug1(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1 ; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1
; CHECK-NEXT: [[TMP2:%.*]] = zext i32 [[TMP1]] to i64 ; CHECK-NEXT: [[CONV:%.*]] = zext i32 [[CT]] to i64
; CHECK-NEXT: ret i64 [[TMP2]] ; CHECK-NEXT: ret i64 [[CONV]]
; ;
%ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 false) %ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 false)
%conv = zext i32 %ct to i64 %conv = zext i32 %ct to i64
%tobool = icmp ne i32 %x, 0 %tobool = icmp ne i32 %x, 0
%cond = select i1 %tobool, i64 %conv, i64 32 %cond = select i1 %tobool, i64 %conv, i64 32
ret i64 %cond ret i64 %cond
} }
define i16 @select_bug2(i32 %x) { define i16 @select_bug2(i32 %x) {
; CHECK-LABEL: @select_bug2( ; CHECK-LABEL: @select_bug2(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1 ; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1
; CHECK-NEXT: [[TMP2:%.*]] = trunc i32 [[TMP1]] to i16 ; CHECK-NEXT: [[CONV:%.*]] = trunc i32 [[CT]] to i16
; CHECK-NEXT: ret i16 [[TMP2]] ; CHECK-NEXT: ret i16 [[CONV]]
; ;
%ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 false) %ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 false)
%conv = trunc i32 %ct to i16 %conv = trunc i32 %ct to i16
%tobool = icmp ne i32 %x, 0 %tobool = icmp ne i32 %x, 0
%cond = select i1 %tobool, i16 %conv, i16 32 %cond = select i1 %tobool, i16 %conv, i16 32
ret i16 %cond ret i16 %cond
} }
define i128 @test7(i128 %x) { define i128 @test7(i128 %x) {
; CHECK-LABEL: @test7( ; CHECK-LABEL: @test7(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i128 @llvm.ctlz.i128(i128 [[X:%.*]], i1 false), !range !3 ; CHECK-NEXT: [[CT:%.*]] = tail call i128 @llvm.ctlz.i128(i128 [[X:%.*]], i1 false), !range !3
; CHECK-NEXT: ret i128 [[TMP1]] ; CHECK-NEXT: ret i128 [[CT]]
; ;
%ct = tail call i128 @llvm.ctlz.i128(i128 %x, i1 true) %ct = tail call i128 @llvm.ctlz.i128(i128 %x, i1 true)
%tobool = icmp ne i128 %x, 0 %tobool = icmp ne i128 %x, 0
%cond = select i1 %tobool, i128 %ct, i128 128 %cond = select i1 %tobool, i128 %ct, i128 128
ret i128 %cond ret i128 %cond
} }
define i128 @test8(i128 %x) { define i128 @test8(i128 %x) {
; CHECK-LABEL: @test8( ; CHECK-LABEL: @test8(
; CHECK-NEXT: [[TMP1:%.*]] = tail call i128 @llvm.cttz.i128(i128 [[X:%.*]], i1 false), !range !3 ; CHECK-NEXT: [[CT:%.*]] = tail call i128 @llvm.cttz.i128(i128 [[X:%.*]], i1 false), !range !3
; CHECK-NEXT: ret i128 [[TMP1]] ; CHECK-NEXT: ret i128 [[CT]]
; ;
%ct = tail call i128 @llvm.cttz.i128(i128 %x, i1 true) %ct = tail call i128 @llvm.cttz.i128(i128 %x, i1 true)
%tobool = icmp ne i128 %x, 0 %tobool = icmp ne i128 %x, 0
%cond = select i1 %tobool, i128 %ct, i128 128 %cond = select i1 %tobool, i128 %ct, i128 128
ret i128 %cond ret i128 %cond
} }
define i32 @test_ctlz_not_bw(i32 %x) { define i32 @test_ctlz_not_bw(i32 %x) {
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines;
%cmp = icmp ne i32 %x, 0 %cmp = icmp ne i32 %x, 0
%sel = select i1 %cmp, i32 %ct, i32 123 %sel = select i1 %cmp, i32 %ct, i32 123
%res = or i32 %sel, %ct %res = or i32 %sel, %ct
ret i32 %res ret i32 %res
} }
define <2 x i32> @test_ctlz_bw_vec(<2 x i32> %x) { define <2 x i32> @test_ctlz_bw_vec(<2 x i32> %x) {
; CHECK-LABEL: @test_ctlz_bw_vec( ; CHECK-LABEL: @test_ctlz_bw_vec(
; CHECK-NEXT: [[TMP1:%.*]] = tail call <2 x i32> @llvm.ctlz.v2i32(<2 x i32> [[X:%.*]], i1 false) ; CHECK-NEXT: [[CT:%.*]] = tail call <2 x i32> @llvm.ctlz.v2i32(<2 x i32> [[X:%.*]], i1 false)
; CHECK-NEXT: ret <2 x i32> [[TMP1]] ; CHECK-NEXT: ret <2 x i32> [[CT]]
; ;
%ct = tail call <2 x i32> @llvm.ctlz.v2i32(<2 x i32> %x, i1 true) %ct = tail call <2 x i32> @llvm.ctlz.v2i32(<2 x i32> %x, i1 true)
%cmp = icmp ne <2 x i32> %x, zeroinitializer %cmp = icmp ne <2 x i32> %x, zeroinitializer
%res = select <2 x i1> %cmp, <2 x i32> %ct, <2 x i32> <i32 32, i32 32> %res = select <2 x i1> %cmp, <2 x i32> %ct, <2 x i32> <i32 32, i32 32>
ret <2 x i32> %res ret <2 x i32> %res
} }
define <2 x i32> @test_ctlz_not_bw_vec(<2 x i32> %x) { define <2 x i32> @test_ctlz_not_bw_vec(<2 x i32> %x) {
; CHECK-LABEL: @test_ctlz_not_bw_vec( ; CHECK-LABEL: @test_ctlz_not_bw_vec(
; CHECK-NEXT: [[CT:%.*]] = tail call <2 x i32> @llvm.ctlz.v2i32(<2 x i32> [[X:%.*]], i1 true) ; CHECK-NEXT: [[CT:%.*]] = tail call <2 x i32> @llvm.ctlz.v2i32(<2 x i32> [[X:%.*]], i1 true)
; CHECK-NEXT: [[CMP:%.*]] = icmp eq <2 x i32> [[X]], zeroinitializer ; CHECK-NEXT: [[CMP:%.*]] = icmp eq <2 x i32> [[X]], zeroinitializer
; CHECK-NEXT: [[RES:%.*]] = select <2 x i1> [[CMP]], <2 x i32> zeroinitializer, <2 x i32> [[CT]] ; CHECK-NEXT: [[RES:%.*]] = select <2 x i1> [[CMP]], <2 x i32> zeroinitializer, <2 x i32> [[CT]]
; CHECK-NEXT: ret <2 x i32> [[RES]] ; CHECK-NEXT: ret <2 x i32> [[RES]]
; ;
%ct = tail call <2 x i32> @llvm.ctlz.v2i32(<2 x i32> %x, i1 false) %ct = tail call <2 x i32> @llvm.ctlz.v2i32(<2 x i32> %x, i1 false)
%cmp = icmp ne <2 x i32> %x, zeroinitializer %cmp = icmp ne <2 x i32> %x, zeroinitializer
%res = select <2 x i1> %cmp, <2 x i32> %ct, <2 x i32> <i32 0, i32 0> %res = select <2 x i1> %cmp, <2 x i32> %ct, <2 x i32> <i32 0, i32 0>
ret <2 x i32> %res ret <2 x i32> %res
} }
define <2 x i32> @test_cttz_bw_vec(<2 x i32> %x) { define <2 x i32> @test_cttz_bw_vec(<2 x i32> %x) {
; CHECK-LABEL: @test_cttz_bw_vec( ; CHECK-LABEL: @test_cttz_bw_vec(
; CHECK-NEXT: [[TMP1:%.*]] = tail call <2 x i32> @llvm.cttz.v2i32(<2 x i32> [[X:%.*]], i1 false) ; CHECK-NEXT: [[CT:%.*]] = tail call <2 x i32> @llvm.cttz.v2i32(<2 x i32> [[X:%.*]], i1 false)
; CHECK-NEXT: ret <2 x i32> [[TMP1]] ; CHECK-NEXT: ret <2 x i32> [[CT]]
; ;
%ct = tail call <2 x i32> @llvm.cttz.v2i32(<2 x i32> %x, i1 true) %ct = tail call <2 x i32> @llvm.cttz.v2i32(<2 x i32> %x, i1 true)
%cmp = icmp ne <2 x i32> %x, zeroinitializer %cmp = icmp ne <2 x i32> %x, zeroinitializer
%res = select <2 x i1> %cmp, <2 x i32> %ct, <2 x i32> <i32 32, i32 32> %res = select <2 x i1> %cmp, <2 x i32> %ct, <2 x i32> <i32 32, i32 32>
ret <2 x i32> %res ret <2 x i32> %res
} }
define <2 x i32> @test_cttz_not_bw_vec(<2 x i32> %x) { define <2 x i32> @test_cttz_not_bw_vec(<2 x i32> %x) {
Show All 19 Lines;
%tobool = icmp ne i32 %x, 0 %tobool = icmp ne i32 %x, 0
%cond = select i1 %tobool, i32 %ct, i32 32 %cond = select i1 %tobool, i32 %ct, i32 32
store i32 %ct, i32* %p store i32 %ct, i32* %p
ret i32 %cond ret i32 %cond
} }
define i32 @test_multiuse_undef(i32 %x, i32* %p) { define i32 @test_multiuse_undef(i32 %x, i32* %p) {
; CHECK-LABEL: @test_multiuse_undef( ; CHECK-LABEL: @test_multiuse_undef(
; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.ctlz.i32(i32 [[X:%.*]], i1 true), !range !1 ; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.ctlz.i32(i32 [[X:%.*]], i1 false), !range !1
; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @llvm.ctlz.i32(i32 [[X]], i1 false), !range !1
; CHECK-NEXT: store i32 [[CT]], i32* [[P:%.*]], align 4 ; CHECK-NEXT: store i32 [[CT]], i32* [[P:%.*]], align 4
; CHECK-NEXT: ret i32 [[TMP1]] ; CHECK-NEXT: ret i32 [[CT]]
; ;
%ct = tail call i32 @llvm.ctlz.i32(i32 %x, i1 true) %ct = tail call i32 @llvm.ctlz.i32(i32 %x, i1 true)
%tobool = icmp ne i32 %x, 0 %tobool = icmp ne i32 %x, 0
%cond = select i1 %tobool, i32 %ct, i32 32 %cond = select i1 %tobool, i32 %ct, i32 32
store i32 %ct, i32* %p store i32 %ct, i32* %p
ret i32 %cond ret i32 %cond
} }
define i64 @test_multiuse_zext_def(i32 %x, i64* %p) { define i64 @test_multiuse_zext_def(i32 %x, i64* %p) {
; CHECK-LABEL: @test_multiuse_zext_def( ; CHECK-LABEL: @test_multiuse_zext_def(
; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1 ; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1
; CHECK-NEXT: [[CONV:%.*]] = zext i32 [[CT]] to i64 ; CHECK-NEXT: [[CONV:%.*]] = zext i32 [[CT]] to i64
; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X]], i1 false), !range !1
; CHECK-NEXT: [[TMP2:%.*]] = zext i32 [[TMP1]] to i64
; CHECK-NEXT: store i64 [[CONV]], i64* [[P:%.*]], align 4 ; CHECK-NEXT: store i64 [[CONV]], i64* [[P:%.*]], align 4
; CHECK-NEXT: ret i64 [[TMP2]] ; CHECK-NEXT: ret i64 [[CONV]]
; ;
%ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 false) %ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 false)
%conv = zext i32 %ct to i64 %conv = zext i32 %ct to i64
%tobool = icmp ne i32 %x, 0 %tobool = icmp ne i32 %x, 0
%cond = select i1 %tobool, i64 %conv, i64 32 %cond = select i1 %tobool, i64 %conv, i64 32
store i64 %conv, i64* %p store i64 %conv, i64* %p
ret i64 %cond ret i64 %cond
} }
define i64 @test_multiuse_zext_undef(i32 %x, i64* %p) { define i64 @test_multiuse_zext_undef(i32 %x, i64* %p) {
; CHECK-LABEL: @test_multiuse_zext_undef( ; CHECK-LABEL: @test_multiuse_zext_undef(
; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 true), !range !1 ; CHECK-NEXT: [[CT:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X:%.*]], i1 false), !range !1
; CHECK-NEXT: [[CONV:%.*]] = zext i32 [[CT]] to i64 ; CHECK-NEXT: [[CONV:%.*]] = zext i32 [[CT]] to i64
; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @llvm.cttz.i32(i32 [[X]], i1 false), !range !1
; CHECK-NEXT: [[TMP2:%.*]] = zext i32 [[TMP1]] to i64
; CHECK-NEXT: store i64 [[CONV]], i64* [[P:%.*]], align 4 ; CHECK-NEXT: store i64 [[CONV]], i64* [[P:%.*]], align 4
; CHECK-NEXT: ret i64 [[TMP2]] ; CHECK-NEXT: ret i64 [[CONV]]
; ;
%ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 true) %ct = tail call i32 @llvm.cttz.i32(i32 %x, i1 true)
%conv = zext i32 %ct to i64 %conv = zext i32 %ct to i64
%tobool = icmp ne i32 %x, 0 %tobool = icmp ne i32 %x, 0
%cond = select i1 %tobool, i64 %conv, i64 32 %cond = select i1 %tobool, i64 %conv, i64 32
store i64 %conv, i64* %p store i64 %conv, i64* %p
ret i64 %cond ret i64 %cond
} }
define i16 @test_multiuse_trunc_def(i64 %x, i16 *%p) { define i16 @test_multiuse_trunc_def(i64 %x, i16 *%p) {
; CHECK-LABEL: @test_multiuse_trunc_def( ; CHECK-LABEL: @test_multiuse_trunc_def(
; CHECK-NEXT: [[CT:%.*]] = tail call i64 @llvm.cttz.i64(i64 [[X:%.*]], i1 false), !range !2 ; CHECK-NEXT: [[CT:%.*]] = tail call i64 @llvm.cttz.i64(i64 [[X:%.*]], i1 false), !range !2
; CHECK-NEXT: [[CONV:%.*]] = trunc i64 [[CT]] to i16 ; CHECK-NEXT: [[CONV:%.*]] = trunc i64 [[CT]] to i16
; CHECK-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.cttz.i64(i64 [[X]], i1 false), !range !2
; CHECK-NEXT: [[TMP2:%.*]] = trunc i64 [[TMP1]] to i16
; CHECK-NEXT: store i16 [[CONV]], i16* [[P:%.*]], align 2 ; CHECK-NEXT: store i16 [[CONV]], i16* [[P:%.*]], align 2
; CHECK-NEXT: ret i16 [[TMP2]] ; CHECK-NEXT: ret i16 [[CONV]]
; ;
%ct = tail call i64 @llvm.cttz.i64(i64 %x, i1 false) %ct = tail call i64 @llvm.cttz.i64(i64 %x, i1 false)
%conv = trunc i64 %ct to i16 %conv = trunc i64 %ct to i16
%tobool = icmp ne i64 %x, 0 %tobool = icmp ne i64 %x, 0
%cond = select i1 %tobool, i16 %conv, i16 64 %cond = select i1 %tobool, i16 %conv, i16 64
store i16 %conv, i16* %p store i16 %conv, i16* %p
ret i16 %cond ret i16 %cond
} }
define i16 @test_multiuse_trunc_undef(i64 %x, i16 *%p) { define i16 @test_multiuse_trunc_undef(i64 %x, i16 *%p) {
; CHECK-LABEL: @test_multiuse_trunc_undef( ; CHECK-LABEL: @test_multiuse_trunc_undef(
; CHECK-NEXT: [[CT:%.*]] = tail call i64 @llvm.cttz.i64(i64 [[X:%.*]], i1 true), !range !2 ; CHECK-NEXT: [[CT:%.*]] = tail call i64 @llvm.cttz.i64(i64 [[X:%.*]], i1 false), !range !2
; CHECK-NEXT: [[CONV:%.*]] = trunc i64 [[CT]] to i16 ; CHECK-NEXT: [[CONV:%.*]] = trunc i64 [[CT]] to i16
; CHECK-NEXT: [[TMP1:%.*]] = tail call i64 @llvm.cttz.i64(i64 [[X]], i1 false), !range !2
; CHECK-NEXT: [[TMP2:%.*]] = trunc i64 [[TMP1]] to i16
; CHECK-NEXT: store i16 [[CONV]], i16* [[P:%.*]], align 2 ; CHECK-NEXT: store i16 [[CONV]], i16* [[P:%.*]], align 2
; CHECK-NEXT: ret i16 [[TMP2]] ; CHECK-NEXT: ret i16 [[CONV]]
; ;
%ct = tail call i64 @llvm.cttz.i64(i64 %x, i1 true) %ct = tail call i64 @llvm.cttz.i64(i64 %x, i1 true)
%conv = trunc i64 %ct to i16 %conv = trunc i64 %ct to i16
%tobool = icmp ne i64 %x, 0 %tobool = icmp ne i64 %x, 0
%cond = select i1 %tobool, i16 %conv, i16 64 %cond = select i1 %tobool, i16 %conv, i16 64
store i16 %conv, i16* %p store i16 %conv, i16* %p
ret i16 %cond ret i16 %cond
} }
Show All 11 Lines