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");
202 BasicBlock *PreHeader = L->getLoopPreheader();
204 assert(PreHeader && Header);
205 for (
const PHINode &PN : Header->phis()) {
206 if (isa<ConstantInt>(PN.getIncomingValueForBlock(PreHeader)))
222 if (SE && SimplifyIVs) {
228 while (!DeadInsts.
empty()) {
230 if (
Instruction *Inst = dyn_cast_or_null<Instruction>(V))
237 const DataLayout &
DL = L->getHeader()->getModule()->getDataLayout();
243 Inst.replaceAllUsesWith(V);
253 const APInt *C1, *C2;
255 auto *InnerI = dyn_cast<Instruction>(Inst.getOperand(0));
256 auto *InnerOBO = cast<OverflowingBinaryOperator>(Inst.getOperand(0));
259 Inst.setOperand(0,
X);
261 Inst.setHasNoUnsignedWrap(Inst.hasNoUnsignedWrap() &&
262 InnerOBO->hasNoUnsignedWrap());
263 Inst.setHasNoSignedWrap(Inst.hasNoSignedWrap() &&
264 InnerOBO->hasNoSignedWrap() &&
300 bool PreserveLCSSA,
Loop **RemainderLoop) {
301 assert(DT &&
"DomTree is required");
303 if (!L->getLoopPreheader()) {
304 LLVM_DEBUG(
dbgs() <<
" Can't unroll; loop preheader-insertion failed.\n");
308 if (!L->getLoopLatch()) {
309 LLVM_DEBUG(
dbgs() <<
" Can't unroll; loop exit-block-insertion failed.\n");
314 if (!L->isSafeToClone()) {
315 LLVM_DEBUG(
dbgs() <<
" Can't unroll; Loop body cannot be cloned.\n");
319 if (L->getHeader()->hasAddressTaken()) {
322 dbgs() <<
" Won't unroll loop: address of header block is taken.\n");
330 BasicBlock *Preheader = L->getLoopPreheader();
334 L->getExitBlocks(ExitBlocks);
335 std::vector<BasicBlock *> OriginalLoopBlocks = L->getBlocks();
339 unsigned EstimatedLoopInvocationWeight = 0;
340 std::optional<unsigned> OriginalTripCount =
345 if (MaxTripCount && ULO.
Count > MaxTripCount)
346 ULO.
Count = MaxTripCount;
350 unsigned TripMultiple;
351 unsigned BreakoutTrip;
358 L->getExitingBlocks(ExitingBlocks);
359 for (
auto *ExitingBlock : ExitingBlocks) {
362 auto *BI = dyn_cast<BranchInst>(ExitingBlock->getTerminator());
369 if (
Info.TripCount != 0) {
371 Info.TripMultiple = 0;
373 Info.BreakoutTrip =
Info.TripMultiple =
376 Info.ExitOnTrue = !L->contains(BI->getSuccessor(0));
377 Info.ExitingBlocks.push_back(ExitingBlock);
378 LLVM_DEBUG(
dbgs() <<
" Exiting block %" << ExitingBlock->getName()
379 <<
": TripCount=" <<
Info.TripCount
380 <<
", TripMultiple=" <<
Info.TripMultiple
381 <<
", BreakoutTrip=" <<
Info.BreakoutTrip <<
"\n");
387 const bool CompletelyUnroll = ULO.
Count == MaxTripCount;
389 const bool PreserveOnlyFirst = CompletelyUnroll && MaxOrZero;
393 if (CompletelyUnroll)
402 bool NeedToFixLCSSA =
403 PreserveLCSSA && CompletelyUnroll &&
417 bool LatchIsExiting = L->isLoopExiting(LatchBlock);
418 if (!LatchBI || (LatchBI->isConditional() && !LatchIsExiting)) {
420 dbgs() <<
"Can't unroll; a conditional latch must exit the loop");
421 return LoopUnrollResult::Unmodified;
429 bool HasConvergent =
false;
430 for (
auto &BB : L->blocks())
432 if (
auto *CB = dyn_cast<CallBase>(&
I))
433 HasConvergent |= CB->isConvergent();
435 "Can't runtime unroll if loop contains a convergent operation.");
438 bool EpilogProfitability =
446 PreserveLCSSA, RemainderLoop)) {
451 "generated when assuming runtime trip count\n");
452 return LoopUnrollResult::Unmodified;
458 if (CompletelyUnroll) {
459 LLVM_DEBUG(
dbgs() <<
"COMPLETELY UNROLLING loop %" << Header->getName()
460 <<
" with trip count " << ULO.
Count <<
"!\n");
465 <<
"completely unrolled loop with "
466 << NV(
"UnrollCount", ULO.
Count) <<
" iterations";
469 LLVM_DEBUG(
dbgs() <<
"UNROLLING loop %" << Header->getName() <<
" by "
479 Diag <<
"unrolled loop by a factor of " << NV(
"UnrollCount", ULO.
Count);
481 Diag <<
" with run-time trip count";
504 ++NumUnrolledNotLatch;
509 std::vector<PHINode*> OrigPHINode;
511 OrigPHINode.push_back(cast<PHINode>(
I));
514 std::vector<BasicBlock *> Headers;
515 std::vector<BasicBlock *> Latches;
516 Headers.push_back(Header);
517 Latches.push_back(LatchBlock);
529 std::vector<BasicBlock*> UnrolledLoopBlocks = L->getBlocks();
536 for (
Loop *SubLoop : *L)
537 LoopsToSimplify.
insert(SubLoop);
541 if (Header->getParent()->shouldEmitDebugInfoForProfiling() &&
545 if (!
I.isDebugOrPseudoInst())
547 auto NewDIL = DIL->cloneByMultiplyingDuplicationFactor(ULO.
Count);
549 I.setDebugLoc(*NewDIL);
552 <<
"Failed to create new discriminator: "
553 << DIL->getFilename() <<
" Line: " << DIL->getLine());
564 auto BlockInsertPt = std::next(LatchBlock->
getIterator());
565 for (
unsigned It = 1; It != ULO.
Count; ++It) {
573 Header->getParent()->insert(BlockInsertPt, New);
576 "Header should not be in a sub-loop");
580 LoopsToSimplify.
insert(NewLoops[OldLoop]);
585 for (
PHINode *OrigPHI : OrigPHINode) {
586 PHINode *NewPHI = cast<PHINode>(VMap[OrigPHI]);
588 if (
Instruction *InValI = dyn_cast<Instruction>(InVal))
589 if (It > 1 && L->contains(InValI))
590 InVal = LastValueMap[InValI];
591 VMap[OrigPHI] = InVal;
596 LastValueMap[*BB] = New;
599 LastValueMap[VI->first] = VI->second;
603 if (L->contains(Succ))
606 Value *Incoming =
PHI.getIncomingValueForBlock(*BB);
608 if (It != LastValueMap.
end())
610 PHI.addIncoming(Incoming, New);
617 Headers.push_back(New);
618 if (*BB == LatchBlock)
619 Latches.push_back(New);
623 auto ExitInfoIt = ExitInfos.
find(*BB);
624 if (ExitInfoIt != ExitInfos.
end())
625 ExitInfoIt->second.ExitingBlocks.push_back(New);
628 UnrolledLoopBlocks.push_back(New);
637 auto BBDomNode = DT->
getNode(*BB);
638 auto BBIDom = BBDomNode->
getIDom();
639 BasicBlock *OriginalBBIDom = BBIDom->getBlock();
641 New, cast<BasicBlock>(LastValueMap[cast<Value>(OriginalBBIDom)]));
649 if (
auto *II = dyn_cast<AssumeInst>(&
I))
656 std::string ext = (
Twine(
"It") +
Twine(It)).str();
658 Header->getContext(), ext);
663 for (
PHINode *PN : OrigPHINode) {
664 if (CompletelyUnroll) {
665 PN->replaceAllUsesWith(PN->getIncomingValueForBlock(Preheader));
666 PN->eraseFromParent();
667 }
else if (ULO.
Count > 1) {
668 Value *InVal = PN->removeIncomingValue(LatchBlock,
false);
671 if (
Instruction *InValI = dyn_cast<Instruction>(InVal)) {
672 if (L->contains(InValI))
673 InVal = LastValueMap[InVal];
675 assert(Latches.back() == LastValueMap[LatchBlock] &&
"bad last latch");
676 PN->addIncoming(InVal, Latches.back());
682 for (
unsigned i = 0, e = Latches.size(); i != e; ++i) {
683 unsigned j = (i + 1) % e;
684 Latches[i]->getTerminator()->replaceSuccessorWith(Headers[i], Headers[j]);
692 for (
auto *BB : OriginalLoopBlocks) {
693 auto *BBDomNode = DT->
getNode(BB);
695 for (
auto *ChildDomNode : BBDomNode->children()) {
696 auto *ChildBB = ChildDomNode->getBlock();
697 if (!L->contains(ChildBB))
705 for (
auto *ChildBB : ChildrenToUpdate)
711 DT->
verify(DominatorTree::VerificationLevel::Fast));
714 auto SetDest = [&](
BasicBlock *Src,
bool WillExit,
bool ExitOnTrue) {
715 auto *Term = cast<BranchInst>(Src->getTerminator());
716 const unsigned Idx = ExitOnTrue ^ WillExit;
725 Term->eraseFromParent();
727 DTUpdates.
emplace_back(DominatorTree::Delete, Src, DeadSucc);
730 auto WillExit = [&](
const ExitInfo &
Info,
unsigned i,
unsigned j,
731 bool IsLatch) -> std::optional<bool> {
732 if (CompletelyUnroll) {
733 if (PreserveOnlyFirst) {
741 if (
Info.TripCount && j !=
Info.TripCount)
749 if (IsLatch && j != 0)
754 if (j !=
Info.BreakoutTrip &&
755 (
Info.TripMultiple == 0 || j %
Info.TripMultiple != 0)) {
765 for (
auto &Pair : ExitInfos) {
766 ExitInfo &
Info = Pair.second;
767 for (
unsigned i = 0, e =
Info.ExitingBlocks.size(); i != e; ++i) {
769 unsigned j = (i + 1) % e;
770 bool IsLatch = Pair.first == LatchBlock;
771 std::optional<bool> KnownWillExit = WillExit(
Info, i, j, IsLatch);
772 if (!KnownWillExit) {
773 if (!
Info.FirstExitingBlock)
774 Info.FirstExitingBlock =
Info.ExitingBlocks[i];
783 if (*KnownWillExit && !IsLatch) {
784 if (!
Info.FirstExitingBlock)
785 Info.FirstExitingBlock =
Info.ExitingBlocks[i];
789 SetDest(
Info.ExitingBlocks[i], *KnownWillExit,
Info.ExitOnTrue);
795 if (ExitingBlocks.
size() == 1 && ExitInfos.
size() == 1) {
803 auto &[OriginalExit,
Info] = *ExitInfos.
begin();
804 if (!
Info.FirstExitingBlock)
805 Info.FirstExitingBlock =
Info.ExitingBlocks.back();
807 if (L->contains(
C->getBlock()))
816 if (!LatchIsExiting && CompletelyUnroll) {
826 BranchInst *Term = dyn_cast<BranchInst>(Latch->getTerminator());
828 (CompletelyUnroll && !LatchIsExiting && Latch == Latches.back())) &&
829 "Need a branch as terminator, except when fully unrolling with "
830 "unconditional latch");
831 if (Term && Term->isUnconditional()) {
837 DTUToUse ?
nullptr : DT)) {
839 std::replace(Latches.begin(), Latches.end(), Dest, Fold);
850 DT->
verify(DominatorTree::VerificationLevel::Fast));
857 NumCompletelyUnrolled += CompletelyUnroll;
860 Loop *OuterL = L->getParentLoop();
862 if (CompletelyUnroll) {
866 }
else if (OriginalTripCount) {
870 EstimatedLoopInvocationWeight);
885 if (PreserveLCSSA && OuterL && CompletelyUnroll && !NeedToFixLCSSA)
895 if (NeedToFixLCSSA) {
900 Loop *FixLCSSALoop = OuterL;
901 if (!FixLCSSALoop->
contains(LatchLoop))
906 }
else if (PreserveLCSSA) {
908 "Loops should be in LCSSA form after loop-unroll.");
913 simplifyLoop(OuterL, DT, LI, SE, AC,
nullptr, PreserveLCSSA);
916 for (
Loop *SubLoop : LoopsToSimplify)
917 simplifyLoop(SubLoop, DT, LI, SE, AC,
nullptr, PreserveLCSSA);
920 return CompletelyUnroll ? LoopUnrollResult::FullyUnrolled
921 : LoopUnrollResult::PartiallyUnrolled;
for(const MachineOperand &MO :llvm::drop_begin(OldMI.operands(), Desc.getNumOperands()))
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.
DenseMap< Block *, BlockRelaxAux > Blocks
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
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.
Class for arbitrary precision integers.
APInt sadd_ov(const APInt &RHS, bool &Overflow) const
A cache of @llvm.assume calls within a function.
void registerAssumption(AssumeInst *CI)
Add an @llvm.assume intrinsic to this function's cache.
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
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...
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)
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
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...
InstListType::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 * getHeader() const
void addBasicBlockToLoop(BlockT *NewBB, LoopInfoBase< BlockT, LoopT > &LI)
This method is used by other analyses to update loop information.
void addChildLoop(LoopT *NewChild)
Add the specified loop to be a child of this loop.
LoopT * getParentLoop() const
Return the parent loop if it exists or nullptr for top level loops.
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(const LoopInfo *LI)
Traverse the loop blocks and store the DFS result.
RPOIterator endRPO() const
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 * AllocateLoop(ArgsTy &&...Args)
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.
const MDOperand & getOperand(unsigned I) const
unsigned getNumOperands() const
Return number of MDNode operands.
StringRef getString() const
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.
self_iterator getIterator()
@ C
The default llvm calling convention, compatible with C.
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
bool match(Val *V, const Pattern &P)
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
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.
std::optional< unsigned > getLoopEstimatedTripCount(Loop *L, unsigned *EstimatedLoopInvocationWeight=nullptr)
Returns a loop's estimated trip count based on branch weight metadata.
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...
Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q)
See if we can compute a simplified version of this instruction.
void erase(Container &C, ValueType V)
Wrapper function to remove a value from a container:
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.
bool setLoopEstimatedTripCount(Loop *L, unsigned EstimatedTripCount, unsigned EstimatedLoopInvocationWeight)
Set a loop's branch weight metadata to reflect that loop has EstimatedTripCount iterations and Estima...
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