LLVM: llvm::LoopBase< BlockT, LoopT > Class Template Reference (original) (raw)
Instances of this class are used to represent loops that are detected in the flow graph. More...
#include "[llvm/Support/GenericLoopInfo.h](GenericLoopInfo%5F8h%5Fsource.html)"
| Public Types | |
|---|---|
| typedef std::vector< LoopT * >::const_iterator | iterator |
| typedef std::vector< LoopT * >::const_reverse_iterator | reverse_iterator |
| typedef ArrayRef< BlockT * >::const_iterator | block_iterator |
| typedef std::pair< BlockT *, BlockT * > | Edge |
| Edge type. | |
| Public Member Functions | |
|---|---|
| unsigned | getLoopDepth () const |
| Return the nesting level of this loop. | |
| BlockT * | getHeader () const |
| LoopT * | getParentLoop () const |
| Return the parent loop if it exists or nullptr for top level loops. | |
| const LoopT * | getOutermostLoop () const |
| Get the outermost loop in which this loop is contained. | |
| LoopT * | getOutermostLoop () |
| void | setParentLoop (LoopT *L) |
| This is a raw interface for bypassing addChildLoop. | |
| bool | contains (const LoopT *L) const |
| Return true if the specified loop is contained within in this loop. | |
| bool | contains (const BlockT *BB) const |
| Return true if the specified basic block is in this loop. | |
| template | |
| bool | contains (const InstT *Inst) const |
| Return true if the specified instruction is in this loop. | |
| const std::vector< LoopT * > & | getSubLoops () const |
| Return the loops contained entirely within this loop. | |
| std::vector< LoopT * > & | getSubLoopsVector () |
| iterator | begin () const |
| iterator | end () const |
| reverse_iterator | rbegin () const |
| reverse_iterator | rend () const |
| bool | isInnermost () const |
| Return true if the loop does not contain any (natural) loops. | |
| bool | isOutermost () const |
| Return true if the loop does not have a parent (natural) loop. | |
| ArrayRef< BlockT * > | getBlocks () const |
| Get a list of the basic blocks which make up this loop. | |
| block_iterator | block_begin () const |
| block_iterator | block_end () const |
| iterator_range< block_iterator > | blocks () const |
| unsigned | getNumBlocks () const |
| Get the number of blocks in this loop in constant time. | |
| std::vector< BlockT * > & | getBlocksVector () |
| Return a direct, mutable handle to the blocks vector so that we can mutate it efficiently with techniques like std::remove. | |
| SmallPtrSetImpl< const BlockT * > & | getBlocksSet () |
| Return a direct, mutable handle to the blocks set so that we can mutate it efficiently. | |
| const SmallPtrSetImpl< const BlockT * > & | getBlocksSet () const |
| Return a direct, immutable handle to the blocks set. | |
| bool | isInvalid () const |
| Return true if this loop is no longer valid. | |
| bool | isLoopExiting (const BlockT *BB) const |
| True if terminator in the block can branch to another block that is outside of the current loop. | |
| bool | isLoopLatch (const BlockT *BB) const |
| unsigned | getNumBackEdges () const |
| Calculate the number of back edges to the loop header. | |
| void | getExitingBlocks (SmallVectorImpl< BlockT * > &ExitingBlocks) const |
| Return all blocks inside the loop that have successors outside of the loop. | |
| BlockT * | getExitingBlock () const |
| If getExitingBlocks would return exactly one block, return that block. | |
| void | getExitBlocks (SmallVectorImpl< BlockT * > &ExitBlocks) const |
| Return all of the successor blocks of this loop. | |
| BlockT * | getExitBlock () const |
| If getExitBlocks would return exactly one block, return that block. | |
| bool | hasDedicatedExits () const |
| Return true if no exit block for the loop has a predecessor that is outside the loop. | |
| void | getUniqueExitBlocks (SmallVectorImpl< BlockT * > &ExitBlocks) const |
| Return all unique successor blocks of this loop. | |
| void | getUniqueNonLatchExitBlocks (SmallVectorImpl< BlockT * > &ExitBlocks) const |
| Return all unique successor blocks of this loop except successors from Latch block are not considered. | |
| BlockT * | getUniqueExitBlock () const |
| If getUniqueExitBlocks would return exactly one block, return that block. | |
| BlockT * | getUniqueLatchExitBlock () const |
| Return the unique exit block for the latch, or null if there are multiple different exit blocks or the latch is not exiting. | |
| bool | hasNoExitBlocks () const |
| Return true if this loop does not have any exit blocks. | |
| void | getExitEdges (SmallVectorImpl< Edge > &ExitEdges) const |
| Return all pairs of (inside_block,outside_block). | |
| BlockT * | getLoopPreheader () const |
| If there is a preheader for this loop, return it. | |
| BlockT * | getLoopPredecessor () const |
| If the given loop's header has exactly one unique predecessor outside the loop, return it. | |
| BlockT * | getLoopLatch () const |
| If there is a single latch block for this loop, return it. | |
| void | getLoopLatches (SmallVectorImpl< BlockT * > &LoopLatches) const |
| Return all loop latch blocks of this loop. | |
| SmallVector< const LoopT *, 4 > | getLoopsInPreorder () const |
| Return all loops in the loop nest rooted by the loop in preorder, with siblings in forward program order. | |
| SmallVector< LoopT *, 4 > | getLoopsInPreorder () |
| void | addBasicBlockToLoop (BlockT *NewBB, LoopInfoBase< BlockT, LoopT > &LI) |
| This method is used by other analyses to update loop information. | |
| void | replaceChildLoopWith (LoopT *OldChild, LoopT *NewChild) |
| This is used when splitting loops up. | |
| void | addChildLoop (LoopT *NewChild) |
| Add the specified loop to be a child of this loop. | |
| LoopT * | removeChildLoop (iterator I) |
| This removes the specified child from being a subloop of this loop. | |
| LoopT * | removeChildLoop (LoopT *Child) |
| This removes the specified child from being a subloop of this loop. | |
| void | addBlockEntry (BlockT *BB) |
| This adds a basic block directly to the basic block list. | |
| void | reverseBlock (unsigned from) |
| interface to reverse Blocks[from, end of loop] in this loop | |
| void | reserveBlocks (unsigned size) |
| interface to do reserve() for Blocks | |
| void | moveToHeader (BlockT *BB) |
| This method is used to move BB (which must be part of this loop) to be the loop header of the loop (the block that dominates all others). | |
| void | removeBlockFromLoop (BlockT *BB) |
| This removes the specified basic block from the current loop, updating the Blocks as appropriate. | |
| void | verifyLoop () const |
| Verify loop structure. | |
| void | verifyLoopNest (DenseSet< const LoopT * > *Loops) const |
| Verify loop structure of this loop and all nested loops. | |
| bool | isAnnotatedParallel () const |
| Returns true if the loop is annotated parallel. | |
| void | print (raw_ostream &OS, bool Verbose=false, bool PrintNested=true, unsigned Depth=0) const |
| Print loop with all the BBs inside it. | |
| Static Public Member Functions | |
|---|---|
| template<class Type > | |
| static void | getInnerLoopsInPreorder (const LoopT &L, SmallVectorImpl< Type > &PreOrderLoops) |
| Return all inner loops in the loop nest rooted by the loop in preorder, with siblings in forward program order. | |
| Protected Member Functions |
|---|
template<class BlockT, class LoopT>
class llvm::LoopBase< BlockT, LoopT >
Instances of this class are used to represent loops that are detected in the flow graph.
Definition at line 59 of file GenericLoopInfo.h.
◆ block_iterator
template<class BlockT , class LoopT >
◆ Edge
template<class BlockT , class LoopT >
typedef std::pair<BlockT *, BlockT *> llvm::LoopBase< BlockT, LoopT >::Edge
◆ iterator
template<class BlockT , class LoopT >
◆ reverse_iterator
template<class BlockT , class LoopT >
typedef std::vector<LoopT*>::const_reverse_iterator llvm::LoopBase< BlockT, LoopT >::reverse_iterator
◆ LoopBase() [1/2]
template<class BlockT , class LoopT >
◆ LoopBase() [2/2]
template<class BlockT , class LoopT >
| llvm::LoopBase< BlockT, LoopT >::LoopBase ( BlockT * BB) | inlineexplicitprotected |
|---|
template<class BlockT , class LoopT >
◆ addBasicBlockToLoop()
template<class BlockT , class LoopT >
| void llvm::LoopBase< BlockT, LoopT >::addBasicBlockToLoop | ( | BlockT * | NewBB, |
|---|---|---|---|
| LoopInfoBase< BlockT, LoopT > & | LIB | ||
| ) |
◆ addBlockEntry()
template<class BlockT , class LoopT >
| void llvm::LoopBase< BlockT, LoopT >::addBlockEntry ( BlockT * BB) | inline |
|---|
◆ addChildLoop()
template<class BlockT , class LoopT >
| void llvm::LoopBase< BlockT, LoopT >::addChildLoop ( LoopT * NewChild) | inline |
|---|
Add the specified loop to be a child of this loop.
This updates the loop depth of the new child.
Definition at line 391 of file GenericLoopInfo.h.
References assert(), and llvm::LoopBase< BlockT, LoopT >::isInvalid().
Referenced by llvm::addClonedBlockToLoopInfo(), buildClonedLoops(), cloneLoopNest(), llvm::cloneLoopWithPreheader(), llvm::TileInfo::CreateTiledLoops(), llvm::VPRegionBlock::execute(), hoistLoopToNewParent(), rebuildLoopAfterUnswitch(), separateNestedLoop(), and updateLoopInfo().
◆ begin()
template<class BlockT , class LoopT >
◆ block_begin()
template<class BlockT , class LoopT >
◆ block_end()
template<class BlockT , class LoopT >
◆ blocks()
template<class BlockT , class LoopT >
Definition at line 180 of file GenericLoopInfo.h.
References assert(), llvm::LoopBase< BlockT, LoopT >::block_begin(), llvm::LoopBase< BlockT, LoopT >::block_end(), llvm::LoopBase< BlockT, LoopT >::isInvalid(), and llvm::make_range().
Referenced by buildClonedLoops(), llvm::LoopVectorizationLegality::canFoldTailByMasking(), cloneLoopNest(), llvm::LoopVectorizationCostModel::collectElementTypesForWidening(), llvm::LoopVectorizationCostModel::collectInstsToScalarize(), llvm::SimpleLoopSafetyInfo::computeLoopSafetyInfo(), llvm::ICFLoopSafetyInfo::computeLoopSafetyInfo(), containsDecreasingPointers(), llvm::LoopInfo::erase(), llvm::LoopVectorizationCostModel::expectedCost(), planContainsAdditionalSimplifications(), llvm::AArch64TTIImpl::preferPredicateOverEpilogue(), llvm::LoopVectorizationLegality::prepareToFoldTailByMasking(), llvm::LoopVectorizationCostModel::selectInterleaveCount(), llvm::LoopVectorizationCostModel::setCostBasedWideningDecision(), llvm::LoopVectorizationCostModel::setVectorizedCallDecision(), and llvm::MemorySSA::verifyMemorySSA().
◆ contains() [1/3]
template<class BlockT , class LoopT >
◆ contains() [2/3]
template<class BlockT , class LoopT >
template
◆ contains() [3/3]
template<class BlockT , class LoopT >
Return true if the specified loop is contained within in this loop.
Definition at line 124 of file GenericLoopInfo.h.
References assert(), llvm::LoopBase< BlockT, LoopT >::contains(), and llvm::LoopBase< BlockT, LoopT >::isInvalid().
Referenced by llvm::RecurrenceDescriptor::AddReductionVar(), llvm::LoopSafetyInfo::allLoopPathsLeadToBlock(), llvm::LoopAccessInfo::blockNeedsPredication(), buildClonedLoops(), llvm::LoopVectorizationCostModel::calculateRegisterUsage(), llvm::LoopVectorizationLegality::canFoldTailByMasking(), CanProveNotTakenFirstIteration(), llvm::canSinkOrHoistInst(), collectCastInstrs(), llvm::collectChildrenInLoop(), collectTransitivePredecessors(), llvm::LoopVectorizationCostModel::collectValuesToIgnore(), ConnectProlog(), llvm::LoopBase< BlockT, LoopT >::contains(), llvm::VPRecipeBuilder::createBlockInMask(), llvm::ICFLoopSafetyInfo::doesNotWriteMemoryBefore(), llvm::ScalarEvolution::getAddRecExpr(), getInnermostLoopFor(), llvm::LoopVectorizationCostModel::getInstructionCost(), llvm::getLoopConvergenceHeart(), llvm::LoopBase< BlockT, LoopT >::getLoopLatches(), llvm::LoopBase< BlockT, LoopT >::getNumBackEdges(), getSingleSchedPred(), llvm::VPlanTransforms::handleUncountableEarlyExit(), llvm::hasOutsideLoopUser(), hoistLoopToNewParent(), inSubLoop(), llvm::RecurrenceDescriptor::isFixedOrderRecurrence(), isFoldableInLoop(), llvm::InductionDescriptor::isFPInductionPHI(), llvm::HardwareLoopInfo::isHardwareLoopCandidate(), llvm::LoopBase< BlockT, LoopT >::isLoopExiting(), llvm::LoopBase< BlockT, LoopT >::isLoopLatch(), isNotUsedOrFoldableInLoop(), llvm::isSafeToUnrollAndJam(), llvm::isUniformLoop(), llvm::LPPassManager::markLoopAsDeleted(), llvm::LPMUpdater::markLoopAsDeleted(), needToInsertPhisForLCSSA(), partitionLoopBlocks(), pointerInvalidatedByLoop(), llvm::promoteLoopAccessesToScalars(), rebuildLoopAfterUnswitch(), removeBlockFromLoops(), llvm::LoopInfo::replacementPreservesLCSSAForm(), llvm::LoopVectorizationCostModel::setCostBasedWideningDecision(), llvm::LoopVectorizationCostModel::shouldConsiderInvariant(), sink(), splitPredecessorsOfLoopExit(), llvm::UnrollAndJamLoop(), llvm::UnrollLoop(), unswitchNontrivialInvariants(), unswitchTrivialSwitch(), visitPointers(), and llvm::LoopBlocksTraversal::visitPreorder().
◆ end()
template<class BlockT , class LoopT >
◆ getBlocks()
template<class BlockT , class LoopT >
Get a list of the basic blocks which make up this loop.
Definition at line 173 of file GenericLoopInfo.h.
References assert(), Blocks, and llvm::LoopBase< BlockT, LoopT >::isInvalid().
Referenced by llvm::LoopBase< BlockT, LoopT >::block_begin(), llvm::LoopBase< BlockT, LoopT >::block_end(), llvm::canSinkOrHoistInst(), llvm::cloneLoopWithPreheader(), llvm::SimpleLoopSafetyInfo::computeLoopSafetyInfo(), computeUnrollAndJamCount(), llvm::LoopBase< BlockT, LoopT >::getHeader(), pointerInvalidatedByLoop(), and llvm::UnrollRuntimeLoopRemainder().
◆ getBlocksSet() [1/2]
template<class BlockT , class LoopT >
◆ getBlocksSet() [2/2]
template<class BlockT , class LoopT >
◆ getBlocksVector()
template<class BlockT , class LoopT >
| std::vector< BlockT * > & llvm::LoopBase< BlockT, LoopT >::getBlocksVector ( ) | inline |
|---|
◆ getExitBlock()
template<class BlockT , class LoopT >
◆ getExitBlocks()
◆ getExitEdges()
◆ getExitingBlock()
template<class BlockT , class LoopT >
If getExitingBlocks would return exactly one block, return that block.
getExitingBlock - If getExitingBlocks would return exactly one block, return that block.
Otherwise return null.
Definition at line 48 of file GenericLoopInfoImpl.h.
References llvm::any_of(), assert(), blocks, contains(), and isExitBlock().
Referenced by llvm::LoopVectorizationLegality::canVectorize(), checkLoopsStructure(), llvm::LoopVectorizationCostModel::computeMaxVF(), llvm::LoopVectorizationCostModel::requiresScalarEpilogue(), llvm::splitLoopBound(), and llvm::UnrollAndJamLoop().
◆ getExitingBlocks()
template<class BlockT , class LoopT >
| void llvm::LoopBase< BlockT, LoopT >::getExitingBlocks | ( | SmallVectorImpl< BlockT * > & | ExitingBlocks | ) | const |
|---|
◆ getHeader()
template<class BlockT , class LoopT >
Definition at line 90 of file GenericLoopInfo.h.
References llvm::LoopBase< BlockT, LoopT >::getBlocks().
Referenced by llvm::addClonedBlockToLoopInfo(), llvm::BlockFrequencyInfoImplBase::addLoopSuccessorsToDist(), llvm::RecurrenceDescriptor::AddReductionVar(), llvm::addStringMetadataToLoop(), llvm::LoopSafetyInfo::allLoopPathsLeadToBlock(), llvm::LoopVersioning::annotateInstWithNoAlias(), llvm::LoopBlocksTraversal::begin(), buildClonedLoops(), CanProveNotTakenFirstIteration(), llvm::LoopVectorizationLegality::canVectorize(), checkLoopsStructure(), llvm::cloneLoopWithPreheader(), collectTransitivePredecessors(), llvm::LoopVectorizationCostModel::collectValuesToIgnore(), CompareSCEVComplexity(), llvm::LoopSafetyInfo::computeBlockColors(), llvm::SimpleLoopSafetyInfo::computeLoopSafetyInfo(), llvm::VPRecipeBuilder::createBlockInMask(), llvm::VPRecipeBuilder::createHeaderMask(), createStringMetadata(), llvm::VPRecipeBuilder::createSwitchEdgeMasks(), detectShiftUntilBitTestIdiom(), detectShiftUntilZeroIdiom(), llvm::ICFLoopSafetyInfo::doesNotWriteMemoryBefore(), emitBasicBlockLoopComments(), llvm::InnerLoopVectorizer::emitMemRuntimeChecks(), llvm::LoopVectorizeHints::emitRemarkWithHints(), llvm::LoopBlocksTraversal::end(), llvm::SystemZPostRASchedStrategy::enterMBB(), llvm::VPReductionPHIRecipe::execute(), llvm::LoopVectorizationPlanner::executePlan(), llvm::ScalarEvolution::getAddExpr(), llvm::ScalarEvolution::getAddRecExpr(), llvm::LoopVectorizationCostModel::getInstructionCost(), llvm::LoopNest::getInterveningInstructions(), llvm::getLoopConvergenceHeart(), llvm::LoopBase< BlockT, LoopT >::getLoopLatches(), llvm::BlockFrequencyInfoImplBase::getLoopName(), llvm::LoopBase< BlockT, LoopT >::getNumBackEdges(), llvm::getPtrStride(), getSingleSchedPred(), getStartAndEndForAccess(), llvm::HardwareLoopInfo::HardwareLoopInfo(), llvm::InnerLoopVectorizer::InnerLoopVectorizer(), llvm::ScalarEvolution::isBasicBlockEntryGuardedByCond(), llvm::LoopVectorizationLegality::isConsecutivePtr(), isExistingPhi(), isExplicitVecOuterLoop(), llvm::RecurrenceDescriptor::isFixedOrderRecurrence(), llvm::InductionDescriptor::isFPInductionPHI(), llvm::SimpleLoopSafetyInfo::isGuaranteedToExecute(), llvm::HardwareLoopInfo::isHardwareLoopCandidate(), llvm::InductionDescriptor::isInductionPHI(), llvm::ScalarEvolution::isKnownViaInduction(), isLoadInvariantInLoop(), llvm::LoopBase< BlockT, LoopT >::isLoopLatch(), llvm::RecurrenceDescriptor::isReductionPHI(), llvm::LoopVectorizationPlanner::plan(), pointerInvalidatedByLoop(), llvm::LoopVersioning::prepareNoAliasMetadata(), llvm::MemorySSA::print(), llvm::SCEV::print(), llvm::IVUsers::print(), llvm::EpilogueVectorizerMainLoop::printDebugTracesAtEnd(), llvm::EpilogueVectorizerEpilogueLoop::printDebugTracesAtEnd(), PrintParentLoopComment(), removeBlockFromLoops(), llvm::reportVectorization(), llvm::LPPassManager::runOnFunction(), llvm::SwingSchedulerDAG::schedule(), llvm::LoopVectorizationPlanner::selectEpilogueVectorizationFactor(), llvm::LoopVectorizeHints::setAlreadyVectorized(), llvm::LoopVectorizationCostModel::shouldConsiderInvariant(), llvm::splitLoopBound(), llvm::VPRecipeBuilder::tryToCreateWidenRecipe(), llvm::UnrollAndJamLoop(), updateLoopInfo(), llvm::MachineTraceMetrics::Ensemble::verify(), llvm::LoopVersioning::versionLoop(), and visitPointers().
◆ getInnerLoopsInPreorder()
template<class BlockT , class LoopT >
template<class Type >
◆ getLoopDepth()
template<class BlockT , class LoopT >
Return the nesting level of this loop.
An outer-most loop has depth 1, for consistency with loop depth values used for basic blocks, where depth 0 is used for blocks not inside any loops.
Definition at line 82 of file GenericLoopInfo.h.
References assert(), D, and llvm::LoopBase< BlockT, LoopT >::isInvalid().
Referenced by checkDependencies(), doesContainLoop(), emitBasicBlockLoopComments(), llvm::ScalarEvolution::getAddRecExpr(), llvm::LoopNest::getInnermostLoop(), getInnerMostLoop(), getInnermostLoopFor(), PrintParentLoopComment(), llvm::LoopVectorizationCostModel::selectInterleaveCount(), and UpdateAnalysisInformation().
◆ getLoopLatch()
template<class BlockT , class LoopT >
If there is a single latch block for this loop, return it.
getLoopLatch - If there is a single latch block for this loop, return it.
A latch block is a block that contains a branch back to the header.
Definition at line 256 of file GenericLoopInfoImpl.h.
References assert(), and contains().
Referenced by areInnerLoopLatchPHIsSupported(), areOuterLoopExitPHIsSupported(), llvm::LoopVectorizationLegality::blockNeedsPredication(), llvm::LoopAccessInfo::blockNeedsPredication(), checkLoopsStructure(), collectUsersInExitBlocks(), llvm::LoopVectorizationCostModel::computeMaxVF(), llvm::VPlan::createInitialVPlan(), llvm::InnerLoopVectorizer::emitIterationCountCheck(), llvm::EpilogueVectorizerMainLoop::emitIterationCountCheck(), llvm::EpilogueVectorizerEpilogueLoop::emitMinimumVectorEpilogueIterCountCheck(), llvm::LoopVectorizationPlanner::executePlan(), expandBounds(), llvm::VPRecipeBuilder::fixHeaderPhis(), llvm::LoopVectorizationCostModel::getInstructionCost(), llvm::LoopNest::getInterveningInstructions(), getOuterLoopLatchCmp(), getReductionInstr(), llvm::hasIterationCountInvariantInParent(), llvm::RecurrenceDescriptor::isFixedOrderRecurrence(), llvm::InductionDescriptor::isInductionPHI(), llvm::isUniformLoop(), partitionLoopBlocks(), llvm::LoopVectorizationCostModel::requiresScalarEpilogue(), SplitBlockPredecessorsImpl(), tryToUnrollAndJamLoop(), llvm::UnrollAndJamLoop(), and llvm::UnrollRuntimeLoopRemainder().
◆ getLoopLatches()
template<class BlockT , class LoopT >
◆ getLoopPredecessor()
template<class BlockT , class LoopT >
If the given loop's header has exactly one unique predecessor outside the loop, return it.
getLoopPredecessor - If the given loop's header has exactly one unique predecessor outside the loop, return it.
Otherwise return null. This is less strict that the loop "preheader" concept, which requires the predecessor to have exactly one successor.
Definition at line 235 of file GenericLoopInfoImpl.h.
References assert(), and contains().
Referenced by llvm::ScalarEvolution::isBasicBlockEntryGuardedByCond().
◆ getLoopPreheader()
template<class BlockT , class LoopT >
If there is a preheader for this loop, return it.
getLoopPreheader - If there is a preheader for this loop, return it.
A loop has a preheader if there is only one edge to the header of the loop from outside of the loop. If this is the case, the block branching to the header of the loop is the preheader node.
This method returns null if there is no preheader for the loop.
A loop has a preheader if there is only one edge to the header of the loop from outside of the loop and it is legal to hoist instructions into the predecessor. If this is the case, the block branching to the header of the loop is the preheader node.
This method returns null if there is no preheader for the loop.
Definition at line 210 of file GenericLoopInfoImpl.h.
References assert(), llvm::hasSingleElement(), and llvm::detail::isLegalToHoistInto().
Referenced by llvm::RecurrenceDescriptor::AddReductionVar(), buildClonedLoops(), CanProveNotTakenFirstIteration(), checkLoopsStructure(), llvm::cloneLoopWithPreheader(), llvm::InnerLoopVectorizer::createVectorLoopSkeleton(), createWidenInductionRecipes(), detectPopcountIdiom(), detectShiftUntilBitTestIdiom(), detectShiftUntilLessThanIdiom(), detectShiftUntilZeroIdiom(), llvm::LoopVectorizationPlanner::executePlan(), llvm::PeelingModuloScheduleExpander::expand(), llvm::ModuloScheduleExpanderMVE::expand(), llvm::LoopNest::getInterveningInstructions(), llvm::hoistRegion(), llvm::RecurrenceDescriptor::isFixedOrderRecurrence(), llvm::InductionDescriptor::isInductionPHI(), partitionLoopBlocks(), llvm::promoteLoopAccessesToScalars(), llvm::LoopConstrainer::run(), llvm::splitLoopBound(), llvm::VPRecipeBuilder::tryToCreateWidenRecipe(), llvm::UnrollAndJamLoop(), llvm::PeelingModuloScheduleExpander::validateAgainstModuloScheduleExpander(), and llvm::LoopVersioning::versionLoop().
◆ getLoopsInPreorder() [1/2]
template<class BlockT , class LoopT >
◆ getLoopsInPreorder() [2/2]
template<class BlockT , class LoopT >
◆ getNumBackEdges()
template<class BlockT , class LoopT >
◆ getNumBlocks()
template<class BlockT , class LoopT >
◆ getOutermostLoop() [1/2]
template<class BlockT , class LoopT >
◆ getOutermostLoop() [2/2]
template<class BlockT , class LoopT >
Get the outermost loop in which this loop is contained.
This may be the loop itself, if it already is the outermost loop.
Definition at line 103 of file GenericLoopInfo.h.
◆ getParentLoop()
template<class BlockT , class LoopT >
| LoopT * llvm::LoopBase< BlockT, LoopT >::getParentLoop ( ) const | inline |
|---|
Return the parent loop if it exists or nullptr for top level loops.
A loop is either top-level in a function (that is, it is not contained in any other loop) or it is entirely enclosed in some other loop. If a loop is top-level, it has no parent, otherwise its parent is the innermost loop in which it is enclosed.
Definition at line 99 of file GenericLoopInfo.h.
Referenced by llvm::addClonedBlockToLoopInfo(), buildClonedLoops(), checkLoopsStructure(), llvm::cloneLoopWithPreheader(), emitBasicBlockLoopComments(), llvm::LoopInfo::erase(), llvm::LoopVectorizationPlanner::executePlan(), expandBounds(), getInnerMostLoop(), getInnermostLoopFor(), getTopMostExitingLoop(), llvm::hasIterationCountInvariantInParent(), hoistLoopToNewParent(), llvm::LoopBase< BlockT, LoopT >::isOutermost(), PrintParentLoopComment(), rebuildLoopAfterUnswitch(), removeBlockFromLoops(), llvm::LoopConstrainer::run(), llvm::LoopFlattenPass::run(), llvm::PassManager< Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, LPMUpdater & >::runWithLoopNestPasses(), llvm::UnrollAndJamLoop(), llvm::UnrollLoop(), unswitchNontrivialInvariants(), UpdateAnalysisInformation(), and updateLoopInfo().
◆ getSubLoops()
template<class BlockT , class LoopT >
Return the loops contained entirely within this loop.
Definition at line 145 of file GenericLoopInfo.h.
References assert(), and llvm::LoopBase< BlockT, LoopT >::isInvalid().
Referenced by areInnerLoopLatchPHIsSupported(), llvm::LoopBase< BlockT, LoopT >::begin(), checkLoopsStructure(), llvm::LoopBase< BlockT, LoopT >::end(), llvm::LoopNest::getMaxPerfectDepth(), isEligibleLoopForm(), llvm::LoopBase< BlockT, LoopT >::isInnermost(), populateWorklist(), llvm::LoopBase< BlockT, LoopT >::rbegin(), and llvm::LoopBase< BlockT, LoopT >::rend().
◆ getSubLoopsVector()
template<class BlockT , class LoopT >
| std::vector< LoopT * > & llvm::LoopBase< BlockT, LoopT >::getSubLoopsVector ( ) | inline |
|---|
◆ getUniqueExitBlock()
template<class BlockT , class LoopT >
◆ getUniqueExitBlocks()
template<class BlockT , class LoopT >
| void llvm::LoopBase< BlockT, LoopT >::getUniqueExitBlocks | ( | SmallVectorImpl< BlockT * > & | ExitBlocks | ) | const |
|---|
◆ getUniqueLatchExitBlock()
template<class BlockT , class LoopT >
◆ getUniqueNonLatchExitBlocks()
template<class BlockT , class LoopT >
| void llvm::LoopBase< BlockT, LoopT >::getUniqueNonLatchExitBlocks | ( | SmallVectorImpl< BlockT * > & | ExitBlocks | ) | const |
|---|
Return all unique successor blocks of this loop except successors from Latch block are not considered.
If the exit comes from Latch has also non Latch predecessor in a loop it will be added to ExitBlocks. These are the blocks outside of the current loop which are branched to.
Definition at line 149 of file GenericLoopInfoImpl.h.
References assert(), and llvm::getUniqueExitBlocksHelper().
◆ hasDedicatedExits()
template<class BlockT , class LoopT >
◆ hasNoExitBlocks()
template<class BlockT , class LoopT >
◆ isAnnotatedParallel()
template<class BlockT , class LoopT >
Returns true if the loop is annotated parallel.
Derived classes can override this method using static template polymorphism.
Definition at line 475 of file GenericLoopInfo.h.
◆ isInnermost()
template<class BlockT , class LoopT >
Return true if the loop does not contain any (natural) loops.
Definition at line 167 of file GenericLoopInfo.h.
References llvm::LoopBase< BlockT, LoopT >::getSubLoops().
Referenced by llvm::LoopVectorizationLegality::canVectorize(), cloneLoopNest(), emitBasicBlockLoopComments(), llvm::LoopInfo::erase(), llvm::LoopVectorizationCostModel::getWideningDecision(), isExplicitVecOuterLoop(), llvm::LoopVectorizationCostModel::isProfitableToScalarize(), llvm::LoopVectorizationCostModel::isScalarAfterVectorization(), llvm::LoopVectorizationCostModel::isUniformAfterVectorization(), llvm::LoopVectorizationPlanner::plan(), llvm::LoopVectorizationPlanner::planInVPlanNativePath(), and llvm::reportVectorization().
◆ isInvalid()
template<class BlockT , class LoopT >
Return true if this loop is no longer valid.
The only valid use of this helper is "assert(L.isInvalid())" or equivalent, since IsInvalid is set to true by the destructor. In other words, if this accessor returns true, the caller has already triggered UB by calling this accessor; and so it can only be called in a context where a return value of true indicates a programmer error.
Definition at line 217 of file GenericLoopInfo.h.
Referenced by llvm::LoopBase< BlockT, LoopT >::addBlockEntry(), llvm::LoopBase< BlockT, LoopT >::addChildLoop(), llvm::LoopBase< BlockT, LoopT >::blocks(), llvm::LoopBase< BlockT, LoopT >::contains(), llvm::LoopInfo::erase(), llvm::LoopBase< BlockT, LoopT >::getBlocks(), llvm::LoopBase< BlockT, LoopT >::getBlocksSet(), llvm::LoopBase< BlockT, LoopT >::getBlocksVector(), llvm::LoopBase< BlockT, LoopT >::getLoopDepth(), llvm::LoopBase< BlockT, LoopT >::getLoopLatches(), llvm::LoopBase< BlockT, LoopT >::getNumBackEdges(), llvm::LoopBase< BlockT, LoopT >::getNumBlocks(), llvm::LoopBase< BlockT, LoopT >::getSubLoops(), llvm::LoopBase< BlockT, LoopT >::getSubLoopsVector(), llvm::LoopBase< BlockT, LoopT >::isLoopExiting(), llvm::LoopBase< BlockT, LoopT >::isLoopLatch(), llvm::LoopBase< BlockT, LoopT >::moveToHeader(), llvm::LoopBase< BlockT, LoopT >::removeBlockFromLoop(), llvm::LoopBase< BlockT, LoopT >::removeChildLoop(), llvm::LoopBase< BlockT, LoopT >::reserveBlocks(), llvm::LoopBase< BlockT, LoopT >::reverseBlock(), and llvm::LoopBase< BlockT, LoopT >::setParentLoop().
◆ isLoopExiting()
template<class BlockT , class LoopT >
◆ isLoopLatch()
template<class BlockT , class LoopT >
◆ isOutermost()
template<class BlockT , class LoopT >
◆ moveToHeader()
template<class BlockT , class LoopT >
| void llvm::LoopBase< BlockT, LoopT >::moveToHeader ( BlockT * BB) | inline |
|---|
◆ print()
◆ rbegin()
template<class BlockT , class LoopT >
◆ removeBlockFromLoop()
template<class BlockT , class LoopT >
| void llvm::LoopBase< BlockT, LoopT >::removeBlockFromLoop ( BlockT * BB) | inline |
|---|
◆ removeChildLoop() [1/2]
template<class BlockT , class LoopT >
This removes the specified child from being a subloop of this loop.
The loop is not deleted, as it will presumably be inserted into another loop.
Definition at line 400 of file GenericLoopInfo.h.
References assert(), llvm::LoopBase< BlockT, LoopT >::begin(), I, and llvm::LoopBase< BlockT, LoopT >::isInvalid().
Referenced by llvm::LoopInfo::erase(), hoistLoopToNewParent(), rebuildLoopAfterUnswitch(), and llvm::LoopBase< BlockT, LoopT >::removeChildLoop().
◆ removeChildLoop() [2/2]
template<class BlockT , class LoopT >
| LoopT * llvm::LoopBase< BlockT, LoopT >::removeChildLoop ( LoopT * Child) | inline |
|---|
◆ rend()
template<class BlockT , class LoopT >
◆ replaceChildLoopWith()
template<class BlockT , class LoopT >
| void llvm::LoopBase< BlockT, LoopT >::replaceChildLoopWith | ( | LoopT * | OldChild, |
|---|---|---|---|
| LoopT * | NewChild | ||
| ) |
This is used when splitting loops up.
replaceChildLoopWith - This is used when splitting loops up.
It replaces the OldChild entry in our children list with NewChild, and updates the parent pointer of OldChild to be null and the NewChild to be this loop. This updates the loop depth of the new child.
Definition at line 312 of file GenericLoopInfoImpl.h.
References assert().
Referenced by separateNestedLoop().
◆ reserveBlocks()
template<class BlockT , class LoopT >
◆ reverseBlock()
template<class BlockT , class LoopT >
◆ setParentLoop()
template<class BlockT , class LoopT >
| void llvm::LoopBase< BlockT, LoopT >::setParentLoop ( LoopT * L) | inline |
|---|
◆ verifyLoop()
template<class BlockT , class LoopT >
◆ verifyLoopNest()
Verify loop structure of this loop and all nested loops.
verifyLoop - Verify loop structure of this loop and all nested loops.
Definition at line 402 of file GenericLoopInfoImpl.h.
References assert(), E, I, and Loops.
◆ LoopInfoBase< BlockT, LoopT >
template<class BlockT , class LoopT >
The documentation for this class was generated from the following files:
- include/llvm/Support/GenericLoopInfo.h
- include/llvm/Support/GenericLoopInfoImpl.h