contrib/llvm/lib/CodeGen/RegUsageInfoPropagate.cpp

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