LLVM  3.7.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  /// getTopBlock - Return the "top" block in the loop, which is the first
48  /// block in the linear layout, ignoring any parts of the loop not
49  /// contiguous with the part the contains the header.
50  MachineBasicBlock *getTopBlock();
51 
52  /// getBottomBlock - Return the "bottom" block in the loop, which is the last
53  /// block in the linear layout, ignoring any parts of the loop not
54  /// contiguous with the part the contains the header.
55  MachineBasicBlock *getBottomBlock();
56 
57  void dump() const;
58 
59 private:
61  explicit MachineLoop(MachineBasicBlock *MBB)
63 };
64 
65 // Implementation in LoopInfoImpl.h
66 extern template class LoopInfoBase<MachineBasicBlock, MachineLoop>;
67 
71 
72  void operator=(const MachineLoopInfo &) = delete;
73  MachineLoopInfo(const MachineLoopInfo &) = delete;
74 
75 public:
76  static char ID; // Pass identification, replacement for typeid
77 
80  }
81 
83 
84  /// iterator/begin/end - The interface to the top-level loops in the current
85  /// function.
86  ///
88  inline iterator begin() const { return LI.begin(); }
89  inline iterator end() const { return LI.end(); }
90  bool empty() const { return LI.empty(); }
91 
92  /// getLoopFor - Return the inner most loop that BB lives in. If a basic
93  /// block is in no loop (for example the entry node), null is returned.
94  ///
95  inline MachineLoop *getLoopFor(const MachineBasicBlock *BB) const {
96  return LI.getLoopFor(BB);
97  }
98 
99  /// operator[] - same as getLoopFor...
100  ///
101  inline const MachineLoop *operator[](const MachineBasicBlock *BB) const {
102  return LI.getLoopFor(BB);
103  }
104 
105  /// getLoopDepth - Return the loop nesting level of the specified block...
106  ///
107  inline unsigned getLoopDepth(const MachineBasicBlock *BB) const {
108  return LI.getLoopDepth(BB);
109  }
110 
111  // isLoopHeader - True if the block is a loop header node
112  inline bool isLoopHeader(const MachineBasicBlock *BB) const {
113  return LI.isLoopHeader(BB);
114  }
115 
116  /// runOnFunction - Calculate the natural loop information.
117  ///
118  bool runOnMachineFunction(MachineFunction &F) override;
119 
120  void releaseMemory() override { LI.releaseMemory(); }
121 
122  void getAnalysisUsage(AnalysisUsage &AU) const override;
123 
124  /// removeLoop - This removes the specified top-level loop from this loop info
125  /// object. The loop is not deleted, as it will presumably be inserted into
126  /// another loop.
127  inline MachineLoop *removeLoop(iterator I) { return LI.removeLoop(I); }
128 
129  /// changeLoopFor - Change the top-level loop that contains BB to the
130  /// specified loop. This should be used by transformations that restructure
131  /// the loop hierarchy tree.
133  LI.changeLoopFor(BB, L);
134  }
135 
136  /// changeTopLevelLoop - Replace the specified loop in the top-level loops
137  /// list with the indicated loop.
138  inline void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop) {
139  LI.changeTopLevelLoop(OldLoop, NewLoop);
140  }
141 
142  /// addTopLevelLoop - This adds the specified loop to the collection of
143  /// top-level loops.
144  inline void addTopLevelLoop(MachineLoop *New) {
145  LI.addTopLevelLoop(New);
146  }
147 
148  /// removeBlock - This method completely removes BB from all data structures,
149  /// including all of the Loop objects it is nested in and our mapping from
150  /// MachineBasicBlocks to loops.
152  LI.removeBlock(BB);
153  }
154 };
155 
156 
157 // Allow clients to walk the list of nested loops...
159  typedef const MachineLoop NodeType;
161 
162  static NodeType *getEntryNode(const MachineLoop *L) { return L; }
163  static inline ChildIteratorType child_begin(NodeType *N) {
164  return N->begin();
165  }
166  static inline ChildIteratorType child_end(NodeType *N) {
167  return N->end();
168  }
169 };
170 
171 template <> struct GraphTraits<MachineLoop*> {
174 
175  static NodeType *getEntryNode(MachineLoop *L) { return L; }
176  static inline ChildIteratorType child_begin(NodeType *N) {
177  return N->begin();
178  }
179  static inline ChildIteratorType child_end(NodeType *N) {
180  return N->end();
181  }
182 };
183 
184 } // End llvm namespace
185 
186 #endif
bool empty() const
Definition: LoopInfo.h:535
unsigned getLoopDepth(const BlockT *BB) const
getLoopDepth - Return the loop nesting level of the specified block.
Definition: LoopInfo.h:551
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
LoopT * removeLoop(iterator I)
removeLoop - This removes the specified top-level loop from this loop info object.
Definition: LoopInfo.h:565
iterator begin() const
Definition: LoopInfo.h:531
static NodeType * getEntryNode(const MachineLoop *L)
bool isLoopHeader(const BlockT *BB) const
Definition: LoopInfo.h:557
void addTopLevelLoop(MachineLoop *New)
addTopLevelLoop - This adds the specified loop to the collection of top-level loops.
void changeLoopFor(BlockT *BB, LoopT *L)
changeLoopFor - Change the top-level loop that contains BB to the specified loop. ...
Definition: LoopInfo.h:576
F(f)
LoopT * getLoopFor(const BlockT *BB) const
getLoopFor - Return the inner most loop that BB lives in.
Definition: LoopInfo.h:540
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:528
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
iterator begin() const
void removeBlock(MachineBasicBlock *BB)
removeBlock - This method completely removes BB from all data structures, including all of the Loop o...
iterator end() const
Definition: LoopInfo.h:532
MachineLoopInfo::iterator ChildIteratorType
void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop)
changeTopLevelLoop - Replace the specified loop in the top-level loops list with the indicated loop...
static ChildIteratorType child_begin(NodeType *N)
static ChildIteratorType child_end(NodeType *N)
MachineLoop * getLoopFor(const MachineBasicBlock *BB) const
getLoopFor - Return the inner most loop that BB lives in.
static ChildIteratorType child_end(NodeType *N)
iterator begin() const
Definition: LoopInfo.h:131
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)
static NodeType * getEntryNode(MachineLoop *L)
void releaseMemory()
Definition: LoopInfo.h:517
const MachineLoop * operator[](const MachineBasicBlock *BB) const
operator[] - same as getLoopFor...
iterator end() const
Definition: LoopInfo.h:132
Represent the analysis usage information of a pass.
void addTopLevelLoop(LoopT *New)
addTopLevelLoop - This adds the specified loop to the collection of top-level loops.
Definition: LoopInfo.h:597
MachineLoopInfo::iterator ChildIteratorType
MachineLoop * removeLoop(iterator I)
removeLoop - 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)
changeLoopFor - Change the top-level loop that contains BB to the specified loop. ...
bool isLoopHeader(const MachineBasicBlock *BB) const
unsigned getLoopDepth(const MachineBasicBlock *BB) const
getLoopDepth - Return the loop nesting level of the specified block...
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
static ChildIteratorType child_begin(NodeType *N)
iterator end() const
LoopInfoBase< MachineBasicBlock, MachineLoop >::iterator iterator
iterator/begin/end - The interface to the top-level loops in the current function.
LoopInfo - This class builds and contains all of the top level loop structures in the specified funct...
Definition: LoopInfo.h:57
LoopInfoBase< MachineBasicBlock, MachineLoop > & getBase()