You've already forked linux-packaging-mono
acceptance-tests
data
docs
external
Newtonsoft.Json
api-doc-tools
api-snapshot
aspnetwebstack
bdwgc
binary-reference-assemblies
bockbuild
boringssl
cecil
cecil-legacy
corefx
corert
helix-binaries
ikdasm
ikvm
illinker-test-assets
linker
llvm-project
clang
clang-tools-extra
compiler-rt
eng
libcxx
libcxxabi
libunwind
lld
lldb
llvm
bindings
cmake
docs
examples
include
lib
projects
resources
runtimes
scripts
test
Analysis
Assembler
Bindings
Bitcode
BugPoint
CodeGen
DebugInfo
Examples
ExecutionEngine
Feature
FileCheck
Instrumentation
Integer
JitListener
LTO
Linker
MC
Object
ObjectYAML
Other
SafepointIRVerifier
SymbolRewriter
TableGen
ThinLTO
Transforms
ADCE
AddDiscriminators
AlignmentFromAssumptions
ArgumentPromotion
AtomicExpand
BDCE
BranchFolding
CallSiteSplitting
CalledValuePropagation
CodeExtractor
CodeGenPrepare
ConstProp
ConstantHoisting
ConstantMerge
Coroutines
CorrelatedValuePropagation
CrossDSOCFI
DCE
DeadArgElim
DeadStoreElimination
DivRemPairs
EarlyCSE
EliminateAvailableExternally
EntryExitInstrumenter
ExpandMemCmp
Float2Int
ForcedFunctionAttrs
FunctionAttrs
FunctionImport
GCOVProfiling
GVN
GVNHoist
GVNSink
GlobalDCE
GlobalMerge
GlobalOpt
GlobalSplit
GuardWidening
IPConstantProp
IRCE
IndVarSimplify
IndirectBrExpand
InferAddressSpaces
InferFunctionAttrs
Inline
InstCombine
AArch64
AMDGPU
ARM
NVPTX
PowerPC
X86
2003-05-26-CastMiscompile.ll
2003-05-27-ConstExprCrash.ll
2003-06-05-BranchInvertInfLoop.ll
2003-07-21-ExternalConstant.ll
2003-08-12-AllocaNonNull.ll
2003-09-09-VolatileLoadElim.ll
2003-10-29-CallSiteResolve.ll
2003-11-03-VarargsCallBug.ll
2004-01-13-InstCombineInvokePHI.ll
2004-02-23-ShiftShiftOverflow.ll
2004-03-13-InstCombineInfLoop.ll
2004-04-04-InstCombineReplaceAllUsesWith.ll
2004-05-07-UnsizedCastLoad.ll
2004-07-27-ConstantExprMul.ll
2004-08-09-RemInfLoop.ll
2004-08-10-BoolSetCC.ll
2004-09-20-BadLoadCombine.ll
2004-09-20-BadLoadCombine2.ll
2004-09-28-BadShiftAndSetCC.ll
2004-11-22-Missed-and-fold.ll
2004-11-27-SetCCForCastLargerAndConstant.ll
2004-12-08-RemInfiniteLoop.ll
2005-03-04-ShiftOverflow.ll
2005-04-07-UDivSelectCrash.ll
2005-06-15-DivSelectCrash.ll
2005-06-15-ShiftSetCCCrash.ll
2005-06-16-RangeCrash.ll
2005-07-07-DeadPHILoop.ll
2006-02-13-DemandedMiscompile.ll
2006-02-28-Crash.ll
2006-03-30-ExtractElement.ll
2006-04-28-ShiftShiftLongLong.ll
2006-05-04-DemandedBitCrash.ll
2006-09-15-CastToBool.ll
2006-10-19-SignedToUnsignedCastAndConst-2.ll
2006-10-20-mask.ll
2006-10-26-VectorReassoc.ll
2006-11-10-ashr-miscompile.ll
2006-12-01-BadFPVectorXform.ll
2006-12-05-fp-to-int-ext.ll
2006-12-08-Phi-ICmp-Op-Fold.ll
2006-12-08-Select-ICmp.ll
2006-12-15-Range-Test.ll
2006-12-23-Select-Cmp-Cmp.ll
2007-01-13-ExtCompareMiscompile.ll
2007-01-18-VectorInfLoop.ll
2007-02-01-LoadSinkAlloca.ll
2007-02-07-PointerCast.ll
2007-02-23-PhiFoldInfLoop.ll
2007-03-13-CompareMerge.ll
2007-03-19-BadTruncChangePR1261.ll
2007-03-21-SignedRangeTest.ll
2007-03-25-BadShiftMask.ll
2007-03-25-DoubleShift.ll
2007-03-26-BadShiftMask.ll
2007-04-08-SingleEltVectorCrash.ll
2007-05-10-icmp-or.ll
2007-05-14-Crash.ll
2007-05-18-CastFoldBug.ll
2007-06-06-AshrSignBit.ll
2007-06-21-DivCompareMiscomp.ll
2007-08-02-InfiniteLoop.ll
2007-09-10-AliasConstFold.ll
2007-09-17-AliasConstFold2.ll
2007-10-10-EliminateMemCpy.ll
2007-10-12-Crash.ll
2007-10-28-stacksave.ll
2007-10-31-RangeCrash.ll
2007-10-31-StringCrash.ll
2007-11-07-OpaqueAlignCrash.ll
2007-11-15-CompareMiscomp.ll
2007-11-25-CompatibleAttributes.ll
2007-12-10-ConstFoldCompare.ll
2007-12-12-GEPScale.ll
2007-12-16-AsmNoUnwind.ll
2007-12-18-AddSelCmpSub.ll
2007-12-28-IcmpSub2.ll
2008-01-06-BitCastAttributes.ll
2008-01-06-CastCrash.ll
2008-01-06-VoidCast.ll
2008-01-13-AndCmpCmp.ll
2008-01-14-VarArgTrampoline.ll
2008-01-21-MismatchedCastAndCompare.ll
2008-01-21-MulTrunc.ll
2008-01-27-FloatSelect.ll
2008-02-13-MulURem.ll
2008-02-16-SDivOverflow2.ll
2008-02-23-MulSub.ll
2008-02-28-OrFCmpCrash.ll
2008-03-13-IntToPtr.ll
2008-04-22-ByValBitcast.ll
2008-04-28-VolatileStore.ll
2008-04-29-VolatileLoadDontMerge.ll
2008-04-29-VolatileLoadMerge.ll
2008-05-08-LiveStoreDelete.ll
2008-05-08-StrLenSink.ll
2008-05-09-SinkOfInvoke.ll
2008-05-17-InfLoop.ll
2008-05-18-FoldIntToPtr.ll
2008-05-22-IDivVector.ll
2008-05-22-NegValVector.ll
2008-05-23-CompareFold.ll
2008-05-31-AddBool.ll
2008-05-31-Bools.ll
2008-06-05-ashr-crash.ll
2008-06-08-ICmpPHI.ll
2008-06-13-InfiniteLoopStore.ll
2008-06-13-ReadOnlyCallStore.ll
2008-06-19-UncondLoad.ll
2008-06-21-CompareMiscomp.ll
2008-06-24-StackRestore.ll
2008-07-08-ShiftOneAndOne.ll
2008-07-08-SubAnd.ll
2008-07-08-VolatileLoadMerge.ll
2008-07-09-SubAndError.ll
2008-07-10-CastSextBool.ll
2008-07-11-RemAnd.ll
2008-07-13-DivZero.ll
2008-07-16-fsub.ll
2008-08-05-And.ll
2008-09-02-VectorCrash.ll
2008-10-11-DivCompareFold.ll
2008-10-23-ConstFoldWithoutMask.ll
2008-11-01-SRemDemandedBits.ll
2008-11-08-FCmp.ll
2008-11-27-IDivVector.ll
2008-11-27-MultiplyIntVec.ll
2008-11-27-UDivNegative.ll
2008-12-17-SRemNegConstVec.ll
2009-01-05-i128-crash.ll
2009-01-08-AlignAlloca.ll
2009-01-16-PointerAddrSpace.ll
2009-01-19-fmod-constant-float-specials.ll
2009-01-19-fmod-constant-float.ll
2009-01-24-EmptyStruct.ll
2009-01-31-InfIterate.ll
2009-01-31-Pressure.ll
2009-02-04-FPBitcast.ll
2009-02-11-NotInitialized.ll
2009-02-20-InstCombine-SROA.ll
2009-02-21-LoadCST.ll
2009-02-25-CrashZeroSizeArray.ll
2009-03-18-vector-ashr-crash.ll
2009-03-24-InfLoop.ll
2009-04-07-MulPromoteToI96.ll
2009-05-23-FCmpToICmp.ll
2009-06-11-StoreAddrSpace.ll
2009-06-16-SRemDemandedBits.ll
2009-07-02-MaskedIntVector.ll
2009-12-17-CmpSelectNull.ll
2010-01-28-NegativeSRem.ll
2010-03-03-ExtElim.ll
2010-05-30-memcpy-Struct.ll
2010-11-01-lshr-mask.ll
2010-11-21-SizeZeroTypeGEP.ll
2010-11-23-Distributed.ll
2011-02-14-InfLoop.ll
2011-03-08-SRemMinusOneBadOpt.ll
2011-05-02-VectorBoolean.ll
2011-05-13-InBoundsGEP.ll
2011-05-28-swapmulsub.ll
2011-06-13-nsw-alloca.ll
2011-09-03-Trampoline.ll
2011-10-07-AlignPromotion.ll
2012-01-11-OpaqueBitcastCrash.ll
2012-02-13-FCmp.ll
2012-02-28-ICmp.ll
2012-03-10-InstCombine.ll
2012-04-24-vselect.ll
2012-04-30-SRem.ll
2012-05-28-select-hang.ll
2012-06-06-LoadOfPHIs.ll
2012-07-25-LoadPart.ll
2012-07-30-addrsp-bitcast.ll
2012-08-28-udiv_ashl.ll
2012-09-17-ZeroSizedAlloca.ll
2012-10-25-vector-of-pointers.ll
2012-12-14-simp-vgep.ll
2012-3-15-or-xor-constant.ll
2012-6-7-vselect-bitcast.ll
2013-03-05-Combine-BitcastTy-Into-Alloca.ll
2017-07-07-UMul-ZExt.ll
AddOverFlow.ll
CPP_min_max.ll
ExtractCast.ll
IntPtrCast.ll
JavaCompare.ll
LandingPadClauses.ll
OverlappingInsertvalues.ll
PR30597.ll
README.txt
abs-1.ll
abs_abs.ll
add-shrink.ll
add-sitofp.ll
add.ll
add2.ll
add3.ll
addnegneg.ll
addrspacecast.ll
adjust-for-minmax.ll
alias-recursion.ll
align-2d-gep.ll
align-addr.ll
align-attr.ll
align-external.ll
all-bits-shift.ll
alloca-cast-debuginfo.ll
alloca.ll
allocsize-32.ll
allocsize.ll
and-compare.ll
and-fcmp.ll
and-or-and.ll
and-or-icmps.ll
and-or-not.ll
and-or.ll
and-xor-merge.ll
and-xor-or.ll
and.ll
and2.ll
apint-add.ll
apint-and-compare.ll
apint-and-or-and.ll
apint-and-xor-merge.ll
apint-and.ll
apint-call-cast-target.ll
apint-cast-and-cast.ll
apint-cast-cast-to-and.ll
apint-cast.ll
apint-div1.ll
apint-div2.ll
apint-mul1.ll
apint-mul2.ll
apint-not.ll
apint-or.ll
apint-rem1.ll
apint-rem2.ll
apint-select.ll
apint-shift-simplify.ll
apint-shift.ll
apint-shl-trunc.ll
apint-sub.ll
apint-xor1.ll
apint-xor2.ll
assoc-cast-assoc.ll
assume-loop-align.ll
assume-redundant.ll
assume.ll
assume2.ll
atomic.ll
badmalloc.ll
binop-cast.ll
bit-checks.ll
bitcast-alias-function.ll
bitcast-bigendian.ll
bitcast-bitcast.ll
bitcast-sext-vector.ll
bitcast-store.ll
bitcast-vec-canon.ll
bitcast.ll
bitcount.ll
bitreverse-hang.ll
bitreverse-known-bits.ll
bittest.ll
branch.ll
broadcast.ll
bswap-fold.ll
bswap-known-bits.ll
bswap.ll
builtin-object-size-offset.ll
builtin-object-size-ptr.ll
cabs-array.ll
cabs-discrete.ll
call-cast-attrs.ll
call-cast-target-inalloca.ll
call-cast-target.ll
call-guard.ll
call-intrinsics.ll
call.ll
call2.ll
call_nonnull_arg.ll
canonicalize_branch.ll
cast-call-combine-prof.ll
cast-call-combine.ll
cast-callee-deopt-bundles.ll
cast-int-fcmp-eq-0.ll
cast-mul-select.ll
cast-set.ll
cast.ll
cast_ptr.ll
ceil.ll
clamp-to-minmax.ll
cmp-intrinsic.ll
compare-3way.ll
compare-alloca.ll
compare-signs.ll
compare-udiv.ll
compare-unescaped.ll
consecutive-fences.ll
constant-expr-datalayout.ll
constant-fold-address-space-pointer.ll
constant-fold-alias.ll
constant-fold-compare.ll
constant-fold-gep.ll
constant-fold-iteration.ll
constant-fold-libfunc.ll
constant-fold-math.ll
convergent.ll
copysign.ll
cos-1.ll
cos-2.ll
cos-intrinsic.ll
crash.ll
ctpop.ll
dce-iterate.ll
deadcode.ll
debug-line.ll
debuginfo-dce.ll
debuginfo-dce2.ll
debuginfo-skip.ll
debuginfo.ll
debuginfo_add.ll
default-alignment.ll
demand_shrink_nsw.ll
demorgan.ll
disable-simplify-libcalls.ll
distribute.ll
div-shift-crash.ll
div-shift.ll
div.ll
double-float-shrink-1.ll
double-float-shrink-2.ll
early_constfold_changes_IR.ll
early_dce_clobbers_callgraph.ll
element-atomic-memcpy-to-loads.ll
element-atomic-memintrins.ll
enforce-known-alignment.ll
err-rep-cold.ll
exact.ll
exp2-1.ll
exp2-2.ll
extractelement.ll
extractinsert-tbaa.ll
extractvalue.ll
fabs-libcall.ll
fabs.ll
fast-math-scalarization.ll
fast-math.ll
fcmp-select.ll
fcmp-special.ll
fcmp.ll
fdiv.ll
ffs-1.ll
float-shrink-compare.ll
fls.ll
fma.ll
fmul-sqrt.ll
fmul.ll
fneg-ext.ll
fold-bin-operand.ll
fold-calls.ll
fold-fops-into-selects.ll
fold-phi-load-metadata.ll
fold-phi.ll
fold-sqrt-sqrtf.ll
fold-vector-select.ll
fold-vector-zero.ll
fp-ret-bitcast.ll
fpcast.ll
fpextend.ll
fpextend_x86.ll
fprintf-1.ll
fputs-1.ll
fputs-opt-size.ll
fsub.ll
fwrite-1.ll
gc.relocate.ll
gep-addrspace.ll
gep-sext.ll
gep-vector.ll
gepgep.ll
gepphigep.ll
getelementptr-folding.ll
getelementptr.ll
hoist_instr.ll
icmp-add.ll
icmp-div-constant.ll
icmp-logical.ll
icmp-range.ll
icmp-shl-nsw.ll
icmp-shl-nuw.ll
icmp-shr-lt-gt.ll
icmp-shr.ll
icmp-vec.ll
icmp-xor-signbit.ll
icmp.ll
idioms.ll
indexed-gep-compares.ll
inline-intrinsic-assert.ll
insert-const-shuf.ll
insert-extract-shuffle.ll
insert-val-extract-elem.ll
int_sideeffect.ll
intptr1.ll
intptr2.ll
intptr3.ll
intptr4.ll
intptr5.ll
intptr6.ll
intptr7.ll
intrinsics.ll
invariant.ll
invoke.ll
isascii-1.ll
isdigit-1.ll
known_align.ll
lifetime-asan.ll
lifetime.ll
load-bitcast-select.ll
load-bitcast32.ll
load-bitcast64.ll
load-cmp.ll
load-combine-metadata-2.ll
load-combine-metadata-3.ll
load-combine-metadata-4.ll
load-combine-metadata.ll
load-select.ll
load.ll
load3.ll
load_combine_aa.ll
loadstore-alignment.ll
loadstore-metadata.ll
log-pow-nofastmath.ll
log-pow.ll
logical-select.ll
lshr-phi.ll
lshr.ll
malloc-free-delete.ll
masked_intrinsics.ll
max-of-nots.ll
maxnum.ll
mem-gep-zidx.ll
mem-par-metadata-memcpy.ll
memchr.ll
memcmp-1.ll
memcmp-2.ll
memcmp-constant-fold.ll
memcpy-1.ll
memcpy-2.ll
memcpy-addrspace.ll
memcpy-from-global.ll
memcpy-to-load.ll
memcpy.ll
memcpy_chk-1.ll
memcpy_chk-2.ll
memmove-1.ll
memmove-2.ll
memmove.ll
memmove_chk-1.ll
memmove_chk-2.ll
memset-1.ll
memset-2.ll
memset.ll
memset2.ll
memset_chk-1.ll
memset_chk-2.ll
merge-icmp.ll
min-positive.ll
minmax-fold.ll
minmax-fp.ll
minnum.ll
misc-2002.ll
mul-masked-bits.ll
mul.ll
multi-size-address-space-pointer.ll
multi-use-or.ll
multiple-uses-load-bitcast-select.ll
narrow-switch.ll
narrow.ll
no-negzero.ll
no_cgscc_assert.ll
non-integral-pointers.ll
nonnull-attribute.ll
not.ll
nothrow.ll
nsw.ll
obfuscated_splat.ll
objsize-64.ll
objsize-address-space.ll
objsize-noverify.ll
objsize.ll
odr-linkage.ll
onehot_merge.ll
opaque.ll
or-fcmp.ll
or-shifted-masks.ll
or-xor.ll
or.ll
osx-names.ll
out-of-bounds-indexes.ll
overflow-mul.ll
overflow.ll
phi-load-metadata-2.ll
phi-load-metadata-3.ll
phi-load-metadata.ll
phi-merge-gep.ll
phi-preserve-ir-flags.ll
phi-select-constant.ll
phi.ll
pow-1.ll
pow-2.ll
pow-3.ll
pow-4.ll
pow-exp-nofastmath.ll
pow-exp.ll
pow-sqrt.ll
pr12251.ll
pr12338.ll
pr17827.ll
pr19420.ll
pr20079.ll
pr20678.ll
pr21199.ll
pr21210.ll
pr21651.ll
pr21891.ll
pr23751.ll
pr23809.ll
pr24354.ll
pr24605.ll
pr25342.ll
pr25745.ll
pr2645-0.ll
pr26992.ll
pr26993.ll
pr27236.ll
pr27332.ll
pr27703.ll
pr27996.ll
pr28143.ll
pr28725.ll
pr2996.ll
pr30929.ll
pr31990_wrong_memcpy.ll
pr32686.ll
pr33453.ll
pr33689_same_bitwidth.ll
pr33765.ll
pr34349.ll
pr34627.ll
pr35515.ll
pr36362.ll
prefetch-load.ll
preserve-sminmax.ll
preserved-analyses.ll
prevent-cmp-merge.ll
printf-1.ll
printf-2.ll
printf-3.ll
ptr-int-cast.ll
puts-1.ll
range-check.ll
readnone-maythrow.ll
rem.ll
rotate.ll
round.ll
sdiv-1.ll
sdiv-2.ll
select-2.ll
select-bitext-bitwise-ops.ll
select-bitext.ll
select-cmp-br.ll
select-cmp-cttz-ctlz.ll
select-cmpxchg.ll
select-crash-noverify.ll
select-crash.ll
select-extractelement.ll
select-implied.ll
select-load-call.ll
select-select.ll
select-with-bitwise-ops.ll
select.ll
select_arithmetic.ll
select_meta.ll
set.ll
setcc-strength-reduce.ll
sext.ll
shift-add.ll
shift-shift.ll
shift-sra.ll
shift.ll
shufflevec-bitcast.ll
shufflevec-constant.ll
sign-test-and-or.ll
signed-comparison.ll
signext.ll
simplify-demanded-bits-pointer.ll
simplify-libcalls.ll
sincospi.ll
sink-into-catchswitch.ll
sink-zext.ll
sink_instruction.ll
sitofp.ll
smax-icmp.ll
smin-icmp.ll
sprintf-1.ll
sqrt-nofast.ll
sqrt.ll
srem-simplify-bug.ll
srem1.ll
stack-overalign.ll
stacksaverestore.ll
statepoint.ll
store-load-unaliased-gep.ll
store.ll
stpcpy-1.ll
stpcpy-2.ll
stpcpy_chk-1.ll
stpcpy_chk-2.ll
strcat-1.ll
strcat-2.ll
strcat-3.ll
strchr-1.ll
strchr-2.ll
strcmp-1.ll
strcmp-2.ll
strcpy-1.ll
strcpy-2.ll
strcpy_chk-1.ll
strcpy_chk-2.ll
strcpy_chk-64.ll
strcspn-1.ll
strcspn-2.ll
strlen-1.ll
strlen-2.ll
strncat-1.ll
strncat-2.ll
strncat-3.ll
strncmp-1.ll
strncmp-2.ll
strncmp-wrong-datalayout.ll
strncpy-1.ll
strncpy-2.ll
strncpy_chk-1.ll
strncpy_chk-2.ll
strpbrk-1.ll
strpbrk-2.ll
strrchr-1.ll
strrchr-2.ll
strspn-1.ll
strstr-1.ll
strstr-2.ll
strto-1.ll
struct-assign-tbaa.ll
sub-xor.ll
sub.ll
switch-constant-expr.ll
switch-truncate-crash.ll
tan-nofastmath.ll
tan.ll
tbaa-store-to-load.ll
toascii-1.ll
token.ll
trunc-binop-ext.ll
trunc.ll
type_pun.ll
udiv-simplify.ll
udiv_select_to_select_shift.ll
udivrem-change-width.ll
umax-icmp.ll
umin-icmp.ll
unordered-fcmp-select.ll
unpack-fca.ll
urem-simplify-bug.ll
vararg.ll
vec_demanded_elts.ll
vec_extract_2elts.ll
vec_extract_elt.ll
vec_extract_var_elt.ll
vec_insertelt.ll
vec_narrow.ll
vec_phi_extract.ll
vec_sext.ll
vec_shuffle.ll
vector-casts.ll
vector-mul.ll
vector-type.ll
vector-urem.ll
vector_gep1.ll
vector_gep2.ll
vector_insertelt_shuffle.ll
volatile_store.ll
wcslen-1.ll
wcslen-2.ll
wcslen-3.ll
wcslen-4.ll
weak-symbols.ll
win-math.ll
xor-undef.ll
xor.ll
xor2.ll
zero-point-zero-add.ll
zeroext-and-reduce.ll
zext-bool-add-sub.ll
zext-fold.ll
zext-or-icmp.ll
zext-phi.ll
zext.ll
InstMerge
InstNamer
InstSimplify
InterleavedAccess
Internalize
JumpThreading
LCSSA
LICM
LoadStoreVectorizer
LoopDataPrefetch
LoopDeletion
LoopDistribute
LoopIdiom
LoopInterchange
LoopLoadElim
LoopPredication
LoopReroll
LoopRotate
LoopSimplify
LoopSimplifyCFG
LoopStrengthReduce
LoopUnroll
LoopUnswitch
LoopVectorize
LoopVersioning
LoopVersioningLICM
LowerAtomic
LowerExpectIntrinsic
LowerGuardIntrinsic
LowerInvoke
LowerSwitch
LowerTypeTests
Mem2Reg
MemCpyOpt
MergeFunc
MergeICmps
MetaRenamer
NameAnonGlobals
NaryReassociate
NewGVN
ObjCARC
PGOProfile
PartiallyInlineLibCalls
PhaseOrdering
PlaceSafepoints
PreISelIntrinsicLowering
PruneEH
Reassociate
Reg2Mem
RewriteStatepointsForGC
SCCP
SLPVectorizer
SROA
SafeStack
SampleProfile
Scalarizer
SeparateConstOffsetFromGEP
SimpleLoopUnswitch
SimplifyCFG
Sink
SpeculateAroundPHIs
SpeculativeExecution
StraightLineStrengthReduce
StripDeadPrototypes
StripSymbols
StructurizeCFG
TailCallElim
ThinLTOBitcodeWriter
Util
WholeProgramDevirt
Unit
Verifier
YAMLParser
tools
.clang-format
CMakeLists.txt
TestRunner.sh
lit.cfg.py
lit.site.cfg.py.in
tools
unittests
utils
.arcconfig
.clang-format
.clang-tidy
.gitattributes
.gitignore
CMakeLists.txt
CODE_OWNERS.TXT
CREDITS.TXT
LICENSE.TXT
LLVMBuild.txt
README.txt
RELEASE_TESTERS.TXT
configure
llvm.spec.in
version.txt.in
nuget
openmp
polly
Directory.Build.props
Directory.Build.targets
NuGet.config
azure-pipelines.yml
build.cmd
build.sh
dir.common.props
global.json
llvm.proj
mxe-Win64.cmake.in
nuget-buildtasks
nunit-lite
roslyn-binaries
rx
xunit-binaries
how-to-bump-roslyn-binaries.md
ikvm-native
llvm
m4
man
mcs
mono
msvc
netcore
po
runtime
samples
scripts
support
tools
COPYING.LIB
LICENSE
Makefile.am
Makefile.in
NEWS
README.md
acinclude.m4
aclocal.m4
autogen.sh
code_of_conduct.md
compile
config.guess
config.h.in
config.rpath
config.sub
configure.REMOVED.git-id
configure.ac.REMOVED.git-id
depcomp
install-sh
ltmain.sh.REMOVED.git-id
missing
mkinstalldirs
mono-uninstalled.pc.in
test-driver
winconfig.h
844 lines
24 KiB
LLVM
844 lines
24 KiB
LLVM
![]() |
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
|
||
|
; RUN: opt < %s -instcombine -S | FileCheck %s
|
||
|
|
||
|
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
|
||
|
|
||
|
define i32 @test12(i32 %A) {
|
||
|
; Should be eliminated
|
||
|
; CHECK-LABEL: @test12(
|
||
|
; CHECK-NEXT: [[C:%.*]] = and i32 %A, 8
|
||
|
; CHECK-NEXT: ret i32 [[C]]
|
||
|
;
|
||
|
%B = or i32 %A, 4
|
||
|
%C = and i32 %B, 8
|
||
|
ret i32 %C
|
||
|
}
|
||
|
|
||
|
define i32 @test13(i32 %A) {
|
||
|
; CHECK-LABEL: @test13(
|
||
|
; CHECK-NEXT: ret i32 8
|
||
|
;
|
||
|
%B = or i32 %A, 12
|
||
|
; Always equal to 8
|
||
|
%C = and i32 %B, 8
|
||
|
ret i32 %C
|
||
|
}
|
||
|
|
||
|
define i1 @test14(i32 %A, i32 %B) {
|
||
|
; CHECK-LABEL: @test14(
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = icmp ne i32 %A, %B
|
||
|
; CHECK-NEXT: ret i1 [[TMP1]]
|
||
|
;
|
||
|
%C1 = icmp ult i32 %A, %B
|
||
|
%C2 = icmp ugt i32 %A, %B
|
||
|
; (A < B) | (A > B) === A != B
|
||
|
%D = or i1 %C1, %C2
|
||
|
ret i1 %D
|
||
|
}
|
||
|
|
||
|
define i1 @test15(i32 %A, i32 %B) {
|
||
|
; CHECK-LABEL: @test15(
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = icmp ule i32 %A, %B
|
||
|
; CHECK-NEXT: ret i1 [[TMP1]]
|
||
|
;
|
||
|
%C1 = icmp ult i32 %A, %B
|
||
|
%C2 = icmp eq i32 %A, %B
|
||
|
; (A < B) | (A == B) === A <= B
|
||
|
%D = or i1 %C1, %C2
|
||
|
ret i1 %D
|
||
|
}
|
||
|
|
||
|
define i32 @test16(i32 %A) {
|
||
|
; CHECK-LABEL: @test16(
|
||
|
; CHECK-NEXT: ret i32 %A
|
||
|
;
|
||
|
%B = and i32 %A, 1
|
||
|
; -2 = ~1
|
||
|
%C = and i32 %A, -2
|
||
|
; %D = and int %B, -1 == %B
|
||
|
%D = or i32 %B, %C
|
||
|
ret i32 %D
|
||
|
}
|
||
|
|
||
|
define i32 @test17(i32 %A) {
|
||
|
; CHECK-LABEL: @test17(
|
||
|
; CHECK-NEXT: [[D:%.*]] = and i32 %A, 5
|
||
|
; CHECK-NEXT: ret i32 [[D]]
|
||
|
;
|
||
|
%B = and i32 %A, 1
|
||
|
%C = and i32 %A, 4
|
||
|
; %D = and int %B, 5
|
||
|
%D = or i32 %B, %C
|
||
|
ret i32 %D
|
||
|
}
|
||
|
|
||
|
define i1 @test18(i32 %A) {
|
||
|
; CHECK-LABEL: @test18(
|
||
|
; CHECK-NEXT: [[A_OFF:%.*]] = add i32 %A, -50
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = icmp ugt i32 [[A_OFF]], 49
|
||
|
; CHECK-NEXT: ret i1 [[TMP1]]
|
||
|
;
|
||
|
%B = icmp sge i32 %A, 100
|
||
|
%C = icmp slt i32 %A, 50
|
||
|
%D = or i1 %B, %C
|
||
|
ret i1 %D
|
||
|
}
|
||
|
|
||
|
; FIXME: Vectors should fold too.
|
||
|
define <2 x i1> @test18vec(<2 x i32> %A) {
|
||
|
; CHECK-LABEL: @test18vec(
|
||
|
; CHECK-NEXT: [[B:%.*]] = icmp sgt <2 x i32> %A, <i32 99, i32 99>
|
||
|
; CHECK-NEXT: [[C:%.*]] = icmp slt <2 x i32> %A, <i32 50, i32 50>
|
||
|
; CHECK-NEXT: [[D:%.*]] = or <2 x i1> [[B]], [[C]]
|
||
|
; CHECK-NEXT: ret <2 x i1> [[D]]
|
||
|
;
|
||
|
%B = icmp sge <2 x i32> %A, <i32 100, i32 100>
|
||
|
%C = icmp slt <2 x i32> %A, <i32 50, i32 50>
|
||
|
%D = or <2 x i1> %B, %C
|
||
|
ret <2 x i1> %D
|
||
|
}
|
||
|
|
||
|
define i32 @test20(i32 %x) {
|
||
|
; CHECK-LABEL: @test20(
|
||
|
; CHECK-NEXT: ret i32 %x
|
||
|
;
|
||
|
%y = and i32 %x, 123
|
||
|
%z = or i32 %y, %x
|
||
|
ret i32 %z
|
||
|
}
|
||
|
|
||
|
define i32 @test21(i32 %tmp.1) {
|
||
|
; CHECK-LABEL: @test21(
|
||
|
; CHECK-NEXT: [[TMP_1_MASK1:%.*]] = add i32 %tmp.1, 2
|
||
|
; CHECK-NEXT: ret i32 [[TMP_1_MASK1]]
|
||
|
;
|
||
|
%tmp.1.mask1 = add i32 %tmp.1, 2
|
||
|
%tmp.3 = and i32 %tmp.1.mask1, -2
|
||
|
%tmp.5 = and i32 %tmp.1, 1
|
||
|
;; add tmp.1, 2
|
||
|
%tmp.6 = or i32 %tmp.5, %tmp.3
|
||
|
ret i32 %tmp.6
|
||
|
}
|
||
|
|
||
|
define i32 @test22(i32 %B) {
|
||
|
; CHECK-LABEL: @test22(
|
||
|
; CHECK-NEXT: ret i32 %B
|
||
|
;
|
||
|
%ELIM41 = and i32 %B, 1
|
||
|
%ELIM7 = and i32 %B, -2
|
||
|
%ELIM5 = or i32 %ELIM41, %ELIM7
|
||
|
ret i32 %ELIM5
|
||
|
}
|
||
|
|
||
|
define i16 @test23(i16 %A) {
|
||
|
; CHECK-LABEL: @test23(
|
||
|
; CHECK-NEXT: [[B:%.*]] = lshr i16 %A, 1
|
||
|
; CHECK-NEXT: [[D:%.*]] = xor i16 [[B]], -24575
|
||
|
; CHECK-NEXT: ret i16 [[D]]
|
||
|
;
|
||
|
%B = lshr i16 %A, 1
|
||
|
;; fold or into xor
|
||
|
%C = or i16 %B, -32768
|
||
|
%D = xor i16 %C, 8193
|
||
|
ret i16 %D
|
||
|
}
|
||
|
|
||
|
define <2 x i16> @test23vec(<2 x i16> %A) {
|
||
|
; CHECK-LABEL: @test23vec(
|
||
|
; CHECK-NEXT: [[B:%.*]] = lshr <2 x i16> [[A:%.*]], <i16 1, i16 1>
|
||
|
; CHECK-NEXT: [[D:%.*]] = xor <2 x i16> [[B]], <i16 -24575, i16 -24575>
|
||
|
; CHECK-NEXT: ret <2 x i16> [[D]]
|
||
|
;
|
||
|
%B = lshr <2 x i16> %A, <i16 1, i16 1>
|
||
|
;; fold or into xor
|
||
|
%C = or <2 x i16> %B, <i16 -32768, i16 -32768>
|
||
|
%D = xor <2 x i16> %C, <i16 8193, i16 8193>
|
||
|
ret <2 x i16> %D
|
||
|
}
|
||
|
|
||
|
; PR3266 & PR5276
|
||
|
define i1 @test25(i32 %A, i32 %B) {
|
||
|
; CHECK-LABEL: @test25(
|
||
|
; CHECK-NEXT: [[NOTLHS:%.*]] = icmp ne i32 %A, 0
|
||
|
; CHECK-NEXT: [[NOTRHS:%.*]] = icmp ne i32 %B, 57
|
||
|
; CHECK-NEXT: [[F:%.*]] = and i1 [[NOTRHS]], [[NOTLHS]]
|
||
|
; CHECK-NEXT: ret i1 [[F]]
|
||
|
;
|
||
|
%C = icmp eq i32 %A, 0
|
||
|
%D = icmp eq i32 %B, 57
|
||
|
%E = or i1 %C, %D
|
||
|
%F = xor i1 %E, -1
|
||
|
ret i1 %F
|
||
|
}
|
||
|
|
||
|
; PR5634
|
||
|
define i1 @test26(i32 %A, i32 %B) {
|
||
|
; CHECK-LABEL: @test26(
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = or i32 %A, %B
|
||
|
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[TMP1]], 0
|
||
|
; CHECK-NEXT: ret i1 [[TMP2]]
|
||
|
;
|
||
|
%C1 = icmp eq i32 %A, 0
|
||
|
%C2 = icmp eq i32 %B, 0
|
||
|
; (A == 0) & (A == 0) --> (A|B) == 0
|
||
|
%D = and i1 %C1, %C2
|
||
|
ret i1 %D
|
||
|
}
|
||
|
|
||
|
define i1 @test27(i32* %A, i32* %B) {
|
||
|
; CHECK-LABEL: @test27(
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i32* %A, null
|
||
|
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32* %B, null
|
||
|
; CHECK-NEXT: [[E:%.*]] = and i1 [[TMP1]], [[TMP2]]
|
||
|
; CHECK-NEXT: ret i1 [[E]]
|
||
|
;
|
||
|
%C1 = ptrtoint i32* %A to i32
|
||
|
%C2 = ptrtoint i32* %B to i32
|
||
|
%D = or i32 %C1, %C2
|
||
|
%E = icmp eq i32 %D, 0
|
||
|
ret i1 %E
|
||
|
}
|
||
|
|
||
|
define <2 x i1> @test27vec(<2 x i32*> %A, <2 x i32*> %B) {
|
||
|
; CHECK-LABEL: @test27vec(
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = icmp eq <2 x i32*> %A, zeroinitializer
|
||
|
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq <2 x i32*> %B, zeroinitializer
|
||
|
; CHECK-NEXT: [[E:%.*]] = and <2 x i1> [[TMP1]], [[TMP2]]
|
||
|
; CHECK-NEXT: ret <2 x i1> [[E]]
|
||
|
;
|
||
|
%C1 = ptrtoint <2 x i32*> %A to <2 x i32>
|
||
|
%C2 = ptrtoint <2 x i32*> %B to <2 x i32>
|
||
|
%D = or <2 x i32> %C1, %C2
|
||
|
%E = icmp eq <2 x i32> %D, zeroinitializer
|
||
|
ret <2 x i1> %E
|
||
|
}
|
||
|
|
||
|
; PR5634
|
||
|
define i1 @test28(i32 %A, i32 %B) {
|
||
|
; CHECK-LABEL: @test28(
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = or i32 %A, %B
|
||
|
; CHECK-NEXT: [[TMP2:%.*]] = icmp ne i32 [[TMP1]], 0
|
||
|
; CHECK-NEXT: ret i1 [[TMP2]]
|
||
|
;
|
||
|
%C1 = icmp ne i32 %A, 0
|
||
|
%C2 = icmp ne i32 %B, 0
|
||
|
; (A != 0) | (A != 0) --> (A|B) != 0
|
||
|
%D = or i1 %C1, %C2
|
||
|
ret i1 %D
|
||
|
}
|
||
|
|
||
|
define i1 @test29(i32* %A, i32* %B) {
|
||
|
; CHECK-LABEL: @test29(
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = icmp ne i32* %A, null
|
||
|
; CHECK-NEXT: [[TMP2:%.*]] = icmp ne i32* %B, null
|
||
|
; CHECK-NEXT: [[E:%.*]] = or i1 [[TMP1]], [[TMP2]]
|
||
|
; CHECK-NEXT: ret i1 [[E]]
|
||
|
;
|
||
|
%C1 = ptrtoint i32* %A to i32
|
||
|
%C2 = ptrtoint i32* %B to i32
|
||
|
%D = or i32 %C1, %C2
|
||
|
%E = icmp ne i32 %D, 0
|
||
|
ret i1 %E
|
||
|
}
|
||
|
|
||
|
define <2 x i1> @test29vec(<2 x i32*> %A, <2 x i32*> %B) {
|
||
|
; CHECK-LABEL: @test29vec(
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = icmp ne <2 x i32*> %A, zeroinitializer
|
||
|
; CHECK-NEXT: [[TMP2:%.*]] = icmp ne <2 x i32*> %B, zeroinitializer
|
||
|
; CHECK-NEXT: [[E:%.*]] = or <2 x i1> [[TMP1]], [[TMP2]]
|
||
|
; CHECK-NEXT: ret <2 x i1> [[E]]
|
||
|
;
|
||
|
%C1 = ptrtoint <2 x i32*> %A to <2 x i32>
|
||
|
%C2 = ptrtoint <2 x i32*> %B to <2 x i32>
|
||
|
%D = or <2 x i32> %C1, %C2
|
||
|
%E = icmp ne <2 x i32> %D, zeroinitializer
|
||
|
ret <2 x i1> %E
|
||
|
}
|
||
|
|
||
|
; PR4216
|
||
|
define i32 @test30(i32 %A) {
|
||
|
; CHECK-LABEL: @test30(
|
||
|
; CHECK-NEXT: [[D:%.*]] = and i32 %A, -58312
|
||
|
; CHECK-NEXT: [[E:%.*]] = or i32 [[D]], 32962
|
||
|
; CHECK-NEXT: ret i32 [[E]]
|
||
|
;
|
||
|
%B = or i32 %A, 32962
|
||
|
%C = and i32 %A, -65536
|
||
|
%D = and i32 %B, 40186
|
||
|
%E = or i32 %D, %C
|
||
|
ret i32 %E
|
||
|
}
|
||
|
|
||
|
define <2 x i32> @test30vec(<2 x i32> %A) {
|
||
|
; CHECK-LABEL: @test30vec(
|
||
|
; CHECK-NEXT: [[C:%.*]] = and <2 x i32> [[A:%.*]], <i32 -65536, i32 -65536>
|
||
|
; CHECK-NEXT: [[B:%.*]] = and <2 x i32> [[A]], <i32 7224, i32 7224>
|
||
|
; CHECK-NEXT: [[D:%.*]] = or <2 x i32> [[B]], <i32 32962, i32 32962>
|
||
|
; CHECK-NEXT: [[E:%.*]] = or <2 x i32> [[D]], [[C]]
|
||
|
; CHECK-NEXT: ret <2 x i32> [[E]]
|
||
|
;
|
||
|
%B = or <2 x i32> %A, <i32 32962, i32 32962>
|
||
|
%C = and <2 x i32> %A, <i32 -65536, i32 -65536>
|
||
|
%D = and <2 x i32> %B, <i32 40186, i32 40186>
|
||
|
%E = or <2 x i32> %D, %C
|
||
|
ret <2 x i32> %E
|
||
|
}
|
||
|
|
||
|
; PR4216
|
||
|
define i64 @test31(i64 %A) {
|
||
|
; CHECK-LABEL: @test31(
|
||
|
; CHECK-NEXT: [[E:%.*]] = and i64 %A, 4294908984
|
||
|
; CHECK-NEXT: [[F:%.*]] = or i64 [[E]], 32962
|
||
|
; CHECK-NEXT: ret i64 [[F]]
|
||
|
;
|
||
|
%B = or i64 %A, 194
|
||
|
%D = and i64 %B, 250
|
||
|
|
||
|
%C = or i64 %A, 32768
|
||
|
%E = and i64 %C, 4294941696
|
||
|
|
||
|
%F = or i64 %D, %E
|
||
|
ret i64 %F
|
||
|
}
|
||
|
|
||
|
define <2 x i64> @test31vec(<2 x i64> %A) {
|
||
|
; CHECK-LABEL: @test31vec(
|
||
|
; CHECK-NEXT: [[E:%.*]] = and <2 x i64> [[A:%.*]], <i64 4294908984, i64 4294908984>
|
||
|
; CHECK-NEXT: [[F:%.*]] = or <2 x i64> [[E]], <i64 32962, i64 32962>
|
||
|
; CHECK-NEXT: ret <2 x i64> [[F]]
|
||
|
;
|
||
|
%B = or <2 x i64> %A, <i64 194, i64 194>
|
||
|
%D = and <2 x i64> %B, <i64 250, i64 250>
|
||
|
|
||
|
%C = or <2 x i64> %A, <i64 32768, i64 32768>
|
||
|
%E = and <2 x i64> %C, <i64 4294941696, i64 4294941696>
|
||
|
|
||
|
%F = or <2 x i64> %D, %E
|
||
|
ret <2 x i64> %F
|
||
|
}
|
||
|
|
||
|
; codegen is mature enough to handle vector selects.
|
||
|
define <4 x i32> @test32(<4 x i1> %and.i1352, <4 x i32> %vecinit6.i176, <4 x i32> %vecinit6.i191) {
|
||
|
; CHECK-LABEL: @test32(
|
||
|
; CHECK-NEXT: [[OR_I:%.*]] = select <4 x i1> %and.i1352, <4 x i32> %vecinit6.i176, <4 x i32> %vecinit6.i191
|
||
|
; CHECK-NEXT: ret <4 x i32> [[OR_I]]
|
||
|
;
|
||
|
%and.i135 = sext <4 x i1> %and.i1352 to <4 x i32>
|
||
|
%and.i129 = and <4 x i32> %vecinit6.i176, %and.i135
|
||
|
%neg.i = xor <4 x i32> %and.i135, <i32 -1, i32 -1, i32 -1, i32 -1>
|
||
|
%and.i = and <4 x i32> %vecinit6.i191, %neg.i
|
||
|
%or.i = or <4 x i32> %and.i, %and.i129
|
||
|
ret <4 x i32> %or.i
|
||
|
}
|
||
|
|
||
|
define i1 @test33(i1 %X, i1 %Y) {
|
||
|
; CHECK-LABEL: @test33(
|
||
|
; CHECK-NEXT: [[B:%.*]] = or i1 %X, %Y
|
||
|
; CHECK-NEXT: ret i1 [[B]]
|
||
|
;
|
||
|
%a = or i1 %X, %Y
|
||
|
%b = or i1 %a, %X
|
||
|
ret i1 %b
|
||
|
}
|
||
|
|
||
|
define i32 @test34(i32 %X, i32 %Y) {
|
||
|
; CHECK-LABEL: @test34(
|
||
|
; CHECK-NEXT: [[B:%.*]] = or i32 %X, %Y
|
||
|
; CHECK-NEXT: ret i32 [[B]]
|
||
|
;
|
||
|
%a = or i32 %X, %Y
|
||
|
%b = or i32 %Y, %a
|
||
|
ret i32 %b
|
||
|
}
|
||
|
|
||
|
define i32 @test35(i32 %a, i32 %b) {
|
||
|
; CHECK-LABEL: @test35(
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = or i32 %a, %b
|
||
|
; CHECK-NEXT: [[TMP2:%.*]] = or i32 [[TMP1]], 1135
|
||
|
; CHECK-NEXT: ret i32 [[TMP2]]
|
||
|
;
|
||
|
%1 = or i32 %a, 1135
|
||
|
%2 = or i32 %1, %b
|
||
|
ret i32 %2
|
||
|
}
|
||
|
|
||
|
define i1 @test36(i32 %x) {
|
||
|
; CHECK-LABEL: @test36(
|
||
|
; CHECK-NEXT: [[X_OFF:%.*]] = add i32 %x, -23
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = icmp ult i32 [[X_OFF]], 3
|
||
|
; CHECK-NEXT: ret i1 [[TMP1]]
|
||
|
;
|
||
|
%cmp1 = icmp eq i32 %x, 23
|
||
|
%cmp2 = icmp eq i32 %x, 24
|
||
|
%ret1 = or i1 %cmp1, %cmp2
|
||
|
%cmp3 = icmp eq i32 %x, 25
|
||
|
%ret2 = or i1 %ret1, %cmp3
|
||
|
ret i1 %ret2
|
||
|
}
|
||
|
|
||
|
define i32 @orsext_to_sel(i32 %x, i1 %y) {
|
||
|
; CHECK-LABEL: @orsext_to_sel(
|
||
|
; CHECK-NEXT: [[OR:%.*]] = select i1 %y, i32 -1, i32 %x
|
||
|
; CHECK-NEXT: ret i32 [[OR]]
|
||
|
;
|
||
|
%sext = sext i1 %y to i32
|
||
|
%or = or i32 %sext, %x
|
||
|
ret i32 %or
|
||
|
}
|
||
|
|
||
|
define i32 @orsext_to_sel_swap(i32 %x, i1 %y) {
|
||
|
; CHECK-LABEL: @orsext_to_sel_swap(
|
||
|
; CHECK-NEXT: [[OR:%.*]] = select i1 %y, i32 -1, i32 %x
|
||
|
; CHECK-NEXT: ret i32 [[OR]]
|
||
|
;
|
||
|
%sext = sext i1 %y to i32
|
||
|
%or = or i32 %x, %sext
|
||
|
ret i32 %or
|
||
|
}
|
||
|
|
||
|
define i32 @orsext_to_sel_multi_use(i32 %x, i1 %y) {
|
||
|
; CHECK-LABEL: @orsext_to_sel_multi_use(
|
||
|
; CHECK-NEXT: [[SEXT:%.*]] = sext i1 %y to i32
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or i32 [[SEXT]], %x
|
||
|
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[OR]], [[SEXT]]
|
||
|
; CHECK-NEXT: ret i32 [[ADD]]
|
||
|
;
|
||
|
%sext = sext i1 %y to i32
|
||
|
%or = or i32 %sext, %x
|
||
|
%add = add i32 %sext, %or
|
||
|
ret i32 %add
|
||
|
}
|
||
|
|
||
|
define <2 x i32> @orsext_to_sel_vec(<2 x i32> %x, <2 x i1> %y) {
|
||
|
; CHECK-LABEL: @orsext_to_sel_vec(
|
||
|
; CHECK-NEXT: [[OR:%.*]] = select <2 x i1> %y, <2 x i32> <i32 -1, i32 -1>, <2 x i32> %x
|
||
|
; CHECK-NEXT: ret <2 x i32> [[OR]]
|
||
|
;
|
||
|
%sext = sext <2 x i1> %y to <2 x i32>
|
||
|
%or = or <2 x i32> %sext, %x
|
||
|
ret <2 x i32> %or
|
||
|
}
|
||
|
|
||
|
define <2 x i132> @orsext_to_sel_vec_swap(<2 x i132> %x, <2 x i1> %y) {
|
||
|
; CHECK-LABEL: @orsext_to_sel_vec_swap(
|
||
|
; CHECK-NEXT: [[OR:%.*]] = select <2 x i1> %y, <2 x i132> <i132 -1, i132 -1>, <2 x i132> %x
|
||
|
; CHECK-NEXT: ret <2 x i132> [[OR]]
|
||
|
;
|
||
|
%sext = sext <2 x i1> %y to <2 x i132>
|
||
|
%or = or <2 x i132> %x, %sext
|
||
|
ret <2 x i132> %or
|
||
|
}
|
||
|
|
||
|
; (~A & B) | A --> A | B
|
||
|
|
||
|
define i32 @test39a(i32 %a, float %b) {
|
||
|
; CHECK-LABEL: @test39a(
|
||
|
; CHECK-NEXT: [[A1:%.*]] = mul i32 %a, 42
|
||
|
; CHECK-NEXT: [[B1:%.*]] = bitcast float %b to i32
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or i32 [[A1]], [[B1]]
|
||
|
; CHECK-NEXT: ret i32 [[OR]]
|
||
|
;
|
||
|
%a1 = mul i32 %a, 42 ; thwart complexity-based ordering
|
||
|
%b1 = bitcast float %b to i32 ; thwart complexity-based ordering
|
||
|
%nota = xor i32 %a1, -1
|
||
|
%and = and i32 %nota, %b1
|
||
|
%or = or i32 %and, %a1
|
||
|
ret i32 %or
|
||
|
}
|
||
|
|
||
|
; Commute 'and' operands:
|
||
|
; (B & ~A) | A --> A | B
|
||
|
|
||
|
define i32 @test39b(i32 %a, float %b) {
|
||
|
; CHECK-LABEL: @test39b(
|
||
|
; CHECK-NEXT: [[A1:%.*]] = mul i32 %a, 42
|
||
|
; CHECK-NEXT: [[B1:%.*]] = bitcast float %b to i32
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or i32 [[A1]], [[B1]]
|
||
|
; CHECK-NEXT: ret i32 [[OR]]
|
||
|
;
|
||
|
%a1 = mul i32 %a, 42 ; thwart complexity-based ordering
|
||
|
%b1 = bitcast float %b to i32 ; thwart complexity-based ordering
|
||
|
%nota = xor i32 %a1, -1
|
||
|
%and = and i32 %b1, %nota
|
||
|
%or = or i32 %and, %a1
|
||
|
ret i32 %or
|
||
|
}
|
||
|
|
||
|
; Commute 'or' operands:
|
||
|
; A | (~A & B) --> A | B
|
||
|
|
||
|
define i32 @test39c(i32 %a, float %b) {
|
||
|
; CHECK-LABEL: @test39c(
|
||
|
; CHECK-NEXT: [[A1:%.*]] = mul i32 %a, 42
|
||
|
; CHECK-NEXT: [[B1:%.*]] = bitcast float %b to i32
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or i32 [[A1]], [[B1]]
|
||
|
; CHECK-NEXT: ret i32 [[OR]]
|
||
|
;
|
||
|
%a1 = mul i32 %a, 42 ; thwart complexity-based ordering
|
||
|
%b1 = bitcast float %b to i32 ; thwart complexity-based ordering
|
||
|
%nota = xor i32 %a1, -1
|
||
|
%and = and i32 %nota, %b1
|
||
|
%or = or i32 %a1, %and
|
||
|
ret i32 %or
|
||
|
}
|
||
|
|
||
|
; Commute 'and' operands:
|
||
|
; A | (B & ~A) --> A | B
|
||
|
|
||
|
define i32 @test39d(i32 %a, float %b) {
|
||
|
; CHECK-LABEL: @test39d(
|
||
|
; CHECK-NEXT: [[A1:%.*]] = mul i32 %a, 42
|
||
|
; CHECK-NEXT: [[B1:%.*]] = bitcast float %b to i32
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or i32 [[A1]], [[B1]]
|
||
|
; CHECK-NEXT: ret i32 [[OR]]
|
||
|
;
|
||
|
%a1 = mul i32 %a, 42 ; thwart complexity-based ordering
|
||
|
%b1 = bitcast float %b to i32 ; thwart complexity-based ordering
|
||
|
%nota = xor i32 %a1, -1
|
||
|
%and = and i32 %b1, %nota
|
||
|
%or = or i32 %a1, %and
|
||
|
ret i32 %or
|
||
|
}
|
||
|
|
||
|
define i32 @test40(i32 %a, i32 %b) {
|
||
|
; CHECK-LABEL: @test40(
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = xor i32 %a, -1
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or i32 [[TMP1]], %b
|
||
|
; CHECK-NEXT: ret i32 [[OR]]
|
||
|
;
|
||
|
%and = and i32 %a, %b
|
||
|
%xor = xor i32 %a, -1
|
||
|
%or = or i32 %and, %xor
|
||
|
ret i32 %or
|
||
|
}
|
||
|
|
||
|
define i32 @test40b(i32 %a, i32 %b) {
|
||
|
; CHECK-LABEL: @test40b(
|
||
|
; CHECK-NEXT: [[XOR:%.*]] = xor i32 %a, -1
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or i32 [[XOR]], %b
|
||
|
; CHECK-NEXT: ret i32 [[OR]]
|
||
|
;
|
||
|
%and = and i32 %b, %a
|
||
|
%xor = xor i32 %a, -1
|
||
|
%or = or i32 %and, %xor
|
||
|
ret i32 %or
|
||
|
}
|
||
|
|
||
|
define i32 @test40c(i32 %a, i32 %b) {
|
||
|
; CHECK-LABEL: @test40c(
|
||
|
; CHECK-NEXT: [[XOR:%.*]] = xor i32 %a, -1
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or i32 [[XOR]], %b
|
||
|
; CHECK-NEXT: ret i32 [[OR]]
|
||
|
;
|
||
|
%and = and i32 %b, %a
|
||
|
%xor = xor i32 %a, -1
|
||
|
%or = or i32 %xor, %and
|
||
|
ret i32 %or
|
||
|
}
|
||
|
|
||
|
define i32 @test40d(i32 %a, i32 %b) {
|
||
|
; CHECK-LABEL: @test40d(
|
||
|
; CHECK-NEXT: [[XOR:%.*]] = xor i32 %a, -1
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or i32 [[XOR]], %b
|
||
|
; CHECK-NEXT: ret i32 [[OR]]
|
||
|
;
|
||
|
%and = and i32 %a, %b
|
||
|
%xor = xor i32 %a, -1
|
||
|
%or = or i32 %xor, %and
|
||
|
ret i32 %or
|
||
|
}
|
||
|
|
||
|
define i32 @test45(i32 %x, i32 %y, i32 %z) {
|
||
|
; CHECK-LABEL: @test45(
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = and i32 %x, %z
|
||
|
; CHECK-NEXT: [[OR1:%.*]] = or i32 [[TMP1]], %y
|
||
|
; CHECK-NEXT: ret i32 [[OR1]]
|
||
|
;
|
||
|
%or = or i32 %y, %z
|
||
|
%and = and i32 %x, %or
|
||
|
%or1 = or i32 %and, %y
|
||
|
ret i32 %or1
|
||
|
}
|
||
|
|
||
|
define i1 @test46(i8 signext %c) {
|
||
|
; CHECK-LABEL: @test46(
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = and i8 %c, -33
|
||
|
; CHECK-NEXT: [[TMP2:%.*]] = add i8 [[TMP1]], -65
|
||
|
; CHECK-NEXT: [[TMP3:%.*]] = icmp ult i8 [[TMP2]], 26
|
||
|
; CHECK-NEXT: ret i1 [[TMP3]]
|
||
|
;
|
||
|
%c.off = add i8 %c, -97
|
||
|
%cmp1 = icmp ult i8 %c.off, 26
|
||
|
%c.off17 = add i8 %c, -65
|
||
|
%cmp2 = icmp ult i8 %c.off17, 26
|
||
|
%or = or i1 %cmp1, %cmp2
|
||
|
ret i1 %or
|
||
|
}
|
||
|
|
||
|
define i1 @test47(i8 signext %c) {
|
||
|
; CHECK-LABEL: @test47(
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = and i8 %c, -33
|
||
|
; CHECK-NEXT: [[TMP2:%.*]] = add i8 [[TMP1]], -65
|
||
|
; CHECK-NEXT: [[TMP3:%.*]] = icmp ult i8 [[TMP2]], 27
|
||
|
; CHECK-NEXT: ret i1 [[TMP3]]
|
||
|
;
|
||
|
%c.off = add i8 %c, -65
|
||
|
%cmp1 = icmp ule i8 %c.off, 26
|
||
|
%c.off17 = add i8 %c, -97
|
||
|
%cmp2 = icmp ule i8 %c.off17, 26
|
||
|
%or = or i1 %cmp1, %cmp2
|
||
|
ret i1 %or
|
||
|
}
|
||
|
|
||
|
define i32 @test49(i1 %C) {
|
||
|
; CHECK-LABEL: @test49(
|
||
|
; CHECK-NEXT: [[V:%.*]] = select i1 [[C:%.*]], i32 1019, i32 123
|
||
|
; CHECK-NEXT: ret i32 [[V]]
|
||
|
;
|
||
|
%A = select i1 %C, i32 1000, i32 10
|
||
|
%V = or i32 %A, 123
|
||
|
ret i32 %V
|
||
|
}
|
||
|
|
||
|
define <2 x i32> @test49vec(i1 %C) {
|
||
|
; CHECK-LABEL: @test49vec(
|
||
|
; CHECK-NEXT: [[V:%.*]] = select i1 [[C:%.*]], <2 x i32> <i32 1019, i32 1019>, <2 x i32> <i32 123, i32 123>
|
||
|
; CHECK-NEXT: ret <2 x i32> [[V]]
|
||
|
;
|
||
|
%A = select i1 %C, <2 x i32> <i32 1000, i32 1000>, <2 x i32> <i32 10, i32 10>
|
||
|
%V = or <2 x i32> %A, <i32 123, i32 123>
|
||
|
ret <2 x i32> %V
|
||
|
}
|
||
|
|
||
|
define <2 x i32> @test49vec2(i1 %C) {
|
||
|
; CHECK-LABEL: @test49vec2(
|
||
|
; CHECK-NEXT: [[V:%.*]] = select i1 [[C:%.*]], <2 x i32> <i32 1019, i32 2509>, <2 x i32> <i32 123, i32 351>
|
||
|
; CHECK-NEXT: ret <2 x i32> [[V]]
|
||
|
;
|
||
|
%A = select i1 %C, <2 x i32> <i32 1000, i32 2500>, <2 x i32> <i32 10, i32 30>
|
||
|
%V = or <2 x i32> %A, <i32 123, i32 333>
|
||
|
ret <2 x i32> %V
|
||
|
}
|
||
|
|
||
|
define i32 @test50(i1 %which) {
|
||
|
; CHECK-LABEL: @test50(
|
||
|
; CHECK-NEXT: entry:
|
||
|
; CHECK-NEXT: br i1 [[WHICH:%.*]], label [[FINAL:%.*]], label [[DELAY:%.*]]
|
||
|
; CHECK: delay:
|
||
|
; CHECK-NEXT: br label [[FINAL]]
|
||
|
; CHECK: final:
|
||
|
; CHECK-NEXT: [[A:%.*]] = phi i32 [ 1019, [[ENTRY:%.*]] ], [ 123, [[DELAY]] ]
|
||
|
; CHECK-NEXT: ret i32 [[A]]
|
||
|
;
|
||
|
entry:
|
||
|
br i1 %which, label %final, label %delay
|
||
|
|
||
|
delay:
|
||
|
br label %final
|
||
|
|
||
|
final:
|
||
|
%A = phi i32 [ 1000, %entry ], [ 10, %delay ]
|
||
|
%value = or i32 %A, 123
|
||
|
ret i32 %value
|
||
|
}
|
||
|
|
||
|
define <2 x i32> @test50vec(i1 %which) {
|
||
|
; CHECK-LABEL: @test50vec(
|
||
|
; CHECK-NEXT: entry:
|
||
|
; CHECK-NEXT: br i1 [[WHICH:%.*]], label [[FINAL:%.*]], label [[DELAY:%.*]]
|
||
|
; CHECK: delay:
|
||
|
; CHECK-NEXT: br label [[FINAL]]
|
||
|
; CHECK: final:
|
||
|
; CHECK-NEXT: [[A:%.*]] = phi <2 x i32> [ <i32 1019, i32 1019>, [[ENTRY:%.*]] ], [ <i32 123, i32 123>, [[DELAY]] ]
|
||
|
; CHECK-NEXT: ret <2 x i32> [[A]]
|
||
|
;
|
||
|
entry:
|
||
|
br i1 %which, label %final, label %delay
|
||
|
|
||
|
delay:
|
||
|
br label %final
|
||
|
|
||
|
final:
|
||
|
%A = phi <2 x i32> [ <i32 1000, i32 1000>, %entry ], [ <i32 10, i32 10>, %delay ]
|
||
|
%value = or <2 x i32> %A, <i32 123, i32 123>
|
||
|
ret <2 x i32> %value
|
||
|
}
|
||
|
|
||
|
define <2 x i32> @test50vec2(i1 %which) {
|
||
|
; CHECK-LABEL: @test50vec2(
|
||
|
; CHECK-NEXT: entry:
|
||
|
; CHECK-NEXT: br i1 [[WHICH:%.*]], label [[FINAL:%.*]], label [[DELAY:%.*]]
|
||
|
; CHECK: delay:
|
||
|
; CHECK-NEXT: br label [[FINAL]]
|
||
|
; CHECK: final:
|
||
|
; CHECK-NEXT: [[A:%.*]] = phi <2 x i32> [ <i32 1019, i32 2509>, [[ENTRY:%.*]] ], [ <i32 123, i32 351>, [[DELAY]] ]
|
||
|
; CHECK-NEXT: ret <2 x i32> [[A]]
|
||
|
;
|
||
|
entry:
|
||
|
br i1 %which, label %final, label %delay
|
||
|
|
||
|
delay:
|
||
|
br label %final
|
||
|
|
||
|
final:
|
||
|
%A = phi <2 x i32> [ <i32 1000, i32 2500>, %entry ], [ <i32 10, i32 30>, %delay ]
|
||
|
%value = or <2 x i32> %A, <i32 123, i32 333>
|
||
|
ret <2 x i32> %value
|
||
|
}
|
||
|
|
||
|
; In the next 4 tests, vary the types and predicates for extra coverage.
|
||
|
; (X | (Y & ~X)) -> (X | Y), where 'not' is an inverted cmp
|
||
|
|
||
|
define i1 @or_andn_cmp_1(i32 %a, i32 %b, i32 %c) {
|
||
|
; CHECK-LABEL: @or_andn_cmp_1(
|
||
|
; CHECK-NEXT: [[X:%.*]] = icmp sgt i32 [[A:%.*]], [[B:%.*]]
|
||
|
; CHECK-NEXT: [[Y:%.*]] = icmp ugt i32 [[C:%.*]], 42
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or i1 [[X]], [[Y]]
|
||
|
; CHECK-NEXT: ret i1 [[OR]]
|
||
|
;
|
||
|
%x = icmp sgt i32 %a, %b
|
||
|
%x_inv = icmp sle i32 %a, %b
|
||
|
%y = icmp ugt i32 %c, 42 ; thwart complexity-based ordering
|
||
|
%and = and i1 %y, %x_inv
|
||
|
%or = or i1 %x, %and
|
||
|
ret i1 %or
|
||
|
}
|
||
|
|
||
|
; Commute the 'or':
|
||
|
; ((Y & ~X) | X) -> (X | Y), where 'not' is an inverted cmp
|
||
|
|
||
|
define <2 x i1> @or_andn_cmp_2(<2 x i32> %a, <2 x i32> %b, <2 x i32> %c) {
|
||
|
; CHECK-LABEL: @or_andn_cmp_2(
|
||
|
; CHECK-NEXT: [[X:%.*]] = icmp sge <2 x i32> [[A:%.*]], [[B:%.*]]
|
||
|
; CHECK-NEXT: [[Y:%.*]] = icmp ugt <2 x i32> [[C:%.*]], <i32 42, i32 47>
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or <2 x i1> [[Y]], [[X]]
|
||
|
; CHECK-NEXT: ret <2 x i1> [[OR]]
|
||
|
;
|
||
|
%x = icmp sge <2 x i32> %a, %b
|
||
|
%x_inv = icmp slt <2 x i32> %a, %b
|
||
|
%y = icmp ugt <2 x i32> %c, <i32 42, i32 47> ; thwart complexity-based ordering
|
||
|
%and = and <2 x i1> %y, %x_inv
|
||
|
%or = or <2 x i1> %and, %x
|
||
|
ret <2 x i1> %or
|
||
|
}
|
||
|
|
||
|
; Commute the 'and':
|
||
|
; (X | (~X & Y)) -> (X | Y), where 'not' is an inverted cmp
|
||
|
|
||
|
define i1 @or_andn_cmp_3(i72 %a, i72 %b, i72 %c) {
|
||
|
; CHECK-LABEL: @or_andn_cmp_3(
|
||
|
; CHECK-NEXT: [[X:%.*]] = icmp ugt i72 [[A:%.*]], [[B:%.*]]
|
||
|
; CHECK-NEXT: [[Y:%.*]] = icmp ugt i72 [[C:%.*]], 42
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or i1 [[X]], [[Y]]
|
||
|
; CHECK-NEXT: ret i1 [[OR]]
|
||
|
;
|
||
|
%x = icmp ugt i72 %a, %b
|
||
|
%x_inv = icmp ule i72 %a, %b
|
||
|
%y = icmp ugt i72 %c, 42 ; thwart complexity-based ordering
|
||
|
%and = and i1 %x_inv, %y
|
||
|
%or = or i1 %x, %and
|
||
|
ret i1 %or
|
||
|
}
|
||
|
|
||
|
; Commute the 'or':
|
||
|
; ((~X & Y) | X) -> (X | Y), where 'not' is an inverted cmp
|
||
|
|
||
|
define <3 x i1> @or_andn_cmp_4(<3 x i32> %a, <3 x i32> %b, <3 x i32> %c) {
|
||
|
; CHECK-LABEL: @or_andn_cmp_4(
|
||
|
; CHECK-NEXT: [[X:%.*]] = icmp eq <3 x i32> [[A:%.*]], [[B:%.*]]
|
||
|
; CHECK-NEXT: [[Y:%.*]] = icmp ugt <3 x i32> [[C:%.*]], <i32 42, i32 43, i32 -1>
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or <3 x i1> [[Y]], [[X]]
|
||
|
; CHECK-NEXT: ret <3 x i1> [[OR]]
|
||
|
;
|
||
|
%x = icmp eq <3 x i32> %a, %b
|
||
|
%x_inv = icmp ne <3 x i32> %a, %b
|
||
|
%y = icmp ugt <3 x i32> %c, <i32 42, i32 43, i32 -1> ; thwart complexity-based ordering
|
||
|
%and = and <3 x i1> %x_inv, %y
|
||
|
%or = or <3 x i1> %and, %x
|
||
|
ret <3 x i1> %or
|
||
|
}
|
||
|
|
||
|
; In the next 4 tests, vary the types and predicates for extra coverage.
|
||
|
; (~X | (Y & X)) -> (~X | Y), where 'not' is an inverted cmp
|
||
|
|
||
|
define i1 @orn_and_cmp_1(i37 %a, i37 %b, i37 %c) {
|
||
|
; CHECK-LABEL: @orn_and_cmp_1(
|
||
|
; CHECK-NEXT: [[X_INV:%.*]] = icmp sle i37 [[A:%.*]], [[B:%.*]]
|
||
|
; CHECK-NEXT: [[Y:%.*]] = icmp ugt i37 [[C:%.*]], 42
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or i1 [[X_INV]], [[Y]]
|
||
|
; CHECK-NEXT: ret i1 [[OR]]
|
||
|
;
|
||
|
%x = icmp sgt i37 %a, %b
|
||
|
%x_inv = icmp sle i37 %a, %b
|
||
|
%y = icmp ugt i37 %c, 42 ; thwart complexity-based ordering
|
||
|
%and = and i1 %y, %x
|
||
|
%or = or i1 %x_inv, %and
|
||
|
ret i1 %or
|
||
|
}
|
||
|
|
||
|
; Commute the 'or':
|
||
|
; ((Y & X) | ~X) -> (~X | Y), where 'not' is an inverted cmp
|
||
|
|
||
|
define i1 @orn_and_cmp_2(i16 %a, i16 %b, i16 %c) {
|
||
|
; CHECK-LABEL: @orn_and_cmp_2(
|
||
|
; CHECK-NEXT: [[X_INV:%.*]] = icmp slt i16 [[A:%.*]], [[B:%.*]]
|
||
|
; CHECK-NEXT: [[Y:%.*]] = icmp ugt i16 [[C:%.*]], 42
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or i1 [[Y]], [[X_INV]]
|
||
|
; CHECK-NEXT: ret i1 [[OR]]
|
||
|
;
|
||
|
%x = icmp sge i16 %a, %b
|
||
|
%x_inv = icmp slt i16 %a, %b
|
||
|
%y = icmp ugt i16 %c, 42 ; thwart complexity-based ordering
|
||
|
%and = and i1 %y, %x
|
||
|
%or = or i1 %and, %x_inv
|
||
|
ret i1 %or
|
||
|
}
|
||
|
|
||
|
; Commute the 'and':
|
||
|
; (~X | (X & Y)) -> (~X | Y), where 'not' is an inverted cmp
|
||
|
|
||
|
define <4 x i1> @orn_and_cmp_3(<4 x i32> %a, <4 x i32> %b, <4 x i32> %c) {
|
||
|
; CHECK-LABEL: @orn_and_cmp_3(
|
||
|
; CHECK-NEXT: [[X_INV:%.*]] = icmp ule <4 x i32> [[A:%.*]], [[B:%.*]]
|
||
|
; CHECK-NEXT: [[Y:%.*]] = icmp ugt <4 x i32> [[C:%.*]], <i32 42, i32 0, i32 1, i32 -1>
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or <4 x i1> [[X_INV]], [[Y]]
|
||
|
; CHECK-NEXT: ret <4 x i1> [[OR]]
|
||
|
;
|
||
|
%x = icmp ugt <4 x i32> %a, %b
|
||
|
%x_inv = icmp ule <4 x i32> %a, %b
|
||
|
%y = icmp ugt <4 x i32> %c, <i32 42, i32 0, i32 1, i32 -1> ; thwart complexity-based ordering
|
||
|
%and = and <4 x i1> %x, %y
|
||
|
%or = or <4 x i1> %x_inv, %and
|
||
|
ret <4 x i1> %or
|
||
|
}
|
||
|
|
||
|
; Commute the 'or':
|
||
|
; ((X & Y) | ~X) -> (~X | Y), where 'not' is an inverted cmp
|
||
|
|
||
|
define i1 @orn_and_cmp_4(i32 %a, i32 %b, i32 %c) {
|
||
|
; CHECK-LABEL: @orn_and_cmp_4(
|
||
|
; CHECK-NEXT: [[X_INV:%.*]] = icmp ne i32 [[A:%.*]], [[B:%.*]]
|
||
|
; CHECK-NEXT: [[Y:%.*]] = icmp ugt i32 [[C:%.*]], 42
|
||
|
; CHECK-NEXT: [[OR:%.*]] = or i1 [[Y]], [[X_INV]]
|
||
|
; CHECK-NEXT: ret i1 [[OR]]
|
||
|
;
|
||
|
%x = icmp eq i32 %a, %b
|
||
|
%x_inv = icmp ne i32 %a, %b
|
||
|
%y = icmp ugt i32 %c, 42 ; thwart complexity-based ordering
|
||
|
%and = and i1 %x, %y
|
||
|
%or = or i1 %and, %x_inv
|
||
|
ret i1 %or
|
||
|
}
|
||
|
|
||
|
; The constant vectors are inverses. Make sure we can turn this into a select without crashing trying to truncate the constant to 16xi1.
|
||
|
define <16 x i1> @test51(<16 x i1> %arg, <16 x i1> %arg1) {
|
||
|
; CHECK-LABEL: @test51(
|
||
|
; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <16 x i1> [[ARG:%.*]], <16 x i1> [[ARG1:%.*]], <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 20, i32 5, i32 6, i32 23, i32 24, i32 9, i32 10, i32 27, i32 28, i32 29, i32 30, i32 31>
|
||
|
; CHECK-NEXT: ret <16 x i1> [[TMP1]]
|
||
|
;
|
||
|
%tmp = and <16 x i1> %arg, <i1 true, i1 true, i1 true, i1 true, i1 false, i1 true, i1 true, i1 false, i1 false, i1 true, i1 true, i1 false, i1 false, i1 false, i1 false, i1 false>
|
||
|
%tmp2 = and <16 x i1> %arg1, <i1 false, i1 false, i1 false, i1 false, i1 true, i1 false, i1 false, i1 true, i1 true, i1 false, i1 false, i1 true, i1 true, i1 true, i1 true, i1 true>
|
||
|
%tmp3 = or <16 x i1> %tmp, %tmp2
|
||
|
ret <16 x i1> %tmp3
|
||
|
}
|