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
36namespace llvm {
37void initializeRegUsageInfoPropagationPassPass(PassRegistry &);
38}
39
40using namespace llvm;
41
42#define DEBUG_TYPE "ip-regalloc"
43
44#define RUIP_NAME "Register Usage Information Propagation"
45
46namespace {
47class RegUsageInfoPropagationPass : public MachineFunctionPass {
48
49public:
50  RegUsageInfoPropagationPass() : MachineFunctionPass(ID) {
51    PassRegistry &Registry = *PassRegistry::getPassRegistry();
52    initializeRegUsageInfoPropagationPassPass(Registry);
53  }
54
55  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
63private:
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
72char RegUsageInfoPropagationPass::ID = 0;
73
74INITIALIZE_PASS_BEGIN(RegUsageInfoPropagationPass, "reg-usage-propagation",
75                      RUIP_NAME, false, false)
76INITIALIZE_PASS_DEPENDENCY(PhysicalRegisterUsageInfo)
77INITIALIZE_PASS_END(RegUsageInfoPropagationPass, "reg-usage-propagation",
78                    RUIP_NAME, false, false)
79
80FunctionPass *llvm::createRegUsageInfoPropPass() {
81  return new RegUsageInfoPropagationPass();
82}
83
84void RegUsageInfoPropagationPass::getAnalysisUsage(AnalysisUsage &AU) const {
85  AU.addRequired<PhysicalRegisterUsageInfo>();
86  AU.setPreservesAll();
87  MachineFunctionPass::getAnalysisUsage(AU);
88}
89
90bool 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