LLVM  14.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"
25 #include "llvm/CodeGen/Passes.h"
27 #include "llvm/Support/Debug.h"
30 
31 using namespace llvm;
32 
33 #define DEBUG_TYPE "ip-regalloc"
34 
35 STATISTIC(NumCSROpt,
36  "Number of functions optimized for callee saved registers");
37 
38 namespace {
39 
41 public:
45  }
46 
47  StringRef getPassName() const override {
48  return "Register Usage Information Collector Pass";
49  }
50 
51  void getAnalysisUsage(AnalysisUsage &AU) const override {
53  AU.setPreservesAll();
55  }
56 
57  bool runOnMachineFunction(MachineFunction &MF) override;
58 
59  // Call getCalleeSaves and then also set the bits for subregs and
60  // fully saved superregs.
61  static void computeCalleeSavedRegs(BitVector &SavedRegs, MachineFunction &MF);
62 
63  static char ID;
64 };
65 
66 } // end of anonymous namespace
67 
69 
70 INITIALIZE_PASS_BEGIN(RegUsageInfoCollector, "RegUsageInfoCollector",
71  "Register Usage Information Collector", false, false)
75 
77  return new RegUsageInfoCollector();
78 }
79 
80 // TODO: Move to hook somwehere?
81 
82 // Return true if it is useful to track the used registers for IPRA / no CSR
83 // optimizations. This is not useful for entry points, and computing the
84 // register usage information is expensive.
85 static bool isCallableFunction(const MachineFunction &MF) {
86  switch (MF.getFunction().getCallingConv()) {
95  return false;
96  default:
97  return true;
98  }
99 }
100 
101 bool RegUsageInfoCollector::runOnMachineFunction(MachineFunction &MF) {
104  const LLVMTargetMachine &TM = MF.getTarget();
105 
106  LLVM_DEBUG(dbgs() << " -------------------- " << getPassName()
107  << " -------------------- \nFunction Name : "
108  << MF.getName() << '\n');
109 
110  // Analyzing the register usage may be expensive on some targets.
111  if (!isCallableFunction(MF)) {
112  LLVM_DEBUG(dbgs() << "Not analyzing non-callable function\n");
113  return false;
114  }
115 
116  // If there are no callers, there's no point in computing more precise
117  // register usage here.
118  if (MF.getFunction().use_empty()) {
119  LLVM_DEBUG(dbgs() << "Not analyzing function with no callers\n");
120  return false;
121  }
122 
123  std::vector<uint32_t> RegMask;
124 
125  // Compute the size of the bit vector to represent all the registers.
126  // The bit vector is broken into 32-bit chunks, thus takes the ceil of
127  // the number of registers divided by 32 for the size.
128  unsigned RegMaskSize = MachineOperand::getRegMaskSize(TRI->getNumRegs());
129  RegMask.resize(RegMaskSize, ~((uint32_t)0));
130 
131  const Function &F = MF.getFunction();
132 
133  PhysicalRegisterUsageInfo &PRUI = getAnalysis<PhysicalRegisterUsageInfo>();
134  PRUI.setTargetMachine(TM);
135 
136  LLVM_DEBUG(dbgs() << "Clobbered Registers: ");
137 
138  BitVector SavedRegs;
139  computeCalleeSavedRegs(SavedRegs, MF);
140 
141  const BitVector &UsedPhysRegsMask = MRI->getUsedPhysRegsMask();
142  auto SetRegAsDefined = [&RegMask] (unsigned Reg) {
143  RegMask[Reg / 32] &= ~(1u << Reg % 32);
144  };
145 
146  // Some targets can clobber registers "inside" a call, typically in
147  // linker-generated code.
148  for (const MCPhysReg Reg : TRI->getIntraCallClobberedRegs(&MF))
149  for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI)
150  SetRegAsDefined(*AI);
151 
152  // Scan all the physical registers. When a register is defined in the current
153  // function set it and all the aliasing registers as defined in the regmask.
154  // FIXME: Rewrite to use regunits.
155  for (unsigned PReg = 1, PRegE = TRI->getNumRegs(); PReg < PRegE; ++PReg) {
156  // Don't count registers that are saved and restored.
157  if (SavedRegs.test(PReg))
158  continue;
159  // If a register is defined by an instruction mark it as defined together
160  // with all it's unsaved aliases.
161  if (!MRI->def_empty(PReg)) {
162  for (MCRegAliasIterator AI(PReg, TRI, true); AI.isValid(); ++AI)
163  if (!SavedRegs.test(*AI))
164  SetRegAsDefined(*AI);
165  continue;
166  }
167  // If a register is in the UsedPhysRegsMask set then mark it as defined.
168  // All clobbered aliases will also be in the set, so we can skip setting
169  // as defined all the aliases here.
170  if (UsedPhysRegsMask.test(PReg))
171  SetRegAsDefined(PReg);
172  }
173 
176  ++NumCSROpt;
177  LLVM_DEBUG(dbgs() << MF.getName()
178  << " function optimized for not having CSR.\n");
179  }
180 
181  LLVM_DEBUG(
182  for (unsigned PReg = 1, PRegE = TRI->getNumRegs(); PReg < PRegE; ++PReg) {
183  if (MachineOperand::clobbersPhysReg(&(RegMask[0]), PReg))
184  dbgs() << printReg(PReg, TRI) << " ";
185  }
186 
187  dbgs() << " \n----------------------------------------\n";
188  );
189 
190  PRUI.storeUpdateRegUsageInfo(F, RegMask);
191 
192  return false;
193 }
194 
195 void RegUsageInfoCollector::
196 computeCalleeSavedRegs(BitVector &SavedRegs, MachineFunction &MF) {
199 
200  // Target will return the set of registers that it saves/restores as needed.
201  SavedRegs.clear();
202  TFI.getCalleeSaves(MF, SavedRegs);
203  if (SavedRegs.none())
204  return;
205 
206  // Insert subregs.
207  const MCPhysReg *CSRegs = TRI.getCalleeSavedRegs(&MF);
208  for (unsigned i = 0; CSRegs[i]; ++i) {
209  MCPhysReg Reg = CSRegs[i];
210  if (SavedRegs.test(Reg)) {
211  // Save subregisters
212  for (MCSubRegIterator SR(Reg, &TRI); SR.isValid(); ++SR)
213  SavedRegs.set(*SR);
214  }
215  }
216 }
i
i
Definition: README.txt:29
llvm::TargetFrameLowering::getCalleeSaves
virtual void getCalleeSaves(const MachineFunction &MF, BitVector &SavedRegs) const
Returns the callee-saved registers as computed by determineCalleeSaves in the BitVector SavedRegs.
Definition: TargetFrameLoweringImpl.cpp:65
MachineInstr.h
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
Reg
unsigned Reg
Definition: MachineSink.cpp:1566
llvm::TargetRegisterInfo::getIntraCallClobberedRegs
virtual ArrayRef< MCPhysReg > getIntraCallClobberedRegs(const MachineFunction *MF) const
Return a list of all of the registers which are clobbered "inside" a call to the given function.
Definition: TargetRegisterInfo.h:509
TargetFrameLowering.h
llvm::TargetFrameLowering
Information about stack frame layout on the target.
Definition: TargetFrameLowering.h:43
llvm::MachineRegisterInfo
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Definition: MachineRegisterInfo.h:52
llvm::Function
Definition: Function.h:62
llvm::BitVector::set
BitVector & set()
Definition: BitVector.h:343
llvm::BitVector::clear
void clear()
clear - Removes all bits from the bitvector.
Definition: BitVector.h:327
llvm::BitVector::none
bool none() const
none - Returns true if none of the bits are set.
Definition: BitVector.h:180
Statistic.h
llvm::MCRegisterInfo::getNumRegs
unsigned getNumRegs() const
Return the number of registers this target has (useful for sizing arrays holding per register informa...
Definition: MCRegisterInfo.h:491
llvm::MachineFunctionPass
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Definition: MachineFunctionPass.h:30
MachineBasicBlock.h
llvm::TargetSubtargetInfo::getRegisterInfo
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
Definition: TargetSubtargetInfo.h:124
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:233
Information
Natural Loop Information
Definition: LoopInfo.cpp:1175
llvm::CallingConv::AMDGPU_PS
@ AMDGPU_PS
Calling convention used for Mesa/AMDPAL pixel shaders.
Definition: CallingConv.h:210
llvm::CallingConv::AMDGPU_ES
@ AMDGPU_ES
Calling convention used for AMDPAL shader stage before geometry shader if geometry is in use.
Definition: CallingConv.h:236
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1567
llvm::MachineFunctionPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
Definition: MachineFunctionPass.cpp:102
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
F
#define F(x, y, z)
Definition: MD5.cpp:56
MachineRegisterInfo.h
Collector
Register Usage Information Collector
Definition: RegUsageInfoCollector.cpp:74
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::TargetRegisterInfo::getCalleeSavedRegs
virtual const MCPhysReg * getCalleeSavedRegs(const MachineFunction *MF) const =0
Return a null-terminated list of all of the callee-saved registers on this target.
llvm::TargetFrameLowering::isProfitableForNoCSROpt
virtual bool isProfitableForNoCSROpt(const Function &F) const
Check if the no-CSR optimisation is profitable for the given function.
Definition: TargetFrameLowering.h:433
llvm::MachineFunction::getRegInfo
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Definition: MachineFunction.h:644
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
llvm::MachineOperand::getRegMaskSize
static unsigned getRegMaskSize(unsigned NumRegs)
Returns number of elements needed for a regmask array.
Definition: MachineOperand.h:636
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
llvm::PhysicalRegisterUsageInfo::storeUpdateRegUsageInfo
void storeUpdateRegUsageInfo(const Function &FP, ArrayRef< uint32_t > RegMask)
To store RegMask for given Function *.
Definition: RegisterUsageInfo.cpp:59
false
Definition: StackSlotColoring.cpp:142
llvm::PassRegistry
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
Definition: PassRegistry.h:38
llvm::STATISTIC
STATISTIC(NumFunctions, "Total number of functions")
llvm::BitVector
Definition: BitVector.h:74
llvm::Value::use_empty
bool use_empty() const
Definition: Value.h:344
llvm::CallingConv::AMDGPU_GS
@ AMDGPU_GS
Calling convention used for Mesa/AMDPAL geometry shaders.
Definition: CallingConv.h:207
INITIALIZE_PASS_END
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:58
llvm::MachineRegisterInfo::def_empty
bool def_empty(Register RegNo) const
def_empty - Return true if there are no instructions defining the specified register (it may be live-...
Definition: MachineRegisterInfo.h:426
llvm::CallingConv::AMDGPU_CS
@ AMDGPU_CS
Calling convention used for Mesa/AMDPAL compute shaders.
Definition: CallingConv.h:213
Passes.h
llvm::MachineFunction::getSubtarget
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Definition: MachineFunction.h:634
llvm::initializeRegUsageInfoCollectorPass
void initializeRegUsageInfoCollectorPass(PassRegistry &)
llvm::Function::getCallingConv
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:240
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
isCallableFunction
static bool isCallableFunction(const MachineFunction &MF)
Definition: RegUsageInfoCollector.cpp:85
llvm::MCPhysReg
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
Definition: MCRegister.h:21
MachineFunctionPass.h
llvm::MachineFunction::getName
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
Definition: MachineFunction.cpp:542
llvm::TargetFrameLowering::isSafeForNoCSROpt
static bool isSafeForNoCSROpt(const Function &F)
Check if given function is safe for not having callee saved registers.
Definition: TargetFrameLoweringImpl.cpp:139
llvm::PhysicalRegisterUsageInfo
Definition: RegisterUsageInfo.h:34
llvm::MachineFunction
Definition: MachineFunction.h:234
RegUsageInfoCollector
RegUsageInfoCollector
Definition: RegUsageInfoCollector.cpp:73
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
uint32_t
RegisterUsageInfo.h
MRI
unsigned const MachineRegisterInfo * MRI
Definition: AArch64AdvSIMDScalarPass.cpp:105
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::CallingConv::AMDGPU_KERNEL
@ AMDGPU_KERNEL
Calling convention for AMDGPU code object kernels.
Definition: CallingConv.h:216
llvm::MachineRegisterInfo::getUsedPhysRegsMask
const BitVector & getUsedPhysRegsMask() const
Definition: MachineRegisterInfo.h:883
llvm::createRegUsageInfoCollector
FunctionPass * createRegUsageInfoCollector()
This pass is executed POST-RA to collect which physical registers are preserved by given machine func...
Definition: RegUsageInfoCollector.cpp:76
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(RegUsageInfoCollector, "RegUsageInfoCollector", "Register Usage Information Collector", false, false) INITIALIZE_PASS_END(RegUsageInfoCollector
llvm::BitVector::test
bool test(unsigned Idx) const
Definition: BitVector.h:447
llvm::MachineFunction::getFunction
Function & getFunction()
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:600
llvm::TargetSubtargetInfo::getFrameLowering
virtual const TargetFrameLowering * getFrameLowering() const
Definition: TargetSubtargetInfo.h:93
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
llvm::MachineFunction::getTarget
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
Definition: MachineFunction.h:630
llvm::PhysicalRegisterUsageInfo::setTargetMachine
void setTargetMachine(const LLVMTargetMachine &TM)
Set TargetMachine which is used to print analysis.
llvm::CallingConv::AMDGPU_VS
@ AMDGPU_VS
Calling convention used for Mesa vertex shaders, or AMDPAL last shader stage before rasterization (ve...
Definition: CallingConv.h:204
llvm::CallingConv::AMDGPU_HS
@ AMDGPU_HS
Calling convention used for Mesa/AMDPAL hull shaders (= tessellation control shaders).
Definition: CallingConv.h:223
llvm::LLVMTargetMachine
This class describes a target machine that is implemented with the LLVM target-independent code gener...
Definition: TargetMachine.h:393
llvm::CallingConv::AMDGPU_LS
@ AMDGPU_LS
Calling convention used for AMDPAL vertex shader if tessellation is in use.
Definition: CallingConv.h:231
llvm::MCSubRegIterator
MCSubRegIterator enumerates all sub-registers of Reg.
Definition: MCRegisterInfo.h:594
llvm::MCRegAliasIterator::isValid
bool isValid() const
Definition: MCRegisterInfo.h:805
llvm::Registry
A global registry used in conjunction with static constructors to make pluggable components (like tar...
Definition: Registry.h:44
llvm::MCRegisterInfo::DiffListIterator::isValid
bool isValid() const
isValid - returns true if this iterator is not yet at the end.
Definition: MCRegisterInfo.h:224
MachineOperand.h
TM
const char LLVMTargetMachineRef TM
Definition: PassBuilderBindings.cpp:47
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
llvm::AnalysisUsage::addRequired
AnalysisUsage & addRequired()
Definition: PassAnalysisSupport.h:75
raw_ostream.h
Debug.h
llvm::MCRegAliasIterator
MCRegAliasIterator enumerates all registers aliasing Reg.
Definition: MCRegisterInfo.h:780
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37