26#include "llvm/Config/llvm-config.h"
48#ifdef EXPENSIVE_CHECKS
68 if (HasCoroSuspendInst && isa<AllocaInst>(
I))
77 bool HasCoroSuspendInst)
const {
79 return isLoopInvariant(V, HasCoroSuspendInst);
99 if (
I->mayReadFromMemory())
113 for (
Value *Operand :
I->operands())
128 I->dropUnknownNonDebugMetadata();
159 assert(
Incoming && Backedge &&
"expected non-null incoming and backedges");
178 if (Inc->getOpcode() == Instruction::Add && Inc->getOperand(0) == PN)
179 if (
ConstantInt *CI = dyn_cast<ConstantInt>(Inc->getOperand(1)))
189 if (
BranchInst *BI = dyn_cast_or_null<BranchInst>(Latch->getTerminator()))
190 if (BI->isConditional())
191 return dyn_cast<ICmpInst>(BI->getCondition());
199 ICmpInst *LatchCmpInst = L.getLatchCmpInst();
205 if (Op0 == &IndVar || Op0 == &StepInst)
208 if (Op1 == &IndVar || Op1 == &StepInst)
214std::optional<Loop::LoopBounds>
223 if (!InitialIVValue || !StepInst)
229 Value *StepValue =
nullptr;
230 if (SE.
getSCEV(StepInstOp1) == Step)
231 StepValue = StepInstOp1;
232 else if (SE.
getSCEV(StepInstOp0) == Step)
233 StepValue = StepInstOp0;
239 return LoopBounds(L, *InitialIVValue, *StepInst, StepValue, *FinalIVValue,
247 assert(Latch &&
"Expecting valid latch");
254 "Expecting the latch compare instruction to be a CmpInst");
262 if (LatchCmpInst->
getOperand(0) == &getFinalIVValue())
267 if (LatchCmpInst->
getOperand(0) == &getStepInst() ||
268 LatchCmpInst->
getOperand(1) == &getStepInst())
276 if (
D == Direction::Increasing)
279 if (
D == Direction::Decreasing)
289 dyn_cast<SCEVAddRecExpr>(SE.getSCEV(&getStepInst())))
290 if (
const SCEV *StepRecur = StepAddRecExpr->getStepRecurrence(SE)) {
291 if (SE.isKnownPositive(StepRecur))
292 return Direction::Increasing;
293 if (SE.isKnownNegative(StepRecur))
294 return Direction::Decreasing;
297 return Direction::Unknown;
312 assert(Header &&
"Expected a valid loop header");
320 for (
PHINode &IndVar : Header->phis()) {
326 Value *StepInst = IndVar.getIncomingValueForBlock(Latch);
332 if (StepInst == LatchCmpOp0 || StepInst == LatchCmpOp1)
339 if (&IndVar == LatchCmpOp0 || &IndVar == LatchCmpOp1)
386 "Expecting a loop with valid preheader and latch");
437 if (!Step || !Step->
isOne())
450 if (IgnoreTokens &&
I.getType()->isTokenTy())
453 for (
const Use &U :
I.uses()) {
454 const Instruction *UI = cast<Instruction>(U.getUser());
460 if (
const PHINode *
P = dyn_cast<PHINode>(UI))
461 UserBB =
P->getIncomingBlock(U);
467 if (UserBB != &BB && !L.contains(UserBB) &&
483 bool IgnoreTokens)
const {
503 if (isa<IndirectBrInst>(BB->getTerminator()))
507 if (
auto *CB = dyn_cast<CallBase>(&
I))
508 if (CB->cannotDuplicate())
529 else if (MD != LoopID)
540 "Loop ID needs at least one operand");
542 "Loop ID should refer to itself");
547 BB->getTerminator()->setMetadata(LLVMContext::MD_loop, LoopID);
557 Context, LoopID, {
"llvm.loop.unroll."}, {DisableUnrollMD});
580 if (!DesiredLoopIdMetadata)
583 MDNode *ParallelAccesses =
586 ParallelAccessGroups;
587 if (ParallelAccesses) {
589 MDNode *AccGroup = cast<MDNode>(MD.get());
591 "List item must be an access group");
592 ParallelAccessGroups.
insert(AccGroup);
603 if (!
I.mayReadOrWriteMemory())
606 if (
MDNode *AccessGroup =
I.getMetadata(LLVMContext::MD_access_group)) {
607 auto ContainsAccessGroup = [&ParallelAccessGroups](
MDNode *AG) ->
bool {
608 if (AG->getNumOperands() == 0) {
610 return ParallelAccessGroups.
count(AG);
613 for (
const MDOperand &AccessListItem : AG->operands()) {
614 MDNode *AccGroup = cast<MDNode>(AccessListItem.get());
616 "List item must be an access group");
617 if (ParallelAccessGroups.
count(AccGroup))
623 if (ContainsAccessGroup(AccessGroup))
632 I.getMetadata(LLVMContext::MD_mem_parallel_loop_access);
654 if (
DILocation *L = dyn_cast<DILocation>(MDO)) {
668 if (
DebugLoc DL = PHeadBB->getTerminator()->getDebugLoc())
674 return LocRange(HeadBB->getTerminator()->getDebugLoc());
683 LoopDbgLoc.print(
OS);
690#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
719 bool FoundIB =
false;
722 UnloopUpdater(
Loop *UL,
LoopInfo *LInfo) : Unloop(*UL), LI(LInfo), DFS(UL) {}
724 void updateBlockParents();
726 void removeBlocksFromAncestors();
728 void updateSubloopParents();
737void UnloopUpdater::updateBlockParents() {
738 if (Unloop.getNumBlocks()) {
744 Loop *
L = LI->getLoopFor(POI);
745 Loop *NL = getNearestLoop(POI, L);
750 "uninitialized successor");
751 LI->changeLoopFor(POI, NL);
755 assert((FoundIB || Unloop.contains(L)) &&
"uninitialized successor");
761 bool Changed = FoundIB;
762 for (
unsigned NIters = 0; Changed; ++NIters) {
763 assert(NIters < Unloop.getNumBlocks() &&
"runaway iterative algorithm");
770 POE = DFS.endPostorder();
773 Loop *
L = LI->getLoopFor(*POI);
774 Loop *NL = getNearestLoop(*POI, L);
777 "uninitialized successor");
778 LI->changeLoopFor(*POI, NL);
786void UnloopUpdater::removeBlocksFromAncestors() {
790 Loop *OuterParent = LI->getLoopFor(BB);
791 if (Unloop.contains(OuterParent)) {
794 OuterParent = SubloopParents[OuterParent];
800 assert(OldParent &&
"new loop is not an ancestor of the original");
801 OldParent->removeBlockFromLoop(BB);
807void UnloopUpdater::updateSubloopParents() {
808 while (!Unloop.isInnermost()) {
809 Loop *Subloop = *std::prev(Unloop.end());
810 Unloop.removeChildLoop(std::prev(Unloop.end()));
812 assert(SubloopParents.count(Subloop) &&
"DFS failed to visit subloop");
813 if (
Loop *Parent = SubloopParents[Subloop])
814 Parent->addChildLoop(Subloop);
816 LI->addTopLevelLoop(Subloop);
829 Loop *NearLoop = BBLoop;
831 Loop *Subloop =
nullptr;
832 if (NearLoop != &Unloop && Unloop.contains(NearLoop)) {
837 assert(Subloop &&
"subloop is not an ancestor of the original loop");
840 NearLoop = SubloopParents.insert({Subloop, &Unloop}).first->second;
844 assert(!Subloop &&
"subloop blocks must have a successor");
851 Loop *
L = LI->getLoopFor(Succ);
855 assert((FoundIB || !DFS.hasPostorder(Succ)) &&
"should have seen IB");
858 if (L != &Unloop && Unloop.contains(L)) {
864 assert(
L->getParentLoop() == &Unloop &&
"cannot skip into nested loops");
867 L = SubloopParents[
L];
874 if (L && !
L->contains(&Unloop)) {
875 L =
L->getParentLoop();
878 if (NearLoop == &Unloop || !NearLoop || NearLoop->
contains(L))
882 SubloopParents[Subloop] = NearLoop;
909 if (getLoopFor(BB) != Unloop)
914 changeLoopFor(BB,
nullptr);
935 UnloopUpdater Updater(Unloop,
this);
936 Updater.updateBlockParents();
939 Updater.removeBlocksFromAncestors();
942 Updater.updateSubloopParents();
947 assert(
I != ParentLoop->
end() &&
"Couldn't find loop");
957 if (V->getType()->isTokenTy())
965 const Loop *L = getLoopFor(
I->getParent());
968 if (L->contains(ExitBB))
996 OS <<
"Loop info for function '" <<
F.getName() <<
"':\n";
1005 OS << Banner <<
" (loop: ";
1006 L.getHeader()->printAsOperand(
OS,
false);
1010 OS << *L.getHeader()->getModule();
1017 OS << Banner <<
" (loop: ";
1018 L.getHeader()->printAsOperand(
OS,
false);
1022 OS << *L.getHeader()->getParent();
1028 auto *PreHeader = L.getLoopPreheader();
1030 OS <<
"\n; Preheader:";
1031 PreHeader->print(
OS);
1035 for (
auto *
Block : L.blocks())
1039 OS <<
"Printing <null> block";
1042 L.getExitBlocks(ExitBlocks);
1043 if (!ExitBlocks.
empty()) {
1044 OS <<
"\n; Exit blocks";
1045 for (
auto *
Block : ExitBlocks)
1049 OS <<
"Printing <null> block";
1064 MDNode *MD = dyn_cast<MDNode>(MDO);
1088std::optional<const MDOperand *>
1092 return std::nullopt;
1107 return std::nullopt;
1114 mdconst::extract_or_null<ConstantInt>(MD->
getOperand(1).
get()))
1115 return IntMD->getZExtValue();
1130 return std::nullopt;
1132 ConstantInt *IntMD = mdconst::extract_or_null<ConstantInt>(AttrMD->get());
1134 return std::nullopt;
1147 if (
auto *CB = dyn_cast<CallBase>(&
II)) {
1148 if (!CB->isConvergent())
1153 if (
auto *Token = CB->getConvergenceControlToken()) {
1154 auto *TokenDef = cast<Instruction>(Token);
1155 if (!TheLoop->
contains(TokenDef->getParent()))
1165 return L->getHeader()->getParent()->willReturn();
1175 return L->getHeader()->getParent()->mustProgress() ||
hasMustProgress(L);
1179 return Node->getNumOperands() == 0 && Node->isDistinct();
1196 bool IsVectorMetadata =
false;
1198 if (
MDNode *MD = dyn_cast<MDNode>(
Op)) {
1199 const MDString *S = dyn_cast<MDString>(MD->getOperand(0));
1206 if (!IsVectorMetadata)
1236 LI.analyze(getAnalysis<DominatorTreeWrapperPass>().getDomTree());
1247 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
1279 POE = Traversal.
end();
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
#define LLVM_EXPORT_TEMPLATE
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static bool runOnFunction(Function &F, bool PostInlining)
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
Module.h This file contains the declarations for the Module class.
This header defines various interfaces for pass management in LLVM.
static bool isBlockInLCSSAForm(const Loop &L, const BasicBlock &BB, const DominatorTree &DT, bool IgnoreTokens)
static const char * LLVMLoopMustProgress
static Value * findFinalIVValue(const Loop &L, const PHINode &IndVar, const Instruction &StepInst)
Return the final value of the loop induction variable if found.
static cl::opt< bool, true > VerifyLoopInfoX("verify-loop-info", cl::location(VerifyLoopInfo), cl::Hidden, cl::desc("Verify loop info (time consuming)"))
This file defines the interface for the loop nest analysis.
This file exposes an interface to building/using memory SSA to walk memory instructions using a use/d...
uint64_t IntrinsicInst * II
#define INITIALIZE_PASS_DEPENDENCY(depName)
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
This file defines the make_scope_exit function, which executes user-defined cleanup logic at scope ex...
This file defines the SmallPtrSet class.
This templated class represents "all analyses that operate over <a particular IR unit>" (e....
API to communicate dependencies between analyses during invalidation.
A container for analyses that lazily runs them and caches their results.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Represent the analysis usage information of a pass.
void setPreservesAll()
Set by analyses that do not transform their input at all.
AnalysisUsage & addRequiredTransitive()
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
LLVM Basic Block Representation.
LLVM_ABI const BasicBlock * getUniquePredecessor() const
Return the predecessor of this block if it has a unique predecessor block.
const Function * getParent() const
Return the enclosing method, or null if none.
InstListType::iterator iterator
Instruction iterators...
LLVM_ABI LLVMContext & getContext() const
Get the context in which this basic block lives.
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Conditional or Unconditional Branch instruction.
bool isConditional() const
BasicBlock * getSuccessor(unsigned i) const
bool isUnconditional() const
Value * getCondition() const
Represents analyses that only rely on functions' control flow.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
This class is the base class for the comparison instructions.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ ICMP_SLT
signed less than
@ ICMP_SGT
signed greater than
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE,...
Predicate getPredicate() const
Return the predicate for this instruction.
Predicate getFlippedStrictnessPredicate() const
For predicate of kind "is X or equal to 0" returns the predicate "is X".
This is the shared class of boolean and integer constants.
bool isOne() const
This is just a convenience method to make client code smaller for a common case.
int64_t getSExtValue() const
Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the ...
This class represents an Operation in the Expression.
Analysis pass which computes a DominatorTree.
Core dominator tree base class.
Legacy analysis pass which computes a DominatorTree.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
LLVM_ABI bool isReachableFromEntry(const Use &U) const
Provide an overload for a Use.
FunctionPass class - This class is used to implement most global optimizations.
Module * getParent()
Get the module that this global value is contained inside of...
This instruction compares its operands according to the predicate given to the constructor.
A struct for saving information about induction variables.
BinaryOperator * getInductionBinOp() const
const SCEV * getStep() const
static LLVM_ABI bool isInductionPHI(PHINode *Phi, const Loop *L, ScalarEvolution *SE, InductionDescriptor &D, const SCEV *Expr=nullptr, SmallVectorImpl< Instruction * > *CastsToIgnore=nullptr)
Returns true if Phi is an induction in the loop L.
Instruction::BinaryOps getInductionOpcode() const
Returns binary opcode of the induction operator.
Value * getStartValue() const
LLVM_ABI ConstantInt * getConstIntStepValue() const
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
This is an important class for using LLVM in a threaded context.
Analysis pass that exposes the LoopInfo for a function.
LLVM_ABI LoopInfo run(Function &F, FunctionAnalysisManager &AM)
Instances of this class are used to represent loops that are detected in the flow graph.
bool contains(const Loop *L) const
Return true if the specified loop is contained within in this loop.
bool isOutermost() const
Return true if the loop does not have a parent (natural) loop.
BasicBlock * getLoopLatch() const
If there is a single latch block for this loop, return it.
bool isInnermost() const
Return true if the loop does not contain any (natural) loops.
BasicBlock * getHeader() const
void getLoopLatches(SmallVectorImpl< BasicBlock * > &LoopLatches) const
Return all loop latch blocks of this loop.
void print(raw_ostream &OS, bool Verbose=false, bool PrintNested=true, unsigned Depth=0) const
Print loop with all the BBs inside it.
std::vector< Loop * >::const_iterator iterator
iterator_range< block_iterator > blocks() const
bool isInvalid() const
Return true if this loop is no longer valid.
BasicBlock * getLoopPreheader() const
If there is a preheader for this loop, return it.
LoopT * getParentLoop() const
Return the parent loop if it exists or nullptr for top level loops.
bool hasDedicatedExits() const
Return true if no exit block for the loop has a predecessor that is outside the loop.
BasicBlock * getUniqueExitBlock() const
If getUniqueExitBlocks would return exactly one block, return that block.
LoopT * removeChildLoop(iterator I)
This removes the specified child from being a subloop of this loop.
Store the result of a depth first search within basic blocks contained by a single loop.
std::vector< BasicBlock * >::const_iterator POIterator
Postorder list iterators.
void perform(const LoopInfo *LI)
Traverse the loop blocks and store the DFS result.
Traverse the blocks in a loop using a depth-first search.
POTIterator begin()
Postorder traversal over the graph.
This class builds and contains all of the top-level loop structures in the specified function.
void verify(const DominatorTreeBase< BlockT, false > &DomTree) const
void analyze(const DominatorTreeBase< BlockT, false > &DomTree)
Create the loop forest using a stable algorithm.
void print(raw_ostream &OS) const
LoopT * getLoopFor(const BlockT *BB) const
Return the inner most loop that BB lives in.
std::vector< Loop * >::const_iterator iterator
iterator/begin/end - The interface to the top-level loops in the current function.
The legacy pass manager's analysis pass to compute loop information.
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
void verifyAnalysis() const override
verifyAnalysis() - This member can be implemented by a analysis pass to check state of analysis infor...
void print(raw_ostream &O, const Module *M=nullptr) const override
print - Print out the internal state of the pass.
LLVM_ABI bool wouldBeOutOfLoopUseRequiringLCSSA(const Value *V, const BasicBlock *ExitBB) const
LLVM_ABI bool invalidate(Function &F, const PreservedAnalyses &PA, FunctionAnalysisManager::Invalidator &)
Handle invalidation explicitly.
LLVM_ABI void erase(Loop *L)
Update LoopInfo after removing the last backedge from a loop.
static const BasicBlock & skipEmptyBlockUntil(const BasicBlock *From, const BasicBlock *End, bool CheckUniquePred=false)
Recursivelly traverse all empty 'single successor' basic blocks of From (if there are any).
LLVM_ABI PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
A range representing the start and end location of a loop.
const DebugLoc & getStart() const
Represents a single loop in the control flow graph.
bool isCanonical(ScalarEvolution &SE) const
Return true if the loop induction variable starts at zero and increments by one each time through the...
bool isLCSSAForm(const DominatorTree &DT, bool IgnoreTokens=true) const
Return true if the Loop is in LCSSA form.
std::optional< LoopBounds > getBounds(ScalarEvolution &SE) const
Return the struct LoopBounds collected if all struct members are found, else std::nullopt.
bool isLoopInvariant(const Value *V, bool HasCoroSuspendInst=false) const
Return true if the specified value is loop invariant.
bool isSafeToClone() const
Return true if the loop body is safe to clone in practice.
std::string getLocStr() const
Return a string containing the debug location of the loop (file name + line number if present,...
BranchInst * getLoopGuardBranch() const
Return the loop guard branch, if it exists.
bool isAnnotatedParallel() const
Returns true if the loop is annotated parallel.
DebugLoc getStartLoc() const
Return the debug location of the start of this loop.
LocRange getLocRange() const
Return the source code span of the loop.
ICmpInst * getLatchCmpInst() const
Get the latch condition instruction.
bool getInductionDescriptor(ScalarEvolution &SE, InductionDescriptor &IndDesc) const
Get the loop induction descriptor for the loop induction variable.
bool isRotatedForm() const
Return true if the loop is in rotated form.
void setLoopMustProgress()
Add llvm.loop.mustprogress to this loop's loop id metadata.
PHINode * getInductionVariable(ScalarEvolution &SE) const
Return the loop induction variable if found, else return nullptr.
bool isLoopSimplifyForm() const
Return true if the Loop is in the form that the LoopSimplify form transforms loops to,...
bool isRecursivelyLCSSAForm(const DominatorTree &DT, const LoopInfo &LI, bool IgnoreTokens=true) const
Return true if this Loop and all inner subloops are in LCSSA form.
bool hasLoopInvariantOperands(const Instruction *I, bool HasCoroSuspendInst=false) const
Return true if all the operands of the specified instruction are loop invariant.
void setLoopID(MDNode *LoopID) const
Set the llvm.loop loop id metadata for this loop.
void setLoopAlreadyUnrolled()
Add llvm.loop.unroll.disable to this loop's loop id metadata.
bool makeLoopInvariant(Value *V, bool &Changed, Instruction *InsertPt=nullptr, MemorySSAUpdater *MSSAU=nullptr, ScalarEvolution *SE=nullptr) const
If the given value is an instruction inside of the loop and it can be hoisted, do so to make it trivi...
PHINode * getCanonicalInductionVariable() const
Check to see if the loop has a canonical induction variable: an integer recurrence that starts at 0 a...
bool getIncomingAndBackEdge(BasicBlock *&Incoming, BasicBlock *&Backedge) const
Obtain the unique incoming and back edge.
MDNode * getLoopID() const
Return the llvm.loop loop id metadata node for this loop if it is present.
bool isAuxiliaryInductionVariable(PHINode &AuxIndVar, ScalarEvolution &SE) const
Return true if the given PHINode AuxIndVar is.
LLVM_ABI void replaceOperandWith(unsigned I, Metadata *New)
Replace a specific operand.
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
const MDOperand & getOperand(unsigned I) const
ArrayRef< MDOperand > operands() const
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
unsigned getNumOperands() const
Return number of MDNode operands.
Tracking metadata reference owned by Metadata.
LLVM_ABI StringRef getString() const
static LLVM_ABI MDString * get(LLVMContext &Context, StringRef Str)
MemorySSA * getMemorySSA() const
Get handle on MemorySSA.
LLVM_ABI void moveToPlace(MemoryUseOrDef *What, BasicBlock *BB, MemorySSA::InsertionPlace Where)
MemoryUseOrDef * getMemoryAccess(const Instruction *I) const
Given a memory Mod/Ref'ing instruction, get the MemorySSA access associated with it.
A Module instance is used to store all the information related to an LLVM module.
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Value * getIncomingValueForBlock(const BasicBlock *BB) const
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
PreservedAnalysisChecker getChecker() const
Build a checker for this PreservedAnalyses and the specified analysis type.
This node represents a polynomial recurrence on the trip count of the specified loop.
This class represents an analyzed expression in the program.
The main scalar evolution driver.
LLVM_ABI const SCEV * getSCEV(Value *V)
Return a SCEV expression for the full generality of the specified expression.
LLVM_ABI bool isLoopInvariant(const SCEV *S, const Loop *L)
Return true if the value of the given SCEV is unchanging in the specified loop.
LLVM_ABI void forgetBlockAndLoopDispositions(Value *V=nullptr)
Called when the client has changed the disposition of values in a loop or block.
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
A Use represents the edge between a Value definition and its users.
Value * getOperand(unsigned i) const
LLVM Value Representation.
iterator_range< user_iterator > users()
const ParentTy * getParent() const
self_iterator getIterator()
This class implements an extremely fast bulk output stream that can only output to a stream.
A raw_ostream that writes to an std::string.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
LocationClass< Ty > location(Ty &L)
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI bool getBooleanLoopAttribute(const Loop *TheLoop, StringRef Name)
Returns true if Name is applied to TheLoop and enabled.
bool succ_empty(const Instruction *I)
bool forcePrintModuleIR()
detail::scope_exit< std::decay_t< Callable > > make_scope_exit(Callable &&F)
LLVM_ABI std::optional< bool > getOptionalBoolLoopAttribute(const Loop *TheLoop, StringRef Name)
LLVM_ABI int getIntLoopAttribute(const Loop *TheLoop, StringRef Name, int Default=0)
Find named metadata for a loop with an integer value.
auto pred_end(const MachineBasicBlock *BB)
LLVM_ABI std::optional< const MDOperand * > findStringMetadataForLoop(const Loop *TheLoop, StringRef Name)
Find string metadata for loop.
auto successors(const MachineBasicBlock *BB)
LLVM_ABI MDNode * findOptionMDForLoop(const Loop *TheLoop, StringRef Name)
Find string metadata for a loop.
LLVM_ABI bool isSafeToSpeculativelyExecute(const Instruction *I, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr, bool UseVariableInfo=true, bool IgnoreUBImplyingAttrs=true)
Return true if the instruction does not have any effects besides calculating the result and does not ...
LLVM_ABI bool hasMustProgress(const Loop *L)
Look for the loop attribute that requires progress within the loop.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI bool isMustProgress(const Loop *L)
Return true if this loop can be assumed to make progress.
LLVM_ABI CallBase * getLoopConvergenceHeart(const Loop *TheLoop)
Find the convergence heart of the loop.
LLVM_ABI bool isFinite(const Loop *L)
Return true if this loop can be assumed to run for a finite number of iterations.
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
LLVM_ABI bool VerifyLoopInfo
Enable verification of loop info.
LLVM_ABI std::optional< int > getOptionalIntLoopAttribute(const Loop *TheLoop, StringRef Name)
Find named metadata for a loop with an integer value.
LLVM_ABI bool isValidAsAccessGroup(MDNode *AccGroup)
Return whether an MDNode might represent an access group.
auto pred_begin(const MachineBasicBlock *BB)
LLVM_ABI llvm::MDNode * makePostTransformationMetadata(llvm::LLVMContext &Context, MDNode *OrigLoopID, llvm::ArrayRef< llvm::StringRef > RemovePrefixes, llvm::ArrayRef< llvm::MDNode * > AddAttrs)
Create a new LoopID after the loop has been transformed.
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
@ Default
The result values are uniform if and only if all operands are uniform.
LLVM_ABI void printLoop(Loop &L, raw_ostream &OS, const std::string &Banner="")
Function to print a loop's contents as LLVM's text IR assembly.
LLVM_ABI MDNode * findOptionMDForLoopID(MDNode *LoopID, StringRef Name)
Find and return the loop attribute node for the attribute Name in LoopID.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
A special type used by analysis passes to provide an address that identifies that particular analysis...
Incoming for lane maks phi as machine instruction, incoming register Reg and incoming block Block are...
LLVM_ABI PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Below are some utilities to get the loop guard, loop bounds and induction variable,...
static LLVM_ABI std::optional< Loop::LoopBounds > getBounds(const Loop &L, PHINode &IndVar, ScalarEvolution &SE)
Return the LoopBounds object if.
Direction
An enum for the direction of the loop.
LLVM_ABI ICmpInst::Predicate getCanonicalPredicate() const
Return the canonical predicate for the latch compare instruction, if able to be calcuated.
LLVM_ABI Direction getDirection() const
Get the direction of the loop.