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/MachineRegisterInfo.h"
  16 #include "llvm/CodeGen/MachineFunctionPass.h"
  17 using namespace llvm;
  18
  19 namespace {
  20   class NEONPreAllocPass : public MachineFunctionPass {
  21     const TargetInstrInfo *TII;
  22     MachineRegisterInfo *MRI;
  23
  24   public:
  25     static char ID;
  26     NEONPreAllocPass() : MachineFunctionPass(&ID) {}
  27
  28     virtual bool runOnMachineFunction(MachineFunction &MF);
  29
  30     virtual const char *getPassName() const {
  31       return "NEON register pre-allocation pass";
  32     }
  33
  34   private:
  35     bool FormsRegSequence(MachineInstr *MI,
  36                           unsigned FirstOpnd, unsigned NumRegs) const;
  37     bool PreAllocNEONRegisters(MachineBasicBlock &MBB);
  38   };
  39
  40   char NEONPreAllocPass::ID = 0;
  41 }
  42
  43 static bool isNEONMultiRegOp(int Opcode, unsigned &FirstOpnd, unsigned &NumRegs,
  44                              unsigned &Offset, unsigned &Stride) {
  45   // Default to unit stride with no offset.
  46   Stride = 1;
  47   Offset = 0;
  48
  49   switch (Opcode) {
  50   default:
  51     break;
  52
  53   case ARM::VLD1q8:
  54   case ARM::VLD1q16:
  55   case ARM::VLD1q32:
  56   case ARM::VLD1q64:
  57   case ARM::VLD2d8:
  58   case ARM::VLD2d16:
  59   case ARM::VLD2d32:
  60   case ARM::VLD2LNd8:
  61   case ARM::VLD2LNd16:
  62   case ARM::VLD2LNd32:
  63     FirstOpnd = 0;
  64     NumRegs = 2;
  65     return true;
  66
  67   case ARM::VLD2q8:
  68   case ARM::VLD2q16:
  69   case ARM::VLD2q32:
  70     FirstOpnd = 0;
  71     NumRegs = 4;
  72     return true;
  73
  74   case ARM::VLD2LNq16:
  75   case ARM::VLD2LNq32:
  76     FirstOpnd = 0;
  77     NumRegs = 2;
  78     Offset = 0;
  79     Stride = 2;
  80     return true;
  81
  82   case ARM::VLD2LNq16odd:
  83   case ARM::VLD2LNq32odd:
  84     FirstOpnd = 0;
  85     NumRegs = 2;
  86     Offset = 1;
  87     Stride = 2;
  88     return true;
  89
  90   case ARM::VLD3d8:
  91   case ARM::VLD3d16:
  92   case ARM::VLD3d32:
  93   case ARM::VLD1d64T:
  94   case ARM::VLD3LNd8:
  95   case ARM::VLD3LNd16:
  96   case ARM::VLD3LNd32:
  97     FirstOpnd = 0;
  98     NumRegs = 3;
  99     return true;
 100
 101   case ARM::VLD3q8_UPD:
 102   case ARM::VLD3q16_UPD:
 103   case ARM::VLD3q32_UPD:
 104     FirstOpnd = 0;
 105     NumRegs = 3;
 106     Offset = 0;
 107     Stride = 2;
 108     return true;
 109
 110   case ARM::VLD3q8odd_UPD:
 111   case ARM::VLD3q16odd_UPD:
 112   case ARM::VLD3q32odd_UPD:
 113     FirstOpnd = 0;
 114     NumRegs = 3;
 115     Offset = 1;
 116     Stride = 2;
 117     return true;
 118
 119   case ARM::VLD3LNq16:
 120   case ARM::VLD3LNq32:
 121     FirstOpnd = 0;
 122     NumRegs = 3;
 123     Offset = 0;
 124     Stride = 2;
 125     return true;
 126
 127   case ARM::VLD3LNq16odd:
 128   case ARM::VLD3LNq32odd:
 129     FirstOpnd = 0;
 130     NumRegs = 3;
 131     Offset = 1;
 132     Stride = 2;
 133     return true;
 134
 135   case ARM::VLD4d8:
 136   case ARM::VLD4d16:
 137   case ARM::VLD4d32:
 138   case ARM::VLD1d64Q:
 139   case ARM::VLD4LNd8:
 140   case ARM::VLD4LNd16:
 141   case ARM::VLD4LNd32:
 142     FirstOpnd = 0;
 143     NumRegs = 4;
 144     return true;
 145
 146   case ARM::VLD4q8_UPD:
 147   case ARM::VLD4q16_UPD:
 148   case ARM::VLD4q32_UPD:
 149     FirstOpnd = 0;
 150     NumRegs = 4;
 151     Offset = 0;
 152     Stride = 2;
 153     return true;
 154
 155   case ARM::VLD4q8odd_UPD:
 156   case ARM::VLD4q16odd_UPD:
 157   case ARM::VLD4q32odd_UPD:
 158     FirstOpnd = 0;
 159     NumRegs = 4;
 160     Offset = 1;
 161     Stride = 2;
 162     return true;
 163
 164   case ARM::VLD4LNq16:
 165   case ARM::VLD4LNq32:
 166     FirstOpnd = 0;
 167     NumRegs = 4;
 168     Offset = 0;
 169     Stride = 2;
 170     return true;
 171
 172   case ARM::VLD4LNq16odd:
 173   case ARM::VLD4LNq32odd:
 174     FirstOpnd = 0;
 175     NumRegs = 4;
 176     Offset = 1;
 177     Stride = 2;
 178     return true;
 179
 180   case ARM::VST1q8:
 181   case ARM::VST1q16:
 182   case ARM::VST1q32:
 183   case ARM::VST1q64:
 184   case ARM::VST2d8:
 185   case ARM::VST2d16:
 186   case ARM::VST2d32:
 187   case ARM::VST2LNd8:
 188   case ARM::VST2LNd16:
 189   case ARM::VST2LNd32:
 190     FirstOpnd = 2;
 191     NumRegs = 2;
 192     return true;
 193
 194   case ARM::VST2q8:
 195   case ARM::VST2q16:
 196   case ARM::VST2q32:
 197     FirstOpnd = 2;
 198     NumRegs = 4;
 199     return true;
 200
 201   case ARM::VST2LNq16:
 202   case ARM::VST2LNq32:
 203     FirstOpnd = 2;
 204     NumRegs = 2;
 205     Offset = 0;
 206     Stride = 2;
 207     return true;
 208
 209   case ARM::VST2LNq16odd:
 210   case ARM::VST2LNq32odd:
 211     FirstOpnd = 2;
 212     NumRegs = 2;
 213     Offset = 1;
 214     Stride = 2;
 215     return true;
 216
 217   case ARM::VST3d8:
 218   case ARM::VST3d16:
 219   case ARM::VST3d32:
 220   case ARM::VST1d64T:
 221   case ARM::VST3LNd8:
 222   case ARM::VST3LNd16:
 223   case ARM::VST3LNd32:
 224     FirstOpnd = 2;
 225     NumRegs = 3;
 226     return true;
 227
 228   case ARM::VST3q8_UPD:
 229   case ARM::VST3q16_UPD:
 230   case ARM::VST3q32_UPD:
 231     FirstOpnd = 4;
 232     NumRegs = 3;
 233     Offset = 0;
 234     Stride = 2;
 235     return true;
 236
 237   case ARM::VST3q8odd_UPD:
 238   case ARM::VST3q16odd_UPD:
 239   case ARM::VST3q32odd_UPD:
 240     FirstOpnd = 4;
 241     NumRegs = 3;
 242     Offset = 1;
 243     Stride = 2;
 244     return true;
 245
 246   case ARM::VST3LNq16:
 247   case ARM::VST3LNq32:
 248     FirstOpnd = 2;
 249     NumRegs = 3;
 250     Offset = 0;
 251     Stride = 2;
 252     return true;
 253
 254   case ARM::VST3LNq16odd:
 255   case ARM::VST3LNq32odd:
 256     FirstOpnd = 2;
 257     NumRegs = 3;
 258     Offset = 1;
 259     Stride = 2;
 260     return true;
 261
 262   case ARM::VST4d8:
 263   case ARM::VST4d16:
 264   case ARM::VST4d32:
 265   case ARM::VST1d64Q:
 266   case ARM::VST4LNd8:
 267   case ARM::VST4LNd16:
 268   case ARM::VST4LNd32:
 269     FirstOpnd = 2;
 270     NumRegs = 4;
 271     return true;
 272
 273   case ARM::VST4q8_UPD:
 274   case ARM::VST4q16_UPD:
 275   case ARM::VST4q32_UPD:
 276     FirstOpnd = 4;
 277     NumRegs = 4;
 278     Offset = 0;
 279     Stride = 2;
 280     return true;
 281
 282   case ARM::VST4q8odd_UPD:
 283   case ARM::VST4q16odd_UPD:
 284   case ARM::VST4q32odd_UPD:
 285     FirstOpnd = 4;
 286     NumRegs = 4;
 287     Offset = 1;
 288     Stride = 2;
 289     return true;
 290
 291   case ARM::VST4LNq16:
 292   case ARM::VST4LNq32:
 293     FirstOpnd = 2;
 294     NumRegs = 4;
 295     Offset = 0;
 296     Stride = 2;
 297     return true;
 298
 299   case ARM::VST4LNq16odd:
 300   case ARM::VST4LNq32odd:
 301     FirstOpnd = 2;
 302     NumRegs = 4;
 303     Offset = 1;
 304     Stride = 2;
 305     return true;
 306
 307   case ARM::VTBL2:
 308     FirstOpnd = 1;
 309     NumRegs = 2;
 310     return true;
 311
 312   case ARM::VTBL3:
 313     FirstOpnd = 1;
 314     NumRegs = 3;
 315     return true;
 316
 317   case ARM::VTBL4:
 318     FirstOpnd = 1;
 319     NumRegs = 4;
 320     return true;
 321
 322   case ARM::VTBX2:
 323     FirstOpnd = 2;
 324     NumRegs = 2;
 325     return true;
 326
 327   case ARM::VTBX3:
 328     FirstOpnd = 2;
 329     NumRegs = 3;
 330     return true;
 331
 332   case ARM::VTBX4:
 333     FirstOpnd = 2;
 334     NumRegs = 4;
 335     return true;
 336   }
 337
 338   return false;
 339 }
 340
 341 bool
 342 NEONPreAllocPass::FormsRegSequence(MachineInstr *MI,
 343                                    unsigned FirstOpnd, unsigned NumRegs) const {
 344   MachineOperand &FMO = MI->getOperand(FirstOpnd);
 345   assert(FMO.isReg() && FMO.getSubReg() == 0 && "unexpected operand");
 346   unsigned VirtReg = FMO.getReg();
 347   assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
 348          "expected a virtual register");
 349   if (FMO.isDef()) {
 350     MachineInstr *RegSeq = 0;
 351     for (unsigned R = 0; R < NumRegs; ++R) {
 352       const MachineOperand &MO = MI->getOperand(FirstOpnd + R);
 353       assert(MO.isReg() && MO.getSubReg() == 0 && "unexpected operand");
 354       unsigned VirtReg = MO.getReg();
 355       assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
 356              "expected a virtual register");
 357       // Feeding into a REG_SEQUENCE.
 358       if (!MRI->hasOneNonDBGUse(VirtReg))
 359         return false;
 360       MachineInstr *UseMI = &*MRI->use_nodbg_begin(VirtReg);
 361       if (!UseMI->isRegSequence())
 362         return false;
 363       if (RegSeq && RegSeq != UseMI)
 364         return false;
 365       RegSeq = UseMI;
 366     }
 367
 368     // Make sure trailing operands of REG_SEQUENCE are undef.
 369     unsigned NumExps = (RegSeq->getNumOperands() - 1) / 2;
 370     for (unsigned i = NumRegs * 2 + 1; i < NumExps; i += 2) {
 371       const MachineOperand &MO = RegSeq->getOperand(i);
 372       unsigned VirtReg = MO.getReg();
 373       MachineInstr *DefMI = MRI->getVRegDef(VirtReg);
 374       if (!DefMI || !DefMI->isImplicitDef())
 375         return false;
 376     }
 377     return true;
 378   }
 379
 380   unsigned LastSrcReg = 0;
 381   unsigned LastSubIdx = 0;
 382   for (unsigned R = 0; R < NumRegs; ++R) {
 383     const MachineOperand &MO = MI->getOperand(FirstOpnd + R);
 384     assert(MO.isReg() && MO.getSubReg() == 0 && "unexpected operand");
 385     unsigned VirtReg = MO.getReg();
 386     assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
 387            "expected a virtual register");
 388     // Extracting from a Q or QQ register.
 389     MachineInstr *DefMI = MRI->getVRegDef(VirtReg);
 390     if (!DefMI || !DefMI->isExtractSubreg())
 391       return false;
 392     VirtReg = DefMI->getOperand(1).getReg();
 393     if (LastSrcReg && LastSrcReg != VirtReg)
 394       return false;
 395     LastSrcReg = VirtReg;
 396     const TargetRegisterClass *RC = MRI->getRegClass(VirtReg);
 397     if (RC != ARM::QPRRegisterClass && RC != ARM::QQPRRegisterClass)
 398       return false;
 399     unsigned SubIdx = DefMI->getOperand(2).getImm();
 400     if (LastSubIdx) {
 401       if (LastSubIdx != SubIdx-1)
 402         return false;
 403     } else {
 404       // Must start from arm_dsubreg_0 or arm_qsubreg_0.
 405       if (SubIdx != ARM::DSUBREG_0 && SubIdx != ARM::QSUBREG_0)
 406         return false;
 407     }
 408     LastSubIdx = SubIdx;
 409   }
 410   return true;
 411 }
 412
 413 bool NEONPreAllocPass::PreAllocNEONRegisters(MachineBasicBlock &MBB) {
 414   bool Modified = false;
 415
 416   MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
 417   for (; MBBI != E; ++MBBI) {
 418     MachineInstr *MI = &*MBBI;
 419     unsigned FirstOpnd, NumRegs, Offset, Stride;
 420     if (!isNEONMultiRegOp(MI->getOpcode(), FirstOpnd, NumRegs, Offset, Stride))
 421       continue;
 422     if (llvm::ModelWithRegSequence() &&
 423         FormsRegSequence(MI, FirstOpnd, NumRegs))
 424       continue;
 425
 426     MachineBasicBlock::iterator NextI = llvm::next(MBBI);
 427     for (unsigned R = 0; R < NumRegs; ++R) {
 428       MachineOperand &MO = MI->getOperand(FirstOpnd + R);
 429       assert(MO.isReg() && MO.getSubReg() == 0 && "unexpected operand");
 430       unsigned VirtReg = MO.getReg();
 431       assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
 432              "expected a virtual register");
 433
 434       // For now, just assign a fixed set of adjacent registers.
 435       // This leaves plenty of room for future improvements.
 436       static const unsigned NEONDRegs[] = {
 437         ARM::D0, ARM::D1, ARM::D2, ARM::D3,
 438         ARM::D4, ARM::D5, ARM::D6, ARM::D7
 439       };
 440       MO.setReg(NEONDRegs[Offset + R * Stride]);
 441
 442       if (MO.isUse()) {
 443         // Insert a copy from VirtReg.
 444         TII->copyRegToReg(MBB, MBBI, MO.getReg(), VirtReg,
 445                           ARM::DPRRegisterClass, ARM::DPRRegisterClass,
 446                           DebugLoc());
 447         if (MO.isKill()) {
 448           MachineInstr *CopyMI = prior(MBBI);
 449           CopyMI->findRegisterUseOperand(VirtReg)->setIsKill();
 450         }
 451         MO.setIsKill();
 452       } else if (MO.isDef() && !MO.isDead()) {
 453         // Add a copy to VirtReg.
 454         TII->copyRegToReg(MBB, NextI, VirtReg, MO.getReg(),
 455                           ARM::DPRRegisterClass, ARM::DPRRegisterClass,
 456                           DebugLoc());
 457       }
 458     }
 459   }
 460
 461   return Modified;
 462 }
 463
 464 bool NEONPreAllocPass::runOnMachineFunction(MachineFunction &MF) {
 465   TII = MF.getTarget().getInstrInfo();
 466   MRI = &MF.getRegInfo();
 467
 468   bool Modified = false;
 469   for (MachineFunction::iterator MFI = MF.begin(), E = MF.end(); MFI != E;
 470        ++MFI) {
 471     MachineBasicBlock &MBB = *MFI;
 472     Modified |= PreAllocNEONRegisters(MBB);
 473   }
 474
 475   return Modified;
 476 }
 477
 478 /// createNEONPreAllocPass - returns an instance of the NEON register
 479 /// pre-allocation pass.
 480 FunctionPass *llvm::createNEONPreAllocPass() {
 481   return new NEONPreAllocPass();
 482 }