LLVM  3.7.0
LoopSimplify.cpp
Go to the documentation of this file.
1 //===- LoopSimplify.cpp - Loop Canonicalization Pass ----------------------===//
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 pass performs several transformations to transform natural loops into a
11 // simpler form, which makes subsequent analyses and transformations simpler and
12 // more effective.
13 //
14 // Loop pre-header insertion guarantees that there is a single, non-critical
15 // entry edge from outside of the loop to the loop header. This simplifies a
16 // number of analyses and transformations, such as LICM.
17 //
18 // Loop exit-block insertion guarantees that all exit blocks from the loop
19 // (blocks which are outside of the loop that have predecessors inside of the
20 // loop) only have predecessors from inside of the loop (and are thus dominated
21 // by the loop header). This simplifies transformations such as store-sinking
22 // that are built into LICM.
23 //
24 // This pass also guarantees that loops will have exactly one backedge.
25 //
26 // Indirectbr instructions introduce several complications. If the loop
27 // contains or is entered by an indirectbr instruction, it may not be possible
28 // to transform the loop and make these guarantees. Client code should check
29 // that these conditions are true before relying on them.
30 //
31 // Note that the simplifycfg pass will clean up blocks which are split out but
32 // end up being unnecessary, so usage of this pass should not pessimize
33 // generated code.
34 //
35 // This pass obviously modifies the CFG, but updates loop information and
36 // dominator information.
37 //
38 //===----------------------------------------------------------------------===//
39 
40 #include "llvm/Transforms/Scalar.h"
42 #include "llvm/ADT/SetOperations.h"
43 #include "llvm/ADT/SetVector.h"
44 #include "llvm/ADT/SmallVector.h"
45 #include "llvm/ADT/Statistic.h"
50 #include "llvm/Analysis/LoopInfo.h"
52 #include "llvm/IR/CFG.h"
53 #include "llvm/IR/Constants.h"
54 #include "llvm/IR/DataLayout.h"
55 #include "llvm/IR/Dominators.h"
56 #include "llvm/IR/Function.h"
57 #include "llvm/IR/Instructions.h"
58 #include "llvm/IR/IntrinsicInst.h"
59 #include "llvm/IR/LLVMContext.h"
60 #include "llvm/IR/Module.h"
61 #include "llvm/IR/Type.h"
62 #include "llvm/Support/Debug.h"
67 using namespace llvm;
68 
69 #define DEBUG_TYPE "loop-simplify"
70 
71 STATISTIC(NumInserted, "Number of pre-header or exit blocks inserted");
72 STATISTIC(NumNested , "Number of nested loops split out");
73 
74 // If the block isn't already, move the new block to right after some 'outside
75 // block' block. This prevents the preheader from being placed inside the loop
76 // body, e.g. when the loop hasn't been rotated.
79  Loop *L) {
80  // Check to see if NewBB is already well placed.
81  Function::iterator BBI = NewBB; --BBI;
82  for (unsigned i = 0, e = SplitPreds.size(); i != e; ++i) {
83  if (&*BBI == SplitPreds[i])
84  return;
85  }
86 
87  // If it isn't already after an outside block, move it after one. This is
88  // always good as it makes the uncond branch from the outside block into a
89  // fall-through.
90 
91  // Figure out *which* outside block to put this after. Prefer an outside
92  // block that neighbors a BB actually in the loop.
93  BasicBlock *FoundBB = nullptr;
94  for (unsigned i = 0, e = SplitPreds.size(); i != e; ++i) {
95  Function::iterator BBI = SplitPreds[i];
96  if (++BBI != NewBB->getParent()->end() &&
97  L->contains(BBI)) {
98  FoundBB = SplitPreds[i];
99  break;
100  }
101  }
102 
103  // If our heuristic for a *good* bb to place this after doesn't find
104  // anything, just pick something. It's likely better than leaving it within
105  // the loop.
106  if (!FoundBB)
107  FoundBB = SplitPreds[0];
108  NewBB->moveAfter(FoundBB);
109 }
110 
111 /// InsertPreheaderForLoop - Once we discover that a loop doesn't have a
112 /// preheader, this method is called to insert one. This method has two phases:
113 /// preheader insertion and analysis updating.
114 ///
116  BasicBlock *Header = L->getHeader();
117 
118  // Get analyses that we try to update.
119  auto *AA = PP->getAnalysisIfAvailable<AliasAnalysis>();
121  auto *DT = DTWP ? &DTWP->getDomTree() : nullptr;
122  auto *LIWP = PP->getAnalysisIfAvailable<LoopInfoWrapperPass>();
123  auto *LI = LIWP ? &LIWP->getLoopInfo() : nullptr;
124  bool PreserveLCSSA = PP->mustPreserveAnalysisID(LCSSAID);
125 
126  // Compute the set of predecessors of the loop that are not in the loop.
127  SmallVector<BasicBlock*, 8> OutsideBlocks;
128  for (pred_iterator PI = pred_begin(Header), PE = pred_end(Header);
129  PI != PE; ++PI) {
130  BasicBlock *P = *PI;
131  if (!L->contains(P)) { // Coming in from outside the loop?
132  // If the loop is branched to from an indirect branch, we won't
133  // be able to fully transform the loop, because it prohibits
134  // edge splitting.
135  if (isa<IndirectBrInst>(P->getTerminator())) return nullptr;
136 
137  // Keep track of it.
138  OutsideBlocks.push_back(P);
139  }
140  }
141 
142  // Split out the loop pre-header.
143  BasicBlock *PreheaderBB;
144  PreheaderBB = SplitBlockPredecessors(Header, OutsideBlocks, ".preheader",
145  AA, DT, LI, PreserveLCSSA);
146 
147  DEBUG(dbgs() << "LoopSimplify: Creating pre-header "
148  << PreheaderBB->getName() << "\n");
149 
150  // Make sure that NewBB is put someplace intelligent, which doesn't mess up
151  // code layout too horribly.
152  placeSplitBlockCarefully(PreheaderBB, OutsideBlocks, L);
153 
154  return PreheaderBB;
155 }
156 
157 /// \brief Ensure that the loop preheader dominates all exit blocks.
158 ///
159 /// This method is used to split exit blocks that have predecessors outside of
160 /// the loop.
162  AliasAnalysis *AA, DominatorTree *DT,
163  LoopInfo *LI, Pass *PP) {
164  SmallVector<BasicBlock*, 8> LoopBlocks;
165  for (pred_iterator I = pred_begin(Exit), E = pred_end(Exit); I != E; ++I) {
166  BasicBlock *P = *I;
167  if (L->contains(P)) {
168  // Don't do this if the loop is exited via an indirect branch.
169  if (isa<IndirectBrInst>(P->getTerminator())) return nullptr;
170 
171  LoopBlocks.push_back(P);
172  }
173  }
174 
175  assert(!LoopBlocks.empty() && "No edges coming in from outside the loop?");
176  BasicBlock *NewExitBB = nullptr;
177 
178  bool PreserveLCSSA = PP->mustPreserveAnalysisID(LCSSAID);
179 
180  NewExitBB = SplitBlockPredecessors(Exit, LoopBlocks, ".loopexit", AA, DT,
181  LI, PreserveLCSSA);
182 
183  DEBUG(dbgs() << "LoopSimplify: Creating dedicated exit block "
184  << NewExitBB->getName() << "\n");
185  return NewExitBB;
186 }
187 
188 /// Add the specified block, and all of its predecessors, to the specified set,
189 /// if it's not already in there. Stop predecessor traversal when we reach
190 /// StopBlock.
191 static void addBlockAndPredsToSet(BasicBlock *InputBB, BasicBlock *StopBlock,
192  std::set<BasicBlock*> &Blocks) {
194  Worklist.push_back(InputBB);
195  do {
196  BasicBlock *BB = Worklist.pop_back_val();
197  if (Blocks.insert(BB).second && BB != StopBlock)
198  // If BB is not already processed and it is not a stop block then
199  // insert its predecessor in the work list
200  for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
201  BasicBlock *WBB = *I;
202  Worklist.push_back(WBB);
203  }
204  } while (!Worklist.empty());
205 }
206 
207 /// \brief The first part of loop-nestification is to find a PHI node that tells
208 /// us how to partition the loops.
210  DominatorTree *DT,
211  AssumptionCache *AC) {
212  const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
213  for (BasicBlock::iterator I = L->getHeader()->begin(); isa<PHINode>(I); ) {
214  PHINode *PN = cast<PHINode>(I);
215  ++I;
216  if (Value *V = SimplifyInstruction(PN, DL, nullptr, DT, AC)) {
217  // This is a degenerate PHI already, don't modify it!
218  PN->replaceAllUsesWith(V);
219  if (AA) AA->deleteValue(PN);
220  PN->eraseFromParent();
221  continue;
222  }
223 
224  // Scan this PHI node looking for a use of the PHI node by itself.
225  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
226  if (PN->getIncomingValue(i) == PN &&
227  L->contains(PN->getIncomingBlock(i)))
228  // We found something tasty to remove.
229  return PN;
230  }
231  return nullptr;
232 }
233 
234 /// \brief If this loop has multiple backedges, try to pull one of them out into
235 /// a nested loop.
236 ///
237 /// This is important for code that looks like
238 /// this:
239 ///
240 /// Loop:
241 /// ...
242 /// br cond, Loop, Next
243 /// ...
244 /// br cond2, Loop, Out
245 ///
246 /// To identify this common case, we look at the PHI nodes in the header of the
247 /// loop. PHI nodes with unchanging values on one backedge correspond to values
248 /// that change in the "outer" loop, but not in the "inner" loop.
249 ///
250 /// If we are able to separate out a loop, return the new outer loop that was
251 /// created.
252 ///
253 static Loop *separateNestedLoop(Loop *L, BasicBlock *Preheader,
254  AliasAnalysis *AA, DominatorTree *DT,
255  LoopInfo *LI, ScalarEvolution *SE, Pass *PP,
256  AssumptionCache *AC) {
257  // Don't try to separate loops without a preheader.
258  if (!Preheader)
259  return nullptr;
260 
261  // The header is not a landing pad; preheader insertion should ensure this.
262  assert(!L->getHeader()->isLandingPad() &&
263  "Can't insert backedge to landing pad");
264 
265  PHINode *PN = findPHIToPartitionLoops(L, AA, DT, AC);
266  if (!PN) return nullptr; // No known way to partition.
267 
268  // Pull out all predecessors that have varying values in the loop. This
269  // handles the case when a PHI node has multiple instances of itself as
270  // arguments.
271  SmallVector<BasicBlock*, 8> OuterLoopPreds;
272  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
273  if (PN->getIncomingValue(i) != PN ||
274  !L->contains(PN->getIncomingBlock(i))) {
275  // We can't split indirectbr edges.
276  if (isa<IndirectBrInst>(PN->getIncomingBlock(i)->getTerminator()))
277  return nullptr;
278  OuterLoopPreds.push_back(PN->getIncomingBlock(i));
279  }
280  }
281  DEBUG(dbgs() << "LoopSimplify: Splitting out a new outer loop\n");
282 
283  // If ScalarEvolution is around and knows anything about values in
284  // this loop, tell it to forget them, because we're about to
285  // substantially change it.
286  if (SE)
287  SE->forgetLoop(L);
288 
289  bool PreserveLCSSA = PP->mustPreserveAnalysisID(LCSSAID);
290 
291  BasicBlock *Header = L->getHeader();
292  BasicBlock *NewBB = SplitBlockPredecessors(Header, OuterLoopPreds, ".outer",
293  AA, DT, LI, PreserveLCSSA);
294 
295  // Make sure that NewBB is put someplace intelligent, which doesn't mess up
296  // code layout too horribly.
297  placeSplitBlockCarefully(NewBB, OuterLoopPreds, L);
298 
299  // Create the new outer loop.
300  Loop *NewOuter = new Loop();
301 
302  // Change the parent loop to use the outer loop as its child now.
303  if (Loop *Parent = L->getParentLoop())
304  Parent->replaceChildLoopWith(L, NewOuter);
305  else
306  LI->changeTopLevelLoop(L, NewOuter);
307 
308  // L is now a subloop of our outer loop.
309  NewOuter->addChildLoop(L);
310 
311  for (Loop::block_iterator I = L->block_begin(), E = L->block_end();
312  I != E; ++I)
313  NewOuter->addBlockEntry(*I);
314 
315  // Now reset the header in L, which had been moved by
316  // SplitBlockPredecessors for the outer loop.
317  L->moveToHeader(Header);
318 
319  // Determine which blocks should stay in L and which should be moved out to
320  // the Outer loop now.
321  std::set<BasicBlock*> BlocksInL;
322  for (pred_iterator PI=pred_begin(Header), E = pred_end(Header); PI!=E; ++PI) {
323  BasicBlock *P = *PI;
324  if (DT->dominates(Header, P))
325  addBlockAndPredsToSet(P, Header, BlocksInL);
326  }
327 
328  // Scan all of the loop children of L, moving them to OuterLoop if they are
329  // not part of the inner loop.
330  const std::vector<Loop*> &SubLoops = L->getSubLoops();
331  for (size_t I = 0; I != SubLoops.size(); )
332  if (BlocksInL.count(SubLoops[I]->getHeader()))
333  ++I; // Loop remains in L
334  else
335  NewOuter->addChildLoop(L->removeChildLoop(SubLoops.begin() + I));
336 
337  // Now that we know which blocks are in L and which need to be moved to
338  // OuterLoop, move any blocks that need it.
339  for (unsigned i = 0; i != L->getBlocks().size(); ++i) {
340  BasicBlock *BB = L->getBlocks()[i];
341  if (!BlocksInL.count(BB)) {
342  // Move this block to the parent, updating the exit blocks sets
343  L->removeBlockFromLoop(BB);
344  if ((*LI)[BB] == L)
345  LI->changeLoopFor(BB, NewOuter);
346  --i;
347  }
348  }
349 
350  return NewOuter;
351 }
352 
353 /// \brief This method is called when the specified loop has more than one
354 /// backedge in it.
355 ///
356 /// If this occurs, revector all of these backedges to target a new basic block
357 /// and have that block branch to the loop header. This ensures that loops
358 /// have exactly one backedge.
360  AliasAnalysis *AA,
361  DominatorTree *DT, LoopInfo *LI) {
362  assert(L->getNumBackEdges() > 1 && "Must have > 1 backedge!");
363 
364  // Get information about the loop
365  BasicBlock *Header = L->getHeader();
366  Function *F = Header->getParent();
367 
368  // Unique backedge insertion currently depends on having a preheader.
369  if (!Preheader)
370  return nullptr;
371 
372  // The header is not a landing pad; preheader insertion should ensure this.
373  assert(!Header->isLandingPad() && "Can't insert backedge to landing pad");
374 
375  // Figure out which basic blocks contain back-edges to the loop header.
376  std::vector<BasicBlock*> BackedgeBlocks;
377  for (pred_iterator I = pred_begin(Header), E = pred_end(Header); I != E; ++I){
378  BasicBlock *P = *I;
379 
380  // Indirectbr edges cannot be split, so we must fail if we find one.
381  if (isa<IndirectBrInst>(P->getTerminator()))
382  return nullptr;
383 
384  if (P != Preheader) BackedgeBlocks.push_back(P);
385  }
386 
387  // Create and insert the new backedge block...
388  BasicBlock *BEBlock = BasicBlock::Create(Header->getContext(),
389  Header->getName() + ".backedge", F);
390  BranchInst *BETerminator = BranchInst::Create(Header, BEBlock);
391  BETerminator->setDebugLoc(Header->getFirstNonPHI()->getDebugLoc());
392 
393  DEBUG(dbgs() << "LoopSimplify: Inserting unique backedge block "
394  << BEBlock->getName() << "\n");
395 
396  // Move the new backedge block to right after the last backedge block.
397  Function::iterator InsertPos = BackedgeBlocks.back(); ++InsertPos;
398  F->getBasicBlockList().splice(InsertPos, F->getBasicBlockList(), BEBlock);
399 
400  // Now that the block has been inserted into the function, create PHI nodes in
401  // the backedge block which correspond to any PHI nodes in the header block.
402  for (BasicBlock::iterator I = Header->begin(); isa<PHINode>(I); ++I) {
403  PHINode *PN = cast<PHINode>(I);
404  PHINode *NewPN = PHINode::Create(PN->getType(), BackedgeBlocks.size(),
405  PN->getName()+".be", BETerminator);
406 
407  // Loop over the PHI node, moving all entries except the one for the
408  // preheader over to the new PHI node.
409  unsigned PreheaderIdx = ~0U;
410  bool HasUniqueIncomingValue = true;
411  Value *UniqueValue = nullptr;
412  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
413  BasicBlock *IBB = PN->getIncomingBlock(i);
414  Value *IV = PN->getIncomingValue(i);
415  if (IBB == Preheader) {
416  PreheaderIdx = i;
417  } else {
418  NewPN->addIncoming(IV, IBB);
419  if (HasUniqueIncomingValue) {
420  if (!UniqueValue)
421  UniqueValue = IV;
422  else if (UniqueValue != IV)
423  HasUniqueIncomingValue = false;
424  }
425  }
426  }
427 
428  // Delete all of the incoming values from the old PN except the preheader's
429  assert(PreheaderIdx != ~0U && "PHI has no preheader entry??");
430  if (PreheaderIdx != 0) {
431  PN->setIncomingValue(0, PN->getIncomingValue(PreheaderIdx));
432  PN->setIncomingBlock(0, PN->getIncomingBlock(PreheaderIdx));
433  }
434  // Nuke all entries except the zero'th.
435  for (unsigned i = 0, e = PN->getNumIncomingValues()-1; i != e; ++i)
436  PN->removeIncomingValue(e-i, false);
437 
438  // Finally, add the newly constructed PHI node as the entry for the BEBlock.
439  PN->addIncoming(NewPN, BEBlock);
440 
441  // As an optimization, if all incoming values in the new PhiNode (which is a
442  // subset of the incoming values of the old PHI node) have the same value,
443  // eliminate the PHI Node.
444  if (HasUniqueIncomingValue) {
445  NewPN->replaceAllUsesWith(UniqueValue);
446  if (AA) AA->deleteValue(NewPN);
447  BEBlock->getInstList().erase(NewPN);
448  }
449  }
450 
451  // Now that all of the PHI nodes have been inserted and adjusted, modify the
452  // backedge blocks to just to the BEBlock instead of the header.
453  for (unsigned i = 0, e = BackedgeBlocks.size(); i != e; ++i) {
454  TerminatorInst *TI = BackedgeBlocks[i]->getTerminator();
455  for (unsigned Op = 0, e = TI->getNumSuccessors(); Op != e; ++Op)
456  if (TI->getSuccessor(Op) == Header)
457  TI->setSuccessor(Op, BEBlock);
458  }
459 
460  //===--- Update all analyses which we must preserve now -----------------===//
461 
462  // Update Loop Information - we know that this block is now in the current
463  // loop and all parent loops.
464  L->addBasicBlockToLoop(BEBlock, *LI);
465 
466  // Update dominator information
467  DT->splitBlock(BEBlock);
468 
469  return BEBlock;
470 }
471 
472 /// \brief Simplify one loop and queue further loops for simplification.
473 ///
474 /// FIXME: Currently this accepts both lots of analyses that it uses and a raw
475 /// Pass pointer. The Pass pointer is used by numerous utilities to update
476 /// specific analyses. Rather than a pass it would be much cleaner and more
477 /// explicit if they accepted the analysis directly and then updated it.
478 static bool simplifyOneLoop(Loop *L, SmallVectorImpl<Loop *> &Worklist,
479  AliasAnalysis *AA, DominatorTree *DT, LoopInfo *LI,
480  ScalarEvolution *SE, Pass *PP,
481  AssumptionCache *AC) {
482  bool Changed = false;
483 ReprocessLoop:
484 
485  // Check to see that no blocks (other than the header) in this loop have
486  // predecessors that are not in the loop. This is not valid for natural
487  // loops, but can occur if the blocks are unreachable. Since they are
488  // unreachable we can just shamelessly delete those CFG edges!
489  for (Loop::block_iterator BB = L->block_begin(), E = L->block_end();
490  BB != E; ++BB) {
491  if (*BB == L->getHeader()) continue;
492 
494  for (pred_iterator PI = pred_begin(*BB),
495  PE = pred_end(*BB); PI != PE; ++PI) {
496  BasicBlock *P = *PI;
497  if (!L->contains(P))
498  BadPreds.insert(P);
499  }
500 
501  // Delete each unique out-of-loop (and thus dead) predecessor.
502  for (BasicBlock *P : BadPreds) {
503 
504  DEBUG(dbgs() << "LoopSimplify: Deleting edge from dead predecessor "
505  << P->getName() << "\n");
506 
507  // Inform each successor of each dead pred.
508  for (succ_iterator SI = succ_begin(P), SE = succ_end(P); SI != SE; ++SI)
509  (*SI)->removePredecessor(P);
510  // Zap the dead pred's terminator and replace it with unreachable.
511  TerminatorInst *TI = P->getTerminator();
513  P->getTerminator()->eraseFromParent();
514  new UnreachableInst(P->getContext(), P);
515  Changed = true;
516  }
517  }
518 
519  // If there are exiting blocks with branches on undef, resolve the undef in
520  // the direction which will exit the loop. This will help simplify loop
521  // trip count computations.
522  SmallVector<BasicBlock*, 8> ExitingBlocks;
523  L->getExitingBlocks(ExitingBlocks);
524  for (SmallVectorImpl<BasicBlock *>::iterator I = ExitingBlocks.begin(),
525  E = ExitingBlocks.end(); I != E; ++I)
526  if (BranchInst *BI = dyn_cast<BranchInst>((*I)->getTerminator()))
527  if (BI->isConditional()) {
528  if (UndefValue *Cond = dyn_cast<UndefValue>(BI->getCondition())) {
529 
530  DEBUG(dbgs() << "LoopSimplify: Resolving \"br i1 undef\" to exit in "
531  << (*I)->getName() << "\n");
532 
533  BI->setCondition(ConstantInt::get(Cond->getType(),
534  !L->contains(BI->getSuccessor(0))));
535 
536  // This may make the loop analyzable, force SCEV recomputation.
537  if (SE)
538  SE->forgetLoop(L);
539 
540  Changed = true;
541  }
542  }
543 
544  // Does the loop already have a preheader? If so, don't insert one.
545  BasicBlock *Preheader = L->getLoopPreheader();
546  if (!Preheader) {
547  Preheader = InsertPreheaderForLoop(L, PP);
548  if (Preheader) {
549  ++NumInserted;
550  Changed = true;
551  }
552  }
553 
554  // Next, check to make sure that all exit nodes of the loop only have
555  // predecessors that are inside of the loop. This check guarantees that the
556  // loop preheader/header will dominate the exit blocks. If the exit block has
557  // predecessors from outside of the loop, split the edge now.
558  SmallVector<BasicBlock*, 8> ExitBlocks;
559  L->getExitBlocks(ExitBlocks);
560 
561  SmallSetVector<BasicBlock *, 8> ExitBlockSet(ExitBlocks.begin(),
562  ExitBlocks.end());
563  for (SmallSetVector<BasicBlock *, 8>::iterator I = ExitBlockSet.begin(),
564  E = ExitBlockSet.end(); I != E; ++I) {
565  BasicBlock *ExitBlock = *I;
566  for (pred_iterator PI = pred_begin(ExitBlock), PE = pred_end(ExitBlock);
567  PI != PE; ++PI)
568  // Must be exactly this loop: no subloops, parent loops, or non-loop preds
569  // allowed.
570  if (!L->contains(*PI)) {
571  if (rewriteLoopExitBlock(L, ExitBlock, AA, DT, LI, PP)) {
572  ++NumInserted;
573  Changed = true;
574  }
575  break;
576  }
577  }
578 
579  // If the header has more than two predecessors at this point (from the
580  // preheader and from multiple backedges), we must adjust the loop.
581  BasicBlock *LoopLatch = L->getLoopLatch();
582  if (!LoopLatch) {
583  // If this is really a nested loop, rip it out into a child loop. Don't do
584  // this for loops with a giant number of backedges, just factor them into a
585  // common backedge instead.
586  if (L->getNumBackEdges() < 8) {
587  if (Loop *OuterL =
588  separateNestedLoop(L, Preheader, AA, DT, LI, SE, PP, AC)) {
589  ++NumNested;
590  // Enqueue the outer loop as it should be processed next in our
591  // depth-first nest walk.
592  Worklist.push_back(OuterL);
593 
594  // This is a big restructuring change, reprocess the whole loop.
595  Changed = true;
596  // GCC doesn't tail recursion eliminate this.
597  // FIXME: It isn't clear we can't rely on LLVM to TRE this.
598  goto ReprocessLoop;
599  }
600  }
601 
602  // If we either couldn't, or didn't want to, identify nesting of the loops,
603  // insert a new block that all backedges target, then make it jump to the
604  // loop header.
605  LoopLatch = insertUniqueBackedgeBlock(L, Preheader, AA, DT, LI);
606  if (LoopLatch) {
607  ++NumInserted;
608  Changed = true;
609  }
610  }
611 
612  const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
613 
614  // Scan over the PHI nodes in the loop header. Since they now have only two
615  // incoming values (the loop is canonicalized), we may have simplified the PHI
616  // down to 'X = phi [X, Y]', which should be replaced with 'Y'.
617  PHINode *PN;
618  for (BasicBlock::iterator I = L->getHeader()->begin();
619  (PN = dyn_cast<PHINode>(I++)); )
620  if (Value *V = SimplifyInstruction(PN, DL, nullptr, DT, AC)) {
621  if (AA) AA->deleteValue(PN);
622  if (SE) SE->forgetValue(PN);
623  PN->replaceAllUsesWith(V);
624  PN->eraseFromParent();
625  }
626 
627  // If this loop has multiple exits and the exits all go to the same
628  // block, attempt to merge the exits. This helps several passes, such
629  // as LoopRotation, which do not support loops with multiple exits.
630  // SimplifyCFG also does this (and this code uses the same utility
631  // function), however this code is loop-aware, where SimplifyCFG is
632  // not. That gives it the advantage of being able to hoist
633  // loop-invariant instructions out of the way to open up more
634  // opportunities, and the disadvantage of having the responsibility
635  // to preserve dominator information.
636  bool UniqueExit = true;
637  if (!ExitBlocks.empty())
638  for (unsigned i = 1, e = ExitBlocks.size(); i != e; ++i)
639  if (ExitBlocks[i] != ExitBlocks[0]) {
640  UniqueExit = false;
641  break;
642  }
643  if (UniqueExit) {
644  for (unsigned i = 0, e = ExitingBlocks.size(); i != e; ++i) {
645  BasicBlock *ExitingBlock = ExitingBlocks[i];
646  if (!ExitingBlock->getSinglePredecessor()) continue;
647  BranchInst *BI = dyn_cast<BranchInst>(ExitingBlock->getTerminator());
648  if (!BI || !BI->isConditional()) continue;
649  CmpInst *CI = dyn_cast<CmpInst>(BI->getCondition());
650  if (!CI || CI->getParent() != ExitingBlock) continue;
651 
652  // Attempt to hoist out all instructions except for the
653  // comparison and the branch.
654  bool AllInvariant = true;
655  bool AnyInvariant = false;
656  for (BasicBlock::iterator I = ExitingBlock->begin(); &*I != BI; ) {
657  Instruction *Inst = I++;
658  // Skip debug info intrinsics.
659  if (isa<DbgInfoIntrinsic>(Inst))
660  continue;
661  if (Inst == CI)
662  continue;
663  if (!L->makeLoopInvariant(Inst, AnyInvariant,
664  Preheader ? Preheader->getTerminator()
665  : nullptr)) {
666  AllInvariant = false;
667  break;
668  }
669  }
670  if (AnyInvariant) {
671  Changed = true;
672  // The loop disposition of all SCEV expressions that depend on any
673  // hoisted values have also changed.
674  if (SE)
675  SE->forgetLoopDispositions(L);
676  }
677  if (!AllInvariant) continue;
678 
679  // The block has now been cleared of all instructions except for
680  // a comparison and a conditional branch. SimplifyCFG may be able
681  // to fold it now.
682  if (!FoldBranchToCommonDest(BI))
683  continue;
684 
685  // Success. The block is now dead, so remove it from the loop,
686  // update the dominator tree and delete it.
687  DEBUG(dbgs() << "LoopSimplify: Eliminating exiting block "
688  << ExitingBlock->getName() << "\n");
689 
690  // Notify ScalarEvolution before deleting this block. Currently assume the
691  // parent loop doesn't change (spliting edges doesn't count). If blocks,
692  // CFG edges, or other values in the parent loop change, then we need call
693  // to forgetLoop() for the parent instead.
694  if (SE)
695  SE->forgetLoop(L);
696 
697  assert(pred_begin(ExitingBlock) == pred_end(ExitingBlock));
698  Changed = true;
699  LI->removeBlock(ExitingBlock);
700 
701  DomTreeNode *Node = DT->getNode(ExitingBlock);
702  const std::vector<DomTreeNodeBase<BasicBlock> *> &Children =
703  Node->getChildren();
704  while (!Children.empty()) {
705  DomTreeNode *Child = Children.front();
706  DT->changeImmediateDominator(Child, Node->getIDom());
707  }
708  DT->eraseNode(ExitingBlock);
709 
710  BI->getSuccessor(0)->removePredecessor(ExitingBlock);
711  BI->getSuccessor(1)->removePredecessor(ExitingBlock);
712  ExitingBlock->eraseFromParent();
713  }
714  }
715 
716  return Changed;
717 }
718 
721  AssumptionCache *AC) {
722  bool Changed = false;
723 
724  // Worklist maintains our depth-first queue of loops in this nest to process.
725  SmallVector<Loop *, 4> Worklist;
726  Worklist.push_back(L);
727 
728  // Walk the worklist from front to back, pushing newly found sub loops onto
729  // the back. This will let us process loops from back to front in depth-first
730  // order. We can use this simple process because loops form a tree.
731  for (unsigned Idx = 0; Idx != Worklist.size(); ++Idx) {
732  Loop *L2 = Worklist[Idx];
733  Worklist.append(L2->begin(), L2->end());
734  }
735 
736  while (!Worklist.empty())
737  Changed |= simplifyOneLoop(Worklist.pop_back_val(), Worklist, AA, DT, LI,
738  SE, PP, AC);
739 
740  return Changed;
741 }
742 
743 namespace {
744  struct LoopSimplify : public FunctionPass {
745  static char ID; // Pass identification, replacement for typeid
746  LoopSimplify() : FunctionPass(ID) {
748  }
749 
750  // AA - If we have an alias analysis object to update, this is it, otherwise
751  // this is null.
752  AliasAnalysis *AA;
753  DominatorTree *DT;
754  LoopInfo *LI;
755  ScalarEvolution *SE;
756  AssumptionCache *AC;
757 
758  bool runOnFunction(Function &F) override;
759 
760  void getAnalysisUsage(AnalysisUsage &AU) const override {
762 
763  // We need loop information to identify the loops...
766 
769 
773  AU.addPreservedID(BreakCriticalEdgesID); // No critical edges added.
774  }
775 
776  /// verifyAnalysis() - Verify LoopSimplifyForm's guarantees.
777  void verifyAnalysis() const override;
778  };
779 }
780 
781 char LoopSimplify::ID = 0;
782 INITIALIZE_PASS_BEGIN(LoopSimplify, "loop-simplify",
783  "Canonicalize natural loops", false, false)
787 INITIALIZE_PASS_END(LoopSimplify, "loop-simplify",
788  "Canonicalize natural loops", false, false)
789 
790 // Publicly exposed interface to pass...
791 char &llvm::LoopSimplifyID = LoopSimplify::ID;
792 Pass *llvm::createLoopSimplifyPass() { return new LoopSimplify(); }
793 
794 /// runOnFunction - Run down all loops in the CFG (recursively, but we could do
795 /// it in any convenient order) inserting preheaders...
796 ///
797 bool LoopSimplify::runOnFunction(Function &F) {
798  bool Changed = false;
799  AA = getAnalysisIfAvailable<AliasAnalysis>();
800  LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
801  DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
802  SE = getAnalysisIfAvailable<ScalarEvolution>();
803  AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
804 
805  // Simplify each loop nest in the function.
806  for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)
807  Changed |= simplifyLoop(*I, DT, LI, this, AA, SE, AC);
808 
809  return Changed;
810 }
811 
812 // FIXME: Restore this code when we re-enable verification in verifyAnalysis
813 // below.
814 #if 0
815 static void verifyLoop(Loop *L) {
816  // Verify subloops.
817  for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
818  verifyLoop(*I);
819 
820  // It used to be possible to just assert L->isLoopSimplifyForm(), however
821  // with the introduction of indirectbr, there are now cases where it's
822  // not possible to transform a loop as necessary. We can at least check
823  // that there is an indirectbr near any time there's trouble.
824 
825  // Indirectbr can interfere with preheader and unique backedge insertion.
826  if (!L->getLoopPreheader() || !L->getLoopLatch()) {
827  bool HasIndBrPred = false;
828  for (pred_iterator PI = pred_begin(L->getHeader()),
829  PE = pred_end(L->getHeader()); PI != PE; ++PI)
830  if (isa<IndirectBrInst>((*PI)->getTerminator())) {
831  HasIndBrPred = true;
832  break;
833  }
834  assert(HasIndBrPred &&
835  "LoopSimplify has no excuse for missing loop header info!");
836  (void)HasIndBrPred;
837  }
838 
839  // Indirectbr can interfere with exit block canonicalization.
840  if (!L->hasDedicatedExits()) {
841  bool HasIndBrExiting = false;
842  SmallVector<BasicBlock*, 8> ExitingBlocks;
843  L->getExitingBlocks(ExitingBlocks);
844  for (unsigned i = 0, e = ExitingBlocks.size(); i != e; ++i) {
845  if (isa<IndirectBrInst>((ExitingBlocks[i])->getTerminator())) {
846  HasIndBrExiting = true;
847  break;
848  }
849  }
850 
851  assert(HasIndBrExiting &&
852  "LoopSimplify has no excuse for missing exit block info!");
853  (void)HasIndBrExiting;
854  }
855 }
856 #endif
857 
858 void LoopSimplify::verifyAnalysis() const {
859  // FIXME: This routine is being called mid-way through the loop pass manager
860  // as loop passes destroy this analysis. That's actually fine, but we have no
861  // way of expressing that here. Once all of the passes that destroy this are
862  // hoisted out of the loop pass manager we can add back verification here.
863 #if 0
864  for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)
865  verifyLoop(*I);
866 #endif
867 }
unsigned getNumBackEdges() const
getNumBackEdges - Calculate the number of back edges to the loop header
Definition: LoopInfo.h:165
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
loop Canonicalize natural loops
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
Pass * createLoopSimplifyPass()
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:679
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
void removePredecessor(BasicBlock *Pred, bool DontDeleteUselessPHIs=false)
Notify the BasicBlock that the predecessor Pred is no longer able to reach it.
Definition: BasicBlock.cpp:266
void addIncoming(Value *V, BasicBlock *BB)
addIncoming - Add an incoming value to the end of the PHI list
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
void removeBlock(BlockT *BB)
removeBlock - This method completely removes BB from all data structures, including all of the Loop o...
Definition: LoopInfo.h:605
STATISTIC(NumFunctions,"Total number of functions")
DependenceAnalysis - This class is the main dependence-analysis driver.
iterator end()
Definition: Function.h:459
ScalarEvolution - This class is the main scalar evolution driver.
static PHINode * findPHIToPartitionLoops(Loop *L, AliasAnalysis *AA, DominatorTree *DT, AssumptionCache *AC)
The first part of loop-nestification is to find a PHI node that tells us how to partition the loops...
An immutable pass that tracks lazily created AssumptionCache objects.
A cache of .assume calls within a function.
void changeLoopFor(BlockT *BB, LoopT *L)
changeLoopFor - Change the top-level loop that contains BB to the specified loop. ...
Definition: LoopInfo.h:576
LoopT * getParentLoop() const
Definition: LoopInfo.h:97
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:111
F(f)
const std::vector< BlockT * > & getBlocks() const
getBlocks - Get a list of the basic blocks which make up this loop.
Definition: LoopInfo.h:139
BlockT * getHeader() const
Definition: LoopInfo.h:96
static BasicBlock * rewriteLoopExitBlock(Loop *L, BasicBlock *Exit, AliasAnalysis *AA, DominatorTree *DT, LoopInfo *LI, Pass *PP)
Ensure that the loop preheader dominates all exit blocks.
LoopT * removeChildLoop(iterator I)
removeChildLoop - This removes the specified child from being a subloop of this loop.
Definition: LoopInfo.h:274
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
std::vector< LoopT * >::const_iterator iterator
iterator/begin/end - The interface to the top-level loops in the current function.
Definition: LoopInfo.h:528
BlockT * getLoopLatch() const
getLoopLatch - If there is a single latch block for this loop, return it.
Definition: LoopInfoImpl.h:156
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:231
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:70
Value * removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty=true)
removeIncomingValue - Remove an incoming value.
BasicBlock * InsertPreheaderForLoop(Loop *L, Pass *P)
InsertPreheaderForLoop - Once we discover that a loop doesn't have a preheader, this method is called...
UndefValue - 'undef' values are things that do not have specified contents.
Definition: Constants.h:1220
AnalysisType * getAnalysisIfAvailable() const
getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to get analysis information tha...
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.
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:75
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APInt.h:33
bool mustPreserveAnalysisID(char &AID) const
mustPreserveAnalysisID - This method serves the same function as getAnalysisIfAvailable, but works if you just have an AnalysisID.
Definition: Pass.cpp:48
void getExitingBlocks(SmallVectorImpl< BlockT * > &ExitingBlocks) const
getExitingBlocks - Return all blocks inside the loop that have successors outside of the loop...
Definition: LoopInfoImpl.h:35
void getExitBlocks(SmallVectorImpl< BlockT * > &ExitBlocks) const
getExitBlocks - Return all of the successor blocks of this loop.
Definition: LoopInfoImpl.h:64
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
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
Base class for the actual dominator tree node.
AnalysisUsage & addPreservedID(const void *ID)
void setSuccessor(unsigned idx, BasicBlock *B)
Update the specified successor to point at the provided block.
Definition: InstrTypes.h:67
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:351
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:67
void forgetLoopDispositions(const Loop *L)
Called when the client has changed the disposition of values in this loop.
Interval::succ_iterator succ_end(Interval *I)
Definition: Interval.h:107
unsigned getNumIncomingValues() const
getNumIncomingValues - Return the number of incoming edges
unsigned getNumSuccessors() const
Return the number of successors that this terminator has.
Definition: InstrTypes.h:57
#define P(N)
bool FoldBranchToCommonDest(BranchInst *BI, unsigned BonusInstThreshold=1)
FoldBranchToCommonDest - If this basic block is ONLY a setcc and a branch, and if a predecessor branc...
static void placeSplitBlockCarefully(BasicBlock *NewBB, SmallVectorImpl< BasicBlock * > &SplitPreds, Loop *L)
iterator begin() const
Definition: LoopInfo.h:131
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:35
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
void eraseNode(NodeT *BB)
eraseNode - Removes a node from the dominator tree.
BasicBlock * getSuccessor(unsigned idx) const
Return the specified successor.
Definition: InstrTypes.h:62
BranchInst - Conditional or Unconditional Branch instruction.
char & BreakCriticalEdgesID
UnreachableInst - This function has undefined behavior.
This file contains the declarations for the subclasses of Constant, which represent the different fla...
char & LCSSAID
Definition: LCSSA.cpp:312
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
static BasicBlock * insertUniqueBackedgeBlock(Loop *L, BasicBlock *Preheader, AliasAnalysis *AA, DominatorTree *DT, LoopInfo *LI)
This method is called when the specified loop has more than one backedge in it.
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:114
iterator end() const
Definition: LoopInfo.h:132
Represent the analysis usage information of a pass.
BasicBlock * getIncomingBlock(unsigned i) const
getIncomingBlock - Return incoming basic block number i.
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
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:294
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:117
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:103
const std::vector< DomTreeNodeBase< NodeT > * > & getChildren() const
void forgetValue(Value *V)
forgetValue - This method should be called by the client when it has changed a value in a way that ma...
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:416
void addBlockEntry(BlockT *BB)
addBlockEntry - This adds a basic block directly to the basic block list.
Definition: LoopInfo.h:286
bool hasDedicatedExits() const
hasDedicatedExits - Return true if no exit block for the loop has a predecessor that is outside the l...
Definition: LoopInfo.cpp:328
static UndefValue * get(Type *T)
get() - Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1473
virtual void deleteValue(Value *V)
Methods that clients should call when they transform the program to allow alias analyses to update th...
iterator erase(iterator where)
Definition: ilist.h:465
void removeBlockFromLoop(BlockT *BB)
removeBlockFromLoop - This removes the specified basic block from the current loop, updating the Blocks as appropriate.
Definition: LoopInfo.h:319
char & LoopSimplifyID
bool dominates(const Instruction *Def, const Use &U) const
Return true if Def dominates a use in User.
Definition: Dominators.cpp:214
bool isConditional() const
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:217
void moveAfter(BasicBlock *MovePos)
Unlink this basic block from its current function and insert it right after MovePos in the function M...
Definition: BasicBlock.cpp:110
const BasicBlockListType & getBasicBlockList() const
Definition: Function.h:436
DomTreeNodeBase< NodeT > * getIDom() const
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:299
void setIncomingBlock(unsigned i, BasicBlock *BB)
Value * getIncomingValue(unsigned i) const
getIncomingValue - Return incoming value number x
bool makeLoopInvariant(Value *V, bool &Changed, Instruction *InsertPt=nullptr) const
makeLoopInvariant - If the given value is an instruction inside of the loop and it can be hoisted...
Definition: LoopInfo.cpp:80
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
LoopInfo & getLoopInfo()
Definition: LoopInfo.h:747
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.
Definition: Constants.cpp:582
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
void splice(iterator where, iplist &L2)
Definition: ilist.h:570
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
static bool simplifyOneLoop(Loop *L, SmallVectorImpl< Loop * > &Worklist, AliasAnalysis *AA, DominatorTree *DT, LoopInfo *LI, ScalarEvolution *SE, Pass *PP, AssumptionCache *AC)
Simplify one loop and queue further loops for simplification.
BasicBlock * getSinglePredecessor()
Return the predecessor of this block if it has a single predecessor block.
Definition: BasicBlock.cpp:211
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
std::vector< BlockT * >::const_iterator block_iterator
Definition: LoopInfo.h:140
static Loop * separateNestedLoop(Loop *L, BasicBlock *Preheader, AliasAnalysis *AA, DominatorTree *DT, LoopInfo *LI, ScalarEvolution *SE, Pass *PP, AssumptionCache *AC)
If this loop has multiple backedges, try to pull one of them out into a nested loop.
loop Canonicalize natural false
block_iterator block_end() const
Definition: LoopInfo.h:142
Value * getCondition() const
INITIALIZE_PASS_BEGIN(LoopSimplify,"loop-simplify","Canonicalize natural loops", false, false) INITIALIZE_PASS_END(LoopSimplify
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 ...
void moveToHeader(BlockT *BB)
moveToHeader - This method is used to move BB (which must be part of this loop) to be the loop header...
Definition: LoopInfo.h:304
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
void changeImmediateDominator(DomTreeNodeBase< NodeT > *N, DomTreeNodeBase< NodeT > *NewIDom)
changeImmediateDominator - This method is used to update the dominator tree information when a node's...
void initializeLoopSimplifyPass(PassRegistry &)
LLVM Value Representation.
Definition: Value.h:69
void changeTopLevelLoop(LoopT *OldLoop, LoopT *NewLoop)
changeTopLevelLoop - Replace the specified loop in the top-level loops list with the indicated loop...
Definition: LoopInfo.h:586
#define DEBUG(X)
Definition: Debug.h:92
const std::vector< LoopT * > & getSubLoops() const
iterator/begin/end - Return the loops contained entirely within this loop.
Definition: LoopInfo.h:126
block_iterator block_begin() const
Definition: LoopInfo.h:141
The legacy pass manager's analysis pass to compute loop information.
Definition: LoopInfo.h:737
BasicBlock * SplitBlockPredecessors(BasicBlock *BB, ArrayRef< BasicBlock * > Preds, const char *Suffix, AliasAnalysis *AA=nullptr, DominatorTree *DT=nullptr, LoopInfo *LI=nullptr, bool PreserveLCSSA=false)
SplitBlockPredecessors - This method introduces at least one new basic block into the function and mo...
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
std::vector< LoopT * >::const_iterator iterator
Definition: LoopInfo.h:128
DomTreeNodeBase< NodeT > * getNode(NodeT *BB) const
getNode - return the (Post)DominatorTree node for the specified basic block.
void setIncomingValue(unsigned i, Value *V)
loop simplify
static void addBlockAndPredsToSet(BasicBlock *InputBB, BasicBlock *StopBlock, std::set< BasicBlock * > &Blocks)
Add the specified block, and all of its predecessors, to the specified set, if it's not already in th...
const BasicBlock * getParent() const
Definition: Instruction.h:72
void splitBlock(NodeT *NewBB)
splitBlock - BB is split and now it has one successor.