lib/Target/Mips/MipsOptimizePICCall.cpp

   1 //===--------- MipsOptimizePICCall.cpp - Optimize PIC Calls ---------------===//
   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 eliminates unnecessary instructions that set up $gp and replace
  11 // instructions that load target function addresses with copy instructions.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "Mips.h"
  16 #include "MCTargetDesc/MipsBaseInfo.h"
  17 #include "MipsMachineFunction.h"
  18 #include "MipsTargetMachine.h"
  19 #include "llvm/ADT/ScopedHashTable.h"
  20 #include "llvm/CodeGen/MachineDominators.h"
  21 #include "llvm/CodeGen/MachineRegisterInfo.h"
  22 #include "llvm/Support/CommandLine.h"
  23
  24 using namespace llvm;
  25
  26 #define DEBUG_TYPE "optimize-mips-pic-call"
  27
  28 static cl::opt<bool> LoadTargetFromGOT("mips-load-target-from-got",
  29                                        cl::init(true),
  30                                        cl::desc("Load target address from GOT"),
  31                                        cl::Hidden);
  32
  33 static cl::opt<bool> EraseGPOpnd("mips-erase-gp-opnd",
  34                                  cl::init(true), cl::desc("Erase GP Operand"),
  35                                  cl::Hidden);
  36
  37 namespace {
  38 typedef PointerUnion<const Value *, const PseudoSourceValue *> ValueType;
  39
  40 typedef std::pair<unsigned, unsigned> CntRegP;
  41 typedef RecyclingAllocator<BumpPtrAllocator,
  42                            ScopedHashTableVal<ValueType, CntRegP> >
  43 AllocatorTy;
  44 typedef ScopedHashTable<ValueType, CntRegP, DenseMapInfo<ValueType>,
  45                         AllocatorTy> ScopedHTType;
  46
  47 class MBBInfo {
  48 public:
  49   MBBInfo(MachineDomTreeNode *N);
  50   const MachineDomTreeNode *getNode() const;
  51   bool isVisited() const;
  52   void preVisit(ScopedHTType &ScopedHT);
  53   void postVisit();
  54
  55 private:
  56   MachineDomTreeNode *Node;
  57   ScopedHTType::ScopeTy *HTScope;
  58 };
  59
  60 class OptimizePICCall : public MachineFunctionPass {
  61 public:
  62   OptimizePICCall(TargetMachine &tm) : MachineFunctionPass(ID) {}
  63
  64   const char *getPassName() const override { return "Mips OptimizePICCall"; }
  65
  66   bool runOnMachineFunction(MachineFunction &F) override;
  67
  68   void getAnalysisUsage(AnalysisUsage &AU) const override {
  69     AU.addRequired<MachineDominatorTree>();
  70     MachineFunctionPass::getAnalysisUsage(AU);
  71   }
  72
  73 private:
  74   /// \brief Visit MBB.
  75   bool visitNode(MBBInfo &MBBI);
  76
  77   /// \brief Test if MI jumps to a function via a register.
  78   ///
  79   /// Also, return the virtual register containing the target function's address
  80   /// and the underlying object in Reg and Val respectively, if the function's
  81   /// address can be resolved lazily.
  82   bool isCallViaRegister(MachineInstr &MI, unsigned &Reg,
  83                          ValueType &Val) const;
  84
  85   /// \brief Return the number of instructions that dominate the current
  86   /// instruction and load the function address from object Entry.
  87   unsigned getCount(ValueType Entry);
  88
  89   /// \brief Return the destination virtual register of the last instruction
  90   /// that loads from object Entry.
  91   unsigned getReg(ValueType Entry);
  92
  93   /// \brief Update ScopedHT.
  94   void incCntAndSetReg(ValueType Entry, unsigned Reg);
  95
  96   ScopedHTType ScopedHT;
  97   static char ID;
  98 };
  99
 100 char OptimizePICCall::ID = 0;
 101 } // end of anonymous namespace
 102
 103 /// Return the first MachineOperand of MI if it is a used virtual register.
 104 static MachineOperand *getCallTargetRegOpnd(MachineInstr &MI) {
 105   if (MI.getNumOperands() == 0)
 106     return nullptr;
 107
 108   MachineOperand &MO = MI.getOperand(0);
 109
 110   if (!MO.isReg() || !MO.isUse() ||
 111       !TargetRegisterInfo::isVirtualRegister(MO.getReg()))
 112     return nullptr;
 113
 114   return &MO;
 115 }
 116
 117 /// Return type of register Reg.
 118 static MVT::SimpleValueType getRegTy(unsigned Reg, MachineFunction &MF) {
 119   const TargetRegisterClass *RC = MF.getRegInfo().getRegClass(Reg);
 120   assert(RC->vt_end() - RC->vt_begin() == 1);
 121   return *RC->vt_begin();
 122 }
 123
 124 /// Do the following transformation:
 125 ///
 126 /// jalr $vreg
 127 /// =>
 128 /// copy $t9, $vreg
 129 /// jalr $t9
 130 static void setCallTargetReg(MachineBasicBlock *MBB,
 131                              MachineBasicBlock::iterator I) {
 132   MachineFunction &MF = *MBB->getParent();
 133   const TargetInstrInfo &TII =
 134       *MF.getTarget().getSubtargetImpl()->getInstrInfo();
 135   unsigned SrcReg = I->getOperand(0).getReg();
 136   unsigned DstReg = getRegTy(SrcReg, MF) == MVT::i32 ? Mips::T9 : Mips::T9_64;
 137   BuildMI(*MBB, I, I->getDebugLoc(), TII.get(TargetOpcode::COPY), DstReg)
 138       .addReg(SrcReg);
 139   I->getOperand(0).setReg(DstReg);
 140 }
 141
 142 /// Search MI's operands for register GP and erase it.
 143 static void eraseGPOpnd(MachineInstr &MI) {
 144   if (!EraseGPOpnd)
 145     return;
 146
 147   MachineFunction &MF = *MI.getParent()->getParent();
 148   MVT::SimpleValueType Ty = getRegTy(MI.getOperand(0).getReg(), MF);
 149   unsigned Reg = Ty == MVT::i32 ? Mips::GP : Mips::GP_64;
 150
 151   for (unsigned I = 0; I < MI.getNumOperands(); ++I) {
 152     MachineOperand &MO = MI.getOperand(I);
 153     if (MO.isReg() && MO.getReg() == Reg) {
 154       MI.RemoveOperand(I);
 155       return;
 156     }
 157   }
 158
 159   llvm_unreachable(nullptr);
 160 }
 161
 162 MBBInfo::MBBInfo(MachineDomTreeNode *N) : Node(N), HTScope(nullptr) {}
 163
 164 const MachineDomTreeNode *MBBInfo::getNode() const { return Node; }
 165
 166 bool MBBInfo::isVisited() const { return HTScope; }
 167
 168 void MBBInfo::preVisit(ScopedHTType &ScopedHT) {
 169   HTScope = new ScopedHTType::ScopeTy(ScopedHT);
 170 }
 171
 172 void MBBInfo::postVisit() {
 173   delete HTScope;
 174 }
 175
 176 // OptimizePICCall methods.
 177 bool OptimizePICCall::runOnMachineFunction(MachineFunction &F) {
 178   if (F.getTarget().getSubtarget<MipsSubtarget>().inMips16Mode())
 179     return false;
 180
 181   // Do a pre-order traversal of the dominator tree.
 182   MachineDominatorTree *MDT = &getAnalysis<MachineDominatorTree>();
 183   bool Changed = false;
 184
 185   SmallVector<MBBInfo, 8> WorkList(1, MBBInfo(MDT->getRootNode()));
 186
 187   while (!WorkList.empty()) {
 188     MBBInfo &MBBI = WorkList.back();
 189
 190     // If this MBB has already been visited, destroy the scope for the MBB and
 191     // pop it from the work list.
 192     if (MBBI.isVisited()) {
 193       MBBI.postVisit();
 194       WorkList.pop_back();
 195       continue;
 196     }
 197
 198     // Visit the MBB and add its children to the work list.
 199     MBBI.preVisit(ScopedHT);
 200     Changed |= visitNode(MBBI);
 201     const MachineDomTreeNode *Node = MBBI.getNode();
 202     const std::vector<MachineDomTreeNode *> &Children = Node->getChildren();
 203     WorkList.append(Children.begin(), Children.end());
 204   }
 205
 206   return Changed;
 207 }
 208
 209 bool OptimizePICCall::visitNode(MBBInfo &MBBI) {
 210   bool Changed = false;
 211   MachineBasicBlock *MBB = MBBI.getNode()->getBlock();
 212
 213   for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end(); I != E;
 214        ++I) {
 215     unsigned Reg;
 216     ValueType Entry;
 217
 218     // Skip instructions that are not call instructions via registers.
 219     if (!isCallViaRegister(*I, Reg, Entry))
 220       continue;
 221
 222     Changed = true;
 223     unsigned N = getCount(Entry);
 224
 225     if (N != 0) {
 226       // If a function has been called more than twice, we do not have to emit a
 227       // load instruction to get the function address from the GOT, but can
 228       // instead reuse the address that has been loaded before.
 229       if (N >= 2 && !LoadTargetFromGOT)
 230         getCallTargetRegOpnd(*I)->setReg(getReg(Entry));
 231
 232       // Erase the $gp operand if this isn't the first time a function has
 233       // been called. $gp needs to be set up only if the function call can go
 234       // through a lazy binding stub.
 235       eraseGPOpnd(*I);
 236     }
 237
 238     if (Entry)
 239       incCntAndSetReg(Entry, Reg);
 240
 241     setCallTargetReg(MBB, I);
 242   }
 243
 244   return Changed;
 245 }
 246
 247 bool OptimizePICCall::isCallViaRegister(MachineInstr &MI, unsigned &Reg,
 248                                         ValueType &Val) const {
 249   if (!MI.isCall())
 250     return false;
 251
 252   MachineOperand *MO = getCallTargetRegOpnd(MI);
 253
 254   // Return if MI is not a function call via a register.
 255   if (!MO)
 256     return false;
 257
 258   // Get the instruction that loads the function address from the GOT.
 259   Reg = MO->getReg();
 260   Val = (Value*)nullptr;
 261   MachineRegisterInfo &MRI = MI.getParent()->getParent()->getRegInfo();
 262   MachineInstr *DefMI = MRI.getVRegDef(Reg);
 263
 264   assert(DefMI);
 265
 266   // See if DefMI is an instruction that loads from a GOT entry that holds the
 267   // address of a lazy binding stub.
 268   if (!DefMI->mayLoad() || DefMI->getNumOperands() < 3)
 269     return true;
 270
 271   unsigned Flags = DefMI->getOperand(2).getTargetFlags();
 272
 273   if (Flags != MipsII::MO_GOT_CALL && Flags != MipsII::MO_CALL_LO16)
 274     return true;
 275
 276   // Return the underlying object for the GOT entry in Val.
 277   assert(DefMI->hasOneMemOperand());
 278   Val = (*DefMI->memoperands_begin())->getValue();
 279   if (!Val)
 280     Val = (*DefMI->memoperands_begin())->getPseudoValue();
 281   return true;
 282 }
 283
 284 unsigned OptimizePICCall::getCount(ValueType Entry) {
 285   return ScopedHT.lookup(Entry).first;
 286 }
 287
 288 unsigned OptimizePICCall::getReg(ValueType Entry) {
 289   unsigned Reg = ScopedHT.lookup(Entry).second;
 290   assert(Reg);
 291   return Reg;
 292 }
 293
 294 void OptimizePICCall::incCntAndSetReg(ValueType Entry, unsigned Reg) {
 295   CntRegP P = ScopedHT.lookup(Entry);
 296   ScopedHT.insert(Entry, std::make_pair(P.first + 1, Reg));
 297 }
 298
 299 /// Return an OptimizeCall object.
 300 FunctionPass *llvm::createMipsOptimizePICCallPass(MipsTargetMachine &TM) {
 301   return new OptimizePICCall(TM);
 302 }