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 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::VLD4LNq16a:
 158   case ARM::VLD4LNq32a:
 159     FirstOpnd = 0;
 160     NumRegs = 4;
 161     Offset = 0;
 162     Stride = 2;
 163     return true;
 164
 165   case ARM::VLD4LNq16b:
 166   case ARM::VLD4LNq32b:
 167     FirstOpnd = 0;
 168     NumRegs = 4;
 169     Offset = 1;
 170     Stride = 2;
 171     return true;
 172
 173   case ARM::VST2d8:
 174   case ARM::VST2d16:
 175   case ARM::VST2d32:
 176   case ARM::VST2d64:
 177   case ARM::VST2LNd8:
 178   case ARM::VST2LNd16:
 179   case ARM::VST2LNd32:
 180     FirstOpnd = 4;
 181     NumRegs = 2;
 182     return true;
 183
 184   case ARM::VST2q8:
 185   case ARM::VST2q16:
 186   case ARM::VST2q32:
 187     FirstOpnd = 4;
 188     NumRegs = 4;
 189     return true;
 190
 191   case ARM::VST2LNq16a:
 192   case ARM::VST2LNq32a:
 193     FirstOpnd = 4;
 194     NumRegs = 2;
 195     Offset = 0;
 196     Stride = 2;
 197     return true;
 198
 199   case ARM::VST2LNq16b:
 200   case ARM::VST2LNq32b:
 201     FirstOpnd = 4;
 202     NumRegs = 2;
 203     Offset = 1;
 204     Stride = 2;
 205     return true;
 206
 207   case ARM::VST3d8:
 208   case ARM::VST3d16:
 209   case ARM::VST3d32:
 210   case ARM::VST3d64:
 211   case ARM::VST3LNd8:
 212   case ARM::VST3LNd16:
 213   case ARM::VST3LNd32:
 214     FirstOpnd = 4;
 215     NumRegs = 3;
 216     return true;
 217
 218   case ARM::VST3q8a:
 219   case ARM::VST3q16a:
 220   case ARM::VST3q32a:
 221     FirstOpnd = 5;
 222     NumRegs = 3;
 223     Offset = 0;
 224     Stride = 2;
 225     return true;
 226
 227   case ARM::VST3q8b:
 228   case ARM::VST3q16b:
 229   case ARM::VST3q32b:
 230     FirstOpnd = 5;
 231     NumRegs = 3;
 232     Offset = 1;
 233     Stride = 2;
 234     return true;
 235
 236   case ARM::VST3LNq16a:
 237   case ARM::VST3LNq32a:
 238     FirstOpnd = 4;
 239     NumRegs = 3;
 240     Offset = 0;
 241     Stride = 2;
 242     return true;
 243
 244   case ARM::VST3LNq16b:
 245   case ARM::VST3LNq32b:
 246     FirstOpnd = 4;
 247     NumRegs = 3;
 248     Offset = 1;
 249     Stride = 2;
 250     return true;
 251
 252   case ARM::VST4d8:
 253   case ARM::VST4d16:
 254   case ARM::VST4d32:
 255   case ARM::VST4d64:
 256   case ARM::VST4LNd8:
 257   case ARM::VST4LNd16:
 258   case ARM::VST4LNd32:
 259     FirstOpnd = 4;
 260     NumRegs = 4;
 261     return true;
 262
 263   case ARM::VST4q8a:
 264   case ARM::VST4q16a:
 265   case ARM::VST4q32a:
 266     FirstOpnd = 5;
 267     NumRegs = 4;
 268     Offset = 0;
 269     Stride = 2;
 270     return true;
 271
 272   case ARM::VST4q8b:
 273   case ARM::VST4q16b:
 274   case ARM::VST4q32b:
 275     FirstOpnd = 5;
 276     NumRegs = 4;
 277     Offset = 1;
 278     Stride = 2;
 279     return true;
 280
 281   case ARM::VST4LNq16a:
 282   case ARM::VST4LNq32a:
 283     FirstOpnd = 4;
 284     NumRegs = 4;
 285     Offset = 0;
 286     Stride = 2;
 287     return true;
 288
 289   case ARM::VST4LNq16b:
 290   case ARM::VST4LNq32b:
 291     FirstOpnd = 4;
 292     NumRegs = 4;
 293     Offset = 1;
 294     Stride = 2;
 295     return true;
 296
 297   case ARM::VTBL2:
 298     FirstOpnd = 1;
 299     NumRegs = 2;
 300     return true;
 301
 302   case ARM::VTBL3:
 303     FirstOpnd = 1;
 304     NumRegs = 3;
 305     return true;
 306
 307   case ARM::VTBL4:
 308     FirstOpnd = 1;
 309     NumRegs = 4;
 310     return true;
 311
 312   case ARM::VTBX2:
 313     FirstOpnd = 2;
 314     NumRegs = 2;
 315     return true;
 316
 317   case ARM::VTBX3:
 318     FirstOpnd = 2;
 319     NumRegs = 3;
 320     return true;
 321
 322   case ARM::VTBX4:
 323     FirstOpnd = 2;
 324     NumRegs = 4;
 325     return true;
 326   }
 327
 328   return false;
 329 }
 330
 331 bool NEONPreAllocPass::PreAllocNEONRegisters(MachineBasicBlock &MBB) {
 332   bool Modified = false;
 333
 334   MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
 335   for (; MBBI != E; ++MBBI) {
 336     MachineInstr *MI = &*MBBI;
 337     unsigned FirstOpnd, NumRegs, Offset, Stride;
 338     if (!isNEONMultiRegOp(MI->getOpcode(), FirstOpnd, NumRegs, Offset, Stride))
 339       continue;
 340
 341     MachineBasicBlock::iterator NextI = llvm::next(MBBI);
 342     for (unsigned R = 0; R < NumRegs; ++R) {
 343       MachineOperand &MO = MI->getOperand(FirstOpnd + R);
 344       assert(MO.isReg() && MO.getSubReg() == 0 && "unexpected operand");
 345       unsigned VirtReg = MO.getReg();
 346       assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
 347              "expected a virtual register");
 348
 349       // For now, just assign a fixed set of adjacent registers.
 350       // This leaves plenty of room for future improvements.
 351       static const unsigned NEONDRegs[] = {
 352         ARM::D0, ARM::D1, ARM::D2, ARM::D3,
 353         ARM::D4, ARM::D5, ARM::D6, ARM::D7
 354       };
 355       MO.setReg(NEONDRegs[Offset + R * Stride]);
 356
 357       if (MO.isUse()) {
 358         // Insert a copy from VirtReg.
 359         TII->copyRegToReg(MBB, MBBI, MO.getReg(), VirtReg,
 360                           ARM::DPRRegisterClass, ARM::DPRRegisterClass);
 361         if (MO.isKill()) {
 362           MachineInstr *CopyMI = prior(MBBI);
 363           CopyMI->findRegisterUseOperand(VirtReg)->setIsKill();
 364         }
 365         MO.setIsKill();
 366       } else if (MO.isDef() && !MO.isDead()) {
 367         // Add a copy to VirtReg.
 368         TII->copyRegToReg(MBB, NextI, VirtReg, MO.getReg(),
 369                           ARM::DPRRegisterClass, ARM::DPRRegisterClass);
 370       }
 371     }
 372   }
 373
 374   return Modified;
 375 }
 376
 377 bool NEONPreAllocPass::runOnMachineFunction(MachineFunction &MF) {
 378   TII = MF.getTarget().getInstrInfo();
 379
 380   bool Modified = false;
 381   for (MachineFunction::iterator MFI = MF.begin(), E = MF.end(); MFI != E;
 382        ++MFI) {
 383     MachineBasicBlock &MBB = *MFI;
 384     Modified |= PreAllocNEONRegisters(MBB);
 385   }
 386
 387   return Modified;
 388 }
 389
 390 /// createNEONPreAllocPass - returns an instance of the NEON register
 391 /// pre-allocation pass.
 392 FunctionPass *llvm::createNEONPreAllocPass() {
 393   return new NEONPreAllocPass();
 394 }