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