Index: include/llvm/Analysis/LoopAccessAnalysis.h =================================================================== --- include/llvm/Analysis/LoopAccessAnalysis.h +++ include/llvm/Analysis/LoopAccessAnalysis.h @@ -76,30 +76,6 @@ /// RuntimePointerCheck class. class LoopAccessInfo { public: - /// \brief Collection of parameters used from the vectorizer. - struct VectorizerParams { - /// \brief Maximum simd width. - unsigned MaxVectorWidth; - - /// \brief VF as overridden by the user. - unsigned VectorizationFactor; - /// \brief Interleave factor as overridden by the user. - unsigned VectorizationInterleave; - - /// \\brief When performing memory disambiguation checks at runtime do not - /// make more than this number of comparisons. - unsigned RuntimeMemoryCheckThreshold; - - VectorizerParams(unsigned MaxVectorWidth, - unsigned VectorizationFactor, - unsigned VectorizationInterleave, - unsigned RuntimeMemoryCheckThreshold) : - MaxVectorWidth(MaxVectorWidth), - VectorizationFactor(VectorizationFactor), - VectorizationInterleave(VectorizationInterleave), - RuntimeMemoryCheckThreshold(RuntimeMemoryCheckThreshold) {} - }; - /// This struct holds information about the memory runtime legality check that /// a group of pointers do not overlap. struct RuntimePointerCheck { @@ -139,11 +115,9 @@ LoopAccessInfo(Function *F, Loop *L, ScalarEvolution *SE, const DataLayout *DL, const TargetLibraryInfo *TLI, - AliasAnalysis *AA, DominatorTree *DT, - const VectorizerParams &VectParams) : + AliasAnalysis *AA, DominatorTree *DT) : TheFunction(F), TheLoop(L), SE(SE), DL(DL), TLI(TLI), AA(AA), DT(DT), - NumLoads(0), NumStores(0), MaxSafeDepDistBytes(-1U), - VectParams(VectParams) {} + NumLoads(0), NumStores(0), MaxSafeDepDistBytes(-1U) {} /// Return true we can analyze the memory accesses in the loop and there are /// no memory dependence cycles. Replaces symbolic strides using Strides. @@ -187,9 +161,6 @@ unsigned NumStores; unsigned MaxSafeDepDistBytes; - - /// \brief Vectorizer parameters used by the analysis. - VectorizerParams VectParams; }; Value *stripIntegerCast(Value *V); Index: include/llvm/Transforms/Utils/VectorUtils.h =================================================================== --- include/llvm/Transforms/Utils/VectorUtils.h +++ include/llvm/Transforms/Utils/VectorUtils.h @@ -200,6 +200,22 @@ return Intrinsic::not_intrinsic; } +/// \brief Collection of parameters shared beetween the Loop Vectorizer and the +/// Loop Access Analysis. +struct VectorizerParams { + /// \brief Maximum SIMD width. + static const unsigned MaxVectorWidth; + + /// \brief VF as overridden by the user. + static unsigned VectorizationFactor; + /// \brief Interleave factor as overridden by the user. + static unsigned VectorizationInterleave; + + /// \\brief When performing memory disambiguation checks at runtime do not + /// make more than this number of comparisons. + static const unsigned RuntimeMemoryCheckThreshold; +}; + } // llvm namespace #endif Index: lib/Analysis/LoopAccessAnalysis.cpp =================================================================== --- lib/Analysis/LoopAccessAnalysis.cpp +++ lib/Analysis/LoopAccessAnalysis.cpp @@ -437,10 +437,9 @@ typedef PointerIntPair MemAccessInfo; typedef SmallPtrSet MemAccessInfoSet; - MemoryDepChecker(ScalarEvolution *Se, const DataLayout *Dl, const Loop *L, - const LoopAccessInfo::VectorizerParams &VectParams) + MemoryDepChecker(ScalarEvolution *Se, const DataLayout *Dl, const Loop *L) : SE(Se), DL(Dl), InnermostLoop(L), AccessIdx(0), - ShouldRetryWithRuntimeCheck(false), VectParams(VectParams) {} + ShouldRetryWithRuntimeCheck(false) {} /// \brief Register the location (instructions are given increasing numbers) /// of a write access. @@ -495,9 +494,6 @@ /// vectorize this loop with runtime checks. bool ShouldRetryWithRuntimeCheck; - /// \brief Vectorizer parameters used by the analysis. - LoopAccessInfo::VectorizerParams VectParams; - /// \brief Check whether there is a plausible dependence between the two /// accesses. /// @@ -621,7 +617,8 @@ // Store-load forwarding distance. const unsigned NumCyclesForStoreLoadThroughMemory = 8*TypeByteSize; // Maximum vector factor. - unsigned MaxVFWithoutSLForwardIssues = VectParams.MaxVectorWidth*TypeByteSize; + unsigned MaxVFWithoutSLForwardIssues = + VectorizerParams::MaxVectorWidth * TypeByteSize; if(MaxSafeDepDistBytes < MaxVFWithoutSLForwardIssues) MaxVFWithoutSLForwardIssues = MaxSafeDepDistBytes; @@ -640,7 +637,8 @@ } if (MaxVFWithoutSLForwardIssues < MaxSafeDepDistBytes && - MaxVFWithoutSLForwardIssues != VectParams.MaxVectorWidth*TypeByteSize) + MaxVFWithoutSLForwardIssues != + VectorizerParams::MaxVectorWidth * TypeByteSize) MaxSafeDepDistBytes = MaxVFWithoutSLForwardIssues; return false; } @@ -745,10 +743,10 @@ unsigned Distance = (unsigned) Val.getZExtValue(); // Bail out early if passed-in parameters make vectorization not feasible. - unsigned ForcedFactor = (VectParams.VectorizationFactor ? - VectParams.VectorizationFactor : 1); - unsigned ForcedUnroll = (VectParams.VectorizationInterleave ? - VectParams.VectorizationInterleave : 1); + unsigned ForcedFactor = (VectorizerParams::VectorizationFactor ? + VectorizerParams::VectorizationFactor : 1); + unsigned ForcedUnroll = (VectorizerParams::VectorizationInterleave ? + VectorizerParams::VectorizationInterleave : 1); // 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 @@ -831,7 +829,7 @@ PtrRtCheck.Need = false; const bool IsAnnotatedParallel = TheLoop->isAnnotatedParallel(); - MemoryDepChecker DepChecker(SE, DL, TheLoop, VectParams); + MemoryDepChecker DepChecker(SE, DL, TheLoop); // For each block. for (Loop::block_iterator bb = TheLoop->block_begin(), @@ -1000,7 +998,8 @@ // Check that we did not collect too many pointers or found an unsizeable // pointer. - if (!CanDoRT || NumComparisons > VectParams.RuntimeMemoryCheckThreshold) { + if (!CanDoRT || + NumComparisons > VectorizerParams::RuntimeMemoryCheckThreshold) { PtrRtCheck.reset(); CanDoRT = false; } @@ -1040,14 +1039,15 @@ TheLoop, Strides, true); // Check that we did not collect too many pointers or found an unsizeable // pointer. - if (!CanDoRT || NumComparisons > VectParams.RuntimeMemoryCheckThreshold) { + if (!CanDoRT || + NumComparisons > VectorizerParams::RuntimeMemoryCheckThreshold) { if (!CanDoRT && NumComparisons > 0) emitAnalysis(VectorizationReport() << "cannot check memory dependencies at runtime"); else emitAnalysis(VectorizationReport() << NumComparisons << " exceeds limit of " - << VectParams.RuntimeMemoryCheckThreshold + << VectorizerParams::RuntimeMemoryCheckThreshold << " dependent memory operations checked at runtime"); DEBUG(dbgs() << "LV: Can't vectorize with memory checks\n"); PtrRtCheck.reset(); Index: lib/Transforms/Vectorize/LoopVectorize.cpp =================================================================== --- lib/Transforms/Vectorize/LoopVectorize.cpp +++ lib/Transforms/Vectorize/LoopVectorize.cpp @@ -106,14 +106,19 @@ STATISTIC(LoopsVectorized, "Number of loops vectorized"); STATISTIC(LoopsAnalyzed, "Number of loops analyzed for vectorization"); -static cl::opt -VectorizationFactor("force-vector-width", cl::init(0), cl::Hidden, - cl::desc("Sets the SIMD width. Zero is autoselect.")); - -static cl::opt -VectorizationInterleave("force-vector-interleave", cl::init(0), cl::Hidden, - cl::desc("Sets the vectorization interleave count. " - "Zero is autoselect.")); +static cl::opt +VectorizationFactor("force-vector-width", cl::Hidden, + cl::desc("Sets the SIMD width. Zero is autoselect."), + cl::location(VectorizerParams::VectorizationFactor)); +unsigned VectorizerParams::VectorizationFactor = 0; + +static cl::opt +VectorizationInterleave("force-vector-interleave", cl::Hidden, + cl::desc("Sets the vectorization interleave count. " + "Zero is autoselect."), + cl::location( + VectorizerParams::VectorizationInterleave)); +unsigned VectorizerParams::VectorizationInterleave = 0; static cl::opt EnableIfConversion("enable-if-conversion", cl::init(true), cl::Hidden, @@ -147,10 +152,10 @@ /// When performing memory disambiguation checks at runtime do not make more /// than this number of comparisons. -static const unsigned RuntimeMemoryCheckThreshold = 8; +const unsigned VectorizerParams::RuntimeMemoryCheckThreshold = 8; /// Maximum simd width. -static const unsigned MaxVectorWidth = 64; +const unsigned VectorizerParams::MaxVectorWidth = 64; static cl::opt ForceTargetNumScalarRegs( "force-target-num-scalar-regs", cl::init(0), cl::Hidden, @@ -551,10 +556,7 @@ : NumPredStores(0), TheLoop(L), SE(SE), DL(DL), TLI(TLI), TheFunction(F), TTI(TTI), Induction(nullptr), WidestIndTy(nullptr), - LAI(F, L, SE, DL, TLI, AA, DT, - LoopAccessInfo::VectorizerParams( - MaxVectorWidth, VectorizationFactor, VectorizationInterleave, - RuntimeMemoryCheckThreshold)), + LAI(F, L, SE, DL, TLI, AA, DT), HasFunNoNaNAttr(false) {} /// This enum represents the kinds of reductions that we support. @@ -1019,7 +1021,7 @@ bool validate(unsigned Val) { switch (Kind) { case HK_WIDTH: - return isPowerOf2_32(Val) && Val <= MaxVectorWidth; + return isPowerOf2_32(Val) && Val <= VectorizerParams::MaxVectorWidth; case HK_UNROLL: return isPowerOf2_32(Val) && Val <= MaxInterleaveFactor; case HK_FORCE: