llvm/lib/CodeGen/RegUsageInfoPropagate.cpp

   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/MachineFunctionPass.h"
  23 #include "llvm/CodeGen/MachineFrameInfo.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 #include "llvm/Target/TargetMachine.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) {
  45     PassRegistry &Registry = *PassRegistry::getPassRegistry();
  46     initializeRegUsageInfoPropagationPass(Registry);
  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 {
  54     AU.addRequired<PhysicalRegisterUsageInfo>();
  55     AU.setPreservesAll();
  56     MachineFunctionPass::getAnalysisUsage(AU);
  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)
  79 INITIALIZE_PASS_DEPENDENCY(PhysicalRegisterUsageInfo)
  80 INITIALIZE_PASS_END(RegUsageInfoPropagation, "reg-usage-propagation",
  81                     RUIP_NAME, false, false)
  82
  83 char RegUsageInfoPropagation::ID = 0;
  84
  85 // Assumes call instructions have a single reference to a function.
  86 static const Function *findCalledFunction(const Module &M,
  87                                           const MachineInstr &MI) {
  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
 153 FunctionPass *llvm::createRegUsageInfoPropPass() {
 154   return new RegUsageInfoPropagation();
 155 }