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