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