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
21#include "llvm/CodeGen/MachineBasicBlock.h"
22#include "llvm/CodeGen/MachineFrameInfo.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/Pass.h"
30#include "llvm/Support/Debug.h"
31#include "llvm/Support/raw_ostream.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) {
44    PassRegistry &Registry = *PassRegistry::getPassRegistry();
45    initializeRegUsageInfoPropagationPass(Registry);
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 {
53    AU.addRequired<PhysicalRegisterUsageInfo>();
54    AU.setPreservesAll();
55    MachineFunctionPass::getAnalysisUsage(AU);
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)
78INITIALIZE_PASS_DEPENDENCY(PhysicalRegisterUsageInfo)
79INITIALIZE_PASS_END(RegUsageInfoPropagation, "reg-usage-propagation",
80                    RUIP_NAME, false, false)
81
82char RegUsageInfoPropagation::ID = 0;
83
84// Assumes call instructions have a single reference to a function.
85static const Function *findCalledFunction(const Module &M,
86                                          const MachineInstr &MI) {
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;
116      LLVM_DEBUG(
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
139      LLVM_DEBUG(
140          dbgs()
141          << "Call Instruction After Register Usage Info Propagation : \n"
142          << MI << '\n');
143    }
144  }
145
146  LLVM_DEBUG(
147      dbgs() << " +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
148                "++++++ \n");
149  return Changed;
150}
151
152FunctionPass *llvm::createRegUsageInfoPropPass() {
153  return new RegUsageInfoPropagation();
154}
155