79#define DEBUG_TYPE "loop-unroll"
82STATISTIC(NumCompletelyUnrolled,
"Number of loops completely unrolled");
83STATISTIC(NumUnrolled,
"Number of loops unrolled (completely or otherwise)");
84STATISTIC(NumUnrolledNotLatch,
"Number of loops unrolled without a conditional "
85 "latch (completely or otherwise)");
89 cl::desc(
"Allow runtime unrolled loops to be unrolled "
90 "with epilog instead of prolog."));
94 cl::desc(
"Verify domtree after unrolling"),
95#ifdef EXPENSIVE_CHECKS
104 cl::desc(
"Verify loopinfo after unrolling"),
105#ifdef EXPENSIVE_CHECKS
123 const std::vector<BasicBlock *> &Blocks,
129 for (
Use &U :
I.operands()) {
130 if (
const auto *Def = dyn_cast<Instruction>(U)) {
152 assert(OldLoop &&
"Should (at least) be in the loop being unrolled!");
154 Loop *&NewLoop = NewLoops[OldLoop];
158 "Header should be first in RPO");
204 assert(PreHeader && Header);
205 for (
const PHINode &PN : Header->phis()) {
206 if (isa<ConstantInt>(PN.getIncomingValueForBlock(PreHeader)))
220 if (SE && SimplifyIVs) {
226 while (!DeadInsts.
empty()) {
228 if (
Instruction *Inst = dyn_cast_or_null<Instruction>(V))
241 Inst.replaceAllUsesWith(V);
274 bool PreserveLCSSA,
Loop **RemainderLoop) {
275 assert(DT &&
"DomTree is required");
278 LLVM_DEBUG(
dbgs() <<
" Can't unroll; loop preheader-insertion failed.\n");
283 LLVM_DEBUG(
dbgs() <<
" Can't unroll; loop exit-block-insertion failed.\n");
289 LLVM_DEBUG(
dbgs() <<
" Can't unroll; Loop body cannot be cloned.\n");
296 dbgs() <<
" Won't unroll loop: address of header block is taken.\n");
309 std::vector<BasicBlock *> OriginalLoopBlocks = L->
getBlocks();
316 if (MaxTripCount && ULO.
Count > MaxTripCount)
317 ULO.
Count = MaxTripCount;
321 unsigned TripMultiple;
322 unsigned BreakoutTrip;
330 for (
auto *ExitingBlock : ExitingBlocks) {
333 auto *BI = dyn_cast<BranchInst>(ExitingBlock->getTerminator());
340 if (
Info.TripCount != 0) {
342 Info.TripMultiple = 0;
344 Info.BreakoutTrip =
Info.TripMultiple =
348 Info.ExitingBlocks.push_back(ExitingBlock);
349 LLVM_DEBUG(
dbgs() <<
" Exiting block %" << ExitingBlock->getName()
350 <<
": TripCount=" <<
Info.TripCount
351 <<
", TripMultiple=" <<
Info.TripMultiple
352 <<
", BreakoutTrip=" <<
Info.BreakoutTrip <<
"\n");
358 const bool CompletelyUnroll = ULO.
Count == MaxTripCount;
360 const bool PreserveOnlyFirst = CompletelyUnroll && MaxOrZero;
364 if (CompletelyUnroll)
373 bool NeedToFixLCSSA =
374 PreserveLCSSA && CompletelyUnroll &&
389 if (!LatchBI || (LatchBI->isConditional() && !LatchIsExiting)) {
391 dbgs() <<
"Can't unroll; a conditional latch must exit the loop");
392 return LoopUnrollResult::Unmodified;
400 bool HasConvergent =
false;
401 for (
auto &BB : L->
blocks())
403 if (
auto *CB = dyn_cast<CallBase>(&
I))
404 HasConvergent |= CB->isConvergent();
406 "Can't runtime unroll if loop contains a convergent operation.");
409 bool EpilogProfitability =
417 PreserveLCSSA, RemainderLoop)) {
422 "generated when assuming runtime trip count\n");
423 return LoopUnrollResult::Unmodified;
429 if (CompletelyUnroll) {
430 LLVM_DEBUG(
dbgs() <<
"COMPLETELY UNROLLING loop %" << Header->getName()
431 <<
" with trip count " << ULO.
Count <<
"!\n");
436 <<
"completely unrolled loop with "
437 << NV(
"UnrollCount", ULO.
Count) <<
" iterations";
440 LLVM_DEBUG(
dbgs() <<
"UNROLLING loop %" << Header->getName() <<
" by "
450 Diag <<
"unrolled loop by a factor of " << NV(
"UnrollCount", ULO.
Count);
452 Diag <<
" with run-time trip count";
475 ++NumUnrolledNotLatch;
480 std::vector<PHINode*> OrigPHINode;
482 OrigPHINode.push_back(cast<PHINode>(
I));
485 std::vector<BasicBlock *> Headers;
486 std::vector<BasicBlock *> Latches;
487 Headers.push_back(Header);
488 Latches.push_back(LatchBlock);
500 std::vector<BasicBlock*> UnrolledLoopBlocks = L->
getBlocks();
507 for (
Loop *SubLoop : *L)
508 LoopsToSimplify.
insert(SubLoop);
512 if (Header->getParent()->shouldEmitDebugInfoForProfiling() &&
516 if (!isa<DbgInfoIntrinsic>(&
I))
518 auto NewDIL = DIL->cloneByMultiplyingDuplicationFactor(ULO.
Count);
520 I.setDebugLoc(*NewDIL);
523 <<
"Failed to create new discriminator: "
524 << DIL->getFilename() <<
" Line: " << DIL->getLine());
535 auto BlockInsertPt = std::next(LatchBlock->
getIterator());
536 for (
unsigned It = 1; It != ULO.
Count; ++It) {
544 Header->getParent()->insert(BlockInsertPt, New);
547 "Header should not be in a sub-loop");
551 LoopsToSimplify.
insert(NewLoops[OldLoop]);
556 for (
PHINode *OrigPHI : OrigPHINode) {
557 PHINode *NewPHI = cast<PHINode>(VMap[OrigPHI]);
559 if (
Instruction *InValI = dyn_cast<Instruction>(InVal))
561 InVal = LastValueMap[InValI];
562 VMap[OrigPHI] = InVal;
567 LastValueMap[*BB] = New;
570 LastValueMap[
VI->first] =
VI->second;
577 Value *Incoming =
PHI.getIncomingValueForBlock(*BB);
579 if (It != LastValueMap.
end())
581 PHI.addIncoming(Incoming, New);
588 Headers.push_back(New);
589 if (*BB == LatchBlock)
590 Latches.push_back(New);
594 auto ExitInfoIt = ExitInfos.
find(*BB);
595 if (ExitInfoIt != ExitInfos.
end())
596 ExitInfoIt->second.ExitingBlocks.push_back(New);
599 UnrolledLoopBlocks.push_back(New);
608 auto BBDomNode = DT->
getNode(*BB);
609 auto BBIDom = BBDomNode->
getIDom();
610 BasicBlock *OriginalBBIDom = BBIDom->getBlock();
612 New, cast<BasicBlock>(LastValueMap[cast<Value>(OriginalBBIDom)]));
620 if (
auto *II = dyn_cast<AssumeInst>(&
I))
627 std::string ext = (
Twine(
"It") +
Twine(It)).str();
629 Header->getContext(), ext);
634 for (
PHINode *PN : OrigPHINode) {
635 if (CompletelyUnroll) {
636 PN->replaceAllUsesWith(PN->getIncomingValueForBlock(Preheader));
637 PN->eraseFromParent();
638 }
else if (ULO.
Count > 1) {
639 Value *InVal = PN->removeIncomingValue(LatchBlock,
false);
642 if (
Instruction *InValI = dyn_cast<Instruction>(InVal)) {
644 InVal = LastValueMap[InVal];
646 assert(Latches.back() == LastValueMap[LatchBlock] &&
"bad last latch");
647 PN->addIncoming(InVal, Latches.back());
653 for (
unsigned i = 0, e = Latches.size(); i != e; ++i) {
654 unsigned j = (i + 1) % e;
655 Latches[i]->getTerminator()->replaceSuccessorWith(Headers[i], Headers[j]);
663 for (
auto *BB : OriginalLoopBlocks) {
664 auto *BBDomNode = DT->
getNode(BB);
666 for (
auto *ChildDomNode : BBDomNode->children()) {
667 auto *ChildBB = ChildDomNode->getBlock();
676 for (
auto *ChildBB : ChildrenToUpdate)
682 DT->
verify(DominatorTree::VerificationLevel::Fast));
685 auto SetDest = [&](
BasicBlock *Src,
bool WillExit,
bool ExitOnTrue) {
686 auto *Term = cast<BranchInst>(Src->getTerminator());
687 const unsigned Idx = ExitOnTrue ^ WillExit;
696 Term->eraseFromParent();
698 DTUpdates.
emplace_back(DominatorTree::Delete, Src, DeadSucc);
701 auto WillExit = [&](
const ExitInfo &
Info,
unsigned i,
unsigned j,
702 bool IsLatch) -> std::optional<bool> {
703 if (CompletelyUnroll) {
704 if (PreserveOnlyFirst) {
712 if (
Info.TripCount && j !=
Info.TripCount)
720 if (IsLatch && j != 0)
725 if (j !=
Info.BreakoutTrip &&
726 (
Info.TripMultiple == 0 || j %
Info.TripMultiple != 0)) {
736 for (
auto &Pair : ExitInfos) {
737 ExitInfo &
Info = Pair.second;
738 for (
unsigned i = 0, e =
Info.ExitingBlocks.size(); i != e; ++i) {
740 unsigned j = (i + 1) % e;
741 bool IsLatch = Pair.first == LatchBlock;
742 std::optional<bool> KnownWillExit = WillExit(
Info, i, j, IsLatch);
743 if (!KnownWillExit) {
744 if (!
Info.FirstExitingBlock)
745 Info.FirstExitingBlock =
Info.ExitingBlocks[i];
754 if (*KnownWillExit && !IsLatch) {
755 if (!
Info.FirstExitingBlock)
756 Info.FirstExitingBlock =
Info.ExitingBlocks[i];
760 SetDest(
Info.ExitingBlocks[i], *KnownWillExit,
Info.ExitOnTrue);
766 if (ExitingBlocks.
size() == 1 && ExitInfos.
size() == 1) {
774 auto &[OriginalExit,
Info] = *ExitInfos.
begin();
775 if (!
Info.FirstExitingBlock)
776 Info.FirstExitingBlock =
Info.ExitingBlocks.back();
787 if (!LatchIsExiting && CompletelyUnroll) {
797 BranchInst *Term = dyn_cast<BranchInst>(Latch->getTerminator());
799 (CompletelyUnroll && !LatchIsExiting && Latch == Latches.back())) &&
800 "Need a branch as terminator, except when fully unrolling with "
801 "unconditional latch");
802 if (Term && Term->isUnconditional()) {
808 DTUToUse ?
nullptr : DT)) {
810 std::replace(Latches.begin(), Latches.end(), Dest, Fold);
821 DT->
verify(DominatorTree::VerificationLevel::Fast));
828 NumCompletelyUnrolled += CompletelyUnroll;
833 if (CompletelyUnroll)
848 if (PreserveLCSSA && OuterL && CompletelyUnroll && !NeedToFixLCSSA)
858 if (NeedToFixLCSSA) {
863 Loop *FixLCSSALoop = OuterL;
864 if (!FixLCSSALoop->
contains(LatchLoop))
869 }
else if (PreserveLCSSA) {
871 "Loops should be in LCSSA form after loop-unroll.");
876 simplifyLoop(OuterL, DT, LI, SE, AC,
nullptr, PreserveLCSSA);
879 for (
Loop *SubLoop : LoopsToSimplify)
880 simplifyLoop(SubLoop, DT, LI, SE, AC,
nullptr, PreserveLCSSA);
883 return CompletelyUnroll ? LoopUnrollResult::FullyUnrolled
884 : LoopUnrollResult::PartiallyUnrolled;
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Analysis containing CSE Info
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file defines the DenseMap class.
This file defines a set of templates that efficiently compute a dominator tree over a generic graph.
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
static bool needToInsertPhisForLCSSA(Loop *L, const std::vector< BasicBlock * > &Blocks, LoopInfo *LI)
Check if unrolling created a situation where we need to insert phi nodes to preserve LCSSA form.
static bool isEpilogProfitable(Loop *L)
The function chooses which type of unroll (epilog or prolog) is more profitabale.
static cl::opt< bool > UnrollRuntimeEpilog("unroll-runtime-epilog", cl::init(false), cl::Hidden, cl::desc("Allow runtime unrolled loops to be unrolled " "with epilog instead of prolog."))
static cl::opt< bool > UnrollVerifyLoopInfo("unroll-verify-loopinfo", cl::Hidden, cl::desc("Verify loopinfo after unrolling"), cl::init(false))
static cl::opt< bool > UnrollVerifyDomtree("unroll-verify-domtree", cl::Hidden, cl::desc("Verify domtree after unrolling"), cl::init(false))
Module.h This file contains the declarations for the Module class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file implements a set that has insertion order iteration characteristics.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
This defines the Use class.
A cache of @llvm.assume calls within a function.
void registerAssumption(CondGuardInst *CI)
Add an @llvm.assume intrinsic to this function's cache.
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches,...
const BasicBlock * getUniquePredecessor() const
Return the predecessor of this block if it has a unique predecessor block.
const BasicBlock * getSingleSuccessor() const
Return the successor of this block if it has a single successor.
InstListType::iterator iterator
Instruction iterators...
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...
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr if the function does no...
void removePredecessor(BasicBlock *Pred, bool KeepOneInputPHIs=false)
Update PHI nodes in this BasicBlock before removal of predecessor Pred.
Conditional or Unconditional Branch instruction.
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
A parsed version of the target data layout string in and methods for querying it.
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
iterator find(const_arg_type_t< KeyT > Val)
std::pair< iterator, bool > try_emplace(KeyT &&Key, Ts &&... Args)
iterator_range< iterator > children()
DomTreeNodeBase * getIDom() const
void applyUpdates(ArrayRef< DominatorTree::UpdateType > Updates)
Submit updates to all available trees.
DominatorTree & getDomTree()
Flush DomTree updates and return DomTree.
bool verify(VerificationLevel VL=VerificationLevel::Full) const
verify - checks if the tree is correct.
void changeImmediateDominator(DomTreeNodeBase< NodeT > *N, DomTreeNodeBase< NodeT > *NewIDom)
changeImmediateDominator - This method is used to update the dominator tree information when a node's...
DomTreeNodeBase< NodeT > * addNewBlock(NodeT *BB, NodeT *DomBB)
Add a new node to the dominator tree information.
DomTreeNodeBase< NodeT > * getNode(const NodeT *BB) const
getNode - return the (Post)DominatorTree node for the specified basic block.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Instruction * findNearestCommonDominator(Instruction *I1, Instruction *I2) const
Find the nearest instruction I that dominates both I1 and I2, in the sense that a result produced bef...
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
bool contains(const LoopT *L) const
Return true if the specified loop is contained within in this loop.
BlockT * getLoopLatch() const
If there is a single latch block for this loop, return it.
void getExitBlocks(SmallVectorImpl< BlockT * > &ExitBlocks) const
Return all of the successor blocks of this loop.
void getExitingBlocks(SmallVectorImpl< BlockT * > &ExitingBlocks) const
Return all blocks inside the loop that have successors outside of the loop.
BlockT * getHeader() const
void addBasicBlockToLoop(BlockT *NewBB, LoopInfoBase< BlockT, LoopT > &LI)
This method is used by other analyses to update loop information.
iterator_range< block_iterator > blocks() const
void addChildLoop(LoopT *NewChild)
Add the specified loop to be a child of this loop.
BlockT * getLoopPreheader() const
If there is a preheader for this loop, return it.
ArrayRef< BlockT * > getBlocks() const
Get a list of the basic blocks which make up this loop.
LoopT * getParentLoop() const
Return the parent loop if it exists or nullptr for top level loops.
bool isLoopExiting(const BlockT *BB) const
True if terminator in the block can branch to another block that is outside of the current loop.
Store the result of a depth first search within basic blocks contained by a single loop.
RPOIterator beginRPO() const
Reverse iterate over the cached postorder blocks.
std::vector< BasicBlock * >::const_reverse_iterator RPOIterator
void perform(LoopInfo *LI)
Traverse the loop blocks and store the DFS result.
RPOIterator endRPO() const
LoopT * AllocateLoop(ArgsTy &&... Args)
void verify(const DominatorTreeBase< BlockT, false > &DomTree) const
void addTopLevelLoop(LoopT *New)
This adds the specified loop to the collection of top-level loops.
LoopT * getLoopFor(const BlockT *BB) const
Return the inner most loop that BB lives in.
bool replacementPreservesLCSSAForm(Instruction *From, Value *To)
Returns true if replacing From with To everywhere is guaranteed to preserve LCSSA form.
void erase(Loop *L)
Update LoopInfo after removing the last backedge from a loop.
Represents a single loop in the control flow graph.
bool isLCSSAForm(const DominatorTree &DT, bool IgnoreTokens=true) const
Return true if the Loop is in LCSSA form.
bool isSafeToClone() const
Return true if the loop body is safe to clone in practice.
DebugLoc getStartLoc() const
Return the debug location of the start of this loop.
const MDOperand & getOperand(unsigned I) const
unsigned getNumOperands() const
Return number of MDNode operands.
StringRef getString() const
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Value * getIncomingValueForBlock(const BasicBlock *BB) const
The main scalar evolution driver.
unsigned getSmallConstantTripMultiple(const Loop *L, const SCEV *ExitCount)
Returns the largest constant divisor of the trip count as a normal unsigned value,...
unsigned getSmallConstantMaxTripCount(const Loop *L)
Returns the upper bound of the loop trip count as a normal unsigned value.
bool isBackedgeTakenCountMaxOrZero(const Loop *L)
Return true if the backedge taken count is either the value returned by getConstantMaxBackedgeTakenCo...
void forgetTopmostLoop(const Loop *L)
void forgetValue(Value *V)
This method should be called by the client when it has changed a value in a way that may effect its v...
void forgetBlockAndLoopDispositions(Value *V=nullptr)
Called when the client has changed the disposition of values in a loop or block.
unsigned getSmallConstantTripCount(const Loop *L)
Returns the exact trip count of the loop if we can compute it, and the result is a small constant.
bool insert(const value_type &X)
Insert a new element into the SetVector.
A SetVector that performs no allocations if smaller than a certain size.
reference emplace_back(ArgTypes &&... Args)
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.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
A Use represents the edge between a Value definition and its users.
iterator find(const KeyT &Val)
LLVM Value Representation.
int getNumOccurrences() const
self_iterator getIterator()
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
@ C
The default llvm calling convention, compatible with C.
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
bool simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI, ScalarEvolution *SE, AssumptionCache *AC, MemorySSAUpdater *MSSAU, bool PreserveLCSSA)
Simplify each loop in a loop nest recursively.
bool RecursivelyDeleteTriviallyDeadInstructions(Value *V, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr, std::function< void(Value *)> AboutToDeleteCallback=std::function< void(Value *)>())
If the specified value is a trivially dead instruction, delete it.
auto successors(const MachineBasicBlock *BB)
bool formLCSSARecursively(Loop &L, const DominatorTree &DT, const LoopInfo *LI, ScalarEvolution *SE)
Put a loop nest into LCSSA form.
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
cl::opt< bool > EnableFSDiscriminator
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)
Return true if the result produced by the instruction is not used, and the instruction will return.
BasicBlock * CloneBasicBlock(const BasicBlock *BB, ValueToValueMapTy &VMap, const Twine &NameSuffix="", Function *F=nullptr, ClonedCodeInfo *CodeInfo=nullptr, DebugInfoFinder *DIFinder=nullptr)
Return a copy of the specified basic block, but without embedding the block into a particular functio...
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
bool simplifyLoopIVs(Loop *L, ScalarEvolution *SE, DominatorTree *DT, LoopInfo *LI, const TargetTransformInfo *TTI, SmallVectorImpl< WeakTrackingVH > &Dead)
SimplifyLoopIVs - Simplify users of induction variables within this loop.
SmallVector< ValueTypeFromRangeType< R >, Size > to_vector(R &&Range)
Given a range of type R, iterate the entire range and return a SmallVector with elements of the vecto...
LoopUnrollResult
Represents the result of a UnrollLoop invocation.
@ Unmodified
The loop was not modified.
unsigned changeToUnreachable(Instruction *I, bool PreserveLCSSA=false, DomTreeUpdater *DTU=nullptr, MemorySSAUpdater *MSSAU=nullptr)
Insert an unreachable instruction before the specified instruction, making it and the rest of the cod...
bool MergeBlockIntoPredecessor(BasicBlock *BB, DomTreeUpdater *DTU=nullptr, LoopInfo *LI=nullptr, MemorySSAUpdater *MSSAU=nullptr, MemoryDependenceResults *MemDep=nullptr, bool PredecessorWithTwoSuccessors=false, DominatorTree *DT=nullptr)
Attempts to merge a block into its predecessor, if possible.
void erase_value(Container &C, ValueType V)
Wrapper function to remove a value from a container:
Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q, OptimizationRemarkEmitter *ORE=nullptr)
See if we can compute a simplified version of this instruction.
void cloneAndAdaptNoAliasScopes(ArrayRef< MDNode * > NoAliasDeclScopes, ArrayRef< BasicBlock * > NewBlocks, LLVMContext &Context, StringRef Ext)
Clone the specified noalias decl scopes.
void remapInstructionsInBlocks(ArrayRef< BasicBlock * > Blocks, ValueToValueMapTy &VMap)
Remaps instructions in Blocks using the mapping in VMap.
const Loop * addClonedBlockToLoopInfo(BasicBlock *OriginalBB, BasicBlock *ClonedBB, LoopInfo *LI, NewLoopsMap &NewLoops)
Adds ClonedBB to LoopInfo, creates a new loop for ClonedBB if necessary and adds a mapping from the o...
LoopUnrollResult UnrollLoop(Loop *L, UnrollLoopOptions ULO, LoopInfo *LI, ScalarEvolution *SE, DominatorTree *DT, AssumptionCache *AC, const llvm::TargetTransformInfo *TTI, OptimizationRemarkEmitter *ORE, bool PreserveLCSSA, Loop **RemainderLoop=nullptr)
Unroll the given loop by Count.
void identifyNoAliasScopesToClone(ArrayRef< BasicBlock * > BBs, SmallVectorImpl< MDNode * > &NoAliasDeclScopes)
Find the 'llvm.experimental.noalias.scope.decl' intrinsics in the specified basic blocks and extract ...
void simplifyLoopAfterUnroll(Loop *L, bool SimplifyIVs, LoopInfo *LI, ScalarEvolution *SE, DominatorTree *DT, AssumptionCache *AC, const TargetTransformInfo *TTI)
Perform some cleanup and simplifications on loops after unrolling.
MDNode * GetUnrollMetadata(MDNode *LoopID, StringRef Name)
Given an llvm.loop loop id metadata node, returns the loop hint metadata node with the given name (fo...
bool UnrollRuntimeLoopRemainder(Loop *L, unsigned Count, bool AllowExpensiveTripCount, bool UseEpilogRemainder, bool UnrollRemainder, bool ForgetAllSCEV, LoopInfo *LI, ScalarEvolution *SE, DominatorTree *DT, AssumptionCache *AC, const TargetTransformInfo *TTI, bool PreserveLCSSA, Loop **ResultLoop=nullptr)
Insert code in the prolog/epilog code when unrolling a loop with a run-time trip-count.
bool AllowExpensiveTripCount