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::VLD2d64:
  53   case ARM::VLD2LNd8:
  54   case ARM::VLD2LNd16:
  55   case ARM::VLD2LNd32:
  56     FirstOpnd = 0;
  57     NumRegs = 2;
  58     return true;
  59
  60   case ARM::VLD2q8:
  61   case ARM::VLD2q16:
  62   case ARM::VLD2q32:
  63     FirstOpnd = 0;
  64     NumRegs = 4;
  65     return true;
  66
  67   case ARM::VLD2LNq16a:
  68   case ARM::VLD2LNq32a:
  69     FirstOpnd = 0;
  70     NumRegs = 2;
  71     Offset = 0;
  72     Stride = 2;
  73     return true;
  74
  75   case ARM::VLD2LNq16b:
  76   case ARM::VLD2LNq32b:
  77     FirstOpnd = 0;
  78     NumRegs = 2;
  79     Offset = 1;
  80     Stride = 2;
  81     return true;
  82
  83   case ARM::VLD3d8:
  84   case ARM::VLD3d16:
  85   case ARM::VLD3d32:
  86   case ARM::VLD3d64:
  87   case ARM::VLD3LNd8:
  88   case ARM::VLD3LNd16:
  89   case ARM::VLD3LNd32:
  90     FirstOpnd = 0;
  91     NumRegs = 3;
  92     return true;
  93
  94   case ARM::VLD3q8a:
  95   case ARM::VLD3q16a:
  96   case ARM::VLD3q32a:
  97     FirstOpnd = 0;
  98     NumRegs = 3;
  99     Offset = 0;
 100     Stride = 2;
 101     return true;
 102
 103   case ARM::VLD3q8b:
 104   case ARM::VLD3q16b:
 105   case ARM::VLD3q32b:
 106     FirstOpnd = 0;
 107     NumRegs = 3;
 108     Offset = 1;
 109     Stride = 2;
 110     return true;
 111
 112   case ARM::VLD3LNq16a:
 113   case ARM::VLD3LNq32a:
 114     FirstOpnd = 0;
 115     NumRegs = 3;
 116     Offset = 0;
 117     Stride = 2;
 118     return true;
 119
 120   case ARM::VLD3LNq16b:
 121   case ARM::VLD3LNq32b:
 122     FirstOpnd = 0;
 123     NumRegs = 3;
 124     Offset = 1;
 125     Stride = 2;
 126     return true;
 127
 128   case ARM::VLD4d8:
 129   case ARM::VLD4d16:
 130   case ARM::VLD4d32:
 131   case ARM::VLD4d64:
 132   case ARM::VLD4LNd8:
 133   case ARM::VLD4LNd16:
 134   case ARM::VLD4LNd32:
 135     FirstOpnd = 0;
 136     NumRegs = 4;
 137     return true;
 138
 139   case ARM::VLD4q8a:
 140   case ARM::VLD4q16a:
 141   case ARM::VLD4q32a:
 142     FirstOpnd = 0;
 143     NumRegs = 4;
 144     Offset = 0;
 145     Stride = 2;
 146     return true;
 147
 148   case ARM::VLD4q8b:
 149   case ARM::VLD4q16b:
 150   case ARM::VLD4q32b:
 151     FirstOpnd = 0;
 152     NumRegs = 4;
 153     Offset = 1;
 154     Stride = 2;
 155     return true;
 156
 157   case ARM::VST2d8:
 158   case ARM::VST2d16:
 159   case ARM::VST2d32:
 160   case ARM::VST2d64:
 161   case ARM::VST2LNd8:
 162   case ARM::VST2LNd16:
 163   case ARM::VST2LNd32:
 164     FirstOpnd = 3;
 165     NumRegs = 2;
 166     return true;
 167
 168   case ARM::VST2q8:
 169   case ARM::VST2q16:
 170   case ARM::VST2q32:
 171     FirstOpnd = 3;
 172     NumRegs = 4;
 173     return true;
 174
 175   case ARM::VST3d8:
 176   case ARM::VST3d16:
 177   case ARM::VST3d32:
 178   case ARM::VST3d64:
 179   case ARM::VST3LNd8:
 180   case ARM::VST3LNd16:
 181   case ARM::VST3LNd32:
 182     FirstOpnd = 3;
 183     NumRegs = 3;
 184     return true;
 185
 186   case ARM::VST3q8a:
 187   case ARM::VST3q16a:
 188   case ARM::VST3q32a:
 189     FirstOpnd = 4;
 190     NumRegs = 3;
 191     Offset = 0;
 192     Stride = 2;
 193     return true;
 194
 195   case ARM::VST3q8b:
 196   case ARM::VST3q16b:
 197   case ARM::VST3q32b:
 198     FirstOpnd = 4;
 199     NumRegs = 3;
 200     Offset = 1;
 201     Stride = 2;
 202     return true;
 203
 204   case ARM::VST4d8:
 205   case ARM::VST4d16:
 206   case ARM::VST4d32:
 207   case ARM::VST4d64:
 208   case ARM::VST4LNd8:
 209   case ARM::VST4LNd16:
 210   case ARM::VST4LNd32:
 211     FirstOpnd = 3;
 212     NumRegs = 4;
 213     return true;
 214
 215   case ARM::VST4q8a:
 216   case ARM::VST4q16a:
 217   case ARM::VST4q32a:
 218     FirstOpnd = 4;
 219     NumRegs = 4;
 220     Offset = 0;
 221     Stride = 2;
 222     return true;
 223
 224   case ARM::VST4q8b:
 225   case ARM::VST4q16b:
 226   case ARM::VST4q32b:
 227     FirstOpnd = 4;
 228     NumRegs = 4;
 229     Offset = 1;
 230     Stride = 2;
 231     return true;
 232
 233   case ARM::VTBL2:
 234     FirstOpnd = 1;
 235     NumRegs = 2;
 236     return true;
 237
 238   case ARM::VTBL3:
 239     FirstOpnd = 1;
 240     NumRegs = 3;
 241     return true;
 242
 243   case ARM::VTBL4:
 244     FirstOpnd = 1;
 245     NumRegs = 4;
 246     return true;
 247
 248   case ARM::VTBX2:
 249     FirstOpnd = 2;
 250     NumRegs = 2;
 251     return true;
 252
 253   case ARM::VTBX3:
 254     FirstOpnd = 2;
 255     NumRegs = 3;
 256     return true;
 257
 258   case ARM::VTBX4:
 259     FirstOpnd = 2;
 260     NumRegs = 4;
 261     return true;
 262   }
 263
 264   return false;
 265 }
 266
 267 bool NEONPreAllocPass::PreAllocNEONRegisters(MachineBasicBlock &MBB) {
 268   bool Modified = false;
 269
 270   MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
 271   for (; MBBI != E; ++MBBI) {
 272     MachineInstr *MI = &*MBBI;
 273     unsigned FirstOpnd, NumRegs, Offset, Stride;
 274     if (!isNEONMultiRegOp(MI->getOpcode(), FirstOpnd, NumRegs, Offset, Stride))
 275       continue;
 276
 277     MachineBasicBlock::iterator NextI = next(MBBI);
 278     for (unsigned R = 0; R < NumRegs; ++R) {
 279       MachineOperand &MO = MI->getOperand(FirstOpnd + R);
 280       assert(MO.isReg() && MO.getSubReg() == 0 && "unexpected operand");
 281       unsigned VirtReg = MO.getReg();
 282       assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
 283              "expected a virtual register");
 284
 285       // For now, just assign a fixed set of adjacent registers.
 286       // This leaves plenty of room for future improvements.
 287       static const unsigned NEONDRegs[] = {
 288         ARM::D0, ARM::D1, ARM::D2, ARM::D3,
 289         ARM::D4, ARM::D5, ARM::D6, ARM::D7
 290       };
 291       MO.setReg(NEONDRegs[Offset + R * Stride]);
 292
 293       if (MO.isUse()) {
 294         // Insert a copy from VirtReg.
 295         TII->copyRegToReg(MBB, MBBI, MO.getReg(), VirtReg,
 296                           ARM::DPRRegisterClass, ARM::DPRRegisterClass);
 297         if (MO.isKill()) {
 298           MachineInstr *CopyMI = prior(MBBI);
 299           CopyMI->findRegisterUseOperand(VirtReg)->setIsKill();
 300         }
 301         MO.setIsKill();
 302       } else if (MO.isDef() && !MO.isDead()) {
 303         // Add a copy to VirtReg.
 304         TII->copyRegToReg(MBB, NextI, VirtReg, MO.getReg(),
 305                           ARM::DPRRegisterClass, ARM::DPRRegisterClass);
 306       }
 307     }
 308   }
 309
 310   return Modified;
 311 }
 312
 313 bool NEONPreAllocPass::runOnMachineFunction(MachineFunction &MF) {
 314   TII = MF.getTarget().getInstrInfo();
 315
 316   bool Modified = false;
 317   for (MachineFunction::iterator MFI = MF.begin(), E = MF.end(); MFI != E;
 318        ++MFI) {
 319     MachineBasicBlock &MBB = *MFI;
 320     Modified |= PreAllocNEONRegisters(MBB);
 321   }
 322
 323   return Modified;
 324 }
 325
 326 /// createNEONPreAllocPass - returns an instance of the NEON register
 327 /// pre-allocation pass.
 328 FunctionPass *llvm::createNEONPreAllocPass() {
 329   return new NEONPreAllocPass();
 330 }