LLVM  14.0.0git
RegUsageInfoPropagate.cpp
Go to the documentation of this file.
1 //=--- RegUsageInfoPropagate.cpp - Register Usage Informartion Propagation --=//
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 iterates through MachineInstrs in a given MachineFunction and at
13 /// each callsite queries RegisterUsageInfo for RegMask (calculated based on
14 /// actual register allocation) of the callee function, if the RegMask detail
15 /// is available then this pass will update the RegMask of the call instruction.
16 /// This updated RegMask will be used by the register allocator while allocating
17 /// the current MachineFunction.
18 ///
19 //===----------------------------------------------------------------------===//
20 
26 #include "llvm/CodeGen/Passes.h"
28 #include "llvm/IR/Module.h"
29 #include "llvm/Pass.h"
30 #include "llvm/Support/Debug.h"
33 
34 using namespace llvm;
35 
36 #define DEBUG_TYPE "ip-regalloc"
37 
38 #define RUIP_NAME "Register Usage Information Propagation"
39 
40 namespace {
41 
42 class RegUsageInfoPropagation : public MachineFunctionPass {
43 public:
44  RegUsageInfoPropagation() : MachineFunctionPass(ID) {
47  }
48 
49  StringRef getPassName() const override { return RUIP_NAME; }
50 
51  bool runOnMachineFunction(MachineFunction &MF) override;
52 
53  void getAnalysisUsage(AnalysisUsage &AU) const override {
55  AU.setPreservesAll();
57  }
58 
59  static char ID;
60 
61 private:
62  static void setRegMask(MachineInstr &MI, ArrayRef<uint32_t> RegMask) {
63  assert(RegMask.size() ==
64  MachineOperand::getRegMaskSize(MI.getParent()->getParent()
65  ->getRegInfo().getTargetRegisterInfo()
66  ->getNumRegs())
67  && "expected register mask size");
68  for (MachineOperand &MO : MI.operands()) {
69  if (MO.isRegMask())
70  MO.setRegMask(RegMask.data());
71  }
72  }
73 };
74 
75 } // end of anonymous namespace
76 
77 INITIALIZE_PASS_BEGIN(RegUsageInfoPropagation, "reg-usage-propagation",
78  RUIP_NAME, false, false)
80 INITIALIZE_PASS_END(RegUsageInfoPropagation, "reg-usage-propagation",
82 
83 char RegUsageInfoPropagation::ID = 0;
84 
85 // Assumes call instructions have a single reference to a function.
88  for (const MachineOperand &MO : MI.operands()) {
89  if (MO.isGlobal())
90  return dyn_cast<const Function>(MO.getGlobal());
91 
92  if (MO.isSymbol())
93  return M.getFunction(MO.getSymbolName());
94  }
95 
96  return nullptr;
97 }
98 
99 bool RegUsageInfoPropagation::runOnMachineFunction(MachineFunction &MF) {
100  const Module &M = *MF.getFunction().getParent();
101  PhysicalRegisterUsageInfo *PRUI = &getAnalysis<PhysicalRegisterUsageInfo>();
102 
103  LLVM_DEBUG(dbgs() << " ++++++++++++++++++++ " << getPassName()
104  << " ++++++++++++++++++++ \n");
105  LLVM_DEBUG(dbgs() << "MachineFunction : " << MF.getName() << "\n");
106 
107  const MachineFrameInfo &MFI = MF.getFrameInfo();
108  if (!MFI.hasCalls() && !MFI.hasTailCall())
109  return false;
110 
111  bool Changed = false;
112 
113  for (MachineBasicBlock &MBB : MF) {
114  for (MachineInstr &MI : MBB) {
115  if (!MI.isCall())
116  continue;
117  LLVM_DEBUG(
118  dbgs()
119  << "Call Instruction Before Register Usage Info Propagation : \n"
120  << MI << "\n");
121 
122  auto UpdateRegMask = [&](const Function &F) {
123  const ArrayRef<uint32_t> RegMask = PRUI->getRegUsageInfo(F);
124  if (RegMask.empty())
125  return;
126  setRegMask(MI, RegMask);
127  Changed = true;
128  };
129 
130  if (const Function *F = findCalledFunction(M, MI)) {
131  if (F->isDefinitionExact()) {
132  UpdateRegMask(*F);
133  } else {
134  LLVM_DEBUG(dbgs() << "Function definition is not exact\n");
135  }
136  } else {
137  LLVM_DEBUG(dbgs() << "Failed to find call target function\n");
138  }
139 
140  LLVM_DEBUG(
141  dbgs()
142  << "Call Instruction After Register Usage Info Propagation : \n"
143  << MI << '\n');
144  }
145  }
146 
147  LLVM_DEBUG(
148  dbgs() << " +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
149  "++++++ \n");
150  return Changed;
151 }
152 
154  return new RegUsageInfoPropagation();
155 }
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:103
MachineInstr.h
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::Function
Definition: Function.h:61
Pass.h
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(RegUsageInfoPropagation, "reg-usage-propagation", RUIP_NAME, false, false) INITIALIZE_PASS_END(RegUsageInfoPropagation
llvm::MachineFunctionPass
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Definition: MachineFunctionPass.h:30
MachineBasicBlock.h
Module.h
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
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
llvm::ArrayRef::data
const T * data() const
Definition: ArrayRef.h:162
F
#define F(x, y, z)
Definition: MD5.cpp:56
MachineRegisterInfo.h
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::PhysicalRegisterUsageInfo::getRegUsageInfo
ArrayRef< uint32_t > getRegUsageInfo(const Function &FP)
To query stored RegMask for given Function *, it will returns ane empty array if function is not know...
Definition: RegisterUsageInfo.cpp:65
TargetMachine.h
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
findCalledFunction
static const Function * findCalledFunction(const Module &M, const MachineInstr &MI)
Definition: RegUsageInfoPropagate.cpp:86
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
false
Definition: StackSlotColoring.cpp:142
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:49
llvm::PassRegistry
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
Definition: PassRegistry.h:38
RUIP_NAME
#define RUIP_NAME
Definition: RegUsageInfoPropagate.cpp:38
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
INITIALIZE_PASS_END
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:58
Passes.h
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:572
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
llvm::createRegUsageInfoPropPass
FunctionPass * createRegUsageInfoPropPass()
Return a MachineFunction pass that identifies call sites and propagates register usage information of...
Definition: RegUsageInfoPropagate.cpp:153
MachineFunctionPass.h
llvm::MachineFunction::getName
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
Definition: MachineFunction.cpp:541
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::MachineFunction::getFrameInfo
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
Definition: MachineFunction.h:642
llvm::initializeRegUsageInfoPropagationPass
void initializeRegUsageInfoPropagationPass(PassRegistry &)
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::PhysicalRegisterUsageInfo
Definition: RegisterUsageInfo.h:34
llvm::MachineFunction
Definition: MachineFunction.h:230
llvm::ArrayRef< uint32_t >
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
RegisterUsageInfo.h
llvm::MachineFrameInfo::hasCalls
bool hasCalls() const
Return true if the current function has any function calls.
Definition: MachineFrameInfo.h:581
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::MachineFunction::getFunction
Function & getFunction()
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:592
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
MachineFrameInfo.h
llvm::MachineFrameInfo
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
Definition: MachineFrameInfo.h:107
llvm::Registry
A global registry used in conjunction with static constructors to make pluggable components (like tar...
Definition: Registry.h:44
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
propagation
reg usage propagation
Definition: RegUsageInfoPropagate.cpp:80
llvm::AnalysisUsage::addRequired
AnalysisUsage & addRequired()
Definition: PassAnalysisSupport.h:75
llvm::MachineFrameInfo::hasTailCall
bool hasTailCall() const
Returns true if the function contains a tail call.
Definition: MachineFrameInfo.h:606
raw_ostream.h
Debug.h
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37