LLVM  4.0.0
MachineLoopInfo.h
Go to the documentation of this file.
1 //===- llvm/CodeGen/MachineLoopInfo.h - Natural Loop Calculator -*- C++ -*-===//
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 // natural loops may actually be several loops that share the same header node.
13 //
14 // This analysis calculates the nesting structure of loops in a function. For
15 // each natural loop identified, this analysis identifies natural loops
16 // contained entirely within the loop and the basic blocks the make up the loop.
17 //
18 // It can calculate on the fly various bits of information, for example:
19 //
20 // * whether there is a preheader for the loop
21 // * the number of back edges to the header
22 // * whether or not a particular block branches out of the loop
23 // * the successor blocks of the loop
24 // * the loop depth
25 // * the trip count
26 // * etc...
27 //
28 //===----------------------------------------------------------------------===//
29 
30 #ifndef LLVM_CODEGEN_MACHINELOOPINFO_H
31 #define LLVM_CODEGEN_MACHINELOOPINFO_H
32 
33 #include "llvm/Analysis/LoopInfo.h"
36 
37 namespace llvm {
38 
39 // Implementation in LoopInfoImpl.h
40 class MachineLoop;
41 extern template class LoopBase<MachineBasicBlock, MachineLoop>;
42 
44 public:
45  MachineLoop();
46 
47  /// Return the "top" block in the loop, which is the first block in the linear
48  /// layout, ignoring any parts of the loop not contiguous with the part that
49  /// contains the header.
50  MachineBasicBlock *getTopBlock();
51 
52  /// Return the "bottom" block in the loop, which is the last block in the
53  /// linear layout, ignoring any parts of the loop not contiguous with the part
54  /// that contains the header.
55  MachineBasicBlock *getBottomBlock();
56 
57  /// \brief Find the block that contains the loop control variable and the
58  /// loop test. This will return the latch block if it's one of the exiting
59  /// blocks. Otherwise, return the exiting block. Return 'null' when
60  /// multiple exiting blocks are present.
61  MachineBasicBlock *findLoopControlBlock();
62 
63  void dump() const;
64 
65 private:
69 };
70 
71 // Implementation in LoopInfoImpl.h
72 extern template class LoopInfoBase<MachineBasicBlock, MachineLoop>;
73 
77 
78  void operator=(const MachineLoopInfo &) = delete;
79  MachineLoopInfo(const MachineLoopInfo &) = delete;
80 
81 public:
82  static char ID; // Pass identification, replacement for typeid
83 
86  }
87 
89 
90  /// \brief Find the block that either is the loop preheader, or could
91  /// speculatively be used as the preheader. This is e.g. useful to place
92  /// loop setup code. Code that cannot be speculated should not be placed
93  /// here. SpeculativePreheader is controlling whether it also tries to
94  /// find the speculative preheader if the regular preheader is not present.
95  MachineBasicBlock *findLoopPreheader(MachineLoop *L,
96  bool SpeculativePreheader = false) const;
97 
98  /// The iterator interface to the top-level loops in the current function.
100  inline iterator begin() const { return LI.begin(); }
101  inline iterator end() const { return LI.end(); }
102  bool empty() const { return LI.empty(); }
103 
104  /// Return the innermost loop that BB lives in. If a basic block is in no loop
105  /// (for example the entry node), null is returned.
106  inline MachineLoop *getLoopFor(const MachineBasicBlock *BB) const {
107  return LI.getLoopFor(BB);
108  }
109 
110  /// Same as getLoopFor.
111  inline const MachineLoop *operator[](const MachineBasicBlock *BB) const {
112  return LI.getLoopFor(BB);
113  }
114 
115  /// Return the loop nesting level of the specified block.
116  inline unsigned getLoopDepth(const MachineBasicBlock *BB) const {
117  return LI.getLoopDepth(BB);
118  }
119 
120  /// True if the block is a loop header node.
121  inline bool isLoopHeader(const MachineBasicBlock *BB) const {
122  return LI.isLoopHeader(BB);
123  }
124 
125  /// Calculate the natural loop information.
126  bool runOnMachineFunction(MachineFunction &F) override;
127 
128  void releaseMemory() override { LI.releaseMemory(); }
129 
130  void getAnalysisUsage(AnalysisUsage &AU) const override;
131 
132  /// This removes the specified top-level loop from this loop info object. The
133  /// loop is not deleted, as it will presumably be inserted into another loop.
134  inline MachineLoop *removeLoop(iterator I) { return LI.removeLoop(I); }
135 
136  /// Change the top-level loop that contains BB to the specified loop. This
137  /// should be used by transformations that restructure the loop hierarchy
138  /// tree.
140  LI.changeLoopFor(BB, L);
141  }
142 
143  /// Replace the specified loop in the top-level loops list with the indicated
144  /// loop.
145  inline void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop) {
146  LI.changeTopLevelLoop(OldLoop, NewLoop);
147  }
148 
149  /// This adds the specified loop to the collection of top-level loops.
150  inline void addTopLevelLoop(MachineLoop *New) {
151  LI.addTopLevelLoop(New);
152  }
153 
154  /// This method completely removes BB from all data structures, including all
155  /// of the Loop objects it is nested in and our mapping from
156  /// MachineBasicBlocks to loops.
158  LI.removeBlock(BB);
159  }
160 };
161 
162 
163 // Allow clients to walk the list of nested loops...
165  typedef const MachineLoop *NodeRef;
167 
168  static NodeRef getEntryNode(const MachineLoop *L) { return L; }
169  static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
170  static ChildIteratorType child_end(NodeRef N) { return N->end(); }
171 };
172 
173 template <> struct GraphTraits<MachineLoop*> {
176 
177  static NodeRef getEntryNode(MachineLoop *L) { return L; }
178  static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
179  static ChildIteratorType child_end(NodeRef N) { return N->end(); }
180 };
181 
182 } // End llvm namespace
183 
184 #endif
MachineLoop * L
bool empty() const
Definition: LoopInfo.h:571
unsigned getLoopDepth(const BlockT *BB) const
Return the loop nesting level of the specified block.
Definition: LoopInfo.h:584
static NodeRef getEntryNode(MachineLoop *L)
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
void removeBlock(BlockT *BB)
This method completely removes BB from all data structures, including all of the Loop objects it is n...
Definition: LoopInfo.h:637
LoopT * removeLoop(iterator I)
This removes the specified top-level loop from this loop info object.
Definition: LoopInfo.h:598
iterator begin() const
Definition: LoopInfo.h:567
bool isLoopHeader(const BlockT *BB) const
Definition: LoopInfo.h:590
void addTopLevelLoop(MachineLoop *New)
This adds the specified loop to the collection of top-level loops.
void changeLoopFor(BlockT *BB, LoopT *L)
Change the top-level loop that contains BB to the specified loop.
Definition: LoopInfo.h:609
LoopT * getLoopFor(const BlockT *BB) const
Return the inner most loop that BB lives in.
Definition: LoopInfo.h:575
void initializeMachineLoopInfoPass(PassRegistry &)
std::vector< LoopT * >::const_iterator iterator
iterator/begin/end - The interface to the top-level loops in the current function.
Definition: LoopInfo.h:564
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
iterator begin() const
void removeBlock(MachineBasicBlock *BB)
This method completely removes BB from all data structures, including all of the Loop objects it is n...
static ChildIteratorType child_begin(NodeRef N)
#define F(x, y, z)
Definition: MD5.cpp:51
MachineBasicBlock * MBB
iterator end() const
Definition: LoopInfo.h:568
MachineLoopInfo::iterator ChildIteratorType
void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop)
Replace the specified loop in the top-level loops list with the indicated loop.
MachineLoop * getLoopFor(const MachineBasicBlock *BB) const
Return the innermost loop that BB lives in.
iterator begin() const
Definition: LoopInfo.h:132
void releaseMemory() override
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
void releaseMemory()
Definition: LoopInfo.h:550
const MachineLoop * operator[](const MachineBasicBlock *BB) const
Same as getLoopFor.
iterator end() const
Definition: LoopInfo.h:133
Represent the analysis usage information of a pass.
static ChildIteratorType child_begin(NodeRef N)
static ChildIteratorType child_end(NodeRef N)
void addTopLevelLoop(LoopT *New)
This adds the specified loop to the collection of top-level loops.
Definition: LoopInfo.h:629
MachineLoopInfo::iterator ChildIteratorType
static NodeRef getEntryNode(const MachineLoop *L)
MachineLoop * removeLoop(iterator I)
This removes the specified top-level loop from this loop info object.
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
void changeLoopFor(MachineBasicBlock *BB, MachineLoop *L)
Change the top-level loop that contains BB to the specified loop.
static ChildIteratorType child_end(NodeRef N)
bool isLoopHeader(const MachineBasicBlock *BB) const
True if the block is a loop header node.
unsigned getLoopDepth(const MachineBasicBlock *BB) const
Return the loop nesting level of the specified block.
void changeTopLevelLoop(LoopT *OldLoop, LoopT *NewLoop)
Replace the specified loop in the top-level loops list with the indicated loop.
Definition: LoopInfo.h:619
iterator end() const
LoopInfoBase< MachineBasicBlock, MachineLoop >::iterator iterator
The iterator interface to the top-level loops in the current function.
This class builds and contains all of the top-level loop structures in the specified function...
Definition: LoopInfo.h:60
LoopInfoBase< MachineBasicBlock, MachineLoop > & getBase()