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   bool isLoopInvariant(MachineInstr &I) const;
83 
84   void dump() const;
85 
86 private:
87   friend class LoopInfoBase<MachineBasicBlock, MachineLoop>;
88 
MachineLoop(MachineBasicBlock * MBB)89   explicit MachineLoop(MachineBasicBlock *MBB)
90     : LoopBase<MachineBasicBlock, MachineLoop>(MBB) {}
91 
92   MachineLoop() = default;
93 };
94 
95 // Implementation in LoopInfoImpl.h
96 extern template class LoopInfoBase<MachineBasicBlock, MachineLoop>;
97 
98 class MachineLoopInfo : public MachineFunctionPass {
99   friend class LoopBase<MachineBasicBlock, MachineLoop>;
100 
101   LoopInfoBase<MachineBasicBlock, MachineLoop> LI;
102 
103 public:
104   static char ID; // Pass identification, replacement for typeid
105 
106   MachineLoopInfo();
MachineLoopInfo(MachineDominatorTree & MDT)107   explicit MachineLoopInfo(MachineDominatorTree &MDT)
108       : MachineFunctionPass(ID) {
109     calculate(MDT);
110   }
111   MachineLoopInfo(const MachineLoopInfo &) = delete;
112   MachineLoopInfo &operator=(const MachineLoopInfo &) = delete;
113 
getBase()114   LoopInfoBase<MachineBasicBlock, MachineLoop>& getBase() { return LI; }
115 
116   /// Find the block that either is the loop preheader, or could
117   /// speculatively be used as the preheader. This is e.g. useful to place
118   /// loop setup code. Code that cannot be speculated should not be placed
119   /// here. SpeculativePreheader is controlling whether it also tries to
120   /// find the speculative preheader if the regular preheader is not present.
121   /// With FindMultiLoopPreheader = false, nullptr will be returned if the found
122   /// preheader is the preheader of multiple loops.
123   MachineBasicBlock *
124   findLoopPreheader(MachineLoop *L, bool SpeculativePreheader = false,
125                     bool FindMultiLoopPreheader = false) const;
126 
127   /// The iterator interface to the top-level loops in the current function.
128   using iterator = LoopInfoBase<MachineBasicBlock, MachineLoop>::iterator;
begin()129   inline iterator begin() const { return LI.begin(); }
end()130   inline iterator end() const { return LI.end(); }
empty()131   bool empty() const { return LI.empty(); }
132 
133   /// Return the innermost loop that BB lives in. If a basic block is in no loop
134   /// (for example the entry node), null is returned.
getLoopFor(const MachineBasicBlock * BB)135   inline MachineLoop *getLoopFor(const MachineBasicBlock *BB) const {
136     return LI.getLoopFor(BB);
137   }
138 
139   /// Same as getLoopFor.
140   inline const MachineLoop *operator[](const MachineBasicBlock *BB) const {
141     return LI.getLoopFor(BB);
142   }
143 
144   /// Return the loop nesting level of the specified block.
getLoopDepth(const MachineBasicBlock * BB)145   inline unsigned getLoopDepth(const MachineBasicBlock *BB) const {
146     return LI.getLoopDepth(BB);
147   }
148 
149   /// True if the block is a loop header node.
isLoopHeader(const MachineBasicBlock * BB)150   inline bool isLoopHeader(const MachineBasicBlock *BB) const {
151     return LI.isLoopHeader(BB);
152   }
153 
154   /// Calculate the natural loop information.
155   bool runOnMachineFunction(MachineFunction &F) override;
156   void calculate(MachineDominatorTree &MDT);
157 
releaseMemory()158   void releaseMemory() override { LI.releaseMemory(); }
159 
160   void getAnalysisUsage(AnalysisUsage &AU) const override;
161 
162   /// This removes the specified top-level loop from this loop info object. The
163   /// loop is not deleted, as it will presumably be inserted into another loop.
removeLoop(iterator I)164   inline MachineLoop *removeLoop(iterator I) { return LI.removeLoop(I); }
165 
166   /// Change the top-level loop that contains BB to the specified loop. This
167   /// should be used by transformations that restructure the loop hierarchy
168   /// tree.
changeLoopFor(MachineBasicBlock * BB,MachineLoop * L)169   inline void changeLoopFor(MachineBasicBlock *BB, MachineLoop *L) {
170     LI.changeLoopFor(BB, L);
171   }
172 
173   /// Replace the specified loop in the top-level loops list with the indicated
174   /// loop.
changeTopLevelLoop(MachineLoop * OldLoop,MachineLoop * NewLoop)175   inline void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop) {
176     LI.changeTopLevelLoop(OldLoop, NewLoop);
177   }
178 
179   /// This adds the specified loop to the collection of top-level loops.
addTopLevelLoop(MachineLoop * New)180   inline void addTopLevelLoop(MachineLoop *New) {
181     LI.addTopLevelLoop(New);
182   }
183 
184   /// This method completely removes BB from all data structures, including all
185   /// of the Loop objects it is nested in and our mapping from
186   /// MachineBasicBlocks to loops.
removeBlock(MachineBasicBlock * BB)187   void removeBlock(MachineBasicBlock *BB) {
188     LI.removeBlock(BB);
189   }
190 };
191 
192 // Allow clients to walk the list of nested loops...
193 template <> struct GraphTraits<const MachineLoop*> {
194   using NodeRef = const MachineLoop *;
195   using ChildIteratorType = MachineLoopInfo::iterator;
196 
197   static NodeRef getEntryNode(const MachineLoop *L) { return L; }
198   static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
199   static ChildIteratorType child_end(NodeRef N) { return N->end(); }
200 };
201 
202 template <> struct GraphTraits<MachineLoop*> {
203   using NodeRef = MachineLoop *;
204   using ChildIteratorType = MachineLoopInfo::iterator;
205 
206   static NodeRef getEntryNode(MachineLoop *L) { return L; }
207   static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
208   static ChildIteratorType child_end(NodeRef N) { return N->end(); }
209 };
210 
211 } // end namespace llvm
212 
213 #endif // LLVM_CODEGEN_MACHINELOOPINFO_H
214