LLVM  3.7.0
LoopUnroll.cpp
Go to the documentation of this file.
1 //===-- UnrollLoop.cpp - Loop unrolling utilities -------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements some loop unrolling utilities. It does not define any
11 // actual pass or policy, but provides a single function to perform loop
12 // unrolling.
13 //
14 // The process of unrolling can produce extraneous basic blocks linked with
15 // unconditional branches. This will be corrected in the future.
16 //
17 //===----------------------------------------------------------------------===//
18 
20 #include "llvm/ADT/SmallPtrSet.h"
21 #include "llvm/ADT/Statistic.h"
25 #include "llvm/Analysis/LoopPass.h"
27 #include "llvm/IR/BasicBlock.h"
28 #include "llvm/IR/DataLayout.h"
29 #include "llvm/IR/DiagnosticInfo.h"
30 #include "llvm/IR/Dominators.h"
31 #include "llvm/IR/LLVMContext.h"
32 #include "llvm/Support/Debug.h"
39 using namespace llvm;
40 
41 #define DEBUG_TYPE "loop-unroll"
42 
43 // TODO: Should these be here or in LoopUnroll?
44 STATISTIC(NumCompletelyUnrolled, "Number of loops completely unrolled");
45 STATISTIC(NumUnrolled, "Number of loops unrolled (completely or otherwise)");
46 
47 /// RemapInstruction - Convert the instruction operands from referencing the
48 /// current values into those specified by VMap.
49 static inline void RemapInstruction(Instruction *I,
50  ValueToValueMapTy &VMap) {
51  for (unsigned op = 0, E = I->getNumOperands(); op != E; ++op) {
52  Value *Op = I->getOperand(op);
53  ValueToValueMapTy::iterator It = VMap.find(Op);
54  if (It != VMap.end())
55  I->setOperand(op, It->second);
56  }
57 
58  if (PHINode *PN = dyn_cast<PHINode>(I)) {
59  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
60  ValueToValueMapTy::iterator It = VMap.find(PN->getIncomingBlock(i));
61  if (It != VMap.end())
62  PN->setIncomingBlock(i, cast<BasicBlock>(It->second));
63  }
64  }
65 }
66 
67 /// FoldBlockIntoPredecessor - Folds a basic block into its predecessor if it
68 /// only has one predecessor, and that predecessor only has one successor.
69 /// The LoopInfo Analysis that is passed will be kept consistent. If folding is
70 /// successful references to the containing loop must be removed from
71 /// ScalarEvolution by calling ScalarEvolution::forgetLoop because SE may have
72 /// references to the eliminated BB. The argument ForgottenLoops contains a set
73 /// of loops that have already been forgotten to prevent redundant, expensive
74 /// calls to ScalarEvolution::forgetLoop. Returns the new combined block.
75 static BasicBlock *
77  SmallPtrSetImpl<Loop *> &ForgottenLoops) {
78  // Merge basic blocks into their predecessor if there is only one distinct
79  // pred, and if there is only one distinct successor of the predecessor, and
80  // if there are no PHI nodes.
81  BasicBlock *OnlyPred = BB->getSinglePredecessor();
82  if (!OnlyPred) return nullptr;
83 
84  if (OnlyPred->getTerminator()->getNumSuccessors() != 1)
85  return nullptr;
86 
87  DEBUG(dbgs() << "Merging: " << *BB << "into: " << *OnlyPred);
88 
89  // Resolve any PHI nodes at the start of the block. They are all
90  // guaranteed to have exactly one entry if they exist, unless there are
91  // multiple duplicate (but guaranteed to be equal) entries for the
92  // incoming edges. This occurs when there are multiple edges from
93  // OnlyPred to OnlySucc.
95 
96  // Delete the unconditional branch from the predecessor...
97  OnlyPred->getInstList().pop_back();
98 
99  // Make all PHI nodes that referred to BB now refer to Pred as their
100  // source...
101  BB->replaceAllUsesWith(OnlyPred);
102 
103  // Move all definitions in the successor to the predecessor...
104  OnlyPred->getInstList().splice(OnlyPred->end(), BB->getInstList());
105 
106  // OldName will be valid until erased.
107  StringRef OldName = BB->getName();
108 
109  // Erase basic block from the function...
110 
111  // ScalarEvolution holds references to loop exit blocks.
112  if (LPM) {
114  if (Loop *L = LI->getLoopFor(BB)) {
115  if (ForgottenLoops.insert(L).second)
116  SE->forgetLoop(L);
117  }
118  }
119  }
120  LI->removeBlock(BB);
121 
122  // Inherit predecessor's name if it exists...
123  if (!OldName.empty() && !OnlyPred->hasName())
124  OnlyPred->setName(OldName);
125 
126  BB->eraseFromParent();
127 
128  return OnlyPred;
129 }
130 
131 /// Unroll the given loop by Count. The loop must be in LCSSA form. Returns true
132 /// if unrolling was successful, or false if the loop was unmodified. Unrolling
133 /// can only fail when the loop's latch block is not terminated by a conditional
134 /// branch instruction. However, if the trip count (and multiple) are not known,
135 /// loop unrolling will mostly produce more code that is no faster.
136 ///
137 /// TripCount is generally defined as the number of times the loop header
138 /// executes. UnrollLoop relaxes the definition to permit early exits: here
139 /// TripCount is the iteration on which control exits LatchBlock if no early
140 /// exits were taken. Note that UnrollLoop assumes that the loop counter test
141 /// terminates LatchBlock in order to remove unnecesssary instances of the
142 /// test. In other words, control may exit the loop prior to TripCount
143 /// iterations via an early branch, but control may not exit the loop from the
144 /// LatchBlock's terminator prior to TripCount iterations.
145 ///
146 /// Similarly, TripMultiple divides the number of times that the LatchBlock may
147 /// execute without exiting the loop.
148 ///
149 /// If AllowRuntime is true then UnrollLoop will consider unrolling loops that
150 /// have a runtime (i.e. not compile time constant) trip count. Unrolling these
151 /// loops require a unroll "prologue" that runs "RuntimeTripCount % Count"
152 /// iterations before branching into the unrolled loop. UnrollLoop will not
153 /// runtime-unroll the loop if computing RuntimeTripCount will be expensive and
154 /// AllowExpensiveTripCount is false.
155 ///
156 /// The LoopInfo Analysis that is passed will be kept consistent.
157 ///
158 /// If a LoopPassManager is passed in, and the loop is fully removed, it will be
159 /// removed from the LoopPassManager as well. LPM can also be NULL.
160 ///
161 /// This utility preserves LoopInfo. If DominatorTree or ScalarEvolution are
162 /// available from the Pass it must also preserve those analyses.
163 bool llvm::UnrollLoop(Loop *L, unsigned Count, unsigned TripCount,
164  bool AllowRuntime, bool AllowExpensiveTripCount,
165  unsigned TripMultiple, LoopInfo *LI, Pass *PP,
166  LPPassManager *LPM, AssumptionCache *AC) {
167  BasicBlock *Preheader = L->getLoopPreheader();
168  if (!Preheader) {
169  DEBUG(dbgs() << " Can't unroll; loop preheader-insertion failed.\n");
170  return false;
171  }
172 
173  BasicBlock *LatchBlock = L->getLoopLatch();
174  if (!LatchBlock) {
175  DEBUG(dbgs() << " Can't unroll; loop exit-block-insertion failed.\n");
176  return false;
177  }
178 
179  // Loops with indirectbr cannot be cloned.
180  if (!L->isSafeToClone()) {
181  DEBUG(dbgs() << " Can't unroll; Loop body cannot be cloned.\n");
182  return false;
183  }
184 
185  BasicBlock *Header = L->getHeader();
186  BranchInst *BI = dyn_cast<BranchInst>(LatchBlock->getTerminator());
187 
188  if (!BI || BI->isUnconditional()) {
189  // The loop-rotate pass can be helpful to avoid this in many cases.
190  DEBUG(dbgs() <<
191  " Can't unroll; loop not terminated by a conditional branch.\n");
192  return false;
193  }
194 
195  if (Header->hasAddressTaken()) {
196  // The loop-rotate pass can be helpful to avoid this in many cases.
197  DEBUG(dbgs() <<
198  " Won't unroll loop: address of header block is taken.\n");
199  return false;
200  }
201 
202  if (TripCount != 0)
203  DEBUG(dbgs() << " Trip Count = " << TripCount << "\n");
204  if (TripMultiple != 1)
205  DEBUG(dbgs() << " Trip Multiple = " << TripMultiple << "\n");
206 
207  // Effectively "DCE" unrolled iterations that are beyond the tripcount
208  // and will never be executed.
209  if (TripCount != 0 && Count > TripCount)
210  Count = TripCount;
211 
212  // Don't enter the unroll code if there is nothing to do. This way we don't
213  // need to support "partial unrolling by 1".
214  if (TripCount == 0 && Count < 2)
215  return false;
216 
217  assert(Count > 0);
218  assert(TripMultiple > 0);
219  assert(TripCount == 0 || TripCount % TripMultiple == 0);
220 
221  // Are we eliminating the loop control altogether?
222  bool CompletelyUnroll = Count == TripCount;
223 
224  // We assume a run-time trip count if the compiler cannot
225  // figure out the loop trip count and the unroll-runtime
226  // flag is specified.
227  bool RuntimeTripCount = (TripCount == 0 && Count > 0 && AllowRuntime);
228 
229  if (RuntimeTripCount &&
230  !UnrollRuntimeLoopProlog(L, Count, AllowExpensiveTripCount, LI, LPM))
231  return false;
232 
233  // Notify ScalarEvolution that the loop will be substantially changed,
234  // if not outright eliminated.
235  ScalarEvolution *SE =
236  PP ? PP->getAnalysisIfAvailable<ScalarEvolution>() : nullptr;
237  if (SE)
238  SE->forgetLoop(L);
239 
240  // If we know the trip count, we know the multiple...
241  unsigned BreakoutTrip = 0;
242  if (TripCount != 0) {
243  BreakoutTrip = TripCount % Count;
244  TripMultiple = 0;
245  } else {
246  // Figure out what multiple to use.
247  BreakoutTrip = TripMultiple =
248  (unsigned)GreatestCommonDivisor64(Count, TripMultiple);
249  }
250 
251  // Report the unrolling decision.
252  DebugLoc LoopLoc = L->getStartLoc();
253  Function *F = Header->getParent();
254  LLVMContext &Ctx = F->getContext();
255 
256  if (CompletelyUnroll) {
257  DEBUG(dbgs() << "COMPLETELY UNROLLING loop %" << Header->getName()
258  << " with trip count " << TripCount << "!\n");
259  emitOptimizationRemark(Ctx, DEBUG_TYPE, *F, LoopLoc,
260  Twine("completely unrolled loop with ") +
261  Twine(TripCount) + " iterations");
262  } else {
263  auto EmitDiag = [&](const Twine &T) {
264  emitOptimizationRemark(Ctx, DEBUG_TYPE, *F, LoopLoc,
265  "unrolled loop by a factor of " + Twine(Count) +
266  T);
267  };
268 
269  DEBUG(dbgs() << "UNROLLING loop %" << Header->getName()
270  << " by " << Count);
271  if (TripMultiple == 0 || BreakoutTrip != TripMultiple) {
272  DEBUG(dbgs() << " with a breakout at trip " << BreakoutTrip);
273  EmitDiag(" with a breakout at trip " + Twine(BreakoutTrip));
274  } else if (TripMultiple != 1) {
275  DEBUG(dbgs() << " with " << TripMultiple << " trips per branch");
276  EmitDiag(" with " + Twine(TripMultiple) + " trips per branch");
277  } else if (RuntimeTripCount) {
278  DEBUG(dbgs() << " with run-time trip count");
279  EmitDiag(" with run-time trip count");
280  }
281  DEBUG(dbgs() << "!\n");
282  }
283 
284  bool ContinueOnTrue = L->contains(BI->getSuccessor(0));
285  BasicBlock *LoopExit = BI->getSuccessor(ContinueOnTrue);
286 
287  // For the first iteration of the loop, we should use the precloned values for
288  // PHI nodes. Insert associations now.
289  ValueToValueMapTy LastValueMap;
290  std::vector<PHINode*> OrigPHINode;
291  for (BasicBlock::iterator I = Header->begin(); isa<PHINode>(I); ++I) {
292  OrigPHINode.push_back(cast<PHINode>(I));
293  }
294 
295  std::vector<BasicBlock*> Headers;
296  std::vector<BasicBlock*> Latches;
297  Headers.push_back(Header);
298  Latches.push_back(LatchBlock);
299 
300  // The current on-the-fly SSA update requires blocks to be processed in
301  // reverse postorder so that LastValueMap contains the correct value at each
302  // exit.
303  LoopBlocksDFS DFS(L);
304  DFS.perform(LI);
305 
306  // Stash the DFS iterators before adding blocks to the loop.
307  LoopBlocksDFS::RPOIterator BlockBegin = DFS.beginRPO();
308  LoopBlocksDFS::RPOIterator BlockEnd = DFS.endRPO();
309 
310  for (unsigned It = 1; It != Count; ++It) {
311  std::vector<BasicBlock*> NewBlocks;
313  NewLoops[L] = L;
314 
315  for (LoopBlocksDFS::RPOIterator BB = BlockBegin; BB != BlockEnd; ++BB) {
316  ValueToValueMapTy VMap;
317  BasicBlock *New = CloneBasicBlock(*BB, VMap, "." + Twine(It));
318  Header->getParent()->getBasicBlockList().push_back(New);
319 
320  // Tell LI about New.
321  if (*BB == Header) {
322  assert(LI->getLoopFor(*BB) == L && "Header should not be in a sub-loop");
323  L->addBasicBlockToLoop(New, *LI);
324  } else {
325  // Figure out which loop New is in.
326  const Loop *OldLoop = LI->getLoopFor(*BB);
327  assert(OldLoop && "Should (at least) be in the loop being unrolled!");
328 
329  Loop *&NewLoop = NewLoops[OldLoop];
330  if (!NewLoop) {
331  // Found a new sub-loop.
332  assert(*BB == OldLoop->getHeader() &&
333  "Header should be first in RPO");
334 
335  Loop *NewLoopParent = NewLoops.lookup(OldLoop->getParentLoop());
336  assert(NewLoopParent &&
337  "Expected parent loop before sub-loop in RPO");
338  NewLoop = new Loop;
339  NewLoopParent->addChildLoop(NewLoop);
340 
341  // Forget the old loop, since its inputs may have changed.
342  if (SE)
343  SE->forgetLoop(OldLoop);
344  }
345  NewLoop->addBasicBlockToLoop(New, *LI);
346  }
347 
348  if (*BB == Header)
349  // Loop over all of the PHI nodes in the block, changing them to use
350  // the incoming values from the previous block.
351  for (unsigned i = 0, e = OrigPHINode.size(); i != e; ++i) {
352  PHINode *NewPHI = cast<PHINode>(VMap[OrigPHINode[i]]);
353  Value *InVal = NewPHI->getIncomingValueForBlock(LatchBlock);
354  if (Instruction *InValI = dyn_cast<Instruction>(InVal))
355  if (It > 1 && L->contains(InValI))
356  InVal = LastValueMap[InValI];
357  VMap[OrigPHINode[i]] = InVal;
358  New->getInstList().erase(NewPHI);
359  }
360 
361  // Update our running map of newest clones
362  LastValueMap[*BB] = New;
363  for (ValueToValueMapTy::iterator VI = VMap.begin(), VE = VMap.end();
364  VI != VE; ++VI)
365  LastValueMap[VI->first] = VI->second;
366 
367  // Add phi entries for newly created values to all exit blocks.
368  for (succ_iterator SI = succ_begin(*BB), SE = succ_end(*BB);
369  SI != SE; ++SI) {
370  if (L->contains(*SI))
371  continue;
372  for (BasicBlock::iterator BBI = (*SI)->begin();
373  PHINode *phi = dyn_cast<PHINode>(BBI); ++BBI) {
374  Value *Incoming = phi->getIncomingValueForBlock(*BB);
375  ValueToValueMapTy::iterator It = LastValueMap.find(Incoming);
376  if (It != LastValueMap.end())
377  Incoming = It->second;
378  phi->addIncoming(Incoming, New);
379  }
380  }
381  // Keep track of new headers and latches as we create them, so that
382  // we can insert the proper branches later.
383  if (*BB == Header)
384  Headers.push_back(New);
385  if (*BB == LatchBlock)
386  Latches.push_back(New);
387 
388  NewBlocks.push_back(New);
389  }
390 
391  // Remap all instructions in the most recent iteration
392  for (unsigned i = 0; i < NewBlocks.size(); ++i)
393  for (BasicBlock::iterator I = NewBlocks[i]->begin(),
394  E = NewBlocks[i]->end(); I != E; ++I)
395  ::RemapInstruction(I, LastValueMap);
396  }
397 
398  // Loop over the PHI nodes in the original block, setting incoming values.
399  for (unsigned i = 0, e = OrigPHINode.size(); i != e; ++i) {
400  PHINode *PN = OrigPHINode[i];
401  if (CompletelyUnroll) {
402  PN->replaceAllUsesWith(PN->getIncomingValueForBlock(Preheader));
403  Header->getInstList().erase(PN);
404  }
405  else if (Count > 1) {
406  Value *InVal = PN->removeIncomingValue(LatchBlock, false);
407  // If this value was defined in the loop, take the value defined by the
408  // last iteration of the loop.
409  if (Instruction *InValI = dyn_cast<Instruction>(InVal)) {
410  if (L->contains(InValI))
411  InVal = LastValueMap[InVal];
412  }
413  assert(Latches.back() == LastValueMap[LatchBlock] && "bad last latch");
414  PN->addIncoming(InVal, Latches.back());
415  }
416  }
417 
418  // Now that all the basic blocks for the unrolled iterations are in place,
419  // set up the branches to connect them.
420  for (unsigned i = 0, e = Latches.size(); i != e; ++i) {
421  // The original branch was replicated in each unrolled iteration.
422  BranchInst *Term = cast<BranchInst>(Latches[i]->getTerminator());
423 
424  // The branch destination.
425  unsigned j = (i + 1) % e;
426  BasicBlock *Dest = Headers[j];
427  bool NeedConditional = true;
428 
429  if (RuntimeTripCount && j != 0) {
430  NeedConditional = false;
431  }
432 
433  // For a complete unroll, make the last iteration end with a branch
434  // to the exit block.
435  if (CompletelyUnroll && j == 0) {
436  Dest = LoopExit;
437  NeedConditional = false;
438  }
439 
440  // If we know the trip count or a multiple of it, we can safely use an
441  // unconditional branch for some iterations.
442  if (j != BreakoutTrip && (TripMultiple == 0 || j % TripMultiple != 0)) {
443  NeedConditional = false;
444  }
445 
446  if (NeedConditional) {
447  // Update the conditional branch's successor for the following
448  // iteration.
449  Term->setSuccessor(!ContinueOnTrue, Dest);
450  } else {
451  // Remove phi operands at this loop exit
452  if (Dest != LoopExit) {
453  BasicBlock *BB = Latches[i];
454  for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB);
455  SI != SE; ++SI) {
456  if (*SI == Headers[i])
457  continue;
458  for (BasicBlock::iterator BBI = (*SI)->begin();
459  PHINode *Phi = dyn_cast<PHINode>(BBI); ++BBI) {
460  Phi->removeIncomingValue(BB, false);
461  }
462  }
463  }
464  // Replace the conditional branch with an unconditional one.
465  BranchInst::Create(Dest, Term);
466  Term->eraseFromParent();
467  }
468  }
469 
470  // Merge adjacent basic blocks, if possible.
471  SmallPtrSet<Loop *, 4> ForgottenLoops;
472  for (unsigned i = 0, e = Latches.size(); i != e; ++i) {
473  BranchInst *Term = cast<BranchInst>(Latches[i]->getTerminator());
474  if (Term->isUnconditional()) {
475  BasicBlock *Dest = Term->getSuccessor(0);
476  if (BasicBlock *Fold = FoldBlockIntoPredecessor(Dest, LI, LPM,
477  ForgottenLoops))
478  std::replace(Latches.begin(), Latches.end(), Dest, Fold);
479  }
480  }
481 
482  // FIXME: We could register any cloned assumptions instead of clearing the
483  // whole function's cache.
484  AC->clear();
485 
486  DominatorTree *DT = nullptr;
487  if (PP) {
488  // FIXME: Reconstruct dom info, because it is not preserved properly.
489  // Incrementally updating domtree after loop unrolling would be easy.
490  if (DominatorTreeWrapperPass *DTWP =
492  DT = &DTWP->getDomTree();
493  DT->recalculate(*L->getHeader()->getParent());
494  }
495 
496  // Simplify any new induction variables in the partially unrolled loop.
497  if (SE && !CompletelyUnroll) {
498  SmallVector<WeakVH, 16> DeadInsts;
499  simplifyLoopIVs(L, SE, LPM, DeadInsts);
500 
501  // Aggressively clean up dead instructions that simplifyLoopIVs already
502  // identified. Any remaining should be cleaned up below.
503  while (!DeadInsts.empty())
504  if (Instruction *Inst =
505  dyn_cast_or_null<Instruction>(&*DeadInsts.pop_back_val()))
507  }
508  }
509  // At this point, the code is well formed. We now do a quick sweep over the
510  // inserted code, doing constant propagation and dead code elimination as we
511  // go.
512  const DataLayout &DL = Header->getModule()->getDataLayout();
513  const std::vector<BasicBlock*> &NewLoopBlocks = L->getBlocks();
514  for (std::vector<BasicBlock*>::const_iterator BB = NewLoopBlocks.begin(),
515  BBE = NewLoopBlocks.end(); BB != BBE; ++BB)
516  for (BasicBlock::iterator I = (*BB)->begin(), E = (*BB)->end(); I != E; ) {
517  Instruction *Inst = I++;
518 
519  if (isInstructionTriviallyDead(Inst))
520  (*BB)->getInstList().erase(Inst);
521  else if (Value *V = SimplifyInstruction(Inst, DL))
522  if (LI->replacementPreservesLCSSAForm(Inst, V)) {
523  Inst->replaceAllUsesWith(V);
524  (*BB)->getInstList().erase(Inst);
525  }
526  }
527 
528  NumCompletelyUnrolled += CompletelyUnroll;
529  ++NumUnrolled;
530 
531  Loop *OuterL = L->getParentLoop();
532  // Remove the loop from the LoopPassManager if it's completely removed.
533  if (CompletelyUnroll && LPM != nullptr)
534  LPM->deleteLoopFromQueue(L);
535 
536  // If we have a pass and a DominatorTree we should re-simplify impacted loops
537  // to ensure subsequent analyses can rely on this form. We want to simplify
538  // at least one layer outside of the loop that was unrolled so that any
539  // changes to the parent loop exposed by the unrolling are considered.
540  if (PP && DT) {
541  if (!OuterL && !CompletelyUnroll)
542  OuterL = L;
543  if (OuterL) {
544  simplifyLoop(OuterL, DT, LI, PP, /*AliasAnalysis*/ nullptr, SE, AC);
545 
546  // LCSSA must be performed on the outermost affected loop. The unrolled
547  // loop's last loop latch is guaranteed to be in the outermost loop after
548  // deleteLoopFromQueue updates LoopInfo.
549  Loop *LatchLoop = LI->getLoopFor(Latches.back());
550  if (!OuterL->contains(LatchLoop))
551  while (OuterL->getParentLoop() != LatchLoop)
552  OuterL = OuterL->getParentLoop();
553 
554  formLCSSARecursively(*OuterL, *DT, LI, SE);
555  }
556  }
557 
558  return true;
559 }
560 
561 /// Given an llvm.loop loop id metadata node, returns the loop hint metadata
562 /// node with the given name (for example, "llvm.loop.unroll.count"). If no
563 /// such metadata node exists, then nullptr is returned.
565  // First operand should refer to the loop id itself.
566  assert(LoopID->getNumOperands() > 0 && "requires at least one operand");
567  assert(LoopID->getOperand(0) == LoopID && "invalid loop id");
568 
569  for (unsigned i = 1, e = LoopID->getNumOperands(); i < e; ++i) {
570  MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
571  if (!MD)
572  continue;
573 
574  MDString *S = dyn_cast<MDString>(MD->getOperand(0));
575  if (!S)
576  continue;
577 
578  if (Name.equals(S->getString()))
579  return MD;
580  }
581  return nullptr;
582 }
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:82
iplist< Instruction >::iterator eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing basic block and deletes it...
Definition: Instruction.cpp:70
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
void addIncoming(Value *V, BasicBlock *BB)
addIncoming - Add an incoming value to the end of the PHI list
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:223
void removeBlock(BlockT *BB)
removeBlock - This method completely removes BB from all data structures, including all of the Loop o...
Definition: LoopInfo.h:605
uint64_t GreatestCommonDivisor64(uint64_t A, uint64_t B)
GreatestCommonDivisor64 - Return the greatest common divisor of the two values using Euclid's algorit...
Definition: MathExtras.h:493
bool hasName() const
Definition: Value.h:228
STATISTIC(NumFunctions,"Total number of functions")
ValueT lookup(const KeyT &Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:159
void pop_back()
Definition: ilist.h:559
unsigned getNumOperands() const
Definition: User.h:138
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:942
ScalarEvolution - This class is the main scalar evolution driver.
A cache of .assume calls within a function.
const_iterator begin(StringRef path)
Get begin iterator over path.
Definition: Path.cpp:232
LoopT * getParentLoop() const
Definition: LoopInfo.h:97
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:111
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:740
F(f)
LoopT * getLoopFor(const BlockT *BB) const
getLoopFor - Return the inner most loop that BB lives in.
Definition: LoopInfo.h:540
#define op(i)
static BasicBlock * FoldBlockIntoPredecessor(BasicBlock *BB, LoopInfo *LI, LPPassManager *LPM, SmallPtrSetImpl< Loop * > &ForgottenLoops)
FoldBlockIntoPredecessor - Folds a basic block into its predecessor if it only has one predecessor...
Definition: LoopUnroll.cpp:76
const std::vector< BlockT * > & getBlocks() const
getBlocks - Get a list of the basic blocks which make up this loop.
Definition: LoopInfo.h:139
void emitOptimizationRemark(LLVMContext &Ctx, const char *PassName, const Function &Fn, const DebugLoc &DLoc, const Twine &Msg)
Emit an optimization-applied message.
BlockT * getHeader() const
Definition: LoopInfo.h:96
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
BlockT * getLoopLatch() const
getLoopLatch - If there is a single latch block for this loop, return it.
Definition: LoopInfoImpl.h:156
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:242
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:231
bool isUnconditional() const
void push_back(NodeTy *val)
Definition: ilist.h:554
Value * removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty=true)
removeIncomingValue - Remove an incoming value.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:79
AnalysisType * getAnalysisIfAvailable() const
getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to get analysis information tha...
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr it the function does no...
Definition: BasicBlock.cpp:116
T LLVM_ATTRIBUTE_UNUSED_RESULT pop_back_val()
Definition: SmallVector.h:406
bool simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI, Pass *PP, AliasAnalysis *AA=nullptr, ScalarEvolution *SE=nullptr, AssumptionCache *AC=nullptr)
Simplify each loop in a loop nest recursively.
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches, switches, etc.
Definition: BasicBlock.h:306
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:250
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:104
void addBasicBlockToLoop(BlockT *NewBB, LoopInfoBase< BlockT, LoopT > &LI)
addBasicBlockToLoop - This method is used by other analyses to update loop information.
Definition: LoopInfoImpl.h:187
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: SmallVector.h:57
#define T
void addChildLoop(LoopT *NewChild)
addChildLoop - Add the specified loop to be a child of this loop.
Definition: LoopInfo.h:265
BasicBlock * getSuccessor(unsigned i) const
iterator find(const KeyT &Val)
Definition: ValueMap.h:132
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:351
void perform(LoopInfo *LI)
Traverse the loop blocks and store the DFS result.
Definition: LoopInfo.cpp:731
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:67
Interval::succ_iterator succ_end(Interval *I)
Definition: Interval.h:107
void FoldSingleEntryPHINodes(BasicBlock *BB, AliasAnalysis *AA=nullptr, MemoryDependenceAnalysis *MemDep=nullptr)
FoldSingleEntryPHINodes - We know that BB has one predecessor.
unsigned getNumSuccessors() const
Return the number of successors that this terminator has.
Definition: InstrTypes.h:57
void clear()
Clear the cache of .assume intrinsics for a function.
friend const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:240
BlockT * getLoopPreheader() const
getLoopPreheader - If there is a preheader for this loop, return it.
Definition: LoopInfoImpl.h:108
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:41
BranchInst - Conditional or Unconditional Branch instruction.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:264
bool simplifyLoopIVs(Loop *L, ScalarEvolution *SE, LPPassManager *LPM, SmallVectorImpl< WeakVH > &Dead)
SimplifyLoopIVs - Simplify users of induction variables within this loop.
bool contains(const LoopT *L) const
contains - Return true if the specified loop is contained within in this loop.
Definition: LoopInfo.h:105
const InstListType & getInstList() const
Return the underlying instruction list container.
Definition: BasicBlock.h:252
bool isSafeToClone() const
isSafeToClone - Return true if the loop body is safe to clone in practice.
Definition: LoopInfo.cpp:207
std::vector< BasicBlock * >::const_reverse_iterator RPOIterator
Definition: LoopIterator.h:42
for(unsigned i=0, e=MI->getNumOperands();i!=e;++i)
Value * getOperand(unsigned i) const
Definition: User.h:118
bool RecursivelyDeleteTriviallyDeadInstructions(Value *V, const TargetLibraryInfo *TLI=nullptr)
RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a trivially dead instruction...
Definition: Local.cpp:340
iterator erase(iterator where)
Definition: ilist.h:465
DebugLoc getStartLoc() const
Return the debug location of the start of this loop.
Definition: LoopInfo.h:460
void setSuccessor(unsigned idx, BasicBlock *NewSucc)
iterator end()
Definition: ValueMap.h:112
StringRef getString() const
Definition: Metadata.cpp:375
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:936
const BasicBlockListType & getBasicBlockList() const
Definition: Function.h:436
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:299
iterator end()
Definition: BasicBlock.h:233
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
void deleteLoopFromQueue(Loop *L)
Delete loop from the loop queue and loop hierarchy (LoopInfo).
Definition: LoopPass.cpp:76
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
void splice(iterator where, iplist &L2)
Definition: ilist.h:570
void setOperand(unsigned i, Value *Val)
Definition: User.h:122
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
Store the result of a depth first search within basic blocks contained by a single loop...
Definition: LoopIterator.h:38
Value * getIncomingValueForBlock(const BasicBlock *BB) const
BasicBlock * getSinglePredecessor()
Return the predecessor of this block if it has a single predecessor block.
Definition: BasicBlock.cpp:211
void RemapInstruction(Instruction *I, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
RemapInstruction - Convert the instruction operands from referencing the current values into those sp...
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:136
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...
Definition: LoopUnroll.cpp:564
bool formLCSSARecursively(Loop &L, DominatorTree &DT, LoopInfo *LI, ScalarEvolution *SE=nullptr)
Put a loop nest into LCSSA form.
Definition: LCSSA.cpp:264
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:372
void forgetLoop(const Loop *L)
forgetLoop - This method should be called by the client when it has changed a loop in a way that may ...
iplist< BasicBlock >::iterator eraseFromParent()
Unlink 'this' from the containing function and delete it.
Definition: BasicBlock.cpp:97
#define I(x, y, z)
Definition: MD5.cpp:54
TerminatorInst * getTerminator()
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:124
RPOIterator beginRPO() const
Reverse iterate over the cached postorder blocks.
Definition: LoopIterator.h:77
bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)
isInstructionTriviallyDead - Return true if the result produced by the instruction is not used...
Definition: Local.cpp:282
LLVM Value Representation.
Definition: Value.h:69
#define DEBUG_TYPE
Definition: LoopUnroll.cpp:41
#define DEBUG(X)
Definition: Debug.h:92
void recalculate(FT &F)
recalculate - compute a dominator tree for the given function
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
A single uniqued string.
Definition: Metadata.h:508
Value * SimplifyInstruction(Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
SimplifyInstruction - See if we can compute a simplified version of this instruction.
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:203
bool UnrollRuntimeLoopProlog(Loop *L, unsigned Count, bool AllowExpensiveTripCount, LoopInfo *LI, LPPassManager *LPM)
Insert code in the prolog code when unrolling a loop with a run-time trip-count.
bool replacementPreservesLCSSAForm(Instruction *From, Value *To)
replacementPreservesLCSSAForm - Returns true if replacing From with To everywhere is guaranteed to pr...
Definition: LoopInfo.h:662
BasicBlock * CloneBasicBlock(const BasicBlock *BB, ValueToValueMapTy &VMap, const Twine &NameSuffix="", Function *F=nullptr, ClonedCodeInfo *CodeInfo=nullptr)
CloneBasicBlock - Return a copy of the specified basic block, but without embedding the block into a ...
iterator begin()
Definition: ValueMap.h:111
bool UnrollLoop(Loop *L, unsigned Count, unsigned TripCount, bool AllowRuntime, bool AllowExpensiveTripCount, unsigned TripMultiple, LoopInfo *LI, Pass *PP, LPPassManager *LPM, AssumptionCache *AC)
Unroll the given loop by Count.
Definition: LoopUnroll.cpp:163
RPOIterator endRPO() const
Definition: LoopIterator.h:81
bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:110