llvm::InnerLoopUnroller Class Reference

Inheritance diagram for llvm::InnerLoopUnroller:

Collaboration diagram for llvm::InnerLoopUnroller:

Public Member Functions
	InnerLoopUnroller (Loop *OrigLoop, PredicatedScalarEvolution &PSE, LoopInfo *LI, DominatorTree *DT, const TargetLibraryInfo *TLI, const TargetTransformInfo *TTI, AssumptionCache *AC, OptimizationRemarkEmitter *ORE, unsigned UnrollFactor, LoopVectorizationLegality *LVL, LoopVectorizationCostModel *CM, BlockFrequencyInfo *BFI, ProfileSummaryInfo *PSI, GeneratedRTChecks &Check)
Public Member Functions inherited from llvm::InnerLoopVectorizer
	InnerLoopVectorizer (Loop *OrigLoop, PredicatedScalarEvolution &PSE, LoopInfo *LI, DominatorTree *DT, const TargetLibraryInfo *TLI, const TargetTransformInfo *TTI, AssumptionCache *AC, OptimizationRemarkEmitter *ORE, ElementCount VecWidth, ElementCount MinProfitableTripCount, unsigned UnrollFactor, LoopVectorizationLegality *LVL, LoopVectorizationCostModel *CM, BlockFrequencyInfo *BFI, ProfileSummaryInfo *PSI, GeneratedRTChecks &RTChecks)
virtual	~InnerLoopVectorizer ()=default
virtual std::pair< BasicBlock *, Value * >	createVectorizedLoopSkeleton ()
	Create a new empty loop that will contain vectorized instructions later on, while the old loop will be used as the scalar remainder.
void	fixVectorizedLoop (VPTransformState &State, VPlan &Plan)
	Fix the vectorized code, taking care of header phi's, live-outs, and more.
bool	areSafetyChecksAdded ()
void	scalarizeInstruction (const Instruction *Instr, VPReplicateRecipe *RepRecipe, const VPIteration &Instance, VPTransformState &State)
	A helper function to scalarize a single Instruction in the innermost loop.
void	packScalarIntoVectorValue (VPValue *Def, const VPIteration &Instance, VPTransformState &State)
	Construct the vector value of a scalarized value V one lane at a time.
void	vectorizeInterleaveGroup (const InterleaveGroup< Instruction > *Group, ArrayRef< VPValue * > VPDefs, VPTransformState &State, VPValue *Addr, ArrayRef< VPValue * > StoredValues, VPValue *BlockInMask=nullptr)
	Try to vectorize interleaved access group Group with the base address given in Addr, optionally masking the vector operations if BlockInMask is non-null.
void	fixNonInductionPHIs (VPlan &Plan, VPTransformState &State)
	Fix the non-induction PHIs in Plan.
bool	useOrderedReductions (const RecurrenceDescriptor &RdxDesc)
	Returns true if the reordering of FP operations is not allowed, but we are able to vectorize with strict in-order reductions for the given RdxDesc.
virtual Value *	getBroadcastInstrs (Value *V)
	Create a broadcast instruction.
PHINode *	getReductionResumeValue (const RecurrenceDescriptor &RdxDesc)
PHINode *	createInductionResumeValue (PHINode *OrigPhi, const InductionDescriptor &ID, ArrayRef< BasicBlock * > BypassBlocks, std::pair< BasicBlock *, Value * > AdditionalBypass={nullptr, nullptr})
	Create a new phi node for the induction variable OrigPhi to resume iteration count in the scalar epilogue, from where the vectorized loop left off.

Additional Inherited Members
Public Types inherited from llvm::InnerLoopVectorizer
using	VectorParts = SmallVector< Value *, 2 >
	A type for vectorized values in the new loop.
Protected Types inherited from llvm::InnerLoopVectorizer
using	PhiVector = SmallVector< PHINode *, 4 >
	A small list of PHINodes.
using	ScalarParts = SmallVector< SmallVector< Value *, 4 >, 2 >
	A type for scalarized values in the new loop.
Protected Member Functions inherited from llvm::InnerLoopVectorizer
void	fixupIVUsers (PHINode *OrigPhi, const InductionDescriptor &II, Value *VectorTripCount, Value *EndValue, BasicBlock *MiddleBlock, BasicBlock *VectorHeader, VPlan &Plan)
	Set up the values of the IVs correctly when exiting the vector loop.
void	fixCrossIterationPHIs (VPTransformState &State)
	Handle all cross-iteration phis in the header.
void	fixFixedOrderRecurrence (VPFirstOrderRecurrencePHIRecipe *PhiR, VPTransformState &State)
	Create the exit value of first order recurrences in the middle block and update their users.
void	fixReduction (VPReductionPHIRecipe *Phi, VPTransformState &State)
	Create code for the loop exit value of the reduction.
void	clearReductionWrapFlags (VPReductionPHIRecipe *PhiR, VPTransformState &State)
	Clear NSW/NUW flags from reduction instructions if necessary.
void	sinkScalarOperands (Instruction *PredInst)
	Iteratively sink the scalarized operands of a predicated instruction into the block that was created for it.
void	truncateToMinimalBitwidths (VPTransformState &State)
	Shrinks vector element sizes to the smallest bitwidth they can be legally represented as.
Value *	getOrCreateTripCount (BasicBlock *InsertBlock)
	Returns (and creates if needed) the original loop trip count.
Value *	getOrCreateVectorTripCount (BasicBlock *InsertBlock)
	Returns (and creates if needed) the trip count of the widened loop.
Value *	createBitOrPointerCast (Value *V, VectorType *DstVTy, const DataLayout &DL)
	Returns a bitcasted value to the requested vector type.
void	emitIterationCountCheck (BasicBlock *Bypass)
	Emit a bypass check to see if the vector trip count is zero, including if it overflows.
BasicBlock *	emitSCEVChecks (BasicBlock *Bypass)
	Emit a bypass check to see if all of the SCEV assumptions we've had to make are correct.
BasicBlock *	emitMemRuntimeChecks (BasicBlock *Bypass)
	Emit bypass checks to check any memory assumptions we may have made.
void	createVectorLoopSkeleton (StringRef Prefix)
	Emit basic blocks (prefixed with Prefix) for the iteration check, vector loop preheader, middle block and scalar preheader.
void	createInductionResumeValues (std::pair< BasicBlock *, Value * > AdditionalBypass={nullptr, nullptr})
	Create new phi nodes for the induction variables to resume iteration count in the scalar epilogue, from where the vectorized loop left off.
BasicBlock *	completeLoopSkeleton ()
	Complete the loop skeleton by adding debug MDs, creating appropriate conditional branches in the middle block, preparing the builder and running the verifier.
void	collectPoisonGeneratingRecipes (VPTransformState &State)
	Collect poison-generating recipes that may generate a poison value that is used after vectorization, even when their operands are not poison.
virtual void	printDebugTracesAtStart ()
	Allow subclasses to override and print debug traces before/after vplan execution, when trace information is requested.
virtual void	printDebugTracesAtEnd ()
Protected Attributes inherited from llvm::InnerLoopVectorizer
Loop *	OrigLoop
	The original loop.
PredicatedScalarEvolution &	PSE
	A wrapper around ScalarEvolution used to add runtime SCEV checks.
LoopInfo *	LI
	Loop Info.
DominatorTree *	DT
	Dominator Tree.
const TargetLibraryInfo *	TLI
	Target Library Info.
const TargetTransformInfo *	TTI
	Target Transform Info.
AssumptionCache *	AC
	Assumption Cache.
OptimizationRemarkEmitter *	ORE
	Interface to emit optimization remarks.
ElementCount	VF
	The vectorization SIMD factor to use.
ElementCount	MinProfitableTripCount
unsigned	UF
	The vectorization unroll factor to use.
IRBuilder	Builder
	The builder that we use.
BasicBlock *	LoopVectorPreHeader
	The vector-loop preheader.
BasicBlock *	LoopScalarPreHeader
	The scalar-loop preheader.
BasicBlock *	LoopMiddleBlock
	Middle Block between the vector and the scalar.
BasicBlock *	LoopExitBlock
	The unique ExitBlock of the scalar loop if one exists.
BasicBlock *	LoopScalarBody
	The scalar loop body.
SmallVector< BasicBlock *, 4 >	LoopBypassBlocks
	A list of all bypass blocks. The first block is the entry of the loop.
SmallVector< Instruction *, 4 >	PredicatedInstructions
	Store instructions that were predicated.
Value *	TripCount = nullptr
	Trip count of the original loop.
Value *	VectorTripCount = nullptr
	Trip count of the widened loop (TripCount - TripCount % (VF*UF))
LoopVectorizationLegality *	Legal
	The legality analysis.
LoopVectorizationCostModel *	Cost
	The profitablity analysis.
bool	AddedSafetyChecks = false
DenseMap< PHINode *, Value * >	IVEndValues
BlockFrequencyInfo *	BFI
	BFI and PSI are used to check for profile guided size optimizations.
ProfileSummaryInfo *	PSI
bool	OptForSizeBasedOnProfile
GeneratedRTChecks &	RTChecks
	Structure to hold information about generated runtime checks, responsible for cleaning the checks, if vectorization turns out unprofitable.
SmallMapVector< const RecurrenceDescriptor *, PHINode *, 4 >	ReductionResumeValues

Detailed Description

Definition at line 769 of file LoopVectorize.cpp.

Constructor & Destructor Documentation

InnerLoopUnroller()

llvm::InnerLoopUnroller::InnerLoopUnroller ( Loop *  OrigLoop, PredicatedScalarEvolution &  PSE, LoopInfo *  LI, DominatorTree *  DT, const TargetLibraryInfo *  TLI, const TargetTransformInfo *  TTI, AssumptionCache *  AC, OptimizationRemarkEmitter *  ORE, unsigned  UnrollFactor, LoopVectorizationLegality *  LVL, LoopVectorizationCostModel *  CM, BlockFrequencyInfo *  BFI, ProfileSummaryInfo *  PSI, GeneratedRTChecks &  Check  )

inline

Definition at line 771 of file LoopVectorize.cpp.

References Check.

---

The documentation for this class was generated from the following file:

• lib/Transforms/Vectorize/LoopVectorize.cpp