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/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 using namespace llvm;
  37
  38 #define DEBUG_TYPE "ip-regalloc"
  39
  40 #define RUIP_NAME "Register Usage Information Propagation"
  41
  42 namespace {
  43
  44 class RegUsageInfoPropagation : public MachineFunctionPass {
  45 public:
  46   RegUsageInfoPropagation() : MachineFunctionPass(ID) {
  47     PassRegistry &Registry = *PassRegistry::getPassRegistry();
  48     initializeRegUsageInfoPropagationPass(Registry);
  49   }
  50
  51   StringRef getPassName() const override { return RUIP_NAME; }
  52
  53   bool runOnMachineFunction(MachineFunction &MF) override;
  54
  55   void getAnalysisUsage(AnalysisUsage &AU) const override {
  56     AU.addRequired<PhysicalRegisterUsageInfo>();
  57     AU.setPreservesAll();
  58     MachineFunctionPass::getAnalysisUsage(AU);
  59   }
  60
  61   static char ID;
  62
  63 private:
  64   static void setRegMask(MachineInstr &MI, ArrayRef<uint32_t> RegMask) {
  65     assert(RegMask.size() ==
  66            MachineOperand::getRegMaskSize(MI.getParent()->getParent()
  67                                           ->getRegInfo().getTargetRegisterInfo()
  68                                           ->getNumRegs())
  69            && "expected register mask size");
  70     for (MachineOperand &MO : MI.operands()) {
  71       if (MO.isRegMask())
  72         MO.setRegMask(RegMask.data());
  73     }
  74   }
  75 };
  76
  77 } // end of anonymous namespace
  78
  79 INITIALIZE_PASS_BEGIN(RegUsageInfoPropagation, "reg-usage-propagation",
  80                       RUIP_NAME, false, false)
  81 INITIALIZE_PASS_DEPENDENCY(PhysicalRegisterUsageInfo)
  82 INITIALIZE_PASS_END(RegUsageInfoPropagation, "reg-usage-propagation",
  83                     RUIP_NAME, false, false)
  84
  85 char RegUsageInfoPropagation::ID = 0;
  86
  87 // Assumes call instructions have a single reference to a function.
  88 static const Function *findCalledFunction(const Module &M,
  89                                           const MachineInstr &MI) {
  90   for (const MachineOperand &MO : MI.operands()) {
  91     if (MO.isGlobal())
  92       return dyn_cast<const Function>(MO.getGlobal());
  93
  94     if (MO.isSymbol())
  95       return M.getFunction(MO.getSymbolName());
  96   }
  97
  98   return nullptr;
  99 }
 100
 101 bool RegUsageInfoPropagation::runOnMachineFunction(MachineFunction &MF) {
 102   const Module &M = *MF.getFunction().getParent();
 103   PhysicalRegisterUsageInfo *PRUI = &getAnalysis<PhysicalRegisterUsageInfo>();
 104
 105   LLVM_DEBUG(dbgs() << " ++++++++++++++++++++ " << getPassName()
 106                     << " ++++++++++++++++++++  \n");
 107   LLVM_DEBUG(dbgs() << "MachineFunction : " << MF.getName() << "\n");
 108
 109   const MachineFrameInfo &MFI = MF.getFrameInfo();
 110   if (!MFI.hasCalls() && !MFI.hasTailCall())
 111     return false;
 112
 113   bool Changed = false;
 114
 115   for (MachineBasicBlock &MBB : MF) {
 116     for (MachineInstr &MI : MBB) {
 117       if (!MI.isCall())
 118         continue;
 119       LLVM_DEBUG(
 120           dbgs()
 121           << "Call Instruction Before Register Usage Info Propagation : \n");
 122       LLVM_DEBUG(dbgs() << MI << "\n");
 123
 124       auto UpdateRegMask = [&](const Function &F) {
 125         const ArrayRef<uint32_t> RegMask = PRUI->getRegUsageInfo(F);
 126         if (RegMask.empty())
 127           return;
 128         setRegMask(MI, RegMask);
 129         Changed = true;
 130       };
 131
 132       if (const Function *F = findCalledFunction(M, MI)) {
 133         if (F->isDefinitionExact()) {
 134           UpdateRegMask(*F);
 135         } else {
 136           LLVM_DEBUG(dbgs() << "Function definition is not exact\n");
 137         }
 138       } else {
 139         LLVM_DEBUG(dbgs() << "Failed to find call target function\n");
 140       }
 141
 142       LLVM_DEBUG(
 143           dbgs() << "Call Instruction After Register Usage Info Propagation : "
 144                  << MI << '\n');
 145     }
 146   }
 147
 148   LLVM_DEBUG(
 149       dbgs() << " +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
 150                 "++++++ \n");
 151   return Changed;
 152 }
 153
 154 FunctionPass *llvm::createRegUsageInfoPropPass() {
 155   return new RegUsageInfoPropagation();
 156 }