1 | //===- llvm/CodeGen/MachineLoopInfo.h - Natural Loop Calculator -*- C++ -*-===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | // |
9 | // This file defines the MachineLoopInfo class that is used to identify natural |
10 | // loops and determine the loop depth of various nodes of the CFG. Note that |
11 | // natural loops may actually be several loops that share the same header node. |
12 | // |
13 | // This analysis calculates the nesting structure of loops in a function. For |
14 | // each natural loop identified, this analysis identifies natural loops |
15 | // contained entirely within the loop and the basic blocks the make up the loop. |
16 | // |
17 | // It can calculate on the fly various bits of information, for example: |
18 | // |
19 | // * whether there is a preheader for the loop |
20 | // * the number of back edges to the header |
21 | // * whether or not a particular block branches out of the loop |
22 | // * the successor blocks of the loop |
23 | // * the loop depth |
24 | // * the trip count |
25 | // * etc... |
26 | // |
27 | //===----------------------------------------------------------------------===// |
28 | |
29 | #ifndef LLVM_CODEGEN_MACHINELOOPINFO_H |
30 | #define LLVM_CODEGEN_MACHINELOOPINFO_H |
31 | |
32 | #include "llvm/CodeGen/MachineBasicBlock.h" |
33 | #include "llvm/CodeGen/MachineFunctionPass.h" |
34 | #include "llvm/IR/CFG.h" |
35 | #include "llvm/IR/DebugLoc.h" |
36 | #include "llvm/Support/GenericLoopInfo.h" |
37 | |
38 | namespace llvm { |
39 | |
40 | class MachineDominatorTree; |
41 | // Implementation in LoopInfoImpl.h |
42 | class MachineLoop; |
43 | extern template class LoopBase<MachineBasicBlock, MachineLoop>; |
44 | |
45 | class MachineLoop : public LoopBase<MachineBasicBlock, MachineLoop> { |
46 | public: |
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 | /// 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() const; |
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 | /// Find the llvm.loop metadata for this loop. |
71 | /// If each branch to the header of this loop contains the same llvm.loop |
72 | /// metadata, then this metadata node is returned. Otherwise, if any |
73 | /// latch instruction does not contain the llvm.loop metadata or |
74 | /// multiple latch instructions contain different llvm.loop metadata nodes, |
75 | /// then null is returned. |
76 | MDNode *getLoopID() const; |
77 | |
78 | /// Returns true if the instruction is loop invariant. |
79 | /// I.e., all virtual register operands are defined outside of the loop, |
80 | /// physical registers aren't accessed explicitly, and there are no side |
81 | /// effects that aren't captured by the operands or other flags. |
82 | /// ExcludeReg can be used to exclude the given register from the check |
83 | /// i.e. when we're considering hoisting it's definition but not hoisted it |
84 | /// yet |
85 | bool isLoopInvariant(MachineInstr &I, const Register ExcludeReg = 0) const; |
86 | |
87 | void dump() const; |
88 | |
89 | private: |
90 | friend class LoopInfoBase<MachineBasicBlock, MachineLoop>; |
91 | |
92 | /// Returns true if the given physreg has no defs inside the loop. |
93 | bool isLoopInvariantImplicitPhysReg(Register Reg) const; |
94 | |
95 | explicit MachineLoop(MachineBasicBlock *MBB) |
96 | : LoopBase<MachineBasicBlock, MachineLoop>(MBB) {} |
97 | |
98 | MachineLoop() = default; |
99 | }; |
100 | |
101 | // Implementation in LoopInfoImpl.h |
102 | extern template class LoopInfoBase<MachineBasicBlock, MachineLoop>; |
103 | |
104 | class MachineLoopInfo : public MachineFunctionPass { |
105 | friend class LoopBase<MachineBasicBlock, MachineLoop>; |
106 | |
107 | LoopInfoBase<MachineBasicBlock, MachineLoop> LI; |
108 | |
109 | public: |
110 | static char ID; // Pass identification, replacement for typeid |
111 | |
112 | MachineLoopInfo(); |
113 | explicit MachineLoopInfo(MachineDominatorTree &MDT) |
114 | : MachineFunctionPass(ID) { |
115 | calculate(MDT); |
116 | } |
117 | MachineLoopInfo(const MachineLoopInfo &) = delete; |
118 | MachineLoopInfo &operator=(const MachineLoopInfo &) = delete; |
119 | |
120 | LoopInfoBase<MachineBasicBlock, MachineLoop>& getBase() { return LI; } |
121 | |
122 | /// Find the block that either is the loop preheader, or could |
123 | /// speculatively be used as the preheader. This is e.g. useful to place |
124 | /// loop setup code. Code that cannot be speculated should not be placed |
125 | /// here. SpeculativePreheader is controlling whether it also tries to |
126 | /// find the speculative preheader if the regular preheader is not present. |
127 | /// With FindMultiLoopPreheader = false, nullptr will be returned if the found |
128 | /// preheader is the preheader of multiple loops. |
129 | MachineBasicBlock * |
130 | (MachineLoop *L, bool = false, |
131 | bool = false) const; |
132 | |
133 | /// The iterator interface to the top-level loops in the current function. |
134 | using iterator = LoopInfoBase<MachineBasicBlock, MachineLoop>::iterator; |
135 | inline iterator begin() const { return LI.begin(); } |
136 | inline iterator end() const { return LI.end(); } |
137 | bool empty() const { return LI.empty(); } |
138 | |
139 | /// Return the innermost loop that BB lives in. If a basic block is in no loop |
140 | /// (for example the entry node), null is returned. |
141 | inline MachineLoop *getLoopFor(const MachineBasicBlock *BB) const { |
142 | return LI.getLoopFor(BB); |
143 | } |
144 | |
145 | /// Same as getLoopFor. |
146 | inline const MachineLoop *operator[](const MachineBasicBlock *BB) const { |
147 | return LI.getLoopFor(BB); |
148 | } |
149 | |
150 | /// Return the loop nesting level of the specified block. |
151 | inline unsigned getLoopDepth(const MachineBasicBlock *BB) const { |
152 | return LI.getLoopDepth(BB); |
153 | } |
154 | |
155 | /// True if the block is a loop header node. |
156 | inline bool (const MachineBasicBlock *BB) const { |
157 | return LI.isLoopHeader(BB); |
158 | } |
159 | |
160 | /// Calculate the natural loop information. |
161 | bool runOnMachineFunction(MachineFunction &F) override; |
162 | void calculate(MachineDominatorTree &MDT); |
163 | |
164 | void releaseMemory() override { LI.releaseMemory(); } |
165 | |
166 | void getAnalysisUsage(AnalysisUsage &AU) const override; |
167 | |
168 | /// This removes the specified top-level loop from this loop info object. The |
169 | /// loop is not deleted, as it will presumably be inserted into another loop. |
170 | inline MachineLoop *removeLoop(iterator I) { return LI.removeLoop(I); } |
171 | |
172 | /// Change the top-level loop that contains BB to the specified loop. This |
173 | /// should be used by transformations that restructure the loop hierarchy |
174 | /// tree. |
175 | inline void changeLoopFor(MachineBasicBlock *BB, MachineLoop *L) { |
176 | LI.changeLoopFor(BB, L); |
177 | } |
178 | |
179 | /// Replace the specified loop in the top-level loops list with the indicated |
180 | /// loop. |
181 | inline void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop) { |
182 | LI.changeTopLevelLoop(OldLoop, NewLoop); |
183 | } |
184 | |
185 | /// This adds the specified loop to the collection of top-level loops. |
186 | inline void addTopLevelLoop(MachineLoop *New) { |
187 | LI.addTopLevelLoop(New); |
188 | } |
189 | |
190 | /// This method completely removes BB from all data structures, including all |
191 | /// of the Loop objects it is nested in and our mapping from |
192 | /// MachineBasicBlocks to loops. |
193 | void removeBlock(MachineBasicBlock *BB) { |
194 | LI.removeBlock(BB); |
195 | } |
196 | }; |
197 | |
198 | // Allow clients to walk the list of nested loops... |
199 | template <> struct GraphTraits<const MachineLoop*> { |
200 | using NodeRef = const MachineLoop *; |
201 | using ChildIteratorType = MachineLoopInfo::iterator; |
202 | |
203 | static NodeRef getEntryNode(const MachineLoop *L) { return L; } |
204 | static ChildIteratorType child_begin(NodeRef N) { return N->begin(); } |
205 | static ChildIteratorType child_end(NodeRef N) { return N->end(); } |
206 | }; |
207 | |
208 | template <> struct GraphTraits<MachineLoop*> { |
209 | using NodeRef = MachineLoop *; |
210 | using ChildIteratorType = MachineLoopInfo::iterator; |
211 | |
212 | static NodeRef getEntryNode(MachineLoop *L) { return L; } |
213 | static ChildIteratorType child_begin(NodeRef N) { return N->begin(); } |
214 | static ChildIteratorType child_end(NodeRef N) { return N->end(); } |
215 | }; |
216 | |
217 | } // end namespace llvm |
218 | |
219 | #endif // LLVM_CODEGEN_MACHINELOOPINFO_H |
220 | |