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::VST2LNd8:
 182   case ARM::VST2LNd16:
 183   case ARM::VST2LNd32:
 184     FirstOpnd = 2;
 185     NumRegs = 2;
 186     return true;
 187
 188   case ARM::VST2LNq16:
 189   case ARM::VST2LNq32:
 190     FirstOpnd = 2;
 191     NumRegs = 2;
 192     Offset = 0;
 193     Stride = 2;
 194     return true;
 195
 196   case ARM::VST2LNq16odd:
 197   case ARM::VST2LNq32odd:
 198     FirstOpnd = 2;
 199     NumRegs = 2;
 200     Offset = 1;
 201     Stride = 2;
 202     return true;
 203
 204   case ARM::VST3LNd8:
 205   case ARM::VST3LNd16:
 206   case ARM::VST3LNd32:
 207     FirstOpnd = 2;
 208     NumRegs = 3;
 209     return true;
 210
 211   case ARM::VST3LNq16:
 212   case ARM::VST3LNq32:
 213     FirstOpnd = 2;
 214     NumRegs = 3;
 215     Offset = 0;
 216     Stride = 2;
 217     return true;
 218
 219   case ARM::VST3LNq16odd:
 220   case ARM::VST3LNq32odd:
 221     FirstOpnd = 2;
 222     NumRegs = 3;
 223     Offset = 1;
 224     Stride = 2;
 225     return true;
 226
 227   case ARM::VST4LNd8:
 228   case ARM::VST4LNd16:
 229   case ARM::VST4LNd32:
 230     FirstOpnd = 2;
 231     NumRegs = 4;
 232     return true;
 233
 234   case ARM::VST4LNq16:
 235   case ARM::VST4LNq32:
 236     FirstOpnd = 2;
 237     NumRegs = 4;
 238     Offset = 0;
 239     Stride = 2;
 240     return true;
 241
 242   case ARM::VST4LNq16odd:
 243   case ARM::VST4LNq32odd:
 244     FirstOpnd = 2;
 245     NumRegs = 4;
 246     Offset = 1;
 247     Stride = 2;
 248     return true;
 249
 250   case ARM::VTBL2:
 251     FirstOpnd = 1;
 252     NumRegs = 2;
 253     return true;
 254
 255   case ARM::VTBL3:
 256     FirstOpnd = 1;
 257     NumRegs = 3;
 258     return true;
 259
 260   case ARM::VTBL4:
 261     FirstOpnd = 1;
 262     NumRegs = 4;
 263     return true;
 264
 265   case ARM::VTBX2:
 266     FirstOpnd = 2;
 267     NumRegs = 2;
 268     return true;
 269
 270   case ARM::VTBX3:
 271     FirstOpnd = 2;
 272     NumRegs = 3;
 273     return true;
 274
 275   case ARM::VTBX4:
 276     FirstOpnd = 2;
 277     NumRegs = 4;
 278     return true;
 279   }
 280
 281   return false;
 282 }
 283
 284 bool
 285 NEONPreAllocPass::FormsRegSequence(MachineInstr *MI,
 286                                    unsigned FirstOpnd, unsigned NumRegs,
 287                                    unsigned Offset, unsigned Stride) const {
 288   MachineOperand &FMO = MI->getOperand(FirstOpnd);
 289   assert(FMO.isReg() && FMO.getSubReg() == 0 && "unexpected operand");
 290   unsigned VirtReg = FMO.getReg();
 291   (void)VirtReg;
 292   assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
 293          "expected a virtual register");
 294
 295   unsigned LastSubIdx = 0;
 296   if (FMO.isDef()) {
 297     MachineInstr *RegSeq = 0;
 298     for (unsigned R = 0; R < NumRegs; ++R) {
 299       const MachineOperand &MO = MI->getOperand(FirstOpnd + R);
 300       assert(MO.isReg() && MO.getSubReg() == 0 && "unexpected operand");
 301       unsigned VirtReg = MO.getReg();
 302       assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
 303              "expected a virtual register");
 304       // Feeding into a REG_SEQUENCE.
 305       if (!MRI->hasOneNonDBGUse(VirtReg))
 306         return false;
 307       MachineInstr *UseMI = &*MRI->use_nodbg_begin(VirtReg);
 308       if (!UseMI->isRegSequence())
 309         return false;
 310       if (RegSeq && RegSeq != UseMI)
 311         return false;
 312       unsigned OpIdx = 1 + (Offset + R * Stride) * 2;
 313       if (UseMI->getOperand(OpIdx).getReg() != VirtReg)
 314         llvm_unreachable("Malformed REG_SEQUENCE instruction!");
 315       unsigned SubIdx = UseMI->getOperand(OpIdx + 1).getImm();
 316       if (LastSubIdx) {
 317         if (LastSubIdx != SubIdx-Stride)
 318           return false;
 319       } else {
 320         // Must start from dsub_0 or qsub_0.
 321         if (SubIdx != (ARM::dsub_0+Offset) &&
 322             SubIdx != (ARM::qsub_0+Offset))
 323           return false;
 324       }
 325       RegSeq = UseMI;
 326       LastSubIdx = SubIdx;
 327     }
 328
 329     // In the case of vld3, etc., make sure the trailing operand of
 330     // REG_SEQUENCE is an undef.
 331     if (NumRegs == 3) {
 332       unsigned OpIdx = 1 + (Offset + 3 * Stride) * 2;
 333       const MachineOperand &MO = RegSeq->getOperand(OpIdx);
 334       unsigned VirtReg = MO.getReg();
 335       MachineInstr *DefMI = MRI->getVRegDef(VirtReg);
 336       if (!DefMI || !DefMI->isImplicitDef())
 337         return false;
 338     }
 339     return true;
 340   }
 341
 342   unsigned LastSrcReg = 0;
 343   SmallVector<unsigned, 4> SubIds;
 344   for (unsigned R = 0; R < NumRegs; ++R) {
 345     const MachineOperand &MO = MI->getOperand(FirstOpnd + R);
 346     assert(MO.isReg() && MO.getSubReg() == 0 && "unexpected operand");
 347     unsigned VirtReg = MO.getReg();
 348     assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
 349            "expected a virtual register");
 350     // Extracting from a Q or QQ register.
 351     MachineInstr *DefMI = MRI->getVRegDef(VirtReg);
 352     if (!DefMI || !DefMI->isCopy() || !DefMI->getOperand(1).getSubReg())
 353       return false;
 354     VirtReg = DefMI->getOperand(1).getReg();
 355     if (LastSrcReg && LastSrcReg != VirtReg)
 356       return false;
 357     LastSrcReg = VirtReg;
 358     const TargetRegisterClass *RC = MRI->getRegClass(VirtReg);
 359     if (RC != ARM::QPRRegisterClass &&
 360         RC != ARM::QQPRRegisterClass &&
 361         RC != ARM::QQQQPRRegisterClass)
 362       return false;
 363     unsigned SubIdx = DefMI->getOperand(1).getSubReg();
 364     if (LastSubIdx) {
 365       if (LastSubIdx != SubIdx-Stride)
 366         return false;
 367     } else {
 368       // Must start from dsub_0 or qsub_0.
 369       if (SubIdx != (ARM::dsub_0+Offset) &&
 370           SubIdx != (ARM::qsub_0+Offset))
 371         return false;
 372     }
 373     SubIds.push_back(SubIdx);
 374     LastSubIdx = SubIdx;
 375   }
 376
 377   // FIXME: Update the uses of EXTRACT_SUBREG from REG_SEQUENCE is
 378   // currently required for correctness. e.g.
 379   //  %reg1041<def> = REG_SEQUENCE %reg1040<kill>, 5, %reg1035<kill>, 6
 380   //  %reg1042<def> = EXTRACT_SUBREG %reg1041, 6
 381   //  %reg1043<def> = EXTRACT_SUBREG %reg1041, 5
 382   //  VST1q16 %reg1025<kill>, 0, %reg1043<kill>, %reg1042<kill>,
 383   // reg1042 and reg1043 should be replaced with reg1041:6 and reg1041:5
 384   // respectively.
 385   // We need to change how we model uses of REG_SEQUENCE.
 386   for (unsigned R = 0; R < NumRegs; ++R) {
 387     MachineOperand &MO = MI->getOperand(FirstOpnd + R);
 388     unsigned OldReg = MO.getReg();
 389     MachineInstr *DefMI = MRI->getVRegDef(OldReg);
 390     assert(DefMI->isCopy());
 391     MO.setReg(LastSrcReg);
 392     MO.setSubReg(SubIds[R]);
 393     MO.setIsKill(false);
 394     // Delete the EXTRACT_SUBREG if its result is now dead.
 395     if (MRI->use_empty(OldReg))
 396       DefMI->eraseFromParent();
 397   }
 398
 399   return true;
 400 }
 401
 402 bool NEONPreAllocPass::PreAllocNEONRegisters(MachineBasicBlock &MBB) {
 403   bool Modified = false;
 404
 405   MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
 406   for (; MBBI != E; ++MBBI) {
 407     MachineInstr *MI = &*MBBI;
 408     unsigned FirstOpnd, NumRegs, Offset, Stride;
 409     if (!isNEONMultiRegOp(MI->getOpcode(), FirstOpnd, NumRegs, Offset, Stride))
 410       continue;
 411     if (FormsRegSequence(MI, FirstOpnd, NumRegs, Offset, Stride))
 412       continue;
 413
 414     MachineBasicBlock::iterator NextI = llvm::next(MBBI);
 415     for (unsigned R = 0; R < NumRegs; ++R) {
 416       MachineOperand &MO = MI->getOperand(FirstOpnd + R);
 417       assert(MO.isReg() && MO.getSubReg() == 0 && "unexpected operand");
 418       unsigned VirtReg = MO.getReg();
 419       assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
 420              "expected a virtual register");
 421
 422       // For now, just assign a fixed set of adjacent registers.
 423       // This leaves plenty of room for future improvements.
 424       static const unsigned NEONDRegs[] = {
 425         ARM::D0, ARM::D1, ARM::D2, ARM::D3,
 426         ARM::D4, ARM::D5, ARM::D6, ARM::D7
 427       };
 428       MO.setReg(NEONDRegs[Offset + R * Stride]);
 429
 430       if (MO.isUse()) {
 431         // Insert a copy from VirtReg.
 432         BuildMI(MBB, MBBI, DebugLoc(), TII->get(TargetOpcode::COPY),MO.getReg())
 433           .addReg(VirtReg, getKillRegState(MO.isKill()));
 434         MO.setIsKill();
 435       } else if (MO.isDef() && !MO.isDead()) {
 436         // Add a copy to VirtReg.
 437         BuildMI(MBB, NextI, DebugLoc(), TII->get(TargetOpcode::COPY), VirtReg)
 438           .addReg(MO.getReg());
 439       }
 440     }
 441   }
 442
 443   return Modified;
 444 }
 445
 446 bool NEONPreAllocPass::runOnMachineFunction(MachineFunction &MF) {
 447   TII = MF.getTarget().getInstrInfo();
 448   MRI = &MF.getRegInfo();
 449
 450   bool Modified = false;
 451   for (MachineFunction::iterator MFI = MF.begin(), E = MF.end(); MFI != E;
 452        ++MFI) {
 453     MachineBasicBlock &MBB = *MFI;
 454     Modified |= PreAllocNEONRegisters(MBB);
 455   }
 456
 457   return Modified;
 458 }
 459
 460 /// createNEONPreAllocPass - returns an instance of the NEON register
 461 /// pre-allocation pass.
 462 FunctionPass *llvm::createNEONPreAllocPass() {
 463   return new NEONPreAllocPass();
 464 }