Line data    Source code

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