1 //===- llvm/CodeGen/MachineLoopInfo.h - Natural Loop Calculator -*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
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.
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.
17 // It can calculate on the fly various bits of information, for example:
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
27 //===----------------------------------------------------------------------===//
29 #ifndef LLVM_CODEGEN_MACHINELOOPINFO_H
30 #define LLVM_CODEGEN_MACHINELOOPINFO_H
32 #include "llvm/Analysis/LoopInfo.h"
33 #include "llvm/CodeGen/MachineBasicBlock.h"
34 #include "llvm/CodeGen/MachineFunctionPass.h"
35 #include "llvm/IR/DebugLoc.h"
36 #include "llvm/Pass.h"
40 class MachineDominatorTree;
41 // Implementation in LoopInfoImpl.h
43 extern template class LoopBase<MachineBasicBlock, MachineLoop>;
45 class MachineLoop : public LoopBase<MachineBasicBlock, MachineLoop> {
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();
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();
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();
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;
73 friend class LoopInfoBase<MachineBasicBlock, MachineLoop>;
75 explicit MachineLoop(MachineBasicBlock *MBB)
76 : LoopBase<MachineBasicBlock, MachineLoop>(MBB) {}
78 MachineLoop() = default;
81 // Implementation in LoopInfoImpl.h
82 extern template class LoopInfoBase<MachineBasicBlock, MachineLoop>;
84 class MachineLoopInfo : public MachineFunctionPass {
85 friend class LoopBase<MachineBasicBlock, MachineLoop>;
87 LoopInfoBase<MachineBasicBlock, MachineLoop> LI;
90 static char ID; // Pass identification, replacement for typeid
93 explicit MachineLoopInfo(MachineDominatorTree &MDT)
94 : MachineFunctionPass(ID) {
97 MachineLoopInfo(const MachineLoopInfo &) = delete;
98 MachineLoopInfo &operator=(const MachineLoopInfo &) = delete;
100 LoopInfoBase<MachineBasicBlock, MachineLoop>& getBase() { return LI; }
102 /// Find the block that either is the loop preheader, or could
103 /// speculatively be used as the preheader. This is e.g. useful to place
104 /// loop setup code. Code that cannot be speculated should not be placed
105 /// here. SpeculativePreheader is controlling whether it also tries to
106 /// find the speculative preheader if the regular preheader is not present.
107 MachineBasicBlock *findLoopPreheader(MachineLoop *L,
108 bool SpeculativePreheader = false) const;
110 /// The iterator interface to the top-level loops in the current function.
111 using iterator = LoopInfoBase<MachineBasicBlock, MachineLoop>::iterator;
112 inline iterator begin() const { return LI.begin(); }
113 inline iterator end() const { return LI.end(); }
114 bool empty() const { return LI.empty(); }
116 /// Return the innermost loop that BB lives in. If a basic block is in no loop
117 /// (for example the entry node), null is returned.
118 inline MachineLoop *getLoopFor(const MachineBasicBlock *BB) const {
119 return LI.getLoopFor(BB);
122 /// Same as getLoopFor.
123 inline const MachineLoop *operator[](const MachineBasicBlock *BB) const {
124 return LI.getLoopFor(BB);
127 /// Return the loop nesting level of the specified block.
128 inline unsigned getLoopDepth(const MachineBasicBlock *BB) const {
129 return LI.getLoopDepth(BB);
132 /// True if the block is a loop header node.
133 inline bool isLoopHeader(const MachineBasicBlock *BB) const {
134 return LI.isLoopHeader(BB);
137 /// Calculate the natural loop information.
138 bool runOnMachineFunction(MachineFunction &F) override;
139 void calculate(MachineDominatorTree &MDT);
141 void releaseMemory() override { LI.releaseMemory(); }
143 void getAnalysisUsage(AnalysisUsage &AU) const override;
145 /// This removes the specified top-level loop from this loop info object. The
146 /// loop is not deleted, as it will presumably be inserted into another loop.
147 inline MachineLoop *removeLoop(iterator I) { return LI.removeLoop(I); }
149 /// Change the top-level loop that contains BB to the specified loop. This
150 /// should be used by transformations that restructure the loop hierarchy
152 inline void changeLoopFor(MachineBasicBlock *BB, MachineLoop *L) {
153 LI.changeLoopFor(BB, L);
156 /// Replace the specified loop in the top-level loops list with the indicated
158 inline void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop) {
159 LI.changeTopLevelLoop(OldLoop, NewLoop);
162 /// This adds the specified loop to the collection of top-level loops.
163 inline void addTopLevelLoop(MachineLoop *New) {
164 LI.addTopLevelLoop(New);
167 /// This method completely removes BB from all data structures, including all
168 /// of the Loop objects it is nested in and our mapping from
169 /// MachineBasicBlocks to loops.
170 void removeBlock(MachineBasicBlock *BB) {
175 // Allow clients to walk the list of nested loops...
176 template <> struct GraphTraits<const MachineLoop*> {
177 using NodeRef = const MachineLoop *;
178 using ChildIteratorType = MachineLoopInfo::iterator;
180 static NodeRef getEntryNode(const MachineLoop *L) { return L; }
181 static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
182 static ChildIteratorType child_end(NodeRef N) { return N->end(); }
185 template <> struct GraphTraits<MachineLoop*> {
186 using NodeRef = MachineLoop *;
187 using ChildIteratorType = MachineLoopInfo::iterator;
189 static NodeRef getEntryNode(MachineLoop *L) { return L; }
190 static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
191 static ChildIteratorType child_end(NodeRef N) { return N->end(); }
194 } // end namespace llvm
196 #endif // LLVM_CODEGEN_MACHINELOOPINFO_H