LLVM 19.0.0git
MachineLoopInfo.h
Go to the documentation of this file.
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
34#include "llvm/IR/CFG.h"
35#include "llvm/IR/DebugLoc.h"
37
38namespace llvm {
39
40class MachineDominatorTree;
41// Implementation in LoopInfoImpl.h
42class MachineLoop;
43extern template class LoopBase<MachineBasicBlock, MachineLoop>;
44
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 /// 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
89private:
91
92 /// Returns true if the given physreg has no defs inside the loop.
93 bool isLoopInvariantImplicitPhysReg(Register Reg) const;
94
97
98 MachineLoop() = default;
99};
100
101// Implementation in LoopInfoImpl.h
103
106
108
109public:
110 static char ID; // Pass identification, replacement for typeid
111
115 calculate(MDT);
116 }
119
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.
130 findLoopPreheader(MachineLoop *L, bool SpeculativePreheader = false,
131 bool FindMultiLoopPreheader = false) const;
132
133 /// The iterator interface to the top-level loops in the current function.
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 isLoopHeader(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.
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.
194 LI.removeBlock(BB);
195 }
196};
197
198// Allow clients to walk the list of nested loops...
200 using NodeRef = const MachineLoop *;
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
208template <> struct GraphTraits<MachineLoop*> {
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
MachineBasicBlock & MBB
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
unsigned Reg
Represent the analysis usage information of a pass.
A debug info location.
Definition: DebugLoc.h:33
Instances of this class are used to represent loops that are detected in the flow graph.
This class builds and contains all of the top-level loop structures in the specified function.
void addTopLevelLoop(LoopT *New)
This adds the specified loop to the collection of top-level loops.
void changeTopLevelLoop(LoopT *OldLoop, LoopT *NewLoop)
Replace the specified loop in the top-level loops list with the indicated loop.
iterator end() const
void removeBlock(BlockT *BB)
This method completely removes BB from all data structures, including all of the Loop objects it is n...
bool isLoopHeader(const BlockT *BB) const
LoopT * removeLoop(iterator I)
This removes the specified top-level loop from this loop info object.
void changeLoopFor(BlockT *BB, LoopT *L)
Change the top-level loop that contains BB to the specified loop.
unsigned getLoopDepth(const BlockT *BB) const
Return the loop nesting level of the specified block.
iterator begin() const
LoopT * getLoopFor(const BlockT *BB) const
Return the inner most loop that BB lives in.
std::vector< LoopT * >::const_iterator iterator
iterator/begin/end - The interface to the top-level loops in the current function.
Metadata node.
Definition: Metadata.h:1067
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Representation of each machine instruction.
Definition: MachineInstr.h:69
MachineLoop * removeLoop(iterator I)
This removes the specified top-level loop from this loop info object.
const MachineLoop * operator[](const MachineBasicBlock *BB) const
Same as getLoopFor.
iterator begin() const
bool isLoopHeader(const MachineBasicBlock *BB) const
True if the block is a loop header node.
void changeLoopFor(MachineBasicBlock *BB, MachineLoop *L)
Change the top-level loop that contains BB to the specified loop.
MachineLoopInfo(const MachineLoopInfo &)=delete
LoopInfoBase< MachineBasicBlock, MachineLoop > & getBase()
MachineLoopInfo & operator=(const MachineLoopInfo &)=delete
void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop)
Replace the specified loop in the top-level loops list with the indicated loop.
void removeBlock(MachineBasicBlock *BB)
This method completely removes BB from all data structures, including all of the Loop objects it is n...
LoopInfoBase< MachineBasicBlock, MachineLoop >::iterator iterator
The iterator interface to the top-level loops in the current function.
MachineLoopInfo(MachineDominatorTree &MDT)
void releaseMemory() override
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
iterator end() const
void addTopLevelLoop(MachineLoop *New)
This adds the specified loop to the collection of top-level loops.
MachineLoop * getLoopFor(const MachineBasicBlock *BB) const
Return the innermost loop that BB lives in.
unsigned getLoopDepth(const MachineBasicBlock *BB) const
Return the loop nesting level of the specified block.
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
#define N
MachineLoopInfo::iterator ChildIteratorType
static ChildIteratorType child_end(NodeRef N)
static NodeRef getEntryNode(MachineLoop *L)
static ChildIteratorType child_begin(NodeRef N)
MachineLoopInfo::iterator ChildIteratorType
static ChildIteratorType child_begin(NodeRef N)
static NodeRef getEntryNode(const MachineLoop *L)
static ChildIteratorType child_end(NodeRef N)