• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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"
34 #include "llvm/CodeGen/MachineBasicBlock.h"
35 #include "llvm/CodeGen/MachineFunctionPass.h"
36 
37 namespace llvm {
38 
39 // Implementation in LoopInfoImpl.h
40 class MachineLoop;
41 extern template class LoopBase<MachineBasicBlock, MachineLoop>;
42 
43 class MachineLoop : public LoopBase<MachineBasicBlock, MachineLoop> {
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:
60   friend class LoopInfoBase<MachineBasicBlock, MachineLoop>;
MachineLoop(MachineBasicBlock * MBB)61   explicit MachineLoop(MachineBasicBlock *MBB)
62     : LoopBase<MachineBasicBlock, MachineLoop>(MBB) {}
63 };
64 
65 // Implementation in LoopInfoImpl.h
66 extern template class LoopInfoBase<MachineBasicBlock, MachineLoop>;
67 
68 class MachineLoopInfo : public MachineFunctionPass {
69   LoopInfoBase<MachineBasicBlock, MachineLoop> LI;
70   friend class LoopBase<MachineBasicBlock, MachineLoop>;
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 
MachineLoopInfo()78   MachineLoopInfo() : MachineFunctionPass(ID) {
79     initializeMachineLoopInfoPass(*PassRegistry::getPassRegistry());
80   }
81 
getBase()82   LoopInfoBase<MachineBasicBlock, MachineLoop>& getBase() { return LI; }
83 
84   /// iterator/begin/end - The interface to the top-level loops in the current
85   /// function.
86   ///
87   typedef LoopInfoBase<MachineBasicBlock, MachineLoop>::iterator iterator;
begin()88   inline iterator begin() const { return LI.begin(); }
end()89   inline iterator end() const { return LI.end(); }
empty()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   ///
getLoopFor(const MachineBasicBlock * BB)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   ///
getLoopDepth(const MachineBasicBlock * BB)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
isLoopHeader(const MachineBasicBlock * BB)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 
releaseMemory()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.
removeLoop(iterator I)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.
changeLoopFor(MachineBasicBlock * BB,MachineLoop * L)132   inline void changeLoopFor(MachineBasicBlock *BB, MachineLoop *L) {
133     LI.changeLoopFor(BB, L);
134   }
135 
136   /// changeTopLevelLoop - Replace the specified loop in the top-level loops
137   /// list with the indicated loop.
changeTopLevelLoop(MachineLoop * OldLoop,MachineLoop * NewLoop)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.
addTopLevelLoop(MachineLoop * New)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.
removeBlock(MachineBasicBlock * BB)151   void removeBlock(MachineBasicBlock *BB) {
152     LI.removeBlock(BB);
153   }
154 };
155 
156 
157 // Allow clients to walk the list of nested loops...
158 template <> struct GraphTraits<const MachineLoop*> {
159   typedef const MachineLoop NodeType;
160   typedef MachineLoopInfo::iterator ChildIteratorType;
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*> {
172   typedef MachineLoop NodeType;
173   typedef MachineLoopInfo::iterator ChildIteratorType;
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
187