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, unsigned &NumRegs,
  40                              unsigned &Offset, unsigned &Stride) {
  41   // Default to unit stride with no offset.
  42   Stride = 1;
  43   Offset = 0;
  44
  45   switch (Opcode) {
  46   default:
  47     break;
  48
  49   case ARM::VLD2d8:
  50   case ARM::VLD2d16:
  51   case ARM::VLD2d32:
  52   case ARM::VLD2LNd8:
  53   case ARM::VLD2LNd16:
  54   case ARM::VLD2LNd32:
  55     FirstOpnd = 0;
  56     NumRegs = 2;
  57     return true;
  58
  59   case ARM::VLD2q8:
  60   case ARM::VLD2q16:
  61   case ARM::VLD2q32:
  62     FirstOpnd = 0;
  63     NumRegs = 4;
  64     return true;
  65
  66   case ARM::VLD3d8:
  67   case ARM::VLD3d16:
  68   case ARM::VLD3d32:
  69   case ARM::VLD3LNd8:
  70   case ARM::VLD3LNd16:
  71   case ARM::VLD3LNd32:
  72     FirstOpnd = 0;
  73     NumRegs = 3;
  74     return true;
  75
  76   case ARM::VLD3q8a:
  77   case ARM::VLD3q16a:
  78   case ARM::VLD3q32a:
  79     FirstOpnd = 0;
  80     NumRegs = 3;
  81     Offset = 0;
  82     Stride = 2;
  83     return true;
  84
  85   case ARM::VLD3q8b:
  86   case ARM::VLD3q16b:
  87   case ARM::VLD3q32b:
  88     FirstOpnd = 0;
  89     NumRegs = 3;
  90     Offset = 1;
  91     Stride = 2;
  92     return true;
  93
  94   case ARM::VLD4d8:
  95   case ARM::VLD4d16:
  96   case ARM::VLD4d32:
  97   case ARM::VLD4LNd8:
  98   case ARM::VLD4LNd16:
  99   case ARM::VLD4LNd32:
 100     FirstOpnd = 0;
 101     NumRegs = 4;
 102     return true;
 103
 104   case ARM::VLD4q8a:
 105   case ARM::VLD4q16a:
 106   case ARM::VLD4q32a:
 107     FirstOpnd = 0;
 108     NumRegs = 4;
 109     Offset = 0;
 110     Stride = 2;
 111     return true;
 112
 113   case ARM::VLD4q8b:
 114   case ARM::VLD4q16b:
 115   case ARM::VLD4q32b:
 116     FirstOpnd = 0;
 117     NumRegs = 4;
 118     Offset = 1;
 119     Stride = 2;
 120     return true;
 121
 122   case ARM::VST2d8:
 123   case ARM::VST2d16:
 124   case ARM::VST2d32:
 125   case ARM::VST2LNd8:
 126   case ARM::VST2LNd16:
 127   case ARM::VST2LNd32:
 128     FirstOpnd = 3;
 129     NumRegs = 2;
 130     return true;
 131
 132   case ARM::VST2q8:
 133   case ARM::VST2q16:
 134   case ARM::VST2q32:
 135     FirstOpnd = 3;
 136     NumRegs = 4;
 137     return true;
 138
 139   case ARM::VST3d8:
 140   case ARM::VST3d16:
 141   case ARM::VST3d32:
 142   case ARM::VST3LNd8:
 143   case ARM::VST3LNd16:
 144   case ARM::VST3LNd32:
 145     FirstOpnd = 3;
 146     NumRegs = 3;
 147     return true;
 148
 149   case ARM::VST4d8:
 150   case ARM::VST4d16:
 151   case ARM::VST4d32:
 152   case ARM::VST4LNd8:
 153   case ARM::VST4LNd16:
 154   case ARM::VST4LNd32:
 155     FirstOpnd = 3;
 156     NumRegs = 4;
 157     return true;
 158
 159   case ARM::VTBL2:
 160     FirstOpnd = 1;
 161     NumRegs = 2;
 162     return true;
 163
 164   case ARM::VTBL3:
 165     FirstOpnd = 1;
 166     NumRegs = 3;
 167     return true;
 168
 169   case ARM::VTBL4:
 170     FirstOpnd = 1;
 171     NumRegs = 4;
 172     return true;
 173
 174   case ARM::VTBX2:
 175     FirstOpnd = 2;
 176     NumRegs = 2;
 177     return true;
 178
 179   case ARM::VTBX3:
 180     FirstOpnd = 2;
 181     NumRegs = 3;
 182     return true;
 183
 184   case ARM::VTBX4:
 185     FirstOpnd = 2;
 186     NumRegs = 4;
 187     return true;
 188   }
 189
 190   return false;
 191 }
 192
 193 bool NEONPreAllocPass::PreAllocNEONRegisters(MachineBasicBlock &MBB) {
 194   bool Modified = false;
 195
 196   MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
 197   for (; MBBI != E; ++MBBI) {
 198     MachineInstr *MI = &*MBBI;
 199     unsigned FirstOpnd, NumRegs, Offset, Stride;
 200     if (!isNEONMultiRegOp(MI->getOpcode(), FirstOpnd, NumRegs, Offset, Stride))
 201       continue;
 202
 203     MachineBasicBlock::iterator NextI = next(MBBI);
 204     for (unsigned R = 0; R < NumRegs; ++R) {
 205       MachineOperand &MO = MI->getOperand(FirstOpnd + R);
 206       assert(MO.isReg() && MO.getSubReg() == 0 && "unexpected operand");
 207       unsigned VirtReg = MO.getReg();
 208       assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
 209              "expected a virtual register");
 210
 211       // For now, just assign a fixed set of adjacent registers.
 212       // This leaves plenty of room for future improvements.
 213       static const unsigned NEONDRegs[] = {
 214         ARM::D0, ARM::D1, ARM::D2, ARM::D3,
 215         ARM::D4, ARM::D5, ARM::D6, ARM::D7
 216       };
 217       MO.setReg(NEONDRegs[Offset + R * Stride]);
 218
 219       if (MO.isUse()) {
 220         // Insert a copy from VirtReg.
 221         TII->copyRegToReg(MBB, MBBI, MO.getReg(), VirtReg,
 222                           ARM::DPRRegisterClass, ARM::DPRRegisterClass);
 223         if (MO.isKill()) {
 224           MachineInstr *CopyMI = prior(MBBI);
 225           CopyMI->findRegisterUseOperand(VirtReg)->setIsKill();
 226         }
 227         MO.setIsKill();
 228       } else if (MO.isDef() && !MO.isDead()) {
 229         // Add a copy to VirtReg.
 230         TII->copyRegToReg(MBB, NextI, VirtReg, MO.getReg(),
 231                           ARM::DPRRegisterClass, ARM::DPRRegisterClass);
 232       }
 233     }
 234   }
 235
 236   return Modified;
 237 }
 238
 239 bool NEONPreAllocPass::runOnMachineFunction(MachineFunction &MF) {
 240   TII = MF.getTarget().getInstrInfo();
 241
 242   bool Modified = false;
 243   for (MachineFunction::iterator MFI = MF.begin(), E = MF.end(); MFI != E;
 244        ++MFI) {
 245     MachineBasicBlock &MBB = *MFI;
 246     Modified |= PreAllocNEONRegisters(MBB);
 247   }
 248
 249   return Modified;
 250 }
 251
 252 /// createNEONPreAllocPass - returns an instance of the NEON register
 253 /// pre-allocation pass.
 254 FunctionPass *llvm::createNEONPreAllocPass() {
 255   return new NEONPreAllocPass();
 256 }