lib/Target/ARM/NEONPreAllocPass.cpp

   1 //===-- NEONPreAllocPass.cpp - Allocate adjacent NEON registers--*- C++ -*-===//
   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 #define DEBUG_TYPE "neon-prealloc"
  11 #include "ARM.h"
  12 #include "ARMInstrInfo.h"
  13 #include "llvm/CodeGen/MachineInstr.h"
  14 #include "llvm/CodeGen/MachineInstrBuilder.h"
  15 #include "llvm/CodeGen/MachineFunctionPass.h"
  16 using namespace llvm;
  17
  18 namespace {
  19   class VISIBILITY_HIDDEN NEONPreAllocPass : public MachineFunctionPass {
  20     const TargetInstrInfo *TII;
  21
  22   public:
  23     static char ID;
  24     NEONPreAllocPass() : MachineFunctionPass(&ID) {}
  25
  26     virtual bool runOnMachineFunction(MachineFunction &MF);
  27
  28     virtual const char *getPassName() const {
  29       return "NEON register pre-allocation pass";
  30     }
  31
  32   private:
  33     bool PreAllocNEONRegisters(MachineBasicBlock &MBB);
  34   };
  35
  36   char NEONPreAllocPass::ID = 0;
  37 }
  38
  39 static bool isNEONMultiRegOp(int Opcode, unsigned &FirstOpnd,
  40                              unsigned &NumRegs) {
  41   switch (Opcode) {
  42   default:
  43     break;
  44
  45   case ARM::VLD2d8:
  46   case ARM::VLD2d16:
  47   case ARM::VLD2d32:
  48     FirstOpnd = 0;
  49     NumRegs = 2;
  50     return true;
  51
  52   case ARM::VLD3d8:
  53   case ARM::VLD3d16:
  54   case ARM::VLD3d32:
  55     FirstOpnd = 0;
  56     NumRegs = 3;
  57     return true;
  58
  59   case ARM::VLD4d8:
  60   case ARM::VLD4d16:
  61   case ARM::VLD4d32:
  62     FirstOpnd = 0;
  63     NumRegs = 4;
  64     return true;
  65
  66   case ARM::VST2d8:
  67   case ARM::VST2d16:
  68   case ARM::VST2d32:
  69     FirstOpnd = 3;
  70     NumRegs = 2;
  71     return true;
  72
  73   case ARM::VST3d8:
  74   case ARM::VST3d16:
  75   case ARM::VST3d32:
  76     FirstOpnd = 3;
  77     NumRegs = 3;
  78     return true;
  79
  80   case ARM::VST4d8:
  81   case ARM::VST4d16:
  82   case ARM::VST4d32:
  83     FirstOpnd = 3;
  84     NumRegs = 4;
  85     return true;
  86
  87   case ARM::VTBL2:
  88     FirstOpnd = 1;
  89     NumRegs = 2;
  90     return true;
  91
  92   case ARM::VTBL3:
  93     FirstOpnd = 1;
  94     NumRegs = 3;
  95     return true;
  96
  97   case ARM::VTBL4:
  98     FirstOpnd = 1;
  99     NumRegs = 4;
 100     return true;
 101
 102   case ARM::VTBX2:
 103     FirstOpnd = 2;
 104     NumRegs = 2;
 105     return true;
 106
 107   case ARM::VTBX3:
 108     FirstOpnd = 2;
 109     NumRegs = 3;
 110     return true;
 111
 112   case ARM::VTBX4:
 113     FirstOpnd = 2;
 114     NumRegs = 4;
 115     return true;
 116   }
 117
 118   return false;
 119 }
 120
 121 bool NEONPreAllocPass::PreAllocNEONRegisters(MachineBasicBlock &MBB) {
 122   bool Modified = false;
 123
 124   MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
 125   for (; MBBI != E; ++MBBI) {
 126     MachineInstr *MI = &*MBBI;
 127     unsigned FirstOpnd, NumRegs;
 128     if (!isNEONMultiRegOp(MI->getOpcode(), FirstOpnd, NumRegs))
 129       continue;
 130
 131     MachineBasicBlock::iterator NextI = next(MBBI);
 132     for (unsigned R = 0; R < NumRegs; ++R) {
 133       MachineOperand &MO = MI->getOperand(FirstOpnd + R);
 134       assert(MO.isReg() && MO.getSubReg() == 0 && "unexpected operand");
 135       unsigned VirtReg = MO.getReg();
 136       assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
 137              "expected a virtual register");
 138
 139       // For now, just assign a fixed set of adjacent registers.
 140       // This leaves plenty of room for future improvements.
 141       static const unsigned NEONDRegs[] = {
 142         ARM::D0, ARM::D1, ARM::D2, ARM::D3
 143       };
 144       MO.setReg(NEONDRegs[R]);
 145
 146       if (MO.isUse()) {
 147         // Insert a copy from VirtReg.
 148         AddDefaultPred(BuildMI(MBB, MBBI, MI->getDebugLoc(),
 149                                TII->get(ARM::FCPYD), MO.getReg())
 150                        .addReg(VirtReg));
 151         if (MO.isKill()) {
 152           MachineInstr *CopyMI = prior(MBBI);
 153           CopyMI->findRegisterUseOperand(VirtReg)->setIsKill();
 154         }
 155         MO.setIsKill();
 156       } else if (MO.isDef() && !MO.isDead()) {
 157         // Add a copy to VirtReg.
 158         AddDefaultPred(BuildMI(MBB, NextI, MI->getDebugLoc(),
 159                                TII->get(ARM::FCPYD), VirtReg)
 160                        .addReg(MO.getReg()));
 161       }
 162     }
 163   }
 164
 165   return Modified;
 166 }
 167
 168 bool NEONPreAllocPass::runOnMachineFunction(MachineFunction &MF) {
 169   TII = MF.getTarget().getInstrInfo();
 170
 171   bool Modified = false;
 172   for (MachineFunction::iterator MFI = MF.begin(), E = MF.end(); MFI != E;
 173        ++MFI) {
 174     MachineBasicBlock &MBB = *MFI;
 175     Modified |= PreAllocNEONRegisters(MBB);
 176   }
 177
 178   return Modified;
 179 }
 180
 181 /// createNEONPreAllocPass - returns an instance of the NEON register
 182 /// pre-allocation pass.
 183 FunctionPass *llvm::createNEONPreAllocPass() {
 184   return new NEONPreAllocPass();
 185 }