This is an archive of the discontinued LLVM Phabricator instance.

Differential D5066

Rename getMaximumUnrollFactor().
ClosedPublic

Authored by spatel on Aug 26 2014, 8:28 AM.

Details

Reviewers
rengolin
nadav
aschwaighofer
hfinkel
Commits
rGb653de1ada7e: Rename getMaximumUnrollFactor -> getMaxInterleaveFactor; also rename option…
rL217528: Rename getMaximumUnrollFactor -> getMaxInterleaveFactor; also rename option…
Summary

"getMaximumUnrollFactor()" isn't used by the loop unroller at all. It's strictly a loop vectorizer variable, so I propose renaming it to "getMaxVectorUnrollFactor()" with this patch. No functional change intended.

Ideally, I think we would move this subtarget-specific variable into the SchedMachineModel. That's where we already have a variable for "LoopMicroOpBufferSize" which is used by the loop unroller. If that's a good change, let me know, and I'll work on a patch for it.

Diff Detail

Repository
rL LLVM

Event Timeline

spatel updated this revision to Diff 12949.Aug 26 2014, 8:28 AM
spatel retitled this revision from to Rename getMaximumUnrollFactor()..
spatel updated this object.
spatel edited the test plan for this revision. (Show Details)
spatel added reviewers: aschwaighofer, hfinkel, nadav.
spatel added a subscriber: Unknown Object (MLST).
Herald added a subscriber: mcrosier. · View Herald TranscriptAug 26 2014, 8:28 AM
hfinkel edited edge metadata.Aug 26 2014, 8:32 AM

I agree that this should be renamed. We actually call this the interleaving factor (not the unrolling factor) in user-facing things (like the pragmas and metadata); I think the renaming should reflect that.

rengolin added a subscriber: rengolin.Aug 26 2014, 9:50 AM

I agree with Hal, interleave factor is a much better name, and is independent of the loop (or any other) vectorizer. The comments should also be changed to explain that.

--renato

spatel updated this revision to Diff 12954.Aug 26 2014, 10:35 AM
spatel added a reviewer: rengolin.

Thanks very much for the feedback, Hal and Renato.

I wasn't aware of the pragmas in clang - good to know about those.

In this version of the patch, I have changed the name to "getMaxVectorInterleaveFactor". I also made a bunch of interior changes in LoopVectorizer...but there are 2 "seams" where we still use "unroll":

  1. I stopped short of changing the cl::opt names - if we really want to unify on "interleave" I assume we want to change those too so they match the pragmas? That will require changing 80+ test cases in test-suite. If everyone agrees that is better, I'll certainly make that change too.
  1. Eventually the interleave factor becomes an ingredient in "UF", the unroll factor: if (UF > MaxInterleaveSize) UF = MaxInterleaveSize;

I have not looked at the logic in LV close enough to know if "UF" is the appropriate name. Any opinions?

aschwaighofer edited edge metadata.Aug 26 2014, 12:00 PM

I also thing it makes sense to rename this to interleave factor to point out the difference between interleaved unrolling vs concatenating unrolling. Interleaving is not necessarily tied to vectorization. The fact that we interleave in the vectorizer is just an artifact of our implementation. I think it should be getMaxInterleaveFactor(). We are not necessarily interleaving vector instructions.

Thanks for cleaning this up!

rengolin edited edge metadata.Aug 26 2014, 1:03 PM

Hi Sanjay,

In this version of the patch, I have changed the name to "getMaxVectorInterleaveFactor". I also made a bunch of interior changes in LoopVectorizer...but there are 2 "seams" where we still use "unroll":

Please, drop the "Vector" as it's not directly related to the interleaving.

  1. I stopped short of changing the cl::opt names - if we really want to unify on "interleave" I assume we want to change those too so they match the pragmas? That will require changing 80+ test cases in test-suite. If everyone agrees that is better, I'll certainly make that change too.

That's a good point. We certainly could, but that'd have to be an alias, at least for now.

Arnold, how public are those flags nowadays? The decision to either keep it forever, rename now or anything in between will have to be based on that.

  1. Eventually the interleave factor becomes an ingredient in "UF", the unroll factor: if (UF > MaxInterleaveSize) UF = MaxInterleaveSize;

I have not looked at the logic in LV close enough to know if "UF" is the appropriate name. Any opinions?

I think the name is correct as it is.

IIRC, UF is the actual unrolling factor, which bases its decision ultimately on the interleave factor, since it's generally not profitable to "just unroll" at a factor greater than the interleave, even if the data dependencies allow it.

cheers,
--renato

spatel updated this revision to Diff 12963.Aug 26 2014, 1:24 PM
spatel edited edge metadata.

Changed name to: "getMaxInterleaveFactor" - sorry that I missed the earlier comment that this is independent of the vectorizer.

spatel added a comment.Sep 3 2014, 9:11 AM

Ping.

There's still a question of whether to change the cl::opt names either in this patch or later?

hfinkel added a comment.Sep 3 2014, 9:41 AM
  • Original Message -----

From: "Sanjay Patel" <spatel@rotateright.com>
To: spatel@rotateright.com, nrotem@apple.com, hfinkel@anl.gov, "renato golin" <renato.golin@linaro.org>,
aschwaighofer@apple.com
Cc: mcrosier@codeaurora.org, llvm-commits@cs.uiuc.edu
Sent: Wednesday, September 3, 2014 11:11:54 AM
Subject: Re: [PATCH] Rename getMaximumUnrollFactor().

Ping.

There's still a question of whether to change the cl::opt names
either in this patch or later?

Those are for development and debugging. I think that either is fine, but you might as well do it now for consistency.

-Hal

http://reviews.llvm.org/D5066

spatel updated this revision to Diff 13482.Sep 9 2014, 10:58 AM

Rebased and updated to change the cl::opt params - and so affects lots of LV testcases that use that param.

Please let me know if this is ok to commit. Thanks!

rengolin accepted this revision.Sep 10 2014, 3:04 AM
rengolin edited edge metadata.

Hi Sanjay,

LGTM, Thanks!

This revision is now accepted and ready to land.Sep 10 2014, 3:04 AM
spatel closed this revision.Sep 10 2014, 11:08 AM
spatel updated this revision to Diff 13553.

Closed by commit rL217528 (authored by @spatel).

spatel added a comment.Sep 10 2014, 11:08 AM

Thanks all for the review - committed at r217528.

Revision Contents

PathSize
llvm/
trunk/
include/
llvm/
Analysis/
4 lines
lib/
Analysis/
6 lines
CodeGen/
4 lines
Target/
AArch64/
4 lines
ARM/
2 lines
PowerPC/
4 lines
R600/
4 lines
X86/
4 lines
Transforms/
Vectorize/
80 lines
test/
Transforms/
LoopVectorize/
2 lines
2 lines
2 lines
X86/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
XCore/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines

Diff 13553

llvm/trunk/include/llvm/Analysis/TargetTransformInfo.h

Show First 20 Lines • Show All 340 Lines • ▼ Show 20 Linespublic:
/// \return The number of scalar or vector registers that the target has. /// \return The number of scalar or vector registers that the target has.
/// If 'Vectors' is true, it returns the number of vector registers. If it is /// If 'Vectors' is true, it returns the number of vector registers. If it is
/// set to false, it returns the number of scalar registers. /// set to false, it returns the number of scalar registers.
virtual unsigned getNumberOfRegisters(bool Vector) const; virtual unsigned getNumberOfRegisters(bool Vector) const;
/// \return The width of the largest scalar or vector register type. /// \return The width of the largest scalar or vector register type.
virtual unsigned getRegisterBitWidth(bool Vector) const; virtual unsigned getRegisterBitWidth(bool Vector) const;
/// \return The maximum unroll factor that the vectorizer should try to /// \return The maximum interleave factor that any transform should try to
/// perform for this target. This number depends on the level of parallelism /// perform for this target. This number depends on the level of parallelism
/// and the number of execution units in the CPU. /// and the number of execution units in the CPU.
virtual unsigned getMaximumUnrollFactor() const; virtual unsigned getMaxInterleaveFactor() const;
/// \return The expected cost of arithmetic ops, such as mul, xor, fsub, etc. /// \return The expected cost of arithmetic ops, such as mul, xor, fsub, etc.
virtual unsigned virtual unsigned
getArithmeticInstrCost(unsigned Opcode, Type *Ty, getArithmeticInstrCost(unsigned Opcode, Type *Ty,
OperandValueKind Opd1Info = OK_AnyValue, OperandValueKind Opd1Info = OK_AnyValue,
OperandValueKind Opd2Info = OK_AnyValue, OperandValueKind Opd2Info = OK_AnyValue,
OperandValueProperties Opd1PropInfo = OP_None, OperandValueProperties Opd1PropInfo = OP_None,
OperandValueProperties Opd2PropInfo = OP_None) const; OperandValueProperties Opd2PropInfo = OP_None) const;
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

llvm/trunk/lib/Analysis/TargetTransformInfo.cpp

Show First 20 Lines • Show All 161 Lines • ▼ Show 20 Lines
unsigned TargetTransformInfo::getNumberOfRegisters(bool Vector) const { unsigned TargetTransformInfo::getNumberOfRegisters(bool Vector) const {
return PrevTTI->getNumberOfRegisters(Vector); return PrevTTI->getNumberOfRegisters(Vector);
} }
unsigned TargetTransformInfo::getRegisterBitWidth(bool Vector) const { unsigned TargetTransformInfo::getRegisterBitWidth(bool Vector) const {
return PrevTTI->getRegisterBitWidth(Vector); return PrevTTI->getRegisterBitWidth(Vector);
} }
unsigned TargetTransformInfo::getMaximumUnrollFactor() const { unsigned TargetTransformInfo::getMaxInterleaveFactor() const {
return PrevTTI->getMaximumUnrollFactor(); return PrevTTI->getMaxInterleaveFactor();
} }
unsigned TargetTransformInfo::getArithmeticInstrCost( unsigned TargetTransformInfo::getArithmeticInstrCost(
unsigned Opcode, Type *Ty, OperandValueKind Op1Info, unsigned Opcode, Type *Ty, OperandValueKind Op1Info,
OperandValueKind Op2Info, OperandValueProperties Opd1PropInfo, OperandValueKind Op2Info, OperandValueProperties Opd1PropInfo,
OperandValueProperties Opd2PropInfo) const { OperandValueProperties Opd2PropInfo) const {
return PrevTTI->getArithmeticInstrCost(Opcode, Ty, Op1Info, Op2Info, return PrevTTI->getArithmeticInstrCost(Opcode, Ty, Op1Info, Op2Info,
Opd1PropInfo, Opd2PropInfo); Opd1PropInfo, Opd2PropInfo);
▲ Show 20 Lines • Show All 380 Lines • ▼ Show 20 Linesstruct NoTTI final : ImmutablePass, TargetTransformInfo {
unsigned getNumberOfRegisters(bool Vector) const override { unsigned getNumberOfRegisters(bool Vector) const override {
return 8; return 8;
} }
unsigned getRegisterBitWidth(bool Vector) const override { unsigned getRegisterBitWidth(bool Vector) const override {
return 32; return 32;
} }
unsigned getMaximumUnrollFactor() const override { unsigned getMaxInterleaveFactor() const override {
return 1; return 1;
} }
unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind, unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind,
OperandValueKind, OperandValueProperties, OperandValueKind, OperandValueProperties,
OperandValueProperties) const override { OperandValueProperties) const override {
return 1; return 1;
} }
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/trunk/lib/CodeGen/BasicTargetTransformInfo.cpp

Show First 20 Lines • Show All 95 Lines • ▼ Show 20 Lines void getUnrollingPreferences(Loop *L,
UnrollingPreferences &UP) const override; UnrollingPreferences &UP) const override;
/// @} /// @}
/// \name Vector TTI Implementations /// \name Vector TTI Implementations
/// @{ /// @{
unsigned getNumberOfRegisters(bool Vector) const override; unsigned getNumberOfRegisters(bool Vector) const override;
unsigned getMaximumUnrollFactor() const override; unsigned getMaxInterleaveFactor() const override;
unsigned getRegisterBitWidth(bool Vector) const override; unsigned getRegisterBitWidth(bool Vector) const override;
unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind, unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind,
OperandValueKind, OperandValueProperties, OperandValueKind, OperandValueProperties,
OperandValueProperties) const override; OperandValueProperties) const override;
unsigned getShuffleCost(ShuffleKind Kind, Type *Tp, unsigned getShuffleCost(ShuffleKind Kind, Type *Tp,
int Index, Type *SubTp) const override; int Index, Type *SubTp) const override;
unsigned getCastInstrCost(unsigned Opcode, Type *Dst, unsigned getCastInstrCost(unsigned Opcode, Type *Dst,
Type *Src) const override; Type *Src) const override;
▲ Show 20 Lines • Show All 166 Lines • ▼ Show 20 Lines
unsigned BasicTTI::getNumberOfRegisters(bool Vector) const { unsigned BasicTTI::getNumberOfRegisters(bool Vector) const {
return 1; return 1;
} }
unsigned BasicTTI::getRegisterBitWidth(bool Vector) const { unsigned BasicTTI::getRegisterBitWidth(bool Vector) const {
return 32; return 32;
} }
unsigned BasicTTI::getMaximumUnrollFactor() const { unsigned BasicTTI::getMaxInterleaveFactor() const {
return 1; return 1;
} }
unsigned BasicTTI::getArithmeticInstrCost(unsigned Opcode, Type *Ty, unsigned BasicTTI::getArithmeticInstrCost(unsigned Opcode, Type *Ty,
OperandValueKind, OperandValueKind, OperandValueKind, OperandValueKind,
OperandValueProperties, OperandValueProperties,
OperandValueProperties) const { OperandValueProperties) const {
// Check if any of the operands are vector operands. // Check if any of the operands are vector operands.
▲ Show 20 Lines • Show All 349 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

Show First 20 Lines • Show All 98 Lines • ▼ Show 20 Lines unsigned getRegisterBitWidth(bool Vector) const override {
if (Vector) { if (Vector) {
if (ST->hasNEON()) if (ST->hasNEON())
return 128; return 128;
return 0; return 0;
} }
return 64; return 64;
} }
unsigned getMaximumUnrollFactor() const override; unsigned getMaxInterleaveFactor() const override;
unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src) const unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src) const
override; override;
unsigned getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index) const unsigned getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index) const
override; override;
unsigned getArithmeticInstrCost( unsigned getArithmeticInstrCost(
▲ Show 20 Lines • Show All 395 Lines • ▼ Show 20 Lines if (!I->isVectorTy())
continue; continue;
if (I->getScalarSizeInBits() * I->getVectorNumElements() == 128) if (I->getScalarSizeInBits() * I->getVectorNumElements() == 128)
Cost += getMemoryOpCost(Instruction::Store, I, 128, 0) + Cost += getMemoryOpCost(Instruction::Store, I, 128, 0) +
getMemoryOpCost(Instruction::Load, I, 128, 0); getMemoryOpCost(Instruction::Load, I, 128, 0);
} }
return Cost; return Cost;
} }
unsigned AArch64TTI::getMaximumUnrollFactor() const { unsigned AArch64TTI::getMaxInterleaveFactor() const {
if (ST->isCortexA57() || ST->isCyclone()) if (ST->isCortexA57() || ST->isCyclone())
return 4; return 4;
return 2; return 2;
} }

llvm/trunk/lib/Target/ARM/ARMTargetTransformInfo.cpp

Show First 20 Lines • Show All 98 Lines • ▼ Show 20 Lines if (Vector) {
if (ST->hasNEON()) if (ST->hasNEON())
return 128; return 128;
return 0; return 0;
} }
return 32; return 32;
} }
unsigned getMaximumUnrollFactor() const override { unsigned getMaxInterleaveFactor() const override {
// These are out of order CPUs: // These are out of order CPUs:
if (ST->isCortexA15() || ST->isSwift()) if (ST->isCortexA15() || ST->isSwift())
return 2; return 2;
return 1; return 1;
} }
unsigned getShuffleCost(ShuffleKind Kind, Type *Tp, unsigned getShuffleCost(ShuffleKind Kind, Type *Tp,
int Index, Type *SubTp) const override; int Index, Type *SubTp) const override;
▲ Show 20 Lines • Show All 473 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/PowerPC/PPCTargetTransformInfo.cpp

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Linespublic:
/// @} /// @}
/// \name Vector TTI Implementations /// \name Vector TTI Implementations
/// @{ /// @{
unsigned getNumberOfRegisters(bool Vector) const override; unsigned getNumberOfRegisters(bool Vector) const override;
unsigned getRegisterBitWidth(bool Vector) const override; unsigned getRegisterBitWidth(bool Vector) const override;
unsigned getMaximumUnrollFactor() const override; unsigned getMaxInterleaveFactor() const override;
unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind, unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind,
OperandValueKind, OperandValueProperties, OperandValueKind, OperandValueProperties,
OperandValueProperties) const override; OperandValueProperties) const override;
unsigned getShuffleCost(ShuffleKind Kind, Type *Tp, unsigned getShuffleCost(ShuffleKind Kind, Type *Tp,
int Index, Type *SubTp) const override; int Index, Type *SubTp) const override;
unsigned getCastInstrCost(unsigned Opcode, Type *Dst, unsigned getCastInstrCost(unsigned Opcode, Type *Dst,
Type *Src) const override; Type *Src) const override;
unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
▲ Show 20 Lines • Show All 188 Lines • ▼ Show 20 Linesunsigned PPCTTI::getRegisterBitWidth(bool Vector) const {
} }
if (ST->isPPC64()) if (ST->isPPC64())
return 64; return 64;
return 32; return 32;
} }
unsigned PPCTTI::getMaximumUnrollFactor() const { unsigned PPCTTI::getMaxInterleaveFactor() const {
unsigned Directive = ST->getDarwinDirective(); unsigned Directive = ST->getDarwinDirective();
// The 440 has no SIMD support, but floating-point instructions // The 440 has no SIMD support, but floating-point instructions
// have a 5-cycle latency, so unroll by 5x for latency hiding. // have a 5-cycle latency, so unroll by 5x for latency hiding.
if (Directive == PPC::DIR_440) if (Directive == PPC::DIR_440)
return 5; return 5;
// The A2 has no SIMD support, but floating-point instructions // The A2 has no SIMD support, but floating-point instructions
// have a 6-cycle latency, so unroll by 6x for latency hiding. // have a 6-cycle latency, so unroll by 6x for latency hiding.
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/R600/AMDGPUTargetTransformInfo.cpp

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Linespublic:
void getUnrollingPreferences(Loop *L, void getUnrollingPreferences(Loop *L,
UnrollingPreferences &UP) const override; UnrollingPreferences &UP) const override;
PopcntSupportKind getPopcntSupport(unsigned IntTyWidthInBit) const override; PopcntSupportKind getPopcntSupport(unsigned IntTyWidthInBit) const override;
unsigned getNumberOfRegisters(bool Vector) const override; unsigned getNumberOfRegisters(bool Vector) const override;
unsigned getRegisterBitWidth(bool Vector) const override; unsigned getRegisterBitWidth(bool Vector) const override;
unsigned getMaximumUnrollFactor() const override; unsigned getMaxInterleaveFactor() const override;
/// @} /// @}
}; };
} // end anonymous namespace } // end anonymous namespace
INITIALIZE_AG_PASS(AMDGPUTTI, TargetTransformInfo, "AMDGPUtti", INITIALIZE_AG_PASS(AMDGPUTTI, TargetTransformInfo, "AMDGPUtti",
"AMDGPU Target Transform Info", true, true, false) "AMDGPU Target Transform Info", true, true, false)
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Linesunsigned AMDGPUTTI::getNumberOfRegisters(bool Vec) const {
return 4 * 128; // XXX - 4 channels. Should these count as vector instead? return 4 * 128; // XXX - 4 channels. Should these count as vector instead?
} }
unsigned AMDGPUTTI::getRegisterBitWidth(bool) const { unsigned AMDGPUTTI::getRegisterBitWidth(bool) const {
return 32; return 32;
} }
unsigned AMDGPUTTI::getMaximumUnrollFactor() const { unsigned AMDGPUTTI::getMaxInterleaveFactor() const {
// Semi-arbitrary large amount. // Semi-arbitrary large amount.
return 64; return 64;
} }

llvm/trunk/lib/Target/X86/X86TargetTransformInfo.cpp

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Linespublic:
/// @} /// @}
/// \name Vector TTI Implementations /// \name Vector TTI Implementations
/// @{ /// @{
unsigned getNumberOfRegisters(bool Vector) const override; unsigned getNumberOfRegisters(bool Vector) const override;
unsigned getRegisterBitWidth(bool Vector) const override; unsigned getRegisterBitWidth(bool Vector) const override;
unsigned getMaximumUnrollFactor() const override; unsigned getMaxInterleaveFactor() const override;
unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind, unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind,
OperandValueKind, OperandValueProperties, OperandValueKind, OperandValueProperties,
OperandValueProperties) const override; OperandValueProperties) const override;
unsigned getShuffleCost(ShuffleKind Kind, Type *Tp, unsigned getShuffleCost(ShuffleKind Kind, Type *Tp,
int Index, Type *SubTp) const override; int Index, Type *SubTp) const override;
unsigned getCastInstrCost(unsigned Opcode, Type *Dst, unsigned getCastInstrCost(unsigned Opcode, Type *Dst,
Type *Src) const override; Type *Src) const override;
unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Linesunsigned X86TTI::getRegisterBitWidth(bool Vector) const {
} }
if (ST->is64Bit()) if (ST->is64Bit())
return 64; return 64;
return 32; return 32;
} }
unsigned X86TTI::getMaximumUnrollFactor() const { unsigned X86TTI::getMaxInterleaveFactor() const {
if (ST->isAtom()) if (ST->isAtom())
return 1; return 1;
// Sandybridge and Haswell have multiple execution ports and pipelined // Sandybridge and Haswell have multiple execution ports and pipelined
// vector units. // vector units.
if (ST->hasAVX()) if (ST->hasAVX())
return 4; return 4;
▲ Show 20 Lines • Show All 909 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Lines
STATISTIC(LoopsVectorized, "Number of loops vectorized"); STATISTIC(LoopsVectorized, "Number of loops vectorized");
STATISTIC(LoopsAnalyzed, "Number of loops analyzed for vectorization"); STATISTIC(LoopsAnalyzed, "Number of loops analyzed for vectorization");
static cl::opt<unsigned> static cl::opt<unsigned>
VectorizationFactor("force-vector-width", cl::init(0), cl::Hidden, VectorizationFactor("force-vector-width", cl::init(0), cl::Hidden,
cl::desc("Sets the SIMD width. Zero is autoselect.")); cl::desc("Sets the SIMD width. Zero is autoselect."));
static cl::opt<unsigned> static cl::opt<unsigned>
VectorizationUnroll("force-vector-unroll", cl::init(0), cl::Hidden, VectorizationInterleave("force-vector-interleave", cl::init(0), cl::Hidden,
cl::desc("Sets the vectorization unroll count. " cl::desc("Sets the vectorization interleave count. "
"Zero is autoselect.")); "Zero is autoselect."));
static cl::opt<bool> static cl::opt<bool>
EnableIfConversion("enable-if-conversion", cl::init(true), cl::Hidden, EnableIfConversion("enable-if-conversion", cl::init(true), cl::Hidden,
cl::desc("Enable if-conversion during vectorization.")); cl::desc("Enable if-conversion during vectorization."));
/// We don't vectorize loops with a known constant trip count below this number. /// We don't vectorize loops with a known constant trip count below this number.
static cl::opt<unsigned> static cl::opt<unsigned>
Show All 31 Lines
static cl::opt<unsigned> ForceTargetNumScalarRegs( static cl::opt<unsigned> ForceTargetNumScalarRegs(
"force-target-num-scalar-regs", cl::init(0), cl::Hidden, "force-target-num-scalar-regs", cl::init(0), cl::Hidden,
cl::desc("A flag that overrides the target's number of scalar registers.")); cl::desc("A flag that overrides the target's number of scalar registers."));
static cl::opt<unsigned> ForceTargetNumVectorRegs( static cl::opt<unsigned> ForceTargetNumVectorRegs(
"force-target-num-vector-regs", cl::init(0), cl::Hidden, "force-target-num-vector-regs", cl::init(0), cl::Hidden,
cl::desc("A flag that overrides the target's number of vector registers.")); cl::desc("A flag that overrides the target's number of vector registers."));
/// Maximum vectorization unroll count. /// Maximum vectorization interleave count.
static const unsigned MaxUnrollFactor = 16; static const unsigned MaxInterleaveFactor = 16;
static cl::opt<unsigned> ForceTargetMaxScalarUnrollFactor( static cl::opt<unsigned> ForceTargetMaxScalarInterleaveFactor(
"force-target-max-scalar-unroll", cl::init(0), cl::Hidden, "force-target-max-scalar-interleave", cl::init(0), cl::Hidden,
cl::desc("A flag that overrides the target's max unroll factor for scalar " cl::desc("A flag that overrides the target's max interleave factor for "
"loops.")); "scalar loops."));
static cl::opt<unsigned> ForceTargetMaxVectorUnrollFactor( static cl::opt<unsigned> ForceTargetMaxVectorInterleaveFactor(
"force-target-max-vector-unroll", cl::init(0), cl::Hidden, "force-target-max-vector-interleave", cl::init(0), cl::Hidden,
cl::desc("A flag that overrides the target's max unroll factor for " cl::desc("A flag that overrides the target's max interleave factor for "
"vectorized loops.")); "vectorized loops."));
static cl::opt<unsigned> ForceTargetInstructionCost( static cl::opt<unsigned> ForceTargetInstructionCost(
"force-target-instruction-cost", cl::init(0), cl::Hidden, "force-target-instruction-cost", cl::init(0), cl::Hidden,
cl::desc("A flag that overrides the target's expected cost for " cl::desc("A flag that overrides the target's expected cost for "
"an instruction to a single constant value. Mostly " "an instruction to a single constant value. Mostly "
"useful for getting consistent testing.")); "useful for getting consistent testing."));
▲ Show 20 Lines • Show All 819 Lines • ▼ Show 20 Lines struct Hint {
Hint(const char * Name, unsigned Value, HintKind Kind) Hint(const char * Name, unsigned Value, HintKind Kind)
: Name(Name), Value(Value), Kind(Kind) { } : Name(Name), Value(Value), Kind(Kind) { }
bool validate(unsigned Val) { bool validate(unsigned Val) {
switch (Kind) { switch (Kind) {
case HK_WIDTH: case HK_WIDTH:
return isPowerOf2_32(Val) && Val <= MaxVectorWidth; return isPowerOf2_32(Val) && Val <= MaxVectorWidth;
case HK_UNROLL: case HK_UNROLL:
return isPowerOf2_32(Val) && Val <= MaxUnrollFactor; return isPowerOf2_32(Val) && Val <= MaxInterleaveFactor;
case HK_FORCE: case HK_FORCE:
return (Val <= 1); return (Val <= 1);
} }
return false; return false;
} }
}; };
/// Vectorization width. /// Vectorization width.
Hint Width; Hint Width;
/// Vectorization unroll factor. /// Vectorization interleave factor.
Hint Unroll; Hint Interleave;
/// Vectorization forced /// Vectorization forced
Hint Force; Hint Force;
/// Array to help iterating through all hints. /// Array to help iterating through all hints.
Hint *Hints[3]; // avoiding initialisation due to MSVC2012 Hint *Hints[3]; // avoiding initialisation due to MSVC2012
/// Return the loop metadata prefix. /// Return the loop metadata prefix.
static StringRef Prefix() { return "llvm.loop."; } static StringRef Prefix() { return "llvm.loop."; }
public: public:
enum ForceKind { enum ForceKind {
FK_Undefined = -1, ///< Not selected. FK_Undefined = -1, ///< Not selected.
FK_Disabled = 0, ///< Forcing disabled. FK_Disabled = 0, ///< Forcing disabled.
FK_Enabled = 1, ///< Forcing enabled. FK_Enabled = 1, ///< Forcing enabled.
}; };
LoopVectorizeHints(const Loop *L, bool DisableUnrolling) LoopVectorizeHints(const Loop *L, bool DisableInterleaving)
: Width("vectorize.width", VectorizationFactor, HK_WIDTH), : Width("vectorize.width", VectorizationFactor, HK_WIDTH),
Unroll("interleave.count", DisableUnrolling, HK_UNROLL), Interleave("interleave.count", DisableInterleaving, HK_UNROLL),
Force("vectorize.enable", FK_Undefined, HK_FORCE), Force("vectorize.enable", FK_Undefined, HK_FORCE),
TheLoop(L) { TheLoop(L) {
// FIXME: Move this up initialisation when MSVC requirement is 2013+ // FIXME: Move this up initialisation when MSVC requirement is 2013+
Hints[0] = &Width; Hints[0] = &Width;
Hints[1] = &Unroll; Hints[1] = &Interleave;
Hints[2] = &Force; Hints[2] = &Force;
// Populate values with existing loop metadata. // Populate values with existing loop metadata.
getHintsFromMetadata(); getHintsFromMetadata();
// force-vector-unroll overrides DisableUnrolling. // force-vector-interleave overrides DisableInterleaving.
if (VectorizationUnroll.getNumOccurrences() > 0) if (VectorizationInterleave.getNumOccurrences() > 0)
Unroll.Value = VectorizationUnroll; Interleave.Value = VectorizationInterleave;
DEBUG(if (DisableUnrolling && Unroll.Value == 1) dbgs() DEBUG(if (DisableInterleaving && Interleave.Value == 1) dbgs()
<< "LV: Unrolling disabled by the pass manager\n"); << "LV: Interleaving disabled by the pass manager\n");
} }
/// Mark the loop L as already vectorized by setting the width to 1. /// Mark the loop L as already vectorized by setting the width to 1.
void setAlreadyVectorized() { void setAlreadyVectorized() {
Width.Value = Unroll.Value = 1; Width.Value = Interleave.Value = 1;
// FIXME: Change all lines below for this when we can use MSVC 2013+ // FIXME: Change all lines below for this when we can use MSVC 2013+
//writeHintsToMetadata({ Width, Unroll }); //writeHintsToMetadata({ Width, Unroll });
std::vector<Hint> hints; std::vector<Hint> hints;
hints.reserve(2); hints.reserve(2);
hints.emplace_back(Width); hints.emplace_back(Width);
hints.emplace_back(Unroll); hints.emplace_back(Interleave);
writeHintsToMetadata(std::move(hints)); writeHintsToMetadata(std::move(hints));
} }
/// Dumps all the hint information. /// Dumps all the hint information.
std::string emitRemark() const { std::string emitRemark() const {
Report R; Report R;
if (Force.Value == LoopVectorizeHints::FK_Disabled) if (Force.Value == LoopVectorizeHints::FK_Disabled)
R << "vectorization is explicitly disabled"; R << "vectorization is explicitly disabled";
else { else {
R << "use -Rpass-analysis=loop-vectorize for more info"; R << "use -Rpass-analysis=loop-vectorize for more info";
if (Force.Value == LoopVectorizeHints::FK_Enabled) { if (Force.Value == LoopVectorizeHints::FK_Enabled) {
R << " (Force=true"; R << " (Force=true";
if (Width.Value != 0) if (Width.Value != 0)
R << ", Vector Width=" << Width.Value; R << ", Vector Width=" << Width.Value;
if (Unroll.Value != 0) if (Interleave.Value != 0)
R << ", Interleave Count=" << Unroll.Value; R << ", Interleave Count=" << Interleave.Value;
R << ")"; R << ")";
} }
} }
return R.str(); return R.str();
} }
unsigned getWidth() const { return Width.Value; } unsigned getWidth() const { return Width.Value; }
unsigned getUnroll() const { return Unroll.Value; } unsigned getInterleave() const { return Interleave.Value; }
enum ForceKind getForce() const { return (ForceKind)Force.Value; } enum ForceKind getForce() const { return (ForceKind)Force.Value; }
private: private:
/// Find hints specified in the loop metadata and update local values. /// Find hints specified in the loop metadata and update local values.
void getHintsFromMetadata() { void getHintsFromMetadata() {
MDNode *LoopID = TheLoop->getLoopID(); MDNode *LoopID = TheLoop->getLoopID();
if (!LoopID) if (!LoopID)
return; return;
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Linesstatic void emitMissedWarning(Function *F, Loop *L,
emitOptimizationRemarkMissed(F->getContext(), DEBUG_TYPE, *F, emitOptimizationRemarkMissed(F->getContext(), DEBUG_TYPE, *F,
L->getStartLoc(), LH.emitRemark()); L->getStartLoc(), LH.emitRemark());
if (LH.getForce() == LoopVectorizeHints::FK_Enabled) { if (LH.getForce() == LoopVectorizeHints::FK_Enabled) {
if (LH.getWidth() != 1) if (LH.getWidth() != 1)
emitLoopVectorizeWarning( emitLoopVectorizeWarning(
F->getContext(), *F, L->getStartLoc(), F->getContext(), *F, L->getStartLoc(),
"failed explicitly specified loop vectorization"); "failed explicitly specified loop vectorization");
else if (LH.getUnroll() != 1) else if (LH.getInterleave() != 1)
emitLoopInterleaveWarning( emitLoopInterleaveWarning(
F->getContext(), *F, L->getStartLoc(), F->getContext(), *F, L->getStartLoc(),
"failed explicitly specified loop interleaving"); "failed explicitly specified loop interleaving");
} }
} }
static void addInnerLoop(Loop &L, SmallVectorImpl<Loop *> &V) { static void addInnerLoop(Loop &L, SmallVectorImpl<Loop *> &V) {
if (L.empty()) if (L.empty())
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines#endif /* NDEBUG */
DEBUG(dbgs() << "LV: Loop hints:" DEBUG(dbgs() << "LV: Loop hints:"
<< " force=" << " force="
<< (Hints.getForce() == LoopVectorizeHints::FK_Disabled << (Hints.getForce() == LoopVectorizeHints::FK_Disabled
? "disabled" ? "disabled"
: (Hints.getForce() == LoopVectorizeHints::FK_Enabled : (Hints.getForce() == LoopVectorizeHints::FK_Enabled
? "enabled" ? "enabled"
: "?")) << " width=" << Hints.getWidth() : "?")) << " width=" << Hints.getWidth()
<< " unroll=" << Hints.getUnroll() << "\n"); << " unroll=" << Hints.getInterleave() << "\n");
// Function containing loop // Function containing loop
Function *F = L->getHeader()->getParent(); Function *F = L->getHeader()->getParent();
// Looking at the diagnostic output is the only way to determine if a loop // Looking at the diagnostic output is the only way to determine if a loop
// was vectorized (other than looking at the IR or machine code), so it // was vectorized (other than looking at the IR or machine code), so it
// is important to generate an optimization remark for each loop. Most of // is important to generate an optimization remark for each loop. Most of
// these messages are generated by emitOptimizationRemarkAnalysis. Remarks // these messages are generated by emitOptimizationRemarkAnalysis. Remarks
Show All 10 Lines#endif /* NDEBUG */
if (!AlwaysVectorize && Hints.getForce() != LoopVectorizeHints::FK_Enabled) { if (!AlwaysVectorize && Hints.getForce() != LoopVectorizeHints::FK_Enabled) {
DEBUG(dbgs() << "LV: Not vectorizing: No #pragma vectorize enable.\n"); DEBUG(dbgs() << "LV: Not vectorizing: No #pragma vectorize enable.\n");
emitOptimizationRemarkAnalysis(F->getContext(), DEBUG_TYPE, *F, emitOptimizationRemarkAnalysis(F->getContext(), DEBUG_TYPE, *F,
L->getStartLoc(), Hints.emitRemark()); L->getStartLoc(), Hints.emitRemark());
return false; return false;
} }
if (Hints.getWidth() == 1 && Hints.getUnroll() == 1) { if (Hints.getWidth() == 1 && Hints.getInterleave() == 1) {
DEBUG(dbgs() << "LV: Not vectorizing: Disabled/already vectorized.\n"); DEBUG(dbgs() << "LV: Not vectorizing: Disabled/already vectorized.\n");
emitOptimizationRemarkAnalysis( emitOptimizationRemarkAnalysis(
F->getContext(), DEBUG_TYPE, *F, L->getStartLoc(), F->getContext(), DEBUG_TYPE, *F, L->getStartLoc(),
"loop not vectorized: vector width and interleave count are " "loop not vectorized: vector width and interleave count are "
"explicitly set to 1"); "explicitly set to 1");
return false; return false;
} }
▲ Show 20 Lines • Show All 3,262 Lines • ▼ Show 20 Lines DEBUG(dbgs() <<
"LV: ReadWrite-Write positive dependency with different types\n"); "LV: ReadWrite-Write positive dependency with different types\n");
return false; return false;
} }
unsigned Distance = (unsigned) Val.getZExtValue(); unsigned Distance = (unsigned) Val.getZExtValue();
// Bail out early if passed-in parameters make vectorization not feasible. // Bail out early if passed-in parameters make vectorization not feasible.
unsigned ForcedFactor = VectorizationFactor ? VectorizationFactor : 1; unsigned ForcedFactor = VectorizationFactor ? VectorizationFactor : 1;
unsigned ForcedUnroll = VectorizationUnroll ? VectorizationUnroll : 1; unsigned ForcedUnroll = VectorizationInterleave ? VectorizationInterleave : 1;
// The distance must be bigger than the size needed for a vectorized version // The distance must be bigger than the size needed for a vectorized version
// of the operation and the size of the vectorized operation must not be // of the operation and the size of the vectorized operation must not be
// bigger than the currrent maximum size. // bigger than the currrent maximum size.
if (Distance < 2*TypeByteSize || if (Distance < 2*TypeByteSize ||
2*TypeByteSize > MaxSafeDepDistBytes || 2*TypeByteSize > MaxSafeDepDistBytes ||
Distance < TypeByteSize * ForcedUnroll * ForcedFactor) { Distance < TypeByteSize * ForcedUnroll * ForcedFactor) {
DEBUG(dbgs() << "LV: Failure because of Positive distance " DEBUG(dbgs() << "LV: Failure because of Positive distance "
▲ Show 20 Lines • Show All 860 Lines • ▼ Show 20 LinesLoopVectorizationCostModel::selectUnrollFactor(bool OptForSize,
// 1. If the code has reductions, then we unroll in order to break the cross // 1. If the code has reductions, then we unroll in order to break the cross
// iteration dependency. // iteration dependency.
// 2. If the loop is really small, then we unroll in order to reduce the loop // 2. If the loop is really small, then we unroll in order to reduce the loop
// overhead. // overhead.
// 3. We don't unroll if we think that we will spill registers to memory due // 3. We don't unroll if we think that we will spill registers to memory due
// to the increased register pressure. // to the increased register pressure.
// Use the user preference, unless 'auto' is selected. // Use the user preference, unless 'auto' is selected.
int UserUF = Hints->getUnroll(); int UserUF = Hints->getInterleave();
if (UserUF != 0) if (UserUF != 0)
return UserUF; return UserUF;
// When we optimize for size, we don't unroll. // When we optimize for size, we don't unroll.
if (OptForSize) if (OptForSize)
return 1; return 1;
// We used the distance for the unroll factor. // We used the distance for the unroll factor.
Show All 36 Lines unsigned UF = PowerOf2Floor((TargetNumRegisters - R.LoopInvariantRegs) /
R.MaxLocalUsers); R.MaxLocalUsers);
// Don't count the induction variable as unrolled. // Don't count the induction variable as unrolled.
if (EnableIndVarRegisterHeur) if (EnableIndVarRegisterHeur)
UF = PowerOf2Floor((TargetNumRegisters - R.LoopInvariantRegs - 1) / UF = PowerOf2Floor((TargetNumRegisters - R.LoopInvariantRegs - 1) /
std::max(1U, (R.MaxLocalUsers - 1))); std::max(1U, (R.MaxLocalUsers - 1)));
// Clamp the unroll factor ranges to reasonable factors. // Clamp the unroll factor ranges to reasonable factors.
unsigned MaxUnrollSize = TTI.getMaximumUnrollFactor(); unsigned MaxInterleaveSize = TTI.getMaxInterleaveFactor();
// Check if the user has overridden the unroll max. // Check if the user has overridden the unroll max.
if (VF == 1) { if (VF == 1) {
if (ForceTargetMaxScalarUnrollFactor.getNumOccurrences() > 0) if (ForceTargetMaxScalarInterleaveFactor.getNumOccurrences() > 0)
MaxUnrollSize = ForceTargetMaxScalarUnrollFactor; MaxInterleaveSize = ForceTargetMaxScalarInterleaveFactor;
} else { } else {
if (ForceTargetMaxVectorUnrollFactor.getNumOccurrences() > 0) if (ForceTargetMaxVectorInterleaveFactor.getNumOccurrences() > 0)
MaxUnrollSize = ForceTargetMaxVectorUnrollFactor; MaxInterleaveSize = ForceTargetMaxVectorInterleaveFactor;
} }
// If we did not calculate the cost for VF (because the user selected the VF) // If we did not calculate the cost for VF (because the user selected the VF)
// then we calculate the cost of VF here. // then we calculate the cost of VF here.
if (LoopCost == 0) if (LoopCost == 0)
LoopCost = expectedCost(VF); LoopCost = expectedCost(VF);
// Clamp the calculated UF to be between the 1 and the max unroll factor // Clamp the calculated UF to be between the 1 and the max unroll factor
// that the target allows. // that the target allows.
if (UF > MaxUnrollSize) if (UF > MaxInterleaveSize)
UF = MaxUnrollSize; UF = MaxInterleaveSize;
else if (UF < 1) else if (UF < 1)
UF = 1; UF = 1;
// Unroll if we vectorized this loop and there is a reduction that could // Unroll if we vectorized this loop and there is a reduction that could
// benefit from unrolling. // benefit from unrolling.
if (VF > 1 && Legal->getReductionVars()->size()) { if (VF > 1 && Legal->getReductionVars()->size()) {
DEBUG(dbgs() << "LV: Unrolling because of reductions.\n"); DEBUG(dbgs() << "LV: Unrolling because of reductions.\n");
return UF; return UF;
▲ Show 20 Lines • Show All 636 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/12-12-11-if-conv.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
;CHECK-LABEL: @foo( ;CHECK-LABEL: @foo(
;CHECK: icmp eq <4 x i32> ;CHECK: icmp eq <4 x i32>
;CHECK: select <4 x i1> ;CHECK: select <4 x i1>
;CHECK: ret i32 ;CHECK: ret i32
Show All 31 Lines

llvm/trunk/test/Transforms/LoopVectorize/2012-10-20-infloop.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce
; Check that we don't fall into an infinite loop. ; Check that we don't fall into an infinite loop.
define void @test() nounwind { define void @test() nounwind {
entry: entry:
br label %for.body br label %for.body
for.body: for.body:
%0 = phi i32 [ 1, %entry ], [ 0, %for.body ] %0 = phi i32 [ 1, %entry ], [ 0, %for.body ]
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/2012-10-22-isconsec.ll

; RUN: opt < %s -loop-vectorize -dce -force-vector-unroll=1 -force-vector-width=4 ; RUN: opt < %s -loop-vectorize -dce -force-vector-interleave=1 -force-vector-width=4
; Check that we don't crash. ; Check that we don't crash.
target datalayout = "e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
module asm "\09.ident\09\22GCC: (GNU) 4.6.3 LLVM: 3.2svn\22" module asm "\09.ident\09\22GCC: (GNU) 4.6.3 LLVM: 3.2svn\22"
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/X86/gcc-examples.ll

; RUN: opt < %s -loop-vectorize -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 -dce -instcombine -S | FileCheck %s
; RUN: opt < %s -loop-vectorize -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 -force-vector-unroll=0 -dce -instcombine -S | FileCheck %s -check-prefix=UNROLL ; RUN: opt < %s -loop-vectorize -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7 -force-vector-interleave=0 -dce -instcombine -S | FileCheck %s -check-prefix=UNROLL
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@b = common global [2048 x i32] zeroinitializer, align 16 @b = common global [2048 x i32] zeroinitializer, align 16
@c = common global [2048 x i32] zeroinitializer, align 16 @c = common global [2048 x i32] zeroinitializer, align 16
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/X86/illegal-parallel-loop-uniform-write.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
;CHECK-LABEL: @foo( ;CHECK-LABEL: @foo(
;CHECK-NOT: <4 x i32> ;CHECK-NOT: <4 x i32>
;CHECK: ret void ;CHECK: ret void
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/X86/min-trip-count-switch.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -vectorizer-min-trip-count=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -vectorizer-min-trip-count=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK: <4 x float> ; CHECK: <4 x float>
define void @trivial_loop(float* nocapture %a) nounwind uwtable optsize { define void @trivial_loop(float* nocapture %a) nounwind uwtable optsize {
entry: entry:
br label %for.body br label %for.body
Show All 15 Lines

llvm/trunk/test/Transforms/LoopVectorize/X86/parallel-loops-after-reg2mem.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; The parallel loop has been invalidated by the new memory accesses introduced ; The parallel loop has been invalidated by the new memory accesses introduced
; by reg2mem (Loop::isParallel() starts to return false). Ensure the loop is ; by reg2mem (Loop::isParallel() starts to return false). Ensure the loop is
; now non-vectorizable. ; now non-vectorizable.
Show All 40 Lines

llvm/trunk/test/Transforms/LoopVectorize/X86/parallel-loops.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; A tricky loop: ; A tricky loop:
; ;
; void loop(int *a, int *b) { ; void loop(int *a, int *b) {
; for (int i = 0; i < 512; ++i) { ; for (int i = 0; i < 512; ++i) {
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/X86/small-size.ll

; RUN: opt < %s -basicaa -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -loop-vectorize-with-block-frequency -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -loop-vectorize-with-block-frequency -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@b = common global [2048 x i32] zeroinitializer, align 16 @b = common global [2048 x i32] zeroinitializer, align 16
@c = common global [2048 x i32] zeroinitializer, align 16 @c = common global [2048 x i32] zeroinitializer, align 16
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
@G = common global [32 x [1024 x i32]] zeroinitializer, align 16 @G = common global [32 x [1024 x i32]] zeroinitializer, align 16
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/X86/tripcount.ll

; RUN: opt -S -loop-vectorize -force-vector-width=2 -force-vector-unroll=1 -mcpu=prescott < %s | FileCheck %s ; RUN: opt -S -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -mcpu=prescott < %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:32:32-n8:16:32-S128" 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:32:32-n8:16:32-S128"
target triple = "i386-unknown-freebsd11.0" target triple = "i386-unknown-freebsd11.0"
@big = external global [0 x i32] @big = external global [0 x i32]
; PR18049 ; PR18049
; We need to truncate the exit count to i32. This is legal because the ; We need to truncate the exit count to i32. This is legal because the
Show All 30 Lines

llvm/trunk/test/Transforms/LoopVectorize/X86/unroll-small-loops.ll

; RUN: opt < %s -loop-vectorize -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx -force-vector-width=4 -force-vector-unroll=0 -dce -S \ ; RUN: opt < %s -loop-vectorize -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx -force-vector-width=4 -force-vector-interleave=0 -dce -S \
; RUN: | FileCheck %s --check-prefix=CHECK-VECTOR ; RUN: | FileCheck %s --check-prefix=CHECK-VECTOR
; RUN: opt < %s -loop-vectorize -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx -force-vector-width=1 -force-vector-unroll=0 -dce -S \ ; RUN: opt < %s -loop-vectorize -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx -force-vector-width=1 -force-vector-interleave=0 -dce -S \
; RUN: | FileCheck %s --check-prefix=CHECK-SCALAR ; RUN: | FileCheck %s --check-prefix=CHECK-SCALAR
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; We don't unroll this loop because it has a small constant trip count. ; We don't unroll this loop because it has a small constant trip count.
; ;
; CHECK-VECTOR-LABEL: @foo( ; CHECK-VECTOR-LABEL: @foo(
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/X86/unroll_selection.ll

; RUN: opt < %s -loop-vectorize -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx -force-vector-width=4 -force-vector-unroll=0 -dce -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -mtriple=x86_64-apple-macosx10.8.0 -mcpu=corei7-avx -force-vector-width=4 -force-vector-interleave=0 -dce -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; Don't unroll when we have register pressure. ; Don't unroll when we have register pressure.
;CHECK: reg_pressure ;CHECK: reg_pressure
;CHECK: load <4 x double> ;CHECK: load <4 x double>
;CHECK-NOT: load <4 x double> ;CHECK-NOT: load <4 x double>
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/X86/vectorization-remarks.ll

; RUN: opt < %s -loop-vectorize -mtriple=x86_64-unknown-linux -S -pass-remarks='loop-vectorize' 2>&1 | FileCheck -check-prefix=VECTORIZED %s ; RUN: opt < %s -loop-vectorize -mtriple=x86_64-unknown-linux -S -pass-remarks='loop-vectorize' 2>&1 | FileCheck -check-prefix=VECTORIZED %s
; RUN: opt < %s -loop-vectorize -force-vector-width=1 -force-vector-unroll=4 -mtriple=x86_64-unknown-linux -S -pass-remarks='loop-vectorize' 2>&1 | FileCheck -check-prefix=UNROLLED %s ; RUN: opt < %s -loop-vectorize -force-vector-width=1 -force-vector-interleave=4 -mtriple=x86_64-unknown-linux -S -pass-remarks='loop-vectorize' 2>&1 | FileCheck -check-prefix=UNROLLED %s
; RUN: opt < %s -loop-vectorize -force-vector-width=1 -force-vector-unroll=1 -mtriple=x86_64-unknown-linux -S -pass-remarks-analysis='loop-vectorize' 2>&1 | FileCheck -check-prefix=NONE %s ; RUN: opt < %s -loop-vectorize -force-vector-width=1 -force-vector-interleave=1 -mtriple=x86_64-unknown-linux -S -pass-remarks-analysis='loop-vectorize' 2>&1 | FileCheck -check-prefix=NONE %s
; This code has all the !dbg annotations needed to track source line information, ; This code has all the !dbg annotations needed to track source line information,
; but is missing the llvm.dbg.cu annotation. This prevents code generation from ; but is missing the llvm.dbg.cu annotation. This prevents code generation from
; emitting debug info in the final output. ; emitting debug info in the final output.
; RUN: llc -mtriple x86_64-pc-linux-gnu %s -o - | FileCheck -check-prefix=DEBUG-OUTPUT %s ; RUN: llc -mtriple x86_64-pc-linux-gnu %s -o - | FileCheck -check-prefix=DEBUG-OUTPUT %s
; DEBUG-OUTPUT-NOT: .loc ; DEBUG-OUTPUT-NOT: .loc
; DEBUG-OUTPUT-NOT: {{.*}}.debug_info ; DEBUG-OUTPUT-NOT: {{.*}}.debug_info
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/X86/x86_fp80-vector-store.ll

; RUN: opt -O3 -loop-vectorize -force-vector-unroll=1 -force-vector-width=2 -S < %s | FileCheck %s ; RUN: opt -O3 -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
@x = common global [1024 x x86_fp80] zeroinitializer, align 16 @x = common global [1024 x x86_fp80] zeroinitializer, align 16
;CHECK-LABEL: @example( ;CHECK-LABEL: @example(
;CHECK-NOT: bitcast x86_fp80* {{%[^ ]+}} to <{{[2-9][0-9]*}} x x86_fp80>* ;CHECK-NOT: bitcast x86_fp80* {{%[^ ]+}} to <{{[2-9][0-9]*}} x x86_fp80>*
Show All 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/XCore/no-vector-registers.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-unroll=2 -S -mtriple=xcore | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=2 -S -mtriple=xcore | FileCheck %s
target datalayout = "e-p:32:32:32-a0:0:32-n32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f16:16:32-f32:32:32-f64:32:32" target datalayout = "e-p:32:32:32-a0:0:32-n32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f16:16:32-f32:32:32-f64:32:32"
target triple = "xcore" target triple = "xcore"
; The xcore target has no vector registers, so loop should not be vectorized. ; The xcore target has no vector registers, so loop should not be vectorized.
;CHECK-LABEL: @f( ;CHECK-LABEL: @f(
;CHECK: entry: ;CHECK: entry:
;CHECK-NOT: vector.body ;CHECK-NOT: vector.body
;CHECK-NEXT: br label %do.body ;CHECK-NEXT: br label %do.body
Show All 14 Lines

llvm/trunk/test/Transforms/LoopVectorize/align.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; Make sure we output the abi alignment if no alignment is specified. ; Make sure we output the abi alignment if no alignment is specified.
;CHECK-LABEL: @align ;CHECK-LABEL: @align
;CHECK: load <4 x i32>* {{.*}} align 4 ;CHECK: load <4 x i32>* {{.*}} align 4
Show All 24 Lines

llvm/trunk/test/Transforms/LoopVectorize/bsd_regex.ll

; RUN: opt -S -loop-vectorize -dce -instcombine -force-vector-width=2 -force-vector-unroll=2 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize -dce -instcombine -force-vector-width=2 -force-vector-interleave=2 < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;PR 15830. ;PR 15830.
;CHECK-LABEL: @foo( ;CHECK-LABEL: @foo(
; When scalarizing stores we need to preserve the original order. ; When scalarizing stores we need to preserve the original order.
; Make sure that we are extracting in the correct order (0101, and not 0011). ; Make sure that we are extracting in the correct order (0101, and not 0011).
Show All 29 Lines

llvm/trunk/test/Transforms/LoopVectorize/bzip_reverse_loops.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S -enable-if-conversion | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S -enable-if-conversion | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
;CHECK: fc ;CHECK: fc
;CHECK: load <4 x i16> ;CHECK: load <4 x i16>
;CHECK-NEXT: shufflevector <4 x i16> ;CHECK-NEXT: shufflevector <4 x i16>
;CHECK: select <4 x i1> ;CHECK: select <4 x i1>
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/calloc.ll

; RUN: opt < %s -basicaa -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
;CHECK: hexit ;CHECK: hexit
;CHECK: zext <4 x i8> ;CHECK: zext <4 x i8>
;CHECK: ret ;CHECK: ret
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/cast-induction.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
; rdar://problem/12848162 ; rdar://problem/12848162
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
Show All 21 Lines

llvm/trunk/test/Transforms/LoopVectorize/cpp-new-array.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
;CHECK-LABEL: @cpp_new_arrays( ;CHECK-LABEL: @cpp_new_arrays(
;CHECK: sext i32 ;CHECK: sext i32
;CHECK: load <4 x float> ;CHECK: load <4 x float>
;CHECK: fadd <4 x float> ;CHECK: fadd <4 x float>
Show All 37 Lines

llvm/trunk/test/Transforms/LoopVectorize/dbg.value.ll

; RUN: opt < %s -S -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine | FileCheck %s ; RUN: opt < %s -S -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine | FileCheck %s
; Make sure we vectorize with debugging turned on. ; Make sure we vectorize with debugging turned on.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@A = global [1024 x i32] zeroinitializer, align 16 @A = global [1024 x i32] zeroinitializer, align 16
@B = global [1024 x i32] zeroinitializer, align 16 @B = global [1024 x i32] zeroinitializer, align 16
@C = global [1024 x i32] zeroinitializer, align 16 @C = global [1024 x i32] zeroinitializer, align 16
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/debugloc.ll

; RUN: opt -S < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=2 | FileCheck %s ; RUN: opt -S < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure we are preserving debug info in the vectorized code. ; Make sure we are preserving debug info in the vectorized code.
; CHECK: for.body.lr.ph ; CHECK: for.body.lr.ph
; CHECK: cmp.zero = icmp eq i64 {{.*}}, 0, !dbg ![[LOC:[0-9]+]] ; CHECK: cmp.zero = icmp eq i64 {{.*}}, 0, !dbg ![[LOC:[0-9]+]]
; CHECK: vector.body ; CHECK: vector.body
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/ee-crash.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; This test checks that we deal with an in-loop extractelement (for now, this ; This test checks that we deal with an in-loop extractelement (for now, this
; means not crashing by not vectorizing). ; means not crashing by not vectorizing).
; CHECK-LABEL: @_Z4foo1Pii( ; CHECK-LABEL: @_Z4foo1Pii(
; CHECK-NOT: <4 x i32> ; CHECK-NOT: <4 x i32>
Show All 26 Lines

llvm/trunk/test/Transforms/LoopVectorize/flags.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
;CHECK-LABEL: @flags1( ;CHECK-LABEL: @flags1(
;CHECK: load <4 x i32> ;CHECK: load <4 x i32>
;CHECK: mul nsw <4 x i32> ;CHECK: mul nsw <4 x i32>
;CHECK: store <4 x i32> ;CHECK: store <4 x i32>
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/float-reduction.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
;CHECK-LABEL: @foo( ;CHECK-LABEL: @foo(
;CHECK: fadd fast <4 x float> ;CHECK: fadd fast <4 x float>
;CHECK: ret ;CHECK: ret
define float @foo(float* nocapture %A, i32* nocapture %n) nounwind uwtable readonly ssp { define float @foo(float* nocapture %A, i32* nocapture %n) nounwind uwtable readonly ssp {
entry: entry:
Show All 38 Lines

llvm/trunk/test/Transforms/LoopVectorize/funcall.ll

; RUN: opt -S -loop-vectorize -force-vector-width=2 -force-vector-unroll=1 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure we can vectorize loops with functions to math library functions. ; Make sure we can vectorize loops with functions to math library functions.
; They might read the rounding mode but we are only vectorizing loops that ; They might read the rounding mode but we are only vectorizing loops that
; contain a limited set of function calls and none of them sets the rounding ; contain a limited set of function calls and none of them sets the rounding
; mode, so vectorizing them is safe. ; mode, so vectorizing them is safe.
Show All 23 Lines

llvm/trunk/test/Transforms/LoopVectorize/gcc-examples.ll

; RUN: opt < %s -basicaa -loop-vectorize -force-vector-width=4 -force-vector-unroll=1 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -basicaa -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -dce -instcombine -S | FileCheck %s
; RUN: opt < %s -basicaa -loop-vectorize -force-vector-width=4 -force-vector-unroll=4 -dce -instcombine -S | FileCheck %s -check-prefix=UNROLL ; RUN: opt < %s -basicaa -loop-vectorize -force-vector-width=4 -force-vector-interleave=4 -dce -instcombine -S | FileCheck %s -check-prefix=UNROLL
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@b = common global [2048 x i32] zeroinitializer, align 16 @b = common global [2048 x i32] zeroinitializer, align 16
@c = common global [2048 x i32] zeroinitializer, align 16 @c = common global [2048 x i32] zeroinitializer, align 16
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
@G = common global [32 x [1024 x i32]] zeroinitializer, align 16 @G = common global [32 x [1024 x i32]] zeroinitializer, align 16
▲ Show 20 Lines • Show All 677 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/global_alias.ll

; RUN: opt < %s -O1 -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -O1 -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:64-n32-S64" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:64-n32-S64"
%struct.anon = type { [100 x i32], i32, [100 x i32] } %struct.anon = type { [100 x i32], i32, [100 x i32] }
%struct.anon.0 = type { [100 x [100 x i32]], i32, [100 x [100 x i32]] } %struct.anon.0 = type { [100 x [100 x i32]], i32, [100 x [100 x i32]] }
@Foo = common global %struct.anon zeroinitializer, align 4 @Foo = common global %struct.anon zeroinitializer, align 4
@Bar = common global %struct.anon.0 zeroinitializer, align 4 @Bar = common global %struct.anon.0 zeroinitializer, align 4
▲ Show 20 Lines • Show All 1,068 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/hoist-loads.ll

; RUN: opt -loop-vectorize -force-vector-width=2 -force-vector-unroll=1 -S < %s | FileCheck %s ; RUN: opt -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x float] zeroinitializer, align 16 @B = common global [1024 x float] zeroinitializer, align 16
; Make sure we can vectorize in the presence of hoistable conditional loads. ; Make sure we can vectorize in the presence of hoistable conditional loads.
; CHECK-LABEL: @hoist_cond_load( ; CHECK-LABEL: @hoist_cond_load(
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/i8-induction.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@a = common global i8 0, align 1 @a = common global i8 0, align 1
@b = common global i8 0, align 1 @b = common global i8 0, align 1
define void @f() nounwind uwtable ssp { define void @f() nounwind uwtable ssp {
Show All 22 Lines

llvm/trunk/test/Transforms/LoopVectorize/if-conv-crash.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -enable-if-conversion ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
define fastcc void @DD_dump() nounwind uwtable ssp { define fastcc void @DD_dump() nounwind uwtable ssp {
entry: entry:
br i1 undef, label %lor.lhs.false, label %if.end25 br i1 undef, label %lor.lhs.false, label %if.end25
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/if-conversion-nest.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
;CHECK-LABEL: @foo( ;CHECK-LABEL: @foo(
;CHECK: icmp sgt ;CHECK: icmp sgt
;CHECK: icmp sgt ;CHECK: icmp sgt
;CHECK: icmp slt ;CHECK: icmp slt
;CHECK: select <4 x i1> ;CHECK: select <4 x i1>
Show All 39 Lines

llvm/trunk/test/Transforms/LoopVectorize/if-conversion-reduction.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
;CHECK-LABEL: @reduction_func( ;CHECK-LABEL: @reduction_func(
;CHECK-NOT: load <4 x i32> ;CHECK-NOT: load <4 x i32>
;CHECK: ret i32 ;CHECK: ret i32
define i32 @reduction_func(i32* nocapture %A, i32 %n) nounwind uwtable readonly ssp { define i32 @reduction_func(i32* nocapture %A, i32 %n) nounwind uwtable readonly ssp {
Show All 29 Lines

llvm/trunk/test/Transforms/LoopVectorize/if-conversion.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -enable-if-conversion -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
; This is the loop in this example: ; This is the loop in this example:
; ;
;int function0(int *a, int *b, int start, int end) { ;int function0(int *a, int *b, int start, int end) {
; ;
▲ Show 20 Lines • Show All 162 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/if-pred-stores.ll

; RUN: opt -S -vectorize-num-stores-pred=1 -force-vector-width=1 -force-vector-unroll=2 -loop-vectorize < %s | FileCheck %s --check-prefix=UNROLL ; RUN: opt -S -vectorize-num-stores-pred=1 -force-vector-width=1 -force-vector-interleave=2 -loop-vectorize < %s | FileCheck %s --check-prefix=UNROLL
; RUN: opt -S -vectorize-num-stores-pred=1 -force-vector-width=2 -force-vector-unroll=1 -loop-vectorize -enable-cond-stores-vec < %s | FileCheck %s --check-prefix=VEC ; RUN: opt -S -vectorize-num-stores-pred=1 -force-vector-width=2 -force-vector-interleave=1 -loop-vectorize -enable-cond-stores-vec < %s | FileCheck %s --check-prefix=VEC
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
; Test predication of stores. ; Test predication of stores.
define i32 @test(i32* nocapture %f) #0 { define i32 @test(i32* nocapture %f) #0 {
entry: entry:
br label %for.body br label %for.body
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/increment.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
; This is the loop. ; This is the loop.
; for (i=0; i<n; i++){ ; for (i=0; i<n; i++){
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/induction.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=2 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure that we can handle multiple integer induction variables. ; Make sure that we can handle multiple integer induction variables.
; CHECK-LABEL: @multi_int_induction( ; CHECK-LABEL: @multi_int_induction(
; CHECK: vector.body: ; CHECK: vector.body:
; CHECK: %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ] ; CHECK: %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
; CHECK: %normalized.idx = sub i64 %index, 0 ; CHECK: %normalized.idx = sub i64 %index, 0
Show All 13 Linesfor.body:
%lftr.wideiv = trunc i64 %indvars.iv.next to i32 %lftr.wideiv = trunc i64 %indvars.iv.next to i32
%exitcond = icmp ne i32 %lftr.wideiv, %N %exitcond = icmp ne i32 %lftr.wideiv, %N
br i1 %exitcond, label %for.body, label %for.end br i1 %exitcond, label %for.body, label %for.end
for.end: for.end:
ret void ret void
} }
; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=2 -instcombine -S | FileCheck %s --check-prefix=IND ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 -instcombine -S | FileCheck %s --check-prefix=IND
; Make sure we remove unneeded vectorization of induction variables. ; Make sure we remove unneeded vectorization of induction variables.
; In order for instcombine to cleanup the vectorized induction variables that we ; In order for instcombine to cleanup the vectorized induction variables that we
; create in the loop vectorizer we need to perform some form of redundancy ; create in the loop vectorizer we need to perform some form of redundancy
; elimination to get rid of multiple uses. ; elimination to get rid of multiple uses.
; IND-LABEL: scalar_use ; IND-LABEL: scalar_use
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/induction_plus.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@array = common global [1024 x i32] zeroinitializer, align 16 @array = common global [1024 x i32] zeroinitializer, align 16
;CHECK-LABEL: @array_at_plus_one( ;CHECK-LABEL: @array_at_plus_one(
;CHECK: add i64 %index, 12 ;CHECK: add i64 %index, 12
Show All 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/intrinsic.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
;CHECK-LABEL: @sqrt_f32( ;CHECK-LABEL: @sqrt_f32(
;CHECK: llvm.sqrt.v4f32 ;CHECK: llvm.sqrt.v4f32
;CHECK: ret void ;CHECK: ret void
define void @sqrt_f32(i32 %n, float* noalias %y, float* noalias %x) nounwind uwtable { define void @sqrt_f32(i32 %n, float* noalias %y, float* noalias %x) nounwind uwtable {
▲ Show 20 Lines • Show All 1,185 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/lcssa-crash.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%type1 = type { %type2 } %type1 = type { %type2 }
%type2 = type { [0 x i8*], i8**, i32, i32, i32 } %type2 = type { [0 x i8*], i8**, i32, i32, i32 }
define void @test() nounwind uwtable align 2 { define void @test() nounwind uwtable align 2 {
Show All 31 Lines

llvm/trunk/test/Transforms/LoopVectorize/lifetime.ll

; RUN: opt -S -loop-vectorize -force-vector-width=2 -force-vector-unroll=1 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure we can vectorize loops which contain lifetime markers. ; Make sure we can vectorize loops which contain lifetime markers.
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK: call void @llvm.lifetime.end ; CHECK: call void @llvm.lifetime.end
; CHECK: store <2 x i32> ; CHECK: store <2 x i32>
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/memdep.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=2 -force-vector-unroll=1 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -S | FileCheck %s
; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-unroll=1 -S | FileCheck %s -check-prefix=WIDTH ; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -S | FileCheck %s -check-prefix=WIDTH
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Vectorization with dependence checks. ; Vectorization with dependence checks.
; No plausible dependence - can be vectorized. ; No plausible dependence - can be vectorized.
; for (i = 0; i < 1024; ++i) ; for (i = 0; i < 1024; ++i)
; A[i] = A[i + 1] + 1; ; A[i] = A[i + 1] + 1;
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/metadata-width.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK: store <8 x i32> ; CHECK: store <8 x i32>
; CHECK: ret void ; CHECK: ret void
define void @test1(i32* nocapture %a, i32 %n) #0 { define void @test1(i32* nocapture %a, i32 %n) #0 {
Show All 22 Lines

llvm/trunk/test/Transforms/LoopVectorize/metadata.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @test1(i32* nocapture %a, float* nocapture readonly %b) #0 { define i32 @test1(i32* nocapture %a, float* nocapture readonly %b) #0 {
entry: entry:
br label %for.body br label %for.body
Show All 35 Lines

llvm/trunk/test/Transforms/LoopVectorize/minmax_reduction.ll

; RUN: opt -S -loop-vectorize -dce -instcombine -force-vector-width=2 -force-vector-unroll=1 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize -dce -instcombine -force-vector-width=2 -force-vector-interleave=1 < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
@A = common global [1024 x i32] zeroinitializer, align 16 @A = common global [1024 x i32] zeroinitializer, align 16
@fA = common global [1024 x float] zeroinitializer, align 16 @fA = common global [1024 x float] zeroinitializer, align 16
@dA = common global [1024 x double] zeroinitializer, align 16 @dA = common global [1024 x double] zeroinitializer, align 16
; Signed tests. ; Signed tests.
▲ Show 20 Lines • Show All 876 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/multi-use-reduction-bug.ll

; RUN: opt -indvars -loop-vectorize -force-vector-width=2 -force-vector-unroll=1 -S < %s | FileCheck %s ; RUN: opt -indvars -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -S < %s | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
; We must not vectorize this loop. %add55 is not reduction. Its value is used ; We must not vectorize this loop. %add55 is not reduction. Its value is used
; multiple times. ; multiple times.
; PR18526 ; PR18526
Show All 33 Lines

llvm/trunk/test/Transforms/LoopVectorize/multiple-address-spaces.ll

; RUN: opt < %s -basicaa -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
; From a simple program with two address spaces: ; From a simple program with two address spaces:
; char Y[4*10000] __attribute__((address_space(1))); ; char Y[4*10000] __attribute__((address_space(1)));
; char X[4*10000]; ; char X[4*10000];
; int main() { ; int main() {
; for (int i = 0; i < 4*10000; ++i) ; for (int i = 0; i < 4*10000; ++i)
; X[i] = Y[i] + 1; ; X[i] = Y[i] + 1;
; return 0; ; return 0;
Show All 35 Lines

llvm/trunk/test/Transforms/LoopVectorize/no_idiv_reduction.ll

; RUN: opt -loop-vectorize -force-vector-width=2 -force-vector-unroll=1 -S < %s | FileCheck %s ; RUN: opt -loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -S < %s | FileCheck %s
@a = common global [128 x i32] zeroinitializer, align 16 @a = common global [128 x i32] zeroinitializer, align 16
;; Must not vectorize division reduction. Division is lossy. ;; Must not vectorize division reduction. Division is lossy.
define i32 @g() { define i32 @g() {
entry: entry:
br label %for.body br label %for.body
for.body: for.body:
Show All 15 Lines

llvm/trunk/test/Transforms/LoopVectorize/no_int_induction.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
; int __attribute__((noinline)) sum_array(int *A, int n) { ; int __attribute__((noinline)) sum_array(int *A, int n) {
; return std::accumulate(A, A + n, 0); ; return std::accumulate(A, A + n, 0);
; } ; }
target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-n8:16:32:64-S128"
;CHECK-LABEL: @sum_array( ;CHECK-LABEL: @sum_array(
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/no_outside_user.ll

; RUN: opt -S -loop-vectorize -force-vector-unroll=1 -force-vector-width=2 -pass-remarks-analysis=loop-vectorize < %s 2>&1 | FileCheck %s ; RUN: opt -S -loop-vectorize -force-vector-interleave=1 -force-vector-width=2 -pass-remarks-analysis=loop-vectorize < %s 2>&1 | FileCheck %s
; CHECK: remark: {{.*}}: loop not vectorized: value could not be identified as an induction or reduction variable ; CHECK: remark: {{.*}}: loop not vectorized: value could not be identified as an induction or reduction variable
; CHECK: remark: {{.*}}: loop not vectorized: use of induction value outside of the loop is not handled by vectorizer ; CHECK: remark: {{.*}}: loop not vectorized: use of induction value outside of the loop is not handled by vectorizer
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:32:32-n8:16:32-S128" 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:32:32-n8:16:32-S128"
@f = common global i32 0, align 4 @f = common global i32 0, align 4
@.str = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1 @.str = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/nofloat.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
; Make sure that we don't vectorize functions with 'noimplicitfloat' attributes. ; Make sure that we don't vectorize functions with 'noimplicitfloat' attributes.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
Show All 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/non-const-n.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@b = common global [2048 x i32] zeroinitializer, align 16 @b = common global [2048 x i32] zeroinitializer, align 16
@c = common global [2048 x i32] zeroinitializer, align 16 @c = common global [2048 x i32] zeroinitializer, align 16
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
Show All 29 Lines

llvm/trunk/test/Transforms/LoopVectorize/nsw-crash.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4
target datalayout = target datalayout =
"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
define void @test() { define void @test() {
entry: entry:
br i1 undef, label %while.end, label %while.body.lr.ph br i1 undef, label %while.end, label %while.body.lr.ph
Show All 16 Lines

llvm/trunk/test/Transforms/LoopVectorize/opt.ll

; RUN: opt -S -O3 -force-vector-width=2 -force-vector-unroll=1 < %s | FileCheck --check-prefix=LOOPVEC %s ; RUN: opt -S -O3 -force-vector-width=2 -force-vector-interleave=1 < %s | FileCheck --check-prefix=LOOPVEC %s
; RUN: opt -S -O3 -disable-loop-vectorization -force-vector-width=2 -force-vector-unroll=1 < %s | FileCheck --check-prefix=NOLOOPVEC %s ; RUN: opt -S -O3 -disable-loop-vectorization -force-vector-width=2 -force-vector-interleave=1 < %s | FileCheck --check-prefix=NOLOOPVEC %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; Make sure we can disable vectorization in opt. ; Make sure we can disable vectorization in opt.
; LOOPVEC: add <2 x i32> ; LOOPVEC: add <2 x i32>
; NOLOOPVEC-NOT: add <2 x i32> ; NOLOOPVEC-NOT: add <2 x i32>
Show All 18 Lines

llvm/trunk/test/Transforms/LoopVectorize/ptr_loops.ll

; RUN: opt < %s -basicaa -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S -enable-if-conversion | FileCheck %s ; RUN: opt < %s -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S -enable-if-conversion | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@A = global [36 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 32, i32 33, i32 34, i32 35], align 16 @A = global [36 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 32, i32 33, i32 34, i32 35], align 16
@B = global [36 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 32, i32 33, i32 34, i32 35], align 16 @B = global [36 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 32, i32 33, i32 34, i32 35], align 16
;CHECK-LABEL:@_Z5test1v( ;CHECK-LABEL:@_Z5test1v(
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/read-only.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
;CHECK-LABEL: @read_only_func( ;CHECK-LABEL: @read_only_func(
;CHECK: load <4 x i32> ;CHECK: load <4 x i32>
;CHECK: ret i32 ;CHECK: ret i32
define i32 @read_only_func(i32* nocapture %A, i32* nocapture %B, i32 %n) nounwind uwtable readonly ssp { define i32 @read_only_func(i32* nocapture %A, i32* nocapture %B, i32 %n) nounwind uwtable readonly ssp {
Show All 23 Lines

llvm/trunk/test/Transforms/LoopVectorize/reduction.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
;CHECK-LABEL: @reduction_sum( ;CHECK-LABEL: @reduction_sum(
;CHECK: phi <4 x i32> ;CHECK: phi <4 x i32>
;CHECK: load <4 x i32> ;CHECK: load <4 x i32>
;CHECK: add <4 x i32> ;CHECK: add <4 x i32>
▲ Show 20 Lines • Show All 487 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/reverse_induction.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=2 -force-vector-width=4 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=2 -force-vector-width=4 -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Make sure consecutive vector generates correct negative indices. ; Make sure consecutive vector generates correct negative indices.
; PR15882 ; PR15882
; CHECK-LABEL: @reverse_induction_i64( ; CHECK-LABEL: @reverse_induction_i64(
; CHECK: add <4 x i64> %[[SPLAT:.*]], <i64 0, i64 -1, i64 -2, i64 -3> ; CHECK: add <4 x i64> %[[SPLAT:.*]], <i64 0, i64 -1, i64 -2, i64 -3>
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/reverse_iter.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; Make sure that the reverse iterators are calculated using 64bit arithmetic, not 32. ; Make sure that the reverse iterators are calculated using 64bit arithmetic, not 32.
; ;
; int foo(int n, int *A) { ; int foo(int n, int *A) {
; int sum; ; int sum;
Show All 36 Lines

llvm/trunk/test/Transforms/LoopVectorize/runtime-check-address-space.ll

; RUN: opt -S -march=r600 -mcpu=cayman -basicaa -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine < %s | FileCheck %s ; RUN: opt -S -march=r600 -mcpu=cayman -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine < %s | FileCheck %s
; Check vectorization that would ordinarily require a runtime bounds ; Check vectorization that would ordinarily require a runtime bounds
; check on the pointers when mixing address spaces. For now we cannot ; check on the pointers when mixing address spaces. For now we cannot
; assume address spaces do not alias, and we can't assume that ; assume address spaces do not alias, and we can't assume that
; different pointers are directly comparable. ; different pointers are directly comparable.
; ;
; These all test this basic loop for different combinations of address ; These all test this basic loop for different combinations of address
; spaces, and swapping in globals or adding noalias. ; spaces, and swapping in globals or adding noalias.
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/runtime-check-readonly-address-space.ll

; RUN: opt -S -march=r600 -mcpu=cayman -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine < %s | FileCheck %s ; RUN: opt -S -march=r600 -mcpu=cayman -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine < %s | FileCheck %s
; Artificial datalayout ; Artificial datalayout
target datalayout = "e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048-n32:64" target datalayout = "e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048-n32:64"
define void @add_ints_1_1_1(i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c) #0 { define void @add_ints_1_1_1(i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c) #0 {
; CHECK-LABEL: @add_ints_1_1_1( ; CHECK-LABEL: @add_ints_1_1_1(
; CHECK: <4 x i32> ; CHECK: <4 x i32>
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/runtime-check-readonly.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
;CHECK-LABEL: @add_ints( ;CHECK-LABEL: @add_ints(
;CHECK: br ;CHECK: br
;CHECK: br ;CHECK: br
;CHECK: getelementptr ;CHECK: getelementptr
Show All 30 Lines

llvm/trunk/test/Transforms/LoopVectorize/runtime-check.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
; Make sure we vectorize this loop: ; Make sure we vectorize this loop:
; int foo(float *a, float *b, int n) { ; int foo(float *a, float *b, int n) {
; for (int i=0; i<n; ++i) ; for (int i=0; i<n; ++i)
; a[i] = b[i] * 3; ; a[i] = b[i] * 3;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/runtime-limit.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; We are vectorizing with 6 runtime checks. ; We are vectorizing with 6 runtime checks.
;CHECK-LABEL: func1x6( ;CHECK-LABEL: func1x6(
;CHECK: <4 x i32> ;CHECK: <4 x i32>
;CHECK: ret ;CHECK: ret
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/safegep.ll

; RUN: opt -S -loop-vectorize -force-vector-width=4 -force-vector-unroll=1 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 < %s | FileCheck %s
target datalayout = "e-p:32:32:32-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f16:16:16-f32:32:32-f64:32:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32" target datalayout = "e-p:32:32:32-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f16:16:16-f32:32:32-f64:32:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"
; We can vectorize this code because if the address computation would wrap then ; We can vectorize this code because if the address computation would wrap then
; a load from 0 would take place which is undefined behaviour in address space 0 ; a load from 0 would take place which is undefined behaviour in address space 0
; according to LLVM IR semantics. ; according to LLVM IR semantics.
; PR16592 ; PR16592
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/same-base-access.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S -enable-if-conversion | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S -enable-if-conversion | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
; This is kernel11 from "LivermoreLoops". We can't vectorize it because we ; This is kernel11 from "LivermoreLoops". We can't vectorize it because we
; access both x[k] and x[k-1]. ; access both x[k] and x[k-1].
; ;
; void kernel11(double *x, double *y, int n) { ; void kernel11(double *x, double *y, int n) {
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/scalar-select.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
@b = common global [2048 x i32] zeroinitializer, align 16 @b = common global [2048 x i32] zeroinitializer, align 16
@c = common global [2048 x i32] zeroinitializer, align 16 @c = common global [2048 x i32] zeroinitializer, align 16
Show All 28 Lines

llvm/trunk/test/Transforms/LoopVectorize/scev-exitlim-crash.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=2 -force-vector-width=8 -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=2 -force-vector-width=8 -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx" target triple = "x86_64-apple-macosx"
@b = common global i32 0, align 4 @b = common global i32 0, align 4
@f = common global i32 0, align 4 @f = common global i32 0, align 4
@a = common global i32 0, align 4 @a = common global i32 0, align 4
@d = common global i32* null, align 8 @d = common global i32* null, align 8
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/simple-unroll.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-unroll=2 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-width=4 -force-vector-interleave=2 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
; This is the loop. ; This is the loop.
; for (i=0; i<n; i++){ ; for (i=0; i<n; i++){
Show All 30 Lines

llvm/trunk/test/Transforms/LoopVectorize/small-loop.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
@b = common global [2048 x i32] zeroinitializer, align 16 @b = common global [2048 x i32] zeroinitializer, align 16
@c = common global [2048 x i32] zeroinitializer, align 16 @c = common global [2048 x i32] zeroinitializer, align 16
Show All 24 Lines

llvm/trunk/test/Transforms/LoopVectorize/start-non-zero.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
;CHECK-LABEL: @start_at_nonzero( ;CHECK-LABEL: @start_at_nonzero(
;CHECK: mul nuw <4 x i32> ;CHECK: mul nuw <4 x i32>
;CHECK: ret i32 ;CHECK: ret i32
define i32 @start_at_nonzero(i32* nocapture %a, i32 %start, i32 %end) nounwind uwtable ssp { define i32 @start_at_nonzero(i32* nocapture %a, i32 %start, i32 %end) nounwind uwtable ssp {
Show All 22 Lines

llvm/trunk/test/Transforms/LoopVectorize/store-shuffle-bug.ll

; RUN: opt -S -basicaa -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine < %s | FileCheck %s ; RUN: opt -S -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@uf = common global [100 x i32] zeroinitializer, align 16 @uf = common global [100 x i32] zeroinitializer, align 16
@xi = common global [100 x i32] zeroinitializer, align 16 @xi = common global [100 x i32] zeroinitializer, align 16
@q = common global [100 x i32] zeroinitializer, align 16 @q = common global [100 x i32] zeroinitializer, align 16
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/struct_access.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
%struct.coordinate = type { i32, i32 } %struct.coordinate = type { i32, i32 }
; Make sure that we don't generate a wide load when accessing the struct. ; Make sure that we don't generate a wide load when accessing the struct.
; struct coordinate { ; struct coordinate {
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/tbaa-nodep.ll

; RUN: opt < %s -tbaa -basicaa -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -simplifycfg -S | FileCheck %s ; RUN: opt < %s -tbaa -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -simplifycfg -S | FileCheck %s
; RUN: opt < %s -basicaa -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -simplifycfg -S | FileCheck %s --check-prefix=CHECK-NOTBAA ; RUN: opt < %s -basicaa -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -simplifycfg -S | FileCheck %s --check-prefix=CHECK-NOTBAA
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @test1(i32* nocapture %a, float* nocapture readonly %b) #0 { define i32 @test1(i32* nocapture %a, float* nocapture readonly %b) #0 {
entry: entry:
br label %for.body br label %for.body
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/undef-inst-bug.ll

; RUN: opt -S -loop-vectorize -force-vector-width=4 -force-vector-unroll=1 < %s | FileCheck %s ; RUN: opt -S -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; We use to fail on this loop because we did not properly handle the loop ; We use to fail on this loop because we did not properly handle the loop
; invariant instruction anchored in the loop when used as a getelementptr index. ; invariant instruction anchored in the loop when used as a getelementptr index.
; We would use the index from the original loop resulting in a use not dominated ; We would use the index from the original loop resulting in a use not dominated
; by the definition. ; by the definition.
Show All 27 Lines

llvm/trunk/test/Transforms/LoopVectorize/unroll_novec.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=1 -force-target-num-scalar-regs=16 -force-target-max-scalar-unroll=8 -force-target-instruction-cost=1 -small-loop-cost=40 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-width=1 -force-target-num-scalar-regs=16 -force-target-max-scalar-interleave=8 -force-target-instruction-cost=1 -small-loop-cost=40 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
@a = common global [2048 x i32] zeroinitializer, align 16 @a = common global [2048 x i32] zeroinitializer, align 16
; This is the loop. ; This is the loop.
; for (i=0; i<n; i++){ ; for (i=0; i<n; i++){
Show All 40 Lines

llvm/trunk/test/Transforms/LoopVectorize/value-ptr-bug.ll

; RUN: opt -S -loop-vectorize -force-vector-width=4 -force-vector-unroll=1 -dce -instcombine < %s | FileCheck %s ; RUN: opt -S -loop-vectorize -force-vector-width=4 -force-vector-interleave=1 -dce -instcombine < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; PR16073 ; PR16073
; Because we were caching value pointers across a function call that could RAUW ; Because we were caching value pointers across a function call that could RAUW
; we would generate an undefined value store below: ; we would generate an undefined value store below:
; SCEVExpander::expandCodeFor would change a value (the start value of an ; SCEVExpander::expandCodeFor would change a value (the start value of an
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/vect.omp.persistence.ll

; RUN: opt < %s -O2 -force-vector-unroll=2 -force-vector-width=4 -debug-only=loop-vectorize -stats -S 2>&1 | FileCheck %s ; RUN: opt < %s -O2 -force-vector-interleave=2 -force-vector-width=4 -debug-only=loop-vectorize -stats -S 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; Loop from "rotated" ; Loop from "rotated"
; CHECK: LV: Loop hints: force=enabled ; CHECK: LV: Loop hints: force=enabled
; Loop from "nonrotated" ; Loop from "nonrotated"
; CHECK: LV: Loop hints: force=enabled ; CHECK: LV: Loop hints: force=enabled
; No more loops in the module ; No more loops in the module
; CHECK-NOT: LV: Loop hints: force= ; CHECK-NOT: LV: Loop hints: force=
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/vect.stats.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=4 -force-vector-width=4 -debug-only=loop-vectorize -stats -S 2>&1 | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=4 -force-vector-width=4 -debug-only=loop-vectorize -stats -S 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; ;
; We have 2 loops, one of them is vectorizable and the second one is not. ; We have 2 loops, one of them is vectorizable and the second one is not.
; ;
; CHECK: 2 loop-vectorize - Number of loops analyzed for vectorization ; CHECK: 2 loop-vectorize - Number of loops analyzed for vectorization
; CHECK: 1 loop-vectorize - Number of loops vectorized ; CHECK: 1 loop-vectorize - Number of loops vectorized
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Linesfor.body:
%arrayidx4 = getelementptr inbounds float* %a, i64 %indvars.iv %arrayidx4 = getelementptr inbounds float* %a, i64 %indvars.iv
store float %mul, float* %arrayidx4, align 4 store float %mul, float* %arrayidx4, align 4
%indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
br label %for.header br label %for.header
for.end: for.end:
ret void ret void
} }
No newline at end of file

llvm/trunk/test/Transforms/LoopVectorize/vectorize-once.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S -simplifycfg | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S -simplifycfg | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
; ;
; We want to make sure that we are vectorizeing the scalar loop only once ; We want to make sure that we are vectorizeing the scalar loop only once
; even if the pass manager runs the vectorizer multiple times due to inlining. ; even if the pass manager runs the vectorizer multiple times due to inlining.
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/version-mem-access.ll

; RUN: opt -basicaa -loop-vectorize -enable-mem-access-versioning -force-vector-width=2 -force-vector-unroll=1 < %s -S | FileCheck %s ; RUN: opt -basicaa -loop-vectorize -enable-mem-access-versioning -force-vector-width=2 -force-vector-interleave=1 < %s -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
; CHECK-LABEL: test ; CHECK-LABEL: test
define void @test(i32* noalias %A, i64 %AStride, define void @test(i32* noalias %A, i64 %AStride,
i32* noalias %B, i32 %BStride, i32* noalias %B, i32 %BStride,
i32* noalias %C, i64 %CStride, i32 %N) { i32* noalias %C, i64 %CStride, i32 %N) {
entry: entry:
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/LoopVectorize/write-only.ll

; RUN: opt < %s -loop-vectorize -force-vector-unroll=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s ; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -dce -instcombine -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
;CHECK-LABEL: @read_mod_write_single_ptr( ;CHECK-LABEL: @read_mod_write_single_ptr(
;CHECK: load <4 x float> ;CHECK: load <4 x float>
;CHECK: ret i32 ;CHECK: ret i32
define i32 @read_mod_write_single_ptr(float* nocapture %a, i32 %n) nounwind uwtable ssp { define i32 @read_mod_write_single_ptr(float* nocapture %a, i32 %n) nounwind uwtable ssp {
Show All 17 Lines