LLVM 19.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"
32
33using namespace llvm;
34
35#define DEBUG_TYPE "ip-regalloc"
36
37#define RUIP_NAME "Register Usage Information Propagation"
38
39namespace {
40
41class RegUsageInfoPropagation : public MachineFunctionPass {
42public:
43 RegUsageInfoPropagation() : MachineFunctionPass(ID) {
46 }
47
48 StringRef getPassName() const override { return RUIP_NAME; }
49
50 bool runOnMachineFunction(MachineFunction &MF) override;
51
52 void getAnalysisUsage(AnalysisUsage &AU) const override {
54 AU.setPreservesAll();
56 }
57
58 static char ID;
59
60private:
61 static void setRegMask(MachineInstr &MI, ArrayRef<uint32_t> RegMask) {
62 assert(RegMask.size() ==
63 MachineOperand::getRegMaskSize(MI.getParent()->getParent()
64 ->getRegInfo().getTargetRegisterInfo()
65 ->getNumRegs())
66 && "expected register mask size");
67 for (MachineOperand &MO : MI.operands()) {
68 if (MO.isRegMask())
69 MO.setRegMask(RegMask.data());
70 }
71 }
72};
73
74} // end of anonymous namespace
75
76INITIALIZE_PASS_BEGIN(RegUsageInfoPropagation, "reg-usage-propagation",
77 RUIP_NAME, false, false)
79INITIALIZE_PASS_END(RegUsageInfoPropagation, "reg-usage-propagation",
81
82char RegUsageInfoPropagation::ID = 0;
83
84// Assumes call instructions have a single reference to a function.
87 for (const MachineOperand &MO : MI.operands()) {
88 if (MO.isGlobal())
89 return dyn_cast<const Function>(MO.getGlobal());
90
91 if (MO.isSymbol())
92 return M.getFunction(MO.getSymbolName());
93 }
94
95 return nullptr;
96}
97
98bool RegUsageInfoPropagation::runOnMachineFunction(MachineFunction &MF) {
99 const Module &M = *MF.getFunction().getParent();
100 PhysicalRegisterUsageInfo *PRUI = &getAnalysis<PhysicalRegisterUsageInfo>();
101
102 LLVM_DEBUG(dbgs() << " ++++++++++++++++++++ " << getPassName()
103 << " ++++++++++++++++++++ \n");
104 LLVM_DEBUG(dbgs() << "MachineFunction : " << MF.getName() << "\n");
105
106 const MachineFrameInfo &MFI = MF.getFrameInfo();
107 if (!MFI.hasCalls() && !MFI.hasTailCall())
108 return false;
109
110 bool Changed = false;
111
112 for (MachineBasicBlock &MBB : MF) {
113 for (MachineInstr &MI : MBB) {
114 if (!MI.isCall())
115 continue;
117 dbgs()
118 << "Call Instruction Before Register Usage Info Propagation : \n"
119 << MI << "\n");
120
121 auto UpdateRegMask = [&](const Function &F) {
122 const ArrayRef<uint32_t> RegMask = PRUI->getRegUsageInfo(F);
123 if (RegMask.empty())
124 return;
125 setRegMask(MI, RegMask);
126 Changed = true;
127 };
128
129 if (const Function *F = findCalledFunction(M, MI)) {
130 if (F->isDefinitionExact()) {
131 UpdateRegMask(*F);
132 } else {
133 LLVM_DEBUG(dbgs() << "Function definition is not exact\n");
134 }
135 } else {
136 LLVM_DEBUG(dbgs() << "Failed to find call target function\n");
137 }
138
140 dbgs()
141 << "Call Instruction After Register Usage Info Propagation : \n"
142 << MI << '\n');
143 }
144 }
145
147 dbgs() << " +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
148 "++++++ \n");
149 return Changed;
150}
151
153 return new RegUsageInfoPropagation();
154}
aarch64 promote const
MachineBasicBlock & MBB
#define LLVM_DEBUG(X)
Definition: Debug.h:101
IRTranslator LLVM IR MI
#define F(x, y, z)
Definition: MD5.cpp:55
Module.h This file contains the declarations for the Module class.
#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
reg usage propagation
#define RUIP_NAME
static const Function * findCalledFunction(const Module &M, const MachineInstr &MI)
This pass is required to take advantage of the interprocedural register allocation infrastructure.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
void setPreservesAll()
Set by analyses that do not transform their input at all.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
const T * data() const
Definition: ArrayRef.h:162
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:311
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:655
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
bool hasCalls() const
Return true if the current function has any function calls.
bool hasTailCall() const
Returns true if the function contains a tail call.
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...
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
Function & getFunction()
Return the LLVM function that this machine code represents.
Representation of each machine instruction.
Definition: MachineInstr.h:69
MachineOperand class - Representation of each machine instruction operand.
static unsigned getRegMaskSize(unsigned NumRegs)
Returns number of elements needed for a regmask array.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
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
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...
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
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void initializeRegUsageInfoPropagationPass(PassRegistry &)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
FunctionPass * createRegUsageInfoPropPass()
Return a MachineFunction pass that identifies call sites and propagates register usage information of...