LLVM  4.0.0
MachineLoopInfo.cpp
Go to the documentation of this file.
1 //===- MachineLoopInfo.cpp - Natural Loop Calculator ----------------------===//
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 defines the MachineLoopInfo class that is used to identify natural
11 // loops and determine the loop depth of various nodes of the CFG. Note that
12 // the loops identified may actually be several natural loops that share the
13 // same header node... not just a single natural loop.
14 //
15 //===----------------------------------------------------------------------===//
16 
20 #include "llvm/CodeGen/Passes.h"
21 #include "llvm/Support/Debug.h"
23 using namespace llvm;
24 
25 // Explicitly instantiate methods in LoopInfoImpl.h for MI-level Loops.
28 
29 char MachineLoopInfo::ID = 0;
30 INITIALIZE_PASS_BEGIN(MachineLoopInfo, "machine-loops",
31  "Machine Natural Loop Construction", true, true)
34  "Machine Natural Loop Construction", true, true)
35 
36 char &llvm::MachineLoopInfoID = MachineLoopInfo::ID;
37 
38 bool MachineLoopInfo::runOnMachineFunction(MachineFunction &) {
39  releaseMemory();
40  LI.analyze(getAnalysis<MachineDominatorTree>().getBase());
41  return false;
42 }
43 
45  AU.setPreservesAll();
48 }
49 
51  MachineBasicBlock *TopMBB = getHeader();
52  MachineFunction::iterator Begin = TopMBB->getParent()->begin();
53  if (TopMBB->getIterator() != Begin) {
54  MachineBasicBlock *PriorMBB = &*std::prev(TopMBB->getIterator());
55  while (contains(PriorMBB)) {
56  TopMBB = PriorMBB;
57  if (TopMBB->getIterator() == Begin)
58  break;
59  PriorMBB = &*std::prev(TopMBB->getIterator());
60  }
61  }
62  return TopMBB;
63 }
64 
66  MachineBasicBlock *BotMBB = getHeader();
68  if (BotMBB->getIterator() != std::prev(End)) {
69  MachineBasicBlock *NextMBB = &*std::next(BotMBB->getIterator());
70  while (contains(NextMBB)) {
71  BotMBB = NextMBB;
72  if (BotMBB == &*std::next(BotMBB->getIterator()))
73  break;
74  NextMBB = &*std::next(BotMBB->getIterator());
75  }
76  }
77  return BotMBB;
78 }
79 
81  if (MachineBasicBlock *Latch = getLoopLatch()) {
82  if (isLoopExiting(Latch))
83  return Latch;
84  else
85  return getExitingBlock();
86  }
87  return nullptr;
88 }
89 
92  bool SpeculativePreheader) const {
93  if (MachineBasicBlock *PB = L->getLoopPreheader())
94  return PB;
95 
96  if (!SpeculativePreheader)
97  return nullptr;
98 
99  MachineBasicBlock *HB = L->getHeader(), *LB = L->getLoopLatch();
100  if (HB->pred_size() != 2 || HB->hasAddressTaken())
101  return nullptr;
102  // Find the predecessor of the header that is not the latch block.
103  MachineBasicBlock *Preheader = nullptr;
104  for (MachineBasicBlock *P : HB->predecessors()) {
105  if (P == LB)
106  continue;
107  // Sanity.
108  if (Preheader)
109  return nullptr;
110  Preheader = P;
111  }
112 
113  // Check if the preheader candidate is a successor of any other loop
114  // headers. We want to avoid having two loop setups in the same block.
115  for (MachineBasicBlock *S : Preheader->successors()) {
116  if (S == HB)
117  continue;
118  MachineLoop *T = getLoopFor(S);
119  if (T && T->getHeader() == S)
120  return nullptr;
121  }
122  return Preheader;
123 }
124 
125 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
127  print(dbgs());
128 }
129 #endif
MachineLoop * L
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds...
Definition: Compiler.h:450
bool isLoopExiting(const BlockT *BB) const
True if terminator in the block can branch to another block that is outside of the current loop...
Definition: LoopInfo.h:160
MachineBasicBlock * findLoopPreheader(MachineLoop *L, bool SpeculativePreheader=false) const
Find the block that either is the loop preheader, or could speculatively be used as the preheader...
machine Machine Natural Loop true
iterator_range< succ_iterator > successors()
BlockT * getLoopLatch() const
If there is a single latch block for this loop, return it.
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:53
MachineBasicBlock * getTopBlock()
Return the "top" block in the loop, which is the first block in the linear layout, ignoring any parts of the loop not contiguous with the part that contains the header.
char & MachineLoopInfoID
MachineLoopInfo - This pass is a loop analysis pass.
MachineBasicBlock * getBottomBlock()
Return the "bottom" block in the loop, which is the last block in the linear layout, ignoring any parts of the loop not contiguous with the part that contains the header.
MachineBasicBlock * findLoopControlBlock()
Find the block that contains the loop control variable and the loop test.
COFF::MachineTypes Machine
Definition: COFFYAML.cpp:303
INITIALIZE_PASS_BEGIN(MachineLoopInfo,"machine-loops","Machine Natural Loop Construction", true, true) INITIALIZE_PASS_END(MachineLoopInfo
MachineLoop * getLoopFor(const MachineBasicBlock *BB) const
Return the innermost loop that BB lives in.
#define P(N)
BlockT * getLoopPreheader() const
If there is a preheader for this loop, return it.
Definition: LoopInfoImpl.h:109
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
Represent the analysis usage information of a pass.
bool contains(const LoopT *L) const
Return true if the specified loop is contained within in this loop.
Definition: LoopInfo.h:109
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE,"Assign register bank of generic virtual registers", false, false) RegBankSelect
static const unsigned End
BlockT * getExitingBlock() const
If getExitingBlocks would return exactly one block, return that block.
self_iterator getIterator()
Definition: ilist_node.h:81
iterator_range< pred_iterator > predecessors()
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
Iterator for intrusive lists based on ilist_node.
machine loops
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
void setPreservesAll()
Set by analyses that do not transform their input at all.
bool hasAddressTaken() const
Test whether this block is potentially the target of an indirect branch.
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:368
machine Machine Natural Loop Construction
void print(raw_ostream &OS, unsigned Depth=0, bool Verbose=false) const
Print loop with all the BBs inside it.
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
unsigned pred_size() const
This class builds and contains all of the top-level loop structures in the specified function...
Definition: LoopInfo.h:60