LCOV - code coverage report
Current view: top level - lib/Target/ARM - MLxExpansionPass.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 123 160 76.9 %
Date: 2017-09-14 15:23:50 Functions: 13 14 92.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- MLxExpansionPass.cpp - Expand MLx instrs to avoid hazards ---------===//
       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             : // Expand VFP / NEON floating point MLA / MLS instructions (each to a pair of
      11             : // multiple and add / sub instructions) when special VMLx hazards are detected.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #include "ARM.h"
      16             : #include "ARMBaseInstrInfo.h"
      17             : #include "ARMSubtarget.h"
      18             : #include "llvm/ADT/SmallPtrSet.h"
      19             : #include "llvm/ADT/Statistic.h"
      20             : #include "llvm/CodeGen/MachineFunctionPass.h"
      21             : #include "llvm/CodeGen/MachineInstr.h"
      22             : #include "llvm/CodeGen/MachineInstrBuilder.h"
      23             : #include "llvm/CodeGen/MachineRegisterInfo.h"
      24             : #include "llvm/Support/CommandLine.h"
      25             : #include "llvm/Support/Debug.h"
      26             : #include "llvm/Support/raw_ostream.h"
      27             : #include "llvm/Target/TargetRegisterInfo.h"
      28             : using namespace llvm;
      29             : 
      30             : #define DEBUG_TYPE "mlx-expansion"
      31             : 
      32             : static cl::opt<bool>
      33      144612 : ForceExapnd("expand-all-fp-mlx", cl::init(false), cl::Hidden);
      34             : static cl::opt<unsigned>
      35      144612 : ExpandLimit("expand-limit", cl::init(~0U), cl::Hidden);
      36             : 
      37             : STATISTIC(NumExpand, "Number of fp MLA / MLS instructions expanded");
      38             : 
      39             : namespace {
      40        6885 :   struct MLxExpansion : public MachineFunctionPass {
      41             :     static char ID;
      42        4644 :     MLxExpansion() : MachineFunctionPass(ID) {}
      43             : 
      44             :     bool runOnMachineFunction(MachineFunction &Fn) override;
      45             : 
      46        2315 :     StringRef getPassName() const override {
      47        2315 :       return "ARM MLA / MLS expansion pass";
      48             :     }
      49             : 
      50             :   private:
      51             :     const ARMBaseInstrInfo *TII;
      52             :     const TargetRegisterInfo *TRI;
      53             :     MachineRegisterInfo *MRI;
      54             : 
      55             :     bool isLikeA9;
      56             :     bool isSwift;
      57             :     unsigned MIIdx;
      58             :     MachineInstr* LastMIs[4];
      59             :     SmallPtrSet<MachineInstr*, 4> IgnoreStall;
      60             : 
      61             :     void clearStack();
      62             :     void pushStack(MachineInstr *MI);
      63             :     MachineInstr *getAccDefMI(MachineInstr *MI) const;
      64             :     unsigned getDefReg(MachineInstr *MI) const;
      65             :     bool hasLoopHazard(MachineInstr *MI) const;
      66             :     bool hasRAWHazard(unsigned Reg, MachineInstr *MI) const;
      67             :     bool FindMLxHazard(MachineInstr *MI);
      68             :     void ExpandFPMLxInstruction(MachineBasicBlock &MBB, MachineInstr *MI,
      69             :                                 unsigned MulOpc, unsigned AddSubOpc,
      70             :                                 bool NegAcc, bool HasLane);
      71             :     bool ExpandFPMLxInstructions(MachineBasicBlock &MBB);
      72             :   };
      73             :   char MLxExpansion::ID = 0;
      74             : }
      75             : 
      76             : void MLxExpansion::clearStack() {
      77         673 :   std::fill(LastMIs, LastMIs + 4, nullptr);
      78         434 :   MIIdx = 0;
      79             : }
      80             : 
      81             : void MLxExpansion::pushStack(MachineInstr *MI) {
      82         782 :   LastMIs[MIIdx] = MI;
      83         782 :   if (++MIIdx == 4)
      84         141 :     MIIdx = 0;
      85             : }
      86             : 
      87          16 : MachineInstr *MLxExpansion::getAccDefMI(MachineInstr *MI) const {
      88             :   // Look past COPY and INSERT_SUBREG instructions to find the
      89             :   // real definition MI. This is important for _sfp instructions.
      90          16 :   unsigned Reg = MI->getOperand(1).getReg();
      91          16 :   if (TargetRegisterInfo::isPhysicalRegister(Reg))
      92             :     return nullptr;
      93             : 
      94          16 :   MachineBasicBlock *MBB = MI->getParent();
      95          16 :   MachineInstr *DefMI = MRI->getVRegDef(Reg);
      96             :   while (true) {
      97          16 :     if (DefMI->getParent() != MBB)
      98             :       break;
      99          10 :     if (DefMI->isCopyLike()) {
     100           6 :       Reg = DefMI->getOperand(1).getReg();
     101           6 :       if (TargetRegisterInfo::isVirtualRegister(Reg)) {
     102           0 :         DefMI = MRI->getVRegDef(Reg);
     103             :         continue;
     104             :       }
     105          10 :     } else if (DefMI->isInsertSubreg()) {
     106           0 :       Reg = DefMI->getOperand(2).getReg();
     107           0 :       if (TargetRegisterInfo::isVirtualRegister(Reg)) {
     108           0 :         DefMI = MRI->getVRegDef(Reg);
     109             :         continue;
     110             :       }
     111             :     }
     112             :     break;
     113             :   }
     114             :   return DefMI;
     115             : }
     116             : 
     117           8 : unsigned MLxExpansion::getDefReg(MachineInstr *MI) const {
     118           8 :   unsigned Reg = MI->getOperand(0).getReg();
     119          16 :   if (TargetRegisterInfo::isPhysicalRegister(Reg) ||
     120           8 :       !MRI->hasOneNonDBGUse(Reg))
     121             :     return Reg;
     122             : 
     123           8 :   MachineBasicBlock *MBB = MI->getParent();
     124          16 :   MachineInstr *UseMI = &*MRI->use_instr_nodbg_begin(Reg);
     125           8 :   if (UseMI->getParent() != MBB)
     126             :     return Reg;
     127             : 
     128          16 :   while (UseMI->isCopy() || UseMI->isInsertSubreg()) {
     129           0 :     Reg = UseMI->getOperand(0).getReg();
     130           0 :     if (TargetRegisterInfo::isPhysicalRegister(Reg) ||
     131           0 :         !MRI->hasOneNonDBGUse(Reg))
     132             :       return Reg;
     133           0 :     UseMI = &*MRI->use_instr_nodbg_begin(Reg);
     134           0 :     if (UseMI->getParent() != MBB)
     135             :       return Reg;
     136             :   }
     137             : 
     138             :   return Reg;
     139             : }
     140             : 
     141             : /// hasLoopHazard - Check whether an MLx instruction is chained to itself across
     142             : /// a single-MBB loop.
     143           0 : bool MLxExpansion::hasLoopHazard(MachineInstr *MI) const {
     144           0 :   unsigned Reg = MI->getOperand(1).getReg();
     145           0 :   if (TargetRegisterInfo::isPhysicalRegister(Reg))
     146             :     return false;
     147             : 
     148           0 :   MachineBasicBlock *MBB = MI->getParent();
     149           0 :   MachineInstr *DefMI = MRI->getVRegDef(Reg);
     150             :   while (true) {
     151             : outer_continue:
     152           0 :     if (DefMI->getParent() != MBB)
     153             :       break;
     154             : 
     155           0 :     if (DefMI->isPHI()) {
     156           0 :       for (unsigned i = 1, e = DefMI->getNumOperands(); i < e; i += 2) {
     157           0 :         if (DefMI->getOperand(i + 1).getMBB() == MBB) {
     158           0 :           unsigned SrcReg = DefMI->getOperand(i).getReg();
     159           0 :           if (TargetRegisterInfo::isVirtualRegister(SrcReg)) {
     160           0 :             DefMI = MRI->getVRegDef(SrcReg);
     161             :             goto outer_continue;
     162             :           }
     163             :         }
     164             :       }
     165           0 :     } else if (DefMI->isCopyLike()) {
     166           0 :       Reg = DefMI->getOperand(1).getReg();
     167           0 :       if (TargetRegisterInfo::isVirtualRegister(Reg)) {
     168           0 :         DefMI = MRI->getVRegDef(Reg);
     169             :         continue;
     170             :       }
     171           0 :     } else if (DefMI->isInsertSubreg()) {
     172           0 :       Reg = DefMI->getOperand(2).getReg();
     173           0 :       if (TargetRegisterInfo::isVirtualRegister(Reg)) {
     174           0 :         DefMI = MRI->getVRegDef(Reg);
     175             :         continue;
     176             :       }
     177             :     }
     178             : 
     179             :     break;
     180             :   }
     181             : 
     182           0 :   return DefMI == MI;
     183             : }
     184             : 
     185           8 : bool MLxExpansion::hasRAWHazard(unsigned Reg, MachineInstr *MI) const {
     186             :   // FIXME: Detect integer instructions properly.
     187           8 :   const MCInstrDesc &MCID = MI->getDesc();
     188           8 :   unsigned Domain = MCID.TSFlags & ARMII::DomainMask;
     189           8 :   if (MI->mayStore())
     190             :     return false;
     191           6 :   unsigned Opcode = MCID.getOpcode();
     192           6 :   if (Opcode == ARM::VMOVRS || Opcode == ARM::VMOVRRD)
     193             :     return false;
     194           2 :   if ((Domain & ARMII::DomainVFP) || (Domain & ARMII::DomainNEON))
     195           4 :     return MI->readsRegister(Reg, TRI);
     196             :   return false;
     197             : }
     198             : 
     199             : static bool isFpMulInstruction(unsigned Opcode) {
     200             :   switch (Opcode) {
     201             :   case ARM::VMULS:
     202             :   case ARM::VMULfd:
     203             :   case ARM::VMULfq:
     204             :   case ARM::VMULD:
     205             :   case ARM::VMULslfd:
     206             :   case ARM::VMULslfq:
     207             :     return true;
     208             :   default:
     209             :     return false;
     210             :   }
     211             : }
     212             : 
     213          16 : bool MLxExpansion::FindMLxHazard(MachineInstr *MI) {
     214          32 :   if (NumExpand >= ExpandLimit)
     215             :     return false;
     216             : 
     217          16 :   if (ForceExapnd)
     218             :     return true;
     219             : 
     220          16 :   MachineInstr *DefMI = getAccDefMI(MI);
     221          48 :   if (TII->isFpMLxInstruction(DefMI->getOpcode())) {
     222             :     // r0 = vmla
     223             :     // r3 = vmla r0, r1, r2
     224             :     // takes 16 - 17 cycles
     225             :     //
     226             :     // r0 = vmla
     227             :     // r4 = vmul r1, r2
     228             :     // r3 = vadd r0, r4
     229             :     // takes about 14 - 15 cycles even with vmul stalling for 4 cycles.
     230           2 :     IgnoreStall.insert(DefMI);
     231           2 :     return true;
     232             :   }
     233             : 
     234             :   // On Swift, we mostly care about hazards from multiplication instructions
     235             :   // writing the accumulator and the pipelining of loop iterations by out-of-
     236             :   // order execution. 
     237          14 :   if (isSwift)
     238           0 :     return isFpMulInstruction(DefMI->getOpcode()) || hasLoopHazard(MI);
     239             : 
     240          14 :   if (IgnoreStall.count(MI))
     241             :     return false;
     242             : 
     243             :   // If a VMLA.F is followed by an VADD.F or VMUL.F with no RAW hazard, the
     244             :   // VADD.F or VMUL.F will stall 4 cycles before issue. The 4 cycle stall
     245             :   // preserves the in-order retirement of the instructions.
     246             :   // Look at the next few instructions, if *most* of them can cause hazards,
     247             :   // then the scheduler can't *fix* this, we'd better break up the VMLA.
     248          12 :   unsigned Limit1 = isLikeA9 ? 1 : 4;
     249             :   unsigned Limit2 = isLikeA9 ? 1 : 4;
     250         108 :   for (unsigned i = 1; i <= 4; ++i) {
     251          48 :     int Idx = ((int)MIIdx - i + 4) % 4;
     252          48 :     MachineInstr *NextMI = LastMIs[Idx];
     253          48 :     if (!NextMI)
     254          30 :       continue;
     255             : 
     256          54 :     if (TII->canCauseFpMLxStall(NextMI->getOpcode())) {
     257           0 :       if (i <= Limit1)
     258             :         return true;
     259             :     }
     260             : 
     261             :     // Look for VMLx RAW hazard.
     262          18 :     if (i <= Limit2 && hasRAWHazard(getDefReg(MI), NextMI))
     263             :       return true;
     264             :   }
     265             : 
     266             :   return false;
     267             : }
     268             : 
     269             : /// ExpandFPMLxInstructions - Expand a MLA / MLS instruction into a pair
     270             : /// of MUL + ADD / SUB instructions.
     271             : void
     272           2 : MLxExpansion::ExpandFPMLxInstruction(MachineBasicBlock &MBB, MachineInstr *MI,
     273             :                                      unsigned MulOpc, unsigned AddSubOpc,
     274             :                                      bool NegAcc, bool HasLane) {
     275           2 :   unsigned DstReg = MI->getOperand(0).getReg();
     276           4 :   bool DstDead = MI->getOperand(0).isDead();
     277           2 :   unsigned AccReg = MI->getOperand(1).getReg();
     278           2 :   unsigned Src1Reg = MI->getOperand(2).getReg();
     279           2 :   unsigned Src2Reg = MI->getOperand(3).getReg();
     280           4 :   bool Src1Kill = MI->getOperand(2).isKill();
     281           4 :   bool Src2Kill = MI->getOperand(3).isKill();
     282           2 :   unsigned LaneImm = HasLane ? MI->getOperand(4).getImm() : 0;
     283           2 :   unsigned NextOp = HasLane ? 5 : 4;
     284           4 :   ARMCC::CondCodes Pred = (ARMCC::CondCodes)MI->getOperand(NextOp).getImm();
     285           4 :   unsigned PredReg = MI->getOperand(++NextOp).getReg();
     286             : 
     287           4 :   const MCInstrDesc &MCID1 = TII->get(MulOpc);
     288           4 :   const MCInstrDesc &MCID2 = TII->get(AddSubOpc);
     289           2 :   const MachineFunction &MF = *MI->getParent()->getParent();
     290           2 :   unsigned TmpReg = MRI->createVirtualRegister(
     291           2 :                       TII->getRegClass(MCID1, 0, TRI, MF));
     292             : 
     293           6 :   MachineInstrBuilder MIB = BuildMI(MBB, MI, MI->getDebugLoc(), MCID1, TmpReg)
     294           2 :     .addReg(Src1Reg, getKillRegState(Src1Kill))
     295           2 :     .addReg(Src2Reg, getKillRegState(Src2Kill));
     296           2 :   if (HasLane)
     297           0 :     MIB.addImm(LaneImm);
     298           4 :   MIB.addImm(Pred).addReg(PredReg);
     299             : 
     300           6 :   MIB = BuildMI(MBB, MI, MI->getDebugLoc(), MCID2)
     301           4 :     .addReg(DstReg, getDefRegState(true) | getDeadRegState(DstDead));
     302             : 
     303           2 :   if (NegAcc) {
     304           0 :     bool AccKill = MRI->hasOneNonDBGUse(AccReg);
     305           0 :     MIB.addReg(TmpReg, getKillRegState(true))
     306           0 :        .addReg(AccReg, getKillRegState(AccKill));
     307             :   } else {
     308           2 :     MIB.addReg(AccReg).addReg(TmpReg, getKillRegState(true));
     309             :   }
     310           4 :   MIB.addImm(Pred).addReg(PredReg);
     311             : 
     312             :   DEBUG({
     313             :       dbgs() << "Expanding: " << *MI;
     314             :       dbgs() << "  to:\n";
     315             :       MachineBasicBlock::iterator MII = MI;
     316             :       MII = std::prev(MII);
     317             :       MachineInstr &MI2 = *MII;
     318             :       MII = std::prev(MII);
     319             :       MachineInstr &MI1 = *MII;
     320             :       dbgs() << "    " << MI1;
     321             :       dbgs() << "    " << MI2;
     322             :    });
     323             : 
     324           2 :   MI->eraseFromParent();
     325           2 :   ++NumExpand;
     326           2 : }
     327             : 
     328         239 : bool MLxExpansion::ExpandFPMLxInstructions(MachineBasicBlock &MBB) {
     329         239 :   bool Changed = false;
     330             : 
     331         239 :   clearStack();
     332         239 :   IgnoreStall.clear();
     333             : 
     334         239 :   unsigned Skip = 0;
     335         478 :   MachineBasicBlock::reverse_iterator MII = MBB.rbegin(), E = MBB.rend();
     336        2695 :   while (MII != E) {
     337        7368 :     MachineInstr *MI = &*MII++;
     338             : 
     339        8067 :     if (MI->isPosition() || MI->isImplicitDef() || MI->isCopy())
     340         799 :       continue;
     341             : 
     342        1657 :     const MCInstrDesc &MCID = MI->getDesc();
     343        1852 :     if (MI->isBarrier()) {
     344         195 :       clearStack();
     345         195 :       Skip = 0;
     346         195 :       continue;
     347             :     }
     348             : 
     349        1462 :     unsigned Domain = MCID.TSFlags & ARMII::DomainMask;
     350        1462 :     if (Domain == ARMII::DomainGeneral) {
     351         858 :       if (++Skip == 2)
     352             :         // Assume dual issues of non-VFP / NEON instructions.
     353             :         pushStack(nullptr);
     354             :     } else {
     355         604 :       Skip = 0;
     356             : 
     357             :       unsigned MulOpc, AddSubOpc;
     358             :       bool NegAcc, HasLane;
     359        1208 :       if (!TII->isFpMLxInstruction(MCID.getOpcode(),
     360         620 :                                    MulOpc, AddSubOpc, NegAcc, HasLane) ||
     361          16 :           !FindMLxHazard(MI))
     362             :         pushStack(MI);
     363             :       else {
     364           2 :         ExpandFPMLxInstruction(MBB, MI, MulOpc, AddSubOpc, NegAcc, HasLane);
     365           2 :         Changed = true;
     366             :       }
     367             :     }
     368             :   }
     369             : 
     370         239 :   return Changed;
     371             : }
     372             : 
     373       10849 : bool MLxExpansion::runOnMachineFunction(MachineFunction &Fn) {
     374       10849 :   if (skipFunction(*Fn.getFunction()))
     375             :     return false;
     376             : 
     377       10841 :   TII = static_cast<const ARMBaseInstrInfo *>(Fn.getSubtarget().getInstrInfo());
     378       10841 :   TRI = Fn.getSubtarget().getRegisterInfo();
     379       10841 :   MRI = &Fn.getRegInfo();
     380       10841 :   const ARMSubtarget *STI = &Fn.getSubtarget<ARMSubtarget>();
     381       10841 :   if (!STI->expandMLx())
     382             :     return false;
     383           0 :   isLikeA9 = STI->isLikeA9() || STI->isSwift();
     384         152 :   isSwift = STI->isSwift();
     385             : 
     386         152 :   bool Modified = false;
     387         695 :   for (MachineBasicBlock &MBB : Fn)
     388         239 :     Modified |= ExpandFPMLxInstructions(MBB);
     389             : 
     390             :   return Modified;
     391             : }
     392             : 
     393        2322 : FunctionPass *llvm::createMLxExpansionPass() {
     394        4644 :   return new MLxExpansion();
     395      216918 : }

Generated by: LCOV version 1.13