1 //=--- RegUsageInfoPropagate.cpp - Register Usage Informartion Propagation --=//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 ///
10 /// This pass is required to take advantage of the interprocedural register
11 /// allocation infrastructure.
12 ///
13 /// This pass iterates through MachineInstrs in a given MachineFunction and at
14 /// each callsite queries RegisterUsageInfo for RegMask (calculated based on
15 /// actual register allocation) of the callee function, if the RegMask detail
16 /// is available then this pass will update the RegMask of the call instruction.
17 /// This updated RegMask will be used by the register allocator while allocating
18 /// the current MachineFunction.
19 ///
20 //===----------------------------------------------------------------------===//
21
22 #include "llvm/CodeGen/MachineBasicBlock.h"
23 #include "llvm/CodeGen/MachineFunctionPass.h"
24 #include "llvm/CodeGen/MachineInstr.h"
25 #include "llvm/CodeGen/MachineRegisterInfo.h"
26 #include "llvm/CodeGen/Passes.h"
27 #include "llvm/CodeGen/RegisterUsageInfo.h"
28 #include "llvm/IR/Module.h"
29 #include "llvm/PassAnalysisSupport.h"
30 #include "llvm/Support/Debug.h"
31 #include "llvm/Support/raw_ostream.h"
32 #include "llvm/Target/TargetMachine.h"
33 #include <map>
34 #include <string>
35
36 namespace llvm {
37 void initializeRegUsageInfoPropagationPassPass(PassRegistry &);
38 }
39
40 using namespace llvm;
41
42 #define DEBUG_TYPE "ip-regalloc"
43
44 #define RUIP_NAME "Register Usage Information Propagation"
45
46 namespace {
47 class RegUsageInfoPropagationPass : public MachineFunctionPass {
48
49 public:
RegUsageInfoPropagationPass()50 RegUsageInfoPropagationPass() : MachineFunctionPass(ID) {
51 PassRegistry &Registry = *PassRegistry::getPassRegistry();
52 initializeRegUsageInfoPropagationPassPass(Registry);
53 }
54
getPassName() const55 const char *getPassName() const override { return RUIP_NAME; }
56
57 bool runOnMachineFunction(MachineFunction &MF) override;
58
59 void getAnalysisUsage(AnalysisUsage &AU) const override;
60
61 static char ID;
62
63 private:
setRegMask(MachineInstr & MI,const uint32_t * RegMask)64 static void setRegMask(MachineInstr &MI, const uint32_t *RegMask) {
65 for (MachineOperand &MO : MI.operands()) {
66 if (MO.isRegMask())
67 MO.setRegMask(RegMask);
68 }
69 }
70 };
71 } // end of anonymous namespace
72 char RegUsageInfoPropagationPass::ID = 0;
73
74 INITIALIZE_PASS_BEGIN(RegUsageInfoPropagationPass, "reg-usage-propagation",
75 RUIP_NAME, false, false)
INITIALIZE_PASS_DEPENDENCY(PhysicalRegisterUsageInfo)76 INITIALIZE_PASS_DEPENDENCY(PhysicalRegisterUsageInfo)
77 INITIALIZE_PASS_END(RegUsageInfoPropagationPass, "reg-usage-propagation",
78 RUIP_NAME, false, false)
79
80 FunctionPass *llvm::createRegUsageInfoPropPass() {
81 return new RegUsageInfoPropagationPass();
82 }
83
getAnalysisUsage(AnalysisUsage & AU) const84 void RegUsageInfoPropagationPass::getAnalysisUsage(AnalysisUsage &AU) const {
85 AU.addRequired<PhysicalRegisterUsageInfo>();
86 AU.setPreservesAll();
87 MachineFunctionPass::getAnalysisUsage(AU);
88 }
89
runOnMachineFunction(MachineFunction & MF)90 bool RegUsageInfoPropagationPass::runOnMachineFunction(MachineFunction &MF) {
91 const Module *M = MF.getFunction()->getParent();
92 PhysicalRegisterUsageInfo *PRUI = &getAnalysis<PhysicalRegisterUsageInfo>();
93
94 DEBUG(dbgs() << " ++++++++++++++++++++ " << getPassName()
95 << " ++++++++++++++++++++ \n");
96 DEBUG(dbgs() << "MachineFunction : " << MF.getName() << "\n");
97
98 bool Changed = false;
99
100 for (MachineBasicBlock &MBB : MF) {
101 for (MachineInstr &MI : MBB) {
102 if (!MI.isCall())
103 continue;
104 DEBUG(dbgs()
105 << "Call Instruction Before Register Usage Info Propagation : \n");
106 DEBUG(dbgs() << MI << "\n");
107
108 auto UpdateRegMask = [&](const Function *F) {
109 const auto *RegMask = PRUI->getRegUsageInfo(F);
110 if (!RegMask)
111 return;
112 setRegMask(MI, &(*RegMask)[0]);
113 Changed = true;
114 };
115
116 MachineOperand &Operand = MI.getOperand(0);
117 if (Operand.isGlobal())
118 UpdateRegMask(cast<Function>(Operand.getGlobal()));
119 else if (Operand.isSymbol())
120 UpdateRegMask(M->getFunction(Operand.getSymbolName()));
121
122 DEBUG(dbgs()
123 << "Call Instruction After Register Usage Info Propagation : \n");
124 DEBUG(dbgs() << MI << "\n");
125 }
126 }
127
128 DEBUG(dbgs() << " +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
129 "++++++ \n");
130 return Changed;
131 }
132