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