LLVM  8.0.0svn
Classes | Namespaces | Macros | Functions | Variables
LoopVectorize.cpp File Reference
#include "llvm/Transforms/Vectorize/LoopVectorize.h"
#include "LoopVectorizationPlanner.h"
#include "VPRecipeBuilder.h"
#include "VPlanHCFGBuilder.h"
#include "VPlanHCFGTransforms.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/ADT/Hashing.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/ADT/None.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Twine.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/Analysis/AssumptionCache.h"
#include "llvm/Analysis/BasicAliasAnalysis.h"
#include "llvm/Analysis/BlockFrequencyInfo.h"
#include "llvm/Analysis/CFG.h"
#include "llvm/Analysis/CodeMetrics.h"
#include "llvm/Analysis/DemandedBits.h"
#include "llvm/Analysis/GlobalsModRef.h"
#include "llvm/Analysis/LoopAccessAnalysis.h"
#include "llvm/Analysis/LoopAnalysisManager.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/LoopIterator.h"
#include "llvm/Analysis/OptimizationRemarkEmitter.h"
#include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/Analysis/ScalarEvolutionExpander.h"
#include "llvm/Analysis/ScalarEvolutionExpressions.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/Analysis/VectorUtils.h"
#include "llvm/IR/Attributes.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/CFG.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DebugLoc.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Metadata.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Operator.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/Use.h"
#include "llvm/IR/User.h"
#include "llvm/IR/Value.h"
#include "llvm/IR/ValueHandle.h"
#include "llvm/IR/Verifier.h"
#include "llvm/Pass.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/LoopSimplify.h"
#include "llvm/Transforms/Utils/LoopUtils.h"
#include "llvm/Transforms/Utils/LoopVersioning.h"
#include "llvm/Transforms/Vectorize/LoopVectorizationLegality.h"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <cstdlib>
#include <functional>
#include <iterator>
#include <limits>
#include <memory>
#include <string>
#include <tuple>
#include <utility>
#include <vector>

Go to the source code of this file.

Classes

class  llvm::InnerLoopVectorizer
 InnerLoopVectorizer vectorizes loops which contain only one basic block to a specified vectorization factor (VF). More...
 
class  llvm::InnerLoopUnroller
 
class  llvm::LoopVectorizationCostModel
 LoopVectorizationCostModel - estimates the expected speedups due to vectorization. More...
 
struct  llvm::LoopVectorizationCostModel::RegisterUsage
 A struct that represents some properties of the register usage of a loop. More...
 

Namespaces

 llvm
 Compute iterated dominance frontiers using a linear time algorithm.
 

Macros

#define LV_NAME   "loop-vectorize"
 
#define DEBUG_TYPE   LV_NAME
 

Functions

 STATISTIC (LoopsVectorized, "Number of loops vectorized")
 
 STATISTIC (LoopsAnalyzed, "Number of loops analyzed for vectorization")
 
static TypeToVectorTy (Type *Scalar, unsigned VF)
 A helper function for converting Scalar types to vector types. More...
 
static TypegetMemInstValueType (Value *I)
 A helper function that returns the type of loaded or stored value. More...
 
static bool hasIrregularType (Type *Ty, const DataLayout &DL, unsigned VF)
 A helper function that returns true if the given type is irregular. More...
 
static unsigned getReciprocalPredBlockProb ()
 A helper function that returns the reciprocal of the block probability of predicated blocks. More...
 
static ValueaddFastMathFlag (Value *V)
 A helper function that adds a 'fast' flag to floating-point operations. More...
 
static ConstantgetSignedIntOrFpConstant (Type *Ty, int64_t C)
 A helper function that returns an integer or floating-point constant with value C. More...
 
static InstructiongetDebugLocFromInstOrOperands (Instruction *I)
 Look for a meaningful debug location on the instruction or it's operands. More...
 
static std::string getDebugLocString (const Loop *L)
 
static void emitMissedWarning (Function *F, Loop *L, const LoopVectorizeHints &LH, OptimizationRemarkEmitter *ORE)
 
static bool isExplicitVecOuterLoop (Loop *OuterLp, OptimizationRemarkEmitter *ORE)
 
static void collectSupportedLoops (Loop &L, LoopInfo *LI, OptimizationRemarkEmitter *ORE, SmallVectorImpl< Loop *> &V)
 
static void cse (BasicBlock *BB)
 Perform cse of induction variable instructions. More...
 
static unsigned getScalarizationOverhead (Instruction *I, unsigned VF, const TargetTransformInfo &TTI)
 Estimate the overhead of scalarizing an instruction. More...
 
static unsigned getVectorCallCost (CallInst *CI, unsigned VF, const TargetTransformInfo &TTI, const TargetLibraryInfo *TLI, bool &NeedToScalarize)
 
static unsigned getVectorIntrinsicCost (CallInst *CI, unsigned VF, const TargetTransformInfo &TTI, const TargetLibraryInfo *TLI)
 
static TypesmallestIntegerVectorType (Type *T1, Type *T2)
 
static TypelargestIntegerVectorType (Type *T1, Type *T2)
 
static bool mayDivideByZero (Instruction &I)
 A helper function for checking whether an integer division-related instruction may divide by zero (in which case it must be predicated if executed conditionally in the scalar code). More...
 
static const SCEVgetAddressAccessSCEV (Value *Ptr, LoopVectorizationLegality *Legal, PredicatedScalarEvolution &PSE, const Loop *TheLoop)
 Gets Address Access SCEV after verifying that the access pattern is loop invariant except the induction variable dependence. More...
 
static bool isStrideMul (Instruction *I, LoopVectorizationLegality *Legal)
 
Passllvm::createLoopVectorizePass (bool NoUnrolling=false, bool AlwaysVectorize=true)
 
static void AddRuntimeUnrollDisableMetaData (Loop *L)
 
static bool processLoopInVPlanNativePath (Loop *L, PredicatedScalarEvolution &PSE, LoopInfo *LI, DominatorTree *DT, LoopVectorizationLegality *LVL, TargetTransformInfo *TTI, TargetLibraryInfo *TLI, DemandedBits *DB, AssumptionCache *AC, OptimizationRemarkEmitter *ORE, LoopVectorizeHints &Hints)
 

Variables

static cl::opt< unsignedTinyTripCountVectorThreshold ("vectorizer-min-trip-count", cl::init(16), cl::Hidden, cl::desc("Loops with a constant trip count that is smaller than this " "value are vectorized only if no scalar iteration overheads " "are incurred."))
 Loops with a known constant trip count below this number are vectorized only if no scalar iteration overheads are incurred. More...
 
static cl::opt< boolMaximizeBandwidth ("vectorizer-maximize-bandwidth", cl::init(false), cl::Hidden, cl::desc("Maximize bandwidth when selecting vectorization factor which " "will be determined by the smallest type in loop."))
 
static cl::opt< boolEnableInterleavedMemAccesses ("enable-interleaved-mem-accesses", cl::init(false), cl::Hidden, cl::desc("Enable vectorization on interleaved memory accesses in a loop"))
 
static const unsigned TinyTripCountInterleaveThreshold = 128
 We don't interleave loops with a known constant trip count below this number. More...
 
static cl::opt< unsignedForceTargetNumScalarRegs ("force-target-num-scalar-regs", cl::init(0), cl::Hidden, cl::desc("A flag that overrides the target's number of scalar registers."))
 
static cl::opt< unsignedForceTargetNumVectorRegs ("force-target-num-vector-regs", cl::init(0), cl::Hidden, cl::desc("A flag that overrides the target's number of vector registers."))
 
static cl::opt< unsignedForceTargetMaxScalarInterleaveFactor ("force-target-max-scalar-interleave", cl::init(0), cl::Hidden, cl::desc("A flag that overrides the target's max interleave factor for " "scalar loops."))
 
static cl::opt< unsignedForceTargetMaxVectorInterleaveFactor ("force-target-max-vector-interleave", cl::init(0), cl::Hidden, cl::desc("A flag that overrides the target's max interleave factor for " "vectorized loops."))
 
static cl::opt< unsignedForceTargetInstructionCost ("force-target-instruction-cost", cl::init(0), cl::Hidden, cl::desc("A flag that overrides the target's expected cost for " "an instruction to a single constant value. Mostly " "useful for getting consistent testing."))
 
static cl::opt< unsignedSmallLoopCost ("small-loop-cost", cl::init(20), cl::Hidden, cl::desc("The cost of a loop that is considered 'small' by the interleaver."))
 
static cl::opt< boolLoopVectorizeWithBlockFrequency ("loop-vectorize-with-block-frequency", cl::init(true), cl::Hidden, cl::desc("Enable the use of the block frequency analysis to access PGO " "heuristics minimizing code growth in cold regions and being more " "aggressive in hot regions."))
 
static cl::opt< boolEnableLoadStoreRuntimeInterleave ("enable-loadstore-runtime-interleave", cl::init(true), cl::Hidden, cl::desc("Enable runtime interleaving until load/store ports are saturated"))
 
static cl::opt< unsignedNumberOfStoresToPredicate ("vectorize-num-stores-pred", cl::init(1), cl::Hidden, cl::desc("Max number of stores to be predicated behind an if."))
 The number of stores in a loop that are allowed to need predication. More...
 
static cl::opt< boolEnableIndVarRegisterHeur ("enable-ind-var-reg-heur", cl::init(true), cl::Hidden, cl::desc("Count the induction variable only once when interleaving"))
 
static cl::opt< boolEnableCondStoresVectorization ("enable-cond-stores-vec", cl::init(true), cl::Hidden, cl::desc("Enable if predication of stores during vectorization."))
 
static cl::opt< unsignedMaxNestedScalarReductionIC ("max-nested-scalar-reduction-interleave", cl::init(2), cl::Hidden, cl::desc("The maximum interleave count to use when interleaving a scalar " "reduction in a nested loop."))
 
cl::opt< boolEnableVPlanNativePath ("enable-vplan-native-path", cl::init(false), cl::Hidden, cl::desc("Enable VPlan-native vectorization path with " "support for outer loop vectorization."))
 
static cl::opt< boolVPlanBuildStressTest ("vplan-build-stress-test", cl::init(false), cl::Hidden, cl::desc("Build VPlan for every supported loop nest in the function and bail " "out right after the build (stress test the VPlan H-CFG construction " "in the VPlan-native vectorization path)."))
 
static const char lv_name [] = "Loop Vectorization"
 

Macro Definition Documentation

◆ DEBUG_TYPE

#define DEBUG_TYPE   LV_NAME

Definition at line 153 of file LoopVectorize.cpp.

Referenced by emitMissedWarning().

◆ LV_NAME

#define LV_NAME   "loop-vectorize"

Definition at line 152 of file LoopVectorize.cpp.

Referenced by llvm::LoopVectorizePass::processLoop().

Function Documentation

◆ addFastMathFlag()

static Value* addFastMathFlag ( Value V)
static

A helper function that adds a 'fast' flag to floating-point operations.

Definition at line 297 of file LoopVectorize.cpp.

References llvm::FastMathFlags::setFast().

Referenced by llvm::InnerLoopVectorizer::buildScalarSteps(), llvm::LoopVectorizationPlanner::collectTriviallyDeadInstructions(), and llvm::InnerLoopVectorizer::fixReduction().

◆ AddRuntimeUnrollDisableMetaData()

static void AddRuntimeUnrollDisableMetaData ( Loop L)
static

◆ collectSupportedLoops()

static void collectSupportedLoops ( Loop L,
LoopInfo LI,
OptimizationRemarkEmitter ORE,
SmallVectorImpl< Loop *> &  V 
)
static

◆ cse()

static void cse ( BasicBlock BB)
static

◆ emitMissedWarning()

static void emitMissedWarning ( Function F,
Loop L,
const LoopVectorizeHints LH,
OptimizationRemarkEmitter ORE 
)
static

◆ getAddressAccessSCEV()

static const SCEV* getAddressAccessSCEV ( Value Ptr,
LoopVectorizationLegality Legal,
PredicatedScalarEvolution PSE,
const Loop TheLoop 
)
static

Gets Address Access SCEV after verifying that the access pattern is loop invariant except the induction variable dependence.

This SCEV can be sent to the Target in order to estimate the address calculation cost.

Definition at line 5205 of file LoopVectorize.cpp.

References llvm::dyn_cast(), llvm::PredicatedScalarEvolution::getSCEV(), llvm::PredicatedScalarEvolution::getSE(), and llvm::LoopVectorizationLegality::isInductionVariable().

Referenced by isStrideMul().

◆ getDebugLocFromInstOrOperands()

static Instruction* getDebugLocFromInstOrOperands ( Instruction I)
static

Look for a meaningful debug location on the instruction or it's operands.

Definition at line 723 of file LoopVectorize.cpp.

References llvm::Empty, llvm::Instruction::getDebugLoc(), I, llvm::User::op_begin(), and llvm::User::op_end().

Referenced by llvm::InnerLoopVectorizer::createVectorizedLoopSkeleton().

◆ getDebugLocString()

static std::string getDebugLocString ( const Loop L)
static

◆ getMemInstValueType()

static Type* getMemInstValueType ( Value I)
static

◆ getReciprocalPredBlockProb()

static unsigned getReciprocalPredBlockProb ( )
static

A helper function that returns the reciprocal of the block probability of predicated blocks.

If we return X, we are assuming the predicated block will execute once for every X iterations of the loop header.

TODO: We should use actual block probability here, if available. Currently, we always assume predicated blocks have a 50% chance of executing.

Definition at line 294 of file LoopVectorize.cpp.

Referenced by llvm::LoopVectorizationCostModel::collectInstsToScalarize(), isStrideMul(), and llvm::LoopVectorizationCostModel::setCostBasedWideningDecision().

◆ getScalarizationOverhead()

static unsigned getScalarizationOverhead ( Instruction I,
unsigned  VF,
const TargetTransformInfo TTI 
)
static

◆ getSignedIntOrFpConstant()

static Constant* getSignedIntOrFpConstant ( Type Ty,
int64_t  C 
)
static

A helper function that returns an integer or floating-point constant with value C.

Definition at line 308 of file LoopVectorize.cpp.

References llvm::ConstantFP::get(), llvm::ConstantInt::getSigned(), and llvm::Type::isIntegerTy().

Referenced by llvm::InnerLoopVectorizer::buildScalarSteps().

◆ getVectorCallCost()

static unsigned getVectorCallCost ( CallInst CI,
unsigned  VF,
const TargetTransformInfo TTI,
const TargetLibraryInfo TLI,
bool NeedToScalarize 
)
static

◆ getVectorIntrinsicCost()

static unsigned getVectorIntrinsicCost ( CallInst CI,
unsigned  VF,
const TargetTransformInfo TTI,
const TargetLibraryInfo TLI 
)
static

◆ hasIrregularType()

static bool hasIrregularType ( Type Ty,
const DataLayout DL,
unsigned  VF 
)
static

A helper function that returns true if the given type is irregular.

The type is irregular if its allocated size doesn't equal the store size of an element of the corresponding vector type at the given vectorization factor.

Definition at line 275 of file LoopVectorize.cpp.

References llvm::VectorType::get(), llvm::DataLayout::getTypeAllocSize(), llvm::DataLayout::getTypeAllocSizeInBits(), llvm::DataLayout::getTypeSizeInBits(), and llvm::DataLayout::getTypeStoreSize().

Referenced by llvm::LoopVectorizationCostModel::memoryInstructionCanBeWidened().

◆ isExplicitVecOuterLoop()

static bool isExplicitVecOuterLoop ( Loop OuterLp,
OptimizationRemarkEmitter ORE 
)
static

◆ isStrideMul()

static bool isStrideMul ( Instruction I,
LoopVectorizationLegality Legal 
)
static

Definition at line 5230 of file LoopVectorize.cpp.

References assert(), C, llvm::InnerLoopVectorizer::Cost, first, llvm::VectorType::get(), getAddressAccessSCEV(), llvm::TargetTransformInfo::getAddressComputationCost(), llvm::LoadInst::getAlignment(), llvm::TargetTransformInfo::getGatherScatterOpCost(), llvm::TargetTransformInfo::getInterleavedMemoryOpCost(), llvm::getLoadStoreAddressSpace(), llvm::getLoadStoreAlignment(), llvm::getLoadStorePointerOperand(), llvm::TargetTransformInfo::getMaskedMemoryOpCost(), getMemInstValueType(), llvm::TargetTransformInfo::getMemoryOpCost(), llvm::TargetTransformInfo::getNumberOfParts(), llvm::Instruction::getOpcode(), llvm::User::getOperand(), llvm::LoadInst::getPointerAddressSpace(), getReciprocalPredBlockProb(), getScalarizationOverhead(), llvm::Type::getScalarType(), llvm::PredicatedScalarEvolution::getSE(), llvm::TargetTransformInfo::getShuffleCost(), llvm::Value::getType(), llvm::LoopVectorizationLegality::hasStride(), I, llvm::LoopVectorizationLegality::isConsecutivePtr(), llvm::LoopVectorizationLegality::isMaskRequired(), llvm::Type::isVectorTy(), llvm::InnerLoopVectorizer::Legal, llvm::InnerLoopVectorizer::LI, llvm::SPII::Load, llvm::InnerLoopVectorizer::PSE, llvm::SmallVectorTemplateBase< T, isPodLike >::push_back(), llvm::TargetTransformInfo::SK_Broadcast, llvm::TargetTransformInfo::SK_Reverse, ToVectorTy(), llvm::InnerLoopVectorizer::TTI, and llvm::InnerLoopVectorizer::VF.

Referenced by llvm::LoopVectorizationCostModel::setCostBasedWideningDecision().

◆ largestIntegerVectorType()

static Type* largestIntegerVectorType ( Type T1,
Type T2 
)
static

◆ mayDivideByZero()

static bool mayDivideByZero ( Instruction I)
static

A helper function for checking whether an integer division-related instruction may divide by zero (in which case it must be predicated if executed conditionally in the scalar code).

TODO: It may be worthwhile to generalize and check isKnownNonZero(). Non-zero divisors that are non compile-time constants will not be converted into multiplication, so we will still end up scalarizing the division, but can do so w/o predication.

Definition at line 3711 of file LoopVectorize.cpp.

References assert(), llvm::dyn_cast(), llvm::Instruction::getOpcode(), llvm::User::getOperand(), and llvm::ConstantInt::isZero().

Referenced by llvm::LoopVectorizationCostModel::isScalarWithPredication().

◆ processLoopInVPlanNativePath()

static bool processLoopInVPlanNativePath ( Loop L,
PredicatedScalarEvolution PSE,
LoopInfo LI,
DominatorTree DT,
LoopVectorizationLegality LVL,
TargetTransformInfo TTI,
TargetLibraryInfo TLI,
DemandedBits DB,
AssumptionCache AC,
OptimizationRemarkEmitter ORE,
LoopVectorizeHints Hints 
)
static

◆ smallestIntegerVectorType()

static Type* smallestIntegerVectorType ( Type T1,
Type T2 
)
static

◆ STATISTIC() [1/2]

STATISTIC ( LoopsVectorized  ,
"Number of loops vectorized"   
)

◆ STATISTIC() [2/2]

STATISTIC ( LoopsAnalyzed  ,
"Number of loops analyzed for vectorization"   
)

◆ ToVectorTy()

static Type* ToVectorTy ( Type Scalar,
unsigned  VF 
)
static

A helper function for converting Scalar types to vector types.

If the incoming type is void, we return void. If the VF is 1, we return the scalar type.

Definition at line 257 of file LoopVectorize.cpp.

References llvm::VectorType::get(), and llvm::Type::isVoidTy().

Referenced by llvm::LoopVectorizationCostModel::collectInstsToScalarize(), getScalarizationOverhead(), getVectorCallCost(), llvm::LoopVectorizationCostModel::isOptimizableIVTruncate(), isStrideMul(), llvm::LoopVectorizationCostModel::setCostBasedWideningDecision(), and llvm::InnerLoopVectorizer::widenInstruction().

Variable Documentation

◆ EnableCondStoresVectorization

cl::opt<bool> EnableCondStoresVectorization("enable-cond-stores-vec", cl::init(true), cl::Hidden, cl::desc("Enable if predication of stores during vectorization."))
static

◆ EnableIndVarRegisterHeur

cl::opt<bool> EnableIndVarRegisterHeur("enable-ind-var-reg-heur", cl::init(true), cl::Hidden, cl::desc("Count the induction variable only once when interleaving"))
static

◆ EnableInterleavedMemAccesses

cl::opt<bool> EnableInterleavedMemAccesses("enable-interleaved-mem-accesses", cl::init(false), cl::Hidden, cl::desc("Enable vectorization on interleaved memory accesses in a loop"))
static

◆ EnableLoadStoreRuntimeInterleave

cl::opt<bool> EnableLoadStoreRuntimeInterleave("enable-loadstore-runtime-interleave", cl::init(true), cl::Hidden, cl::desc( "Enable runtime interleaving until load/store ports are saturated"))
static

◆ EnableVPlanNativePath

cl::opt<bool> EnableVPlanNativePath("enable-vplan-native-path", cl::init(false), cl::Hidden, cl::desc("Enable VPlan-native vectorization path with " "support for outer loop vectorization."))

◆ ForceTargetInstructionCost

cl::opt<unsigned> ForceTargetInstructionCost("force-target-instruction-cost", cl::init(0), cl::Hidden, cl::desc("A flag that overrides the target's expected cost for " "an instruction to a single constant value. Mostly " "useful for getting consistent testing."))
static

◆ ForceTargetMaxScalarInterleaveFactor

cl::opt<unsigned> ForceTargetMaxScalarInterleaveFactor("force-target-max-scalar-interleave", cl::init(0), cl::Hidden, cl::desc("A flag that overrides the target's max interleave factor for " "scalar loops."))
static

◆ ForceTargetMaxVectorInterleaveFactor

cl::opt<unsigned> ForceTargetMaxVectorInterleaveFactor("force-target-max-vector-interleave", cl::init(0), cl::Hidden, cl::desc("A flag that overrides the target's max interleave factor for " "vectorized loops."))
static

◆ ForceTargetNumScalarRegs

cl::opt<unsigned> ForceTargetNumScalarRegs("force-target-num-scalar-regs", cl::init(0), cl::Hidden, cl::desc("A flag that overrides the target's number of scalar registers."))
static

◆ ForceTargetNumVectorRegs

cl::opt<unsigned> ForceTargetNumVectorRegs("force-target-num-vector-regs", cl::init(0), cl::Hidden, cl::desc("A flag that overrides the target's number of vector registers."))
static

◆ LoopVectorizeWithBlockFrequency

cl::opt<bool> LoopVectorizeWithBlockFrequency("loop-vectorize-with-block-frequency", cl::init(true), cl::Hidden, cl::desc("Enable the use of the block frequency analysis to access PGO " "heuristics minimizing code growth in cold regions and being more " "aggressive in hot regions."))
static

◆ lv_name

const char lv_name[] = "Loop Vectorization"
static

Definition at line 5783 of file LoopVectorize.cpp.

◆ MaximizeBandwidth

cl::opt<bool> MaximizeBandwidth("vectorizer-maximize-bandwidth", cl::init(false), cl::Hidden, cl::desc("Maximize bandwidth when selecting vectorization factor which " "will be determined by the smallest type in loop."))
static

◆ MaxNestedScalarReductionIC

cl::opt<unsigned> MaxNestedScalarReductionIC("max-nested-scalar-reduction-interleave", cl::init(2), cl::Hidden, cl::desc("The maximum interleave count to use when interleaving a scalar " "reduction in a nested loop."))
static

◆ NumberOfStoresToPredicate

cl::opt<unsigned> NumberOfStoresToPredicate("vectorize-num-stores-pred", cl::init(1), cl::Hidden, cl::desc("Max number of stores to be predicated behind an if."))
static

The number of stores in a loop that are allowed to need predication.

Referenced by llvm::LoopVectorizationCostModel::calculateRegisterUsage().

◆ SmallLoopCost

cl::opt<unsigned> SmallLoopCost("small-loop-cost", cl::init(20), cl::Hidden, cl::desc( "The cost of a loop that is considered 'small' by the interleaver."))
static

◆ TinyTripCountInterleaveThreshold

const unsigned TinyTripCountInterleaveThreshold = 128
static

We don't interleave loops with a known constant trip count below this number.

Definition at line 177 of file LoopVectorize.cpp.

◆ TinyTripCountVectorThreshold

cl::opt<unsigned> TinyTripCountVectorThreshold("vectorizer-min-trip-count", cl::init(16), cl::Hidden, cl::desc("Loops with a constant trip count that is smaller than this " "value are vectorized only if no scalar iteration overheads " "are incurred."))
static

Loops with a known constant trip count below this number are vectorized only if no scalar iteration overheads are incurred.

Referenced by llvm::LoopVectorizePass::processLoop().

◆ VPlanBuildStressTest

cl::opt<bool> VPlanBuildStressTest("vplan-build-stress-test", cl::init(false), cl::Hidden, cl::desc( "Build VPlan for every supported loop nest in the function and bail " "out right after the build (stress test the VPlan H-CFG construction " "in the VPlan-native vectorization path)."))
static