blob: 104655e4552468ad92348d2991607baac45ec7e6 [file] [log] [blame]
Andrew Scull5e1ddfa2018-08-14 10:06:54 +01001//===- 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#include "llvm/IR/DebugLoc.h"
37#include "llvm/Pass.h"
38
39namespace llvm {
40
41// Implementation in LoopInfoImpl.h
42class MachineLoop;
43extern template class LoopBase<MachineBasicBlock, MachineLoop>;
44
45class MachineLoop : public LoopBase<MachineBasicBlock, MachineLoop> {
46public:
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 /// Return the debug location of the start of this loop.
64 /// This looks for a BB terminating instruction with a known debug
65 /// location by looking at the preheader and header blocks. If it
66 /// cannot find a terminating instruction with location information,
67 /// it returns an unknown location.
68 DebugLoc getStartLoc() const;
69
70 void dump() const;
71
72private:
73 friend class LoopInfoBase<MachineBasicBlock, MachineLoop>;
74
75 explicit MachineLoop(MachineBasicBlock *MBB)
76 : LoopBase<MachineBasicBlock, MachineLoop>(MBB) {}
77
78 MachineLoop() = default;
79};
80
81// Implementation in LoopInfoImpl.h
82extern template class LoopInfoBase<MachineBasicBlock, MachineLoop>;
83
84class MachineLoopInfo : public MachineFunctionPass {
85 friend class LoopBase<MachineBasicBlock, MachineLoop>;
86
87 LoopInfoBase<MachineBasicBlock, MachineLoop> LI;
88
89public:
90 static char ID; // Pass identification, replacement for typeid
91
92 MachineLoopInfo() : MachineFunctionPass(ID) {
93 initializeMachineLoopInfoPass(*PassRegistry::getPassRegistry());
94 }
95 MachineLoopInfo(const MachineLoopInfo &) = delete;
96 MachineLoopInfo &operator=(const MachineLoopInfo &) = delete;
97
98 LoopInfoBase<MachineBasicBlock, MachineLoop>& getBase() { return LI; }
99
100 /// \brief Find the block that either is the loop preheader, or could
101 /// speculatively be used as the preheader. This is e.g. useful to place
102 /// loop setup code. Code that cannot be speculated should not be placed
103 /// here. SpeculativePreheader is controlling whether it also tries to
104 /// find the speculative preheader if the regular preheader is not present.
105 MachineBasicBlock *findLoopPreheader(MachineLoop *L,
106 bool SpeculativePreheader = false) const;
107
108 /// The iterator interface to the top-level loops in the current function.
109 using iterator = LoopInfoBase<MachineBasicBlock, MachineLoop>::iterator;
110 inline iterator begin() const { return LI.begin(); }
111 inline iterator end() const { return LI.end(); }
112 bool empty() const { return LI.empty(); }
113
114 /// Return the innermost loop that BB lives in. If a basic block is in no loop
115 /// (for example the entry node), null is returned.
116 inline MachineLoop *getLoopFor(const MachineBasicBlock *BB) const {
117 return LI.getLoopFor(BB);
118 }
119
120 /// Same as getLoopFor.
121 inline const MachineLoop *operator[](const MachineBasicBlock *BB) const {
122 return LI.getLoopFor(BB);
123 }
124
125 /// Return the loop nesting level of the specified block.
126 inline unsigned getLoopDepth(const MachineBasicBlock *BB) const {
127 return LI.getLoopDepth(BB);
128 }
129
130 /// True if the block is a loop header node.
131 inline bool isLoopHeader(const MachineBasicBlock *BB) const {
132 return LI.isLoopHeader(BB);
133 }
134
135 /// Calculate the natural loop information.
136 bool runOnMachineFunction(MachineFunction &F) override;
137
138 void releaseMemory() override { LI.releaseMemory(); }
139
140 void getAnalysisUsage(AnalysisUsage &AU) const override;
141
142 /// This removes the specified top-level loop from this loop info object. The
143 /// loop is not deleted, as it will presumably be inserted into another loop.
144 inline MachineLoop *removeLoop(iterator I) { return LI.removeLoop(I); }
145
146 /// Change the top-level loop that contains BB to the specified loop. This
147 /// should be used by transformations that restructure the loop hierarchy
148 /// tree.
149 inline void changeLoopFor(MachineBasicBlock *BB, MachineLoop *L) {
150 LI.changeLoopFor(BB, L);
151 }
152
153 /// Replace the specified loop in the top-level loops list with the indicated
154 /// loop.
155 inline void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop) {
156 LI.changeTopLevelLoop(OldLoop, NewLoop);
157 }
158
159 /// This adds the specified loop to the collection of top-level loops.
160 inline void addTopLevelLoop(MachineLoop *New) {
161 LI.addTopLevelLoop(New);
162 }
163
164 /// This method completely removes BB from all data structures, including all
165 /// of the Loop objects it is nested in and our mapping from
166 /// MachineBasicBlocks to loops.
167 void removeBlock(MachineBasicBlock *BB) {
168 LI.removeBlock(BB);
169 }
170};
171
172// Allow clients to walk the list of nested loops...
173template <> struct GraphTraits<const MachineLoop*> {
174 using NodeRef = const MachineLoop *;
175 using ChildIteratorType = MachineLoopInfo::iterator;
176
177 static NodeRef getEntryNode(const 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
182template <> struct GraphTraits<MachineLoop*> {
183 using NodeRef = MachineLoop *;
184 using ChildIteratorType = MachineLoopInfo::iterator;
185
186 static NodeRef getEntryNode(MachineLoop *L) { return L; }
187 static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
188 static ChildIteratorType child_end(NodeRef N) { return N->end(); }
189};
190
191} // end namespace llvm
192
193#endif // LLVM_CODEGEN_MACHINELOOPINFO_H