LLVM 19.0.0git
RegUsageInfoCollector.cpp
Go to the documentation of this file.
1//===-- RegUsageInfoCollector.cpp - Register Usage Information Collector --===//
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 pass is required to take advantage of the interprocedural register
10/// allocation infrastructure.
11///
12/// This pass is simple MachineFunction pass which collects register usage
13/// details by iterating through each physical registers and checking
14/// MRI::isPhysRegUsed() then creates a RegMask based on this details.
15/// The pass then stores this RegMask in PhysicalRegisterUsageInfo.cpp
16///
17//===----------------------------------------------------------------------===//
18
19#include "llvm/ADT/Statistic.h"
23#include "llvm/CodeGen/Passes.h"
26#include "llvm/IR/Function.h"
27#include "llvm/Support/Debug.h"
29
30using namespace llvm;
31
32#define DEBUG_TYPE "ip-regalloc"
33
34STATISTIC(NumCSROpt,
35 "Number of functions optimized for callee saved registers");
36
37namespace {
38
40public:
44 }
45
46 StringRef getPassName() const override {
47 return "Register Usage Information Collector Pass";
48 }
49
50 void getAnalysisUsage(AnalysisUsage &AU) const override {
52 AU.setPreservesAll();
54 }
55
56 bool runOnMachineFunction(MachineFunction &MF) override;
57
58 // Call getCalleeSaves and then also set the bits for subregs and
59 // fully saved superregs.
60 static void computeCalleeSavedRegs(BitVector &SavedRegs, MachineFunction &MF);
61
62 static char ID;
63};
64
65} // end of anonymous namespace
66
67char RegUsageInfoCollector::ID = 0;
68
69INITIALIZE_PASS_BEGIN(RegUsageInfoCollector, "RegUsageInfoCollector",
70 "Register Usage Information Collector", false, false)
72INITIALIZE_PASS_END(RegUsageInfoCollector, "RegUsageInfoCollector",
74
76 return new RegUsageInfoCollector();
77}
78
79// TODO: Move to hook somwehere?
80
81// Return true if it is useful to track the used registers for IPRA / no CSR
82// optimizations. This is not useful for entry points, and computing the
83// register usage information is expensive.
84static bool isCallableFunction(const MachineFunction &MF) {
85 switch (MF.getFunction().getCallingConv()) {
94 return false;
95 default:
96 return true;
97 }
98}
99
100bool RegUsageInfoCollector::runOnMachineFunction(MachineFunction &MF) {
103 const LLVMTargetMachine &TM = MF.getTarget();
104
105 LLVM_DEBUG(dbgs() << " -------------------- " << getPassName()
106 << " -------------------- \nFunction Name : "
107 << MF.getName() << '\n');
108
109 // Analyzing the register usage may be expensive on some targets.
110 if (!isCallableFunction(MF)) {
111 LLVM_DEBUG(dbgs() << "Not analyzing non-callable function\n");
112 return false;
113 }
114
115 // If there are no callers, there's no point in computing more precise
116 // register usage here.
117 if (MF.getFunction().use_empty()) {
118 LLVM_DEBUG(dbgs() << "Not analyzing function with no callers\n");
119 return false;
120 }
121
122 std::vector<uint32_t> RegMask;
123
124 // Compute the size of the bit vector to represent all the registers.
125 // The bit vector is broken into 32-bit chunks, thus takes the ceil of
126 // the number of registers divided by 32 for the size.
127 unsigned RegMaskSize = MachineOperand::getRegMaskSize(TRI->getNumRegs());
128 RegMask.resize(RegMaskSize, ~((uint32_t)0));
129
130 const Function &F = MF.getFunction();
131
132 PhysicalRegisterUsageInfo &PRUI = getAnalysis<PhysicalRegisterUsageInfo>();
133 PRUI.setTargetMachine(TM);
134
135 LLVM_DEBUG(dbgs() << "Clobbered Registers: ");
136
137 BitVector SavedRegs;
138 computeCalleeSavedRegs(SavedRegs, MF);
139
140 const BitVector &UsedPhysRegsMask = MRI->getUsedPhysRegsMask();
141 auto SetRegAsDefined = [&RegMask] (unsigned Reg) {
142 RegMask[Reg / 32] &= ~(1u << Reg % 32);
143 };
144
145 // Don't include $noreg in any regmasks.
146 SetRegAsDefined(MCRegister::NoRegister);
147
148 // Some targets can clobber registers "inside" a call, typically in
149 // linker-generated code.
150 for (const MCPhysReg Reg : TRI->getIntraCallClobberedRegs(&MF))
151 for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI)
152 SetRegAsDefined(*AI);
153
154 // Scan all the physical registers. When a register is defined in the current
155 // function set it and all the aliasing registers as defined in the regmask.
156 // FIXME: Rewrite to use regunits.
157 for (unsigned PReg = 1, PRegE = TRI->getNumRegs(); PReg < PRegE; ++PReg) {
158 // Don't count registers that are saved and restored.
159 if (SavedRegs.test(PReg))
160 continue;
161 // If a register is defined by an instruction mark it as defined together
162 // with all it's unsaved aliases.
163 if (!MRI->def_empty(PReg)) {
164 for (MCRegAliasIterator AI(PReg, TRI, true); AI.isValid(); ++AI)
165 if (!SavedRegs.test(*AI))
166 SetRegAsDefined(*AI);
167 continue;
168 }
169 // If a register is in the UsedPhysRegsMask set then mark it as defined.
170 // All clobbered aliases will also be in the set, so we can skip setting
171 // as defined all the aliases here.
172 if (UsedPhysRegsMask.test(PReg))
173 SetRegAsDefined(PReg);
174 }
175
178 ++NumCSROpt;
179 LLVM_DEBUG(dbgs() << MF.getName()
180 << " function optimized for not having CSR.\n");
181 }
182
184 for (unsigned PReg = 1, PRegE = TRI->getNumRegs(); PReg < PRegE; ++PReg) {
185 if (MachineOperand::clobbersPhysReg(&(RegMask[0]), PReg))
186 dbgs() << printReg(PReg, TRI) << " ";
187 }
188
189 dbgs() << " \n----------------------------------------\n";
190 );
191
192 PRUI.storeUpdateRegUsageInfo(F, RegMask);
193
194 return false;
195}
196
197void RegUsageInfoCollector::
198computeCalleeSavedRegs(BitVector &SavedRegs, MachineFunction &MF) {
201
202 // Target will return the set of registers that it saves/restores as needed.
203 SavedRegs.clear();
204 TFI.getCalleeSaves(MF, SavedRegs);
205 if (SavedRegs.none())
206 return;
207
208 // Insert subregs.
209 const MCPhysReg *CSRegs = TRI.getCalleeSavedRegs(&MF);
210 for (unsigned i = 0; CSRegs[i]; ++i) {
211 MCPhysReg Reg = CSRegs[i];
212 if (SavedRegs.test(Reg)) {
213 // Save subregisters
214 for (MCPhysReg SR : TRI.subregs(Reg))
215 SavedRegs.set(SR);
216 }
217 }
218}
unsigned const MachineRegisterInfo * MRI
#define LLVM_DEBUG(X)
Definition: Debug.h:101
Natural Loop Information
Definition: LoopInfo.cpp:1197
#define F(x, y, z)
Definition: MD5.cpp:55
unsigned const TargetRegisterInfo * TRI
const char LLVMTargetMachineRef TM
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:55
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:59
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:52
Register Usage Information Collector
RegUsageInfoCollector
static bool isCallableFunction(const MachineFunction &MF)
This pass is required to take advantage of the interprocedural register allocation infrastructure.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Definition: Statistic.h:167
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
void setPreservesAll()
Set by analyses that do not transform their input at all.
bool test(unsigned Idx) const
Definition: BitVector.h:461
void clear()
clear - Removes all bits from the bitvector.
Definition: BitVector.h:335
BitVector & set()
Definition: BitVector.h:351
bool none() const
none - Returns true if none of the bits are set.
Definition: BitVector.h:188
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:311
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:264
This class describes a target machine that is implemented with the LLVM target-independent code gener...
MCRegAliasIterator enumerates all registers aliasing Reg.
static constexpr unsigned NoRegister
Definition: MCRegister.h:52
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
virtual bool runOnMachineFunction(MachineFunction &MF)=0
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Function & getFunction()
Return the LLVM function that this machine code represents.
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
static unsigned getRegMaskSize(unsigned NumRegs)
Returns number of elements needed for a regmask array.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
Definition: PassRegistry.h:37
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Definition: Pass.cpp:81
void storeUpdateRegUsageInfo(const Function &FP, ArrayRef< uint32_t > RegMask)
To store RegMask for given Function *.
void setTargetMachine(const LLVMTargetMachine &TM)
Set TargetMachine which is used to print analysis.
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
A global registry used in conjunction with static constructors to make pluggable components (like tar...
Definition: Registry.h:44
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Information about stack frame layout on the target.
virtual void getCalleeSaves(const MachineFunction &MF, BitVector &SavedRegs) const
Returns the callee-saved registers as computed by determineCalleeSaves in the BitVector SavedRegs.
virtual bool isProfitableForNoCSROpt(const Function &F) const
Check if the no-CSR optimisation is profitable for the given function.
static bool isSafeForNoCSROpt(const Function &F)
Check if given function is safe for not having callee saved registers.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
virtual const TargetFrameLowering * getFrameLowering() const
bool use_empty() const
Definition: Value.h:344
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
@ AMDGPU_CS
Used for Mesa/AMDPAL compute shaders.
Definition: CallingConv.h:197
@ AMDGPU_VS
Used for Mesa vertex shaders, or AMDPAL last shader stage before rasterization (vertex shader if tess...
Definition: CallingConv.h:188
@ AMDGPU_KERNEL
Used for AMDGPU code object kernels.
Definition: CallingConv.h:200
@ AMDGPU_HS
Used for Mesa/AMDPAL hull shaders (= tessellation control shaders).
Definition: CallingConv.h:206
@ AMDGPU_GS
Used for Mesa/AMDPAL geometry shaders.
Definition: CallingConv.h:191
@ AMDGPU_PS
Used for Mesa/AMDPAL pixel shaders.
Definition: CallingConv.h:194
@ AMDGPU_ES
Used for AMDPAL shader stage before geometry shader if geometry is in use.
Definition: CallingConv.h:218
@ AMDGPU_LS
Used for AMDPAL vertex shader if tessellation is in use.
Definition: CallingConv.h:213
Reg
All possible values of the reg field in the ModR/M byte.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
FunctionPass * createRegUsageInfoCollector()
This pass is executed POST-RA to collect which physical registers are preserved by given machine func...
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
void initializeRegUsageInfoCollectorPass(PassRegistry &)