lib/Target/ARM64/ARM64InstrInfo.cpp

   1 //===- ARM64InstrInfo.cpp - ARM64 Instruction Information -----------------===//
   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 // This file contains the ARM64 implementation of the TargetInstrInfo class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "ARM64InstrInfo.h"
  15 #include "ARM64Subtarget.h"
  16 #include "MCTargetDesc/ARM64AddressingModes.h"
  17 #include "llvm/CodeGen/MachineFrameInfo.h"
  18 #include "llvm/CodeGen/MachineInstrBuilder.h"
  19 #include "llvm/CodeGen/MachineMemOperand.h"
  20 #include "llvm/CodeGen/MachineRegisterInfo.h"
  21 #include "llvm/CodeGen/PseudoSourceValue.h"
  22 #include "llvm/MC/MCInst.h"
  23 #include "llvm/Support/ErrorHandling.h"
  24 #include "llvm/Support/TargetRegistry.h"
  25
  26 using namespace llvm;
  27
  28 #define GET_INSTRINFO_CTOR_DTOR
  29 #include "ARM64GenInstrInfo.inc"
  30
  31 ARM64InstrInfo::ARM64InstrInfo(const ARM64Subtarget &STI)
  32     : ARM64GenInstrInfo(ARM64::ADJCALLSTACKDOWN, ARM64::ADJCALLSTACKUP),
  33       RI(this, &STI), Subtarget(STI) {}
  34
  35 /// GetInstSize - Return the number of bytes of code the specified
  36 /// instruction may be.  This returns the maximum number of bytes.
  37 unsigned ARM64InstrInfo::GetInstSizeInBytes(const MachineInstr *MI) const {
  38   const MCInstrDesc &Desc = MI->getDesc();
  39
  40   switch (Desc.getOpcode()) {
  41   default:
  42     // Anything not explicitly designated otherwise is a nomal 4-byte insn.
  43     return 4;
  44   case TargetOpcode::DBG_VALUE:
  45   case TargetOpcode::EH_LABEL:
  46   case TargetOpcode::IMPLICIT_DEF:
  47   case TargetOpcode::KILL:
  48     return 0;
  49   }
  50
  51   llvm_unreachable("GetInstSizeInBytes()- Unable to determin insn size");
  52 }
  53
  54 static void parseCondBranch(MachineInstr *LastInst, MachineBasicBlock *&Target,
  55                             SmallVectorImpl<MachineOperand> &Cond) {
  56   // Block ends with fall-through condbranch.
  57   switch (LastInst->getOpcode()) {
  58   default:
  59     llvm_unreachable("Unknown branch instruction?");
  60   case ARM64::Bcc:
  61     Target = LastInst->getOperand(1).getMBB();
  62     Cond.push_back(LastInst->getOperand(0));
  63     break;
  64   case ARM64::CBZW:
  65   case ARM64::CBZX:
  66   case ARM64::CBNZW:
  67   case ARM64::CBNZX:
  68     Target = LastInst->getOperand(1).getMBB();
  69     Cond.push_back(MachineOperand::CreateImm(-1));
  70     Cond.push_back(MachineOperand::CreateImm(LastInst->getOpcode()));
  71     Cond.push_back(LastInst->getOperand(0));
  72     break;
  73   case ARM64::TBZ:
  74   case ARM64::TBNZ:
  75     Target = LastInst->getOperand(2).getMBB();
  76     Cond.push_back(MachineOperand::CreateImm(-1));
  77     Cond.push_back(MachineOperand::CreateImm(LastInst->getOpcode()));
  78     Cond.push_back(LastInst->getOperand(0));
  79     Cond.push_back(LastInst->getOperand(1));
  80   }
  81 }
  82
  83 // Branch analysis.
  84 bool ARM64InstrInfo::AnalyzeBranch(MachineBasicBlock &MBB,
  85                                    MachineBasicBlock *&TBB,
  86                                    MachineBasicBlock *&FBB,
  87                                    SmallVectorImpl<MachineOperand> &Cond,
  88                                    bool AllowModify) const {
  89   // If the block has no terminators, it just falls into the block after it.
  90   MachineBasicBlock::iterator I = MBB.end();
  91   if (I == MBB.begin())
  92     return false;
  93   --I;
  94   while (I->isDebugValue()) {
  95     if (I == MBB.begin())
  96       return false;
  97     --I;
  98   }
  99   if (!isUnpredicatedTerminator(I))
 100     return false;
 101
 102   // Get the last instruction in the block.
 103   MachineInstr *LastInst = I;
 104
 105   // If there is only one terminator instruction, process it.
 106   unsigned LastOpc = LastInst->getOpcode();
 107   if (I == MBB.begin() || !isUnpredicatedTerminator(--I)) {
 108     if (isUncondBranchOpcode(LastOpc)) {
 109       TBB = LastInst->getOperand(0).getMBB();
 110       return false;
 111     }
 112     if (isCondBranchOpcode(LastOpc)) {
 113       // Block ends with fall-through condbranch.
 114       parseCondBranch(LastInst, TBB, Cond);
 115       return false;
 116     }
 117     return true; // Can't handle indirect branch.
 118   }
 119
 120   // Get the instruction before it if it is a terminator.
 121   MachineInstr *SecondLastInst = I;
 122   unsigned SecondLastOpc = SecondLastInst->getOpcode();
 123
 124   // If AllowModify is true and the block ends with two or more unconditional
 125   // branches, delete all but the first unconditional branch.
 126   if (AllowModify && isUncondBranchOpcode(LastOpc)) {
 127     while (isUncondBranchOpcode(SecondLastOpc)) {
 128       LastInst->eraseFromParent();
 129       LastInst = SecondLastInst;
 130       LastOpc = LastInst->getOpcode();
 131       if (I == MBB.begin() || !isUnpredicatedTerminator(--I)) {
 132         // Return now the only terminator is an unconditional branch.
 133         TBB = LastInst->getOperand(0).getMBB();
 134         return false;
 135       } else {
 136         SecondLastInst = I;
 137         SecondLastOpc = SecondLastInst->getOpcode();
 138       }
 139     }
 140   }
 141
 142   // If there are three terminators, we don't know what sort of block this is.
 143   if (SecondLastInst && I != MBB.begin() && isUnpredicatedTerminator(--I))
 144     return true;
 145
 146   // If the block ends with a B and a Bcc, handle it.
 147   if (isCondBranchOpcode(SecondLastOpc) && isUncondBranchOpcode(LastOpc)) {
 148     parseCondBranch(SecondLastInst, TBB, Cond);
 149     FBB = LastInst->getOperand(0).getMBB();
 150     return false;
 151   }
 152
 153   // If the block ends with two unconditional branches, handle it.  The second
 154   // one is not executed, so remove it.
 155   if (isUncondBranchOpcode(SecondLastOpc) && isUncondBranchOpcode(LastOpc)) {
 156     TBB = SecondLastInst->getOperand(0).getMBB();
 157     I = LastInst;
 158     if (AllowModify)
 159       I->eraseFromParent();
 160     return false;
 161   }
 162
 163   // ...likewise if it ends with an indirect branch followed by an unconditional
 164   // branch.
 165   if (isIndirectBranchOpcode(SecondLastOpc) && isUncondBranchOpcode(LastOpc)) {
 166     I = LastInst;
 167     if (AllowModify)
 168       I->eraseFromParent();
 169     return true;
 170   }
 171
 172   // Otherwise, can't handle this.
 173   return true;
 174 }
 175
 176 bool ARM64InstrInfo::ReverseBranchCondition(
 177     SmallVectorImpl<MachineOperand> &Cond) const {
 178   if (Cond[0].getImm() != -1) {
 179     // Regular Bcc
 180     ARM64CC::CondCode CC = (ARM64CC::CondCode)(int)Cond[0].getImm();
 181     Cond[0].setImm(ARM64CC::getInvertedCondCode(CC));
 182   } else {
 183     // Folded compare-and-branch
 184     switch (Cond[1].getImm()) {
 185     default:
 186       llvm_unreachable("Unknown conditional branch!");
 187     case ARM64::CBZW:
 188       Cond[1].setImm(ARM64::CBNZW);
 189       break;
 190     case ARM64::CBNZW:
 191       Cond[1].setImm(ARM64::CBZW);
 192       break;
 193     case ARM64::CBZX:
 194       Cond[1].setImm(ARM64::CBNZX);
 195       break;
 196     case ARM64::CBNZX:
 197       Cond[1].setImm(ARM64::CBZX);
 198       break;
 199     case ARM64::TBZ:
 200       Cond[1].setImm(ARM64::TBNZ);
 201       break;
 202     case ARM64::TBNZ:
 203       Cond[1].setImm(ARM64::TBZ);
 204       break;
 205     }
 206   }
 207
 208   return false;
 209 }
 210
 211 unsigned ARM64InstrInfo::RemoveBranch(MachineBasicBlock &MBB) const {
 212   MachineBasicBlock::iterator I = MBB.end();
 213   if (I == MBB.begin())
 214     return 0;
 215   --I;
 216   while (I->isDebugValue()) {
 217     if (I == MBB.begin())
 218       return 0;
 219     --I;
 220   }
 221   if (!isUncondBranchOpcode(I->getOpcode()) &&
 222       !isCondBranchOpcode(I->getOpcode()))
 223     return 0;
 224
 225   // Remove the branch.
 226   I->eraseFromParent();
 227
 228   I = MBB.end();
 229
 230   if (I == MBB.begin())
 231     return 1;
 232   --I;
 233   if (!isCondBranchOpcode(I->getOpcode()))
 234     return 1;
 235
 236   // Remove the branch.
 237   I->eraseFromParent();
 238   return 2;
 239 }
 240
 241 void ARM64InstrInfo::instantiateCondBranch(
 242     MachineBasicBlock &MBB, DebugLoc DL, MachineBasicBlock *TBB,
 243     const SmallVectorImpl<MachineOperand> &Cond) const {
 244   if (Cond[0].getImm() != -1) {
 245     // Regular Bcc
 246     BuildMI(&MBB, DL, get(ARM64::Bcc)).addImm(Cond[0].getImm()).addMBB(TBB);
 247   } else {
 248     // Folded compare-and-branch
 249     const MachineInstrBuilder MIB =
 250         BuildMI(&MBB, DL, get(Cond[1].getImm())).addReg(Cond[2].getReg());
 251     if (Cond.size() > 3)
 252       MIB.addImm(Cond[3].getImm());
 253     MIB.addMBB(TBB);
 254   }
 255 }
 256
 257 unsigned ARM64InstrInfo::InsertBranch(
 258     MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB,
 259     const SmallVectorImpl<MachineOperand> &Cond, DebugLoc DL) const {
 260   // Shouldn't be a fall through.
 261   assert(TBB && "InsertBranch must not be told to insert a fallthrough");
 262
 263   if (FBB == 0) {
 264     if (Cond.empty()) // Unconditional branch?
 265       BuildMI(&MBB, DL, get(ARM64::B)).addMBB(TBB);
 266     else
 267       instantiateCondBranch(MBB, DL, TBB, Cond);
 268     return 1;
 269   }
 270
 271   // Two-way conditional branch.
 272   instantiateCondBranch(MBB, DL, TBB, Cond);
 273   BuildMI(&MBB, DL, get(ARM64::B)).addMBB(FBB);
 274   return 2;
 275 }
 276
 277 // Find the original register that VReg is copied from.
 278 static unsigned removeCopies(const MachineRegisterInfo &MRI, unsigned VReg) {
 279   while (TargetRegisterInfo::isVirtualRegister(VReg)) {
 280     const MachineInstr *DefMI = MRI.getVRegDef(VReg);
 281     if (!DefMI->isFullCopy())
 282       return VReg;
 283     VReg = DefMI->getOperand(1).getReg();
 284   }
 285   return VReg;
 286 }
 287
 288 // Determine if VReg is defined by an instruction that can be folded into a
 289 // csel instruction. If so, return the folded opcode, and the replacement
 290 // register.
 291 static unsigned canFoldIntoCSel(const MachineRegisterInfo &MRI, unsigned VReg,
 292                                 unsigned *NewVReg = 0) {
 293   VReg = removeCopies(MRI, VReg);
 294   if (!TargetRegisterInfo::isVirtualRegister(VReg))
 295     return 0;
 296
 297   bool Is64Bit = ARM64::GPR64allRegClass.hasSubClassEq(MRI.getRegClass(VReg));
 298   const MachineInstr *DefMI = MRI.getVRegDef(VReg);
 299   unsigned Opc = 0;
 300   unsigned SrcOpNum = 0;
 301   switch (DefMI->getOpcode()) {
 302   case ARM64::ADDSXri:
 303   case ARM64::ADDSWri:
 304     // if CPSR is used, do not fold.
 305     if (DefMI->findRegisterDefOperandIdx(ARM64::CPSR, true) == -1)
 306       return 0;
 307   // fall-through to ADDXri and ADDWri.
 308   case ARM64::ADDXri:
 309   case ARM64::ADDWri:
 310     // add x, 1 -> csinc.
 311     if (!DefMI->getOperand(2).isImm() || DefMI->getOperand(2).getImm() != 1 ||
 312         DefMI->getOperand(3).getImm() != 0)
 313       return 0;
 314     SrcOpNum = 1;
 315     Opc = Is64Bit ? ARM64::CSINCXr : ARM64::CSINCWr;
 316     break;
 317
 318   case ARM64::ORNXrr:
 319   case ARM64::ORNWrr: {
 320     // not x -> csinv, represented as orn dst, xzr, src.
 321     unsigned ZReg = removeCopies(MRI, DefMI->getOperand(1).getReg());
 322     if (ZReg != ARM64::XZR && ZReg != ARM64::WZR)
 323       return 0;
 324     SrcOpNum = 2;
 325     Opc = Is64Bit ? ARM64::CSINVXr : ARM64::CSINVWr;
 326     break;
 327   }
 328
 329   case ARM64::SUBSXrr:
 330   case ARM64::SUBSWrr:
 331     // if CPSR is used, do not fold.
 332     if (DefMI->findRegisterDefOperandIdx(ARM64::CPSR, true) == -1)
 333       return 0;
 334   // fall-through to SUBXrr and SUBWrr.
 335   case ARM64::SUBXrr:
 336   case ARM64::SUBWrr: {
 337     // neg x -> csneg, represented as sub dst, xzr, src.
 338     unsigned ZReg = removeCopies(MRI, DefMI->getOperand(1).getReg());
 339     if (ZReg != ARM64::XZR && ZReg != ARM64::WZR)
 340       return 0;
 341     SrcOpNum = 2;
 342     Opc = Is64Bit ? ARM64::CSNEGXr : ARM64::CSNEGWr;
 343     break;
 344   }
 345   default:
 346     return 0;
 347   }
 348   assert(Opc && SrcOpNum && "Missing parameters");
 349
 350   if (NewVReg)
 351     *NewVReg = DefMI->getOperand(SrcOpNum).getReg();
 352   return Opc;
 353 }
 354
 355 bool ARM64InstrInfo::canInsertSelect(
 356     const MachineBasicBlock &MBB, const SmallVectorImpl<MachineOperand> &Cond,
 357     unsigned TrueReg, unsigned FalseReg, int &CondCycles, int &TrueCycles,
 358     int &FalseCycles) const {
 359   // Check register classes.
 360   const MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
 361   const TargetRegisterClass *RC =
 362       RI.getCommonSubClass(MRI.getRegClass(TrueReg), MRI.getRegClass(FalseReg));
 363   if (!RC)
 364     return false;
 365
 366   // Expanding cbz/tbz requires an extra cycle of latency on the condition.
 367   unsigned ExtraCondLat = Cond.size() != 1;
 368
 369   // GPRs are handled by csel.
 370   // FIXME: Fold in x+1, -x, and ~x when applicable.
 371   if (ARM64::GPR64allRegClass.hasSubClassEq(RC) ||
 372       ARM64::GPR32allRegClass.hasSubClassEq(RC)) {
 373     // Single-cycle csel, csinc, csinv, and csneg.
 374     CondCycles = 1 + ExtraCondLat;
 375     TrueCycles = FalseCycles = 1;
 376     if (canFoldIntoCSel(MRI, TrueReg))
 377       TrueCycles = 0;
 378     else if (canFoldIntoCSel(MRI, FalseReg))
 379       FalseCycles = 0;
 380     return true;
 381   }
 382
 383   // Scalar floating point is handled by fcsel.
 384   // FIXME: Form fabs, fmin, and fmax when applicable.
 385   if (ARM64::FPR64RegClass.hasSubClassEq(RC) ||
 386       ARM64::FPR32RegClass.hasSubClassEq(RC)) {
 387     CondCycles = 5 + ExtraCondLat;
 388     TrueCycles = FalseCycles = 2;
 389     return true;
 390   }
 391
 392   // Can't do vectors.
 393   return false;
 394 }
 395
 396 void ARM64InstrInfo::insertSelect(MachineBasicBlock &MBB,
 397                                   MachineBasicBlock::iterator I, DebugLoc DL,
 398                                   unsigned DstReg,
 399                                   const SmallVectorImpl<MachineOperand> &Cond,
 400                                   unsigned TrueReg, unsigned FalseReg) const {
 401   MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
 402
 403   // Parse the condition code, see parseCondBranch() above.
 404   ARM64CC::CondCode CC;
 405   switch (Cond.size()) {
 406   default:
 407     llvm_unreachable("Unknown condition opcode in Cond");
 408   case 1: // b.cc
 409     CC = ARM64CC::CondCode(Cond[0].getImm());
 410     break;
 411   case 3: { // cbz/cbnz
 412     // We must insert a compare against 0.
 413     bool Is64Bit;
 414     switch (Cond[1].getImm()) {
 415     default:
 416       llvm_unreachable("Unknown branch opcode in Cond");
 417     case ARM64::CBZW:
 418       Is64Bit = 0;
 419       CC = ARM64CC::EQ;
 420       break;
 421     case ARM64::CBZX:
 422       Is64Bit = 1;
 423       CC = ARM64CC::EQ;
 424       break;
 425     case ARM64::CBNZW:
 426       Is64Bit = 0;
 427       CC = ARM64CC::NE;
 428       break;
 429     case ARM64::CBNZX:
 430       Is64Bit = 1;
 431       CC = ARM64CC::NE;
 432       break;
 433     }
 434     unsigned SrcReg = Cond[2].getReg();
 435     if (Is64Bit) {
 436       // cmp reg, #0 is actually subs xzr, reg, #0.
 437       MRI.constrainRegClass(SrcReg, &ARM64::GPR64spRegClass);
 438       BuildMI(MBB, I, DL, get(ARM64::SUBSXri), ARM64::XZR)
 439           .addReg(SrcReg)
 440           .addImm(0)
 441           .addImm(0);
 442     } else {
 443       MRI.constrainRegClass(SrcReg, &ARM64::GPR32spRegClass);
 444       BuildMI(MBB, I, DL, get(ARM64::SUBSWri), ARM64::WZR)
 445           .addReg(SrcReg)
 446           .addImm(0)
 447           .addImm(0);
 448     }
 449     break;
 450   }
 451   case 4: { // tbz/tbnz
 452     // We must insert a tst instruction.
 453     switch (Cond[1].getImm()) {
 454     default:
 455       llvm_unreachable("Unknown branch opcode in Cond");
 456     case ARM64::TBZ:
 457       CC = ARM64CC::EQ;
 458       break;
 459     case ARM64::TBNZ:
 460       CC = ARM64CC::NE;
 461       break;
 462     }
 463     // cmp reg, #foo is actually ands xzr, reg, #1<<foo.
 464     BuildMI(MBB, I, DL, get(ARM64::ANDSXri), ARM64::XZR)
 465         .addReg(Cond[2].getReg())
 466         .addImm(ARM64_AM::encodeLogicalImmediate(1ull << Cond[3].getImm(), 64));
 467     break;
 468   }
 469   }
 470
 471   unsigned Opc = 0;
 472   const TargetRegisterClass *RC = 0;
 473   bool TryFold = false;
 474   if (MRI.constrainRegClass(DstReg, &ARM64::GPR64RegClass)) {
 475     RC = &ARM64::GPR64RegClass;
 476     Opc = ARM64::CSELXr;
 477     TryFold = true;
 478   } else if (MRI.constrainRegClass(DstReg, &ARM64::GPR32RegClass)) {
 479     RC = &ARM64::GPR32RegClass;
 480     Opc = ARM64::CSELWr;
 481     TryFold = true;
 482   } else if (MRI.constrainRegClass(DstReg, &ARM64::FPR64RegClass)) {
 483     RC = &ARM64::FPR64RegClass;
 484     Opc = ARM64::FCSELDrrr;
 485   } else if (MRI.constrainRegClass(DstReg, &ARM64::FPR32RegClass)) {
 486     RC = &ARM64::FPR32RegClass;
 487     Opc = ARM64::FCSELSrrr;
 488   }
 489   assert(RC && "Unsupported regclass");
 490
 491   // Try folding simple instructions into the csel.
 492   if (TryFold) {
 493     unsigned NewVReg = 0;
 494     unsigned FoldedOpc = canFoldIntoCSel(MRI, TrueReg, &NewVReg);
 495     if (FoldedOpc) {
 496       // The folded opcodes csinc, csinc and csneg apply the operation to
 497       // FalseReg, so we need to invert the condition.
 498       CC = ARM64CC::getInvertedCondCode(CC);
 499       TrueReg = FalseReg;
 500     } else
 501       FoldedOpc = canFoldIntoCSel(MRI, FalseReg, &NewVReg);
 502
 503     // Fold the operation. Leave any dead instructions for DCE to clean up.
 504     if (FoldedOpc) {
 505       FalseReg = NewVReg;
 506       Opc = FoldedOpc;
 507       // The extends the live range of NewVReg.
 508       MRI.clearKillFlags(NewVReg);
 509     }
 510   }
 511
 512   // Pull all virtual register into the appropriate class.
 513   MRI.constrainRegClass(TrueReg, RC);
 514   MRI.constrainRegClass(FalseReg, RC);
 515
 516   // Insert the csel.
 517   BuildMI(MBB, I, DL, get(Opc), DstReg).addReg(TrueReg).addReg(FalseReg).addImm(
 518       CC);
 519 }
 520
 521 bool ARM64InstrInfo::isCoalescableExtInstr(const MachineInstr &MI,
 522                                            unsigned &SrcReg, unsigned &DstReg,
 523                                            unsigned &SubIdx) const {
 524   switch (MI.getOpcode()) {
 525   default:
 526     return false;
 527   case ARM64::SBFMXri: // aka sxtw
 528   case ARM64::UBFMXri: // aka uxtw
 529     // Check for the 32 -> 64 bit extension case, these instructions can do
 530     // much more.
 531     if (MI.getOperand(2).getImm() != 0 || MI.getOperand(3).getImm() != 31)
 532       return false;
 533     // This is a signed or unsigned 32 -> 64 bit extension.
 534     SrcReg = MI.getOperand(1).getReg();
 535     DstReg = MI.getOperand(0).getReg();
 536     SubIdx = ARM64::sub_32;
 537     return true;
 538   }
 539 }
 540
 541 /// analyzeCompare - For a comparison instruction, return the source registers
 542 /// in SrcReg and SrcReg2, and the value it compares against in CmpValue.
 543 /// Return true if the comparison instruction can be analyzed.
 544 bool ARM64InstrInfo::analyzeCompare(const MachineInstr *MI, unsigned &SrcReg,
 545                                     unsigned &SrcReg2, int &CmpMask,
 546                                     int &CmpValue) const {
 547   switch (MI->getOpcode()) {
 548   default:
 549     break;
 550   case ARM64::SUBSWrr:
 551   case ARM64::SUBSWrs:
 552   case ARM64::SUBSWrx:
 553   case ARM64::SUBSXrr:
 554   case ARM64::SUBSXrs:
 555   case ARM64::SUBSXrx:
 556   case ARM64::ADDSWrr:
 557   case ARM64::ADDSWrs:
 558   case ARM64::ADDSWrx:
 559   case ARM64::ADDSXrr:
 560   case ARM64::ADDSXrs:
 561   case ARM64::ADDSXrx:
 562     // Replace SUBSWrr with SUBWrr if CPSR is not used.
 563     SrcReg = MI->getOperand(1).getReg();
 564     SrcReg2 = MI->getOperand(2).getReg();
 565     CmpMask = ~0;
 566     CmpValue = 0;
 567     return true;
 568   case ARM64::SUBSWri:
 569   case ARM64::ADDSWri:
 570   case ARM64::SUBSXri:
 571   case ARM64::ADDSXri:
 572     SrcReg = MI->getOperand(1).getReg();
 573     SrcReg2 = 0;
 574     CmpMask = ~0;
 575     CmpValue = MI->getOperand(2).getImm();
 576     return true;
 577   case ARM64::ANDSWri:
 578   case ARM64::ANDSXri:
 579     // ANDS does not use the same encoding scheme as the others xxxS
 580     // instructions.
 581     SrcReg = MI->getOperand(1).getReg();
 582     SrcReg2 = 0;
 583     CmpMask = ~0;
 584     CmpValue = ARM64_AM::decodeLogicalImmediate(
 585         MI->getOperand(2).getImm(),
 586         MI->getOpcode() == ARM64::ANDSWri ? 32 : 64);
 587     return true;
 588   }
 589
 590   return false;
 591 }
 592
 593 static bool UpdateOperandRegClass(MachineInstr *Instr) {
 594   MachineBasicBlock *MBB = Instr->getParent();
 595   assert(MBB && "Can't get MachineBasicBlock here");
 596   MachineFunction *MF = MBB->getParent();
 597   assert(MF && "Can't get MachineFunction here");
 598   const TargetMachine *TM = &MF->getTarget();
 599   const TargetInstrInfo *TII = TM->getInstrInfo();
 600   const TargetRegisterInfo *TRI = TM->getRegisterInfo();
 601   MachineRegisterInfo *MRI = &MF->getRegInfo();
 602
 603   for (unsigned OpIdx = 0, EndIdx = Instr->getNumOperands(); OpIdx < EndIdx;
 604        ++OpIdx) {
 605     MachineOperand &MO = Instr->getOperand(OpIdx);
 606     const TargetRegisterClass *OpRegCstraints =
 607         Instr->getRegClassConstraint(OpIdx, TII, TRI);
 608
 609     // If there's no constraint, there's nothing to do.
 610     if (!OpRegCstraints)
 611       continue;
 612     // If the operand is a frame index, there's nothing to do here.
 613     // A frame index operand will resolve correctly during PEI.
 614     if (MO.isFI())
 615       continue;
 616
 617     assert(MO.isReg() &&
 618            "Operand has register constraints without being a register!");
 619
 620     unsigned Reg = MO.getReg();
 621     if (TargetRegisterInfo::isPhysicalRegister(Reg)) {
 622       if (!OpRegCstraints->contains(Reg))
 623         return false;
 624     } else if (!OpRegCstraints->hasSubClassEq(MRI->getRegClass(Reg)) &&
 625                !MRI->constrainRegClass(Reg, OpRegCstraints))
 626       return false;
 627   }
 628
 629   return true;
 630 }
 631
 632 /// optimizeCompareInstr - Convert the instruction supplying the argument to the
 633 /// comparison into one that sets the zero bit in the flags register.
 634 bool ARM64InstrInfo::optimizeCompareInstr(
 635     MachineInstr *CmpInstr, unsigned SrcReg, unsigned SrcReg2, int CmpMask,
 636     int CmpValue, const MachineRegisterInfo *MRI) const {
 637
 638   // Replace SUBSWrr with SUBWrr if CPSR is not used.
 639   int Cmp_CPSR = CmpInstr->findRegisterDefOperandIdx(ARM64::CPSR, true);
 640   if (Cmp_CPSR != -1) {
 641     unsigned NewOpc;
 642     switch (CmpInstr->getOpcode()) {
 643     default:
 644       return false;
 645     case ARM64::ADDSWrr:      NewOpc = ARM64::ADDWrr; break;
 646     case ARM64::ADDSWri:      NewOpc = ARM64::ADDWri; break;
 647     case ARM64::ADDSWrs:      NewOpc = ARM64::ADDWrs; break;
 648     case ARM64::ADDSWrx:      NewOpc = ARM64::ADDWrx; break;
 649     case ARM64::ADDSXrr:      NewOpc = ARM64::ADDXrr; break;
 650     case ARM64::ADDSXri:      NewOpc = ARM64::ADDXri; break;
 651     case ARM64::ADDSXrs:      NewOpc = ARM64::ADDXrs; break;
 652     case ARM64::ADDSXrx:      NewOpc = ARM64::ADDXrx; break;
 653     case ARM64::SUBSWrr:      NewOpc = ARM64::SUBWrr; break;
 654     case ARM64::SUBSWri:      NewOpc = ARM64::SUBWri; break;
 655     case ARM64::SUBSWrs:      NewOpc = ARM64::SUBWrs; break;
 656     case ARM64::SUBSWrx:      NewOpc = ARM64::SUBWrx; break;
 657     case ARM64::SUBSXrr:      NewOpc = ARM64::SUBXrr; break;
 658     case ARM64::SUBSXri:      NewOpc = ARM64::SUBXri; break;
 659     case ARM64::SUBSXrs:      NewOpc = ARM64::SUBXrs; break;
 660     case ARM64::SUBSXrx:      NewOpc = ARM64::SUBXrx; break;
 661     }
 662
 663     const MCInstrDesc &MCID = get(NewOpc);
 664     CmpInstr->setDesc(MCID);
 665     CmpInstr->RemoveOperand(Cmp_CPSR);
 666     bool succeeded = UpdateOperandRegClass(CmpInstr);
 667     (void)succeeded;
 668     assert(succeeded && "Some operands reg class are incompatible!");
 669     return true;
 670   }
 671
 672   // Continue only if we have a "ri" where immediate is zero.
 673   if (CmpValue != 0 || SrcReg2 != 0)
 674     return false;
 675
 676   // CmpInstr is a Compare instruction if destination register is not used.
 677   if (!MRI->use_nodbg_empty(CmpInstr->getOperand(0).getReg()))
 678     return false;
 679
 680   // Get the unique definition of SrcReg.
 681   MachineInstr *MI = MRI->getUniqueVRegDef(SrcReg);
 682   if (!MI)
 683     return false;
 684
 685   // We iterate backward, starting from the instruction before CmpInstr and
 686   // stop when reaching the definition of the source register or done with the
 687   // basic block, to check whether CPSR is used or modified in between.
 688   MachineBasicBlock::iterator I = CmpInstr, E = MI,
 689                               B = CmpInstr->getParent()->begin();
 690
 691   // Early exit if CmpInstr is at the beginning of the BB.
 692   if (I == B)
 693     return false;
 694
 695   // Check whether the definition of SrcReg is in the same basic block as
 696   // Compare. If not, we can't optimize away the Compare.
 697   if (MI->getParent() != CmpInstr->getParent())
 698     return false;
 699
 700   // Check that CPSR isn't set between the comparison instruction and the one we
 701   // want to change.
 702   const TargetRegisterInfo *TRI = &getRegisterInfo();
 703   for (--I; I != E; --I) {
 704     const MachineInstr &Instr = *I;
 705
 706     if (Instr.modifiesRegister(ARM64::CPSR, TRI) ||
 707         Instr.readsRegister(ARM64::CPSR, TRI))
 708       // This instruction modifies or uses CPSR after the one we want to
 709       // change. We can't do this transformation.
 710       return false;
 711     if (I == B)
 712       // The 'and' is below the comparison instruction.
 713       return false;
 714   }
 715
 716   unsigned NewOpc = MI->getOpcode();
 717   switch (MI->getOpcode()) {
 718   default:
 719     return false;
 720   case ARM64::ADDSWrr:
 721   case ARM64::ADDSWri:
 722   case ARM64::ADDSXrr:
 723   case ARM64::ADDSXri:
 724   case ARM64::SUBSWrr:
 725   case ARM64::SUBSWri:
 726   case ARM64::SUBSXrr:
 727   case ARM64::SUBSXri:
 728     break;
 729   case ARM64::ADDWrr:    NewOpc = ARM64::ADDSWrr; break;
 730   case ARM64::ADDWri:    NewOpc = ARM64::ADDSWri; break;
 731   case ARM64::ADDXrr:    NewOpc = ARM64::ADDSXrr; break;
 732   case ARM64::ADDXri:    NewOpc = ARM64::ADDSXri; break;
 733   case ARM64::ADCWr:     NewOpc = ARM64::ADCSWr; break;
 734   case ARM64::ADCXr:     NewOpc = ARM64::ADCSXr; break;
 735   case ARM64::SUBWrr:    NewOpc = ARM64::SUBSWrr; break;
 736   case ARM64::SUBWri:    NewOpc = ARM64::SUBSWri; break;
 737   case ARM64::SUBXrr:    NewOpc = ARM64::SUBSXrr; break;
 738   case ARM64::SUBXri:    NewOpc = ARM64::SUBSXri; break;
 739   case ARM64::SBCWr:     NewOpc = ARM64::SBCSWr; break;
 740   case ARM64::SBCXr:     NewOpc = ARM64::SBCSXr; break;
 741   case ARM64::ANDWri:    NewOpc = ARM64::ANDSWri; break;
 742   case ARM64::ANDXri:    NewOpc = ARM64::ANDSXri; break;
 743   }
 744
 745   // Scan forward for the use of CPSR.
 746   // When checking against MI: if it's a conditional code requires
 747   // checking of V bit, then this is not safe to do.
 748   // It is safe to remove CmpInstr if CPSR is redefined or killed.
 749   // If we are done with the basic block, we need to check whether CPSR is
 750   // live-out.
 751   bool IsSafe = false;
 752   for (MachineBasicBlock::iterator I = CmpInstr,
 753                                    E = CmpInstr->getParent()->end();
 754        !IsSafe && ++I != E;) {
 755     const MachineInstr &Instr = *I;
 756     for (unsigned IO = 0, EO = Instr.getNumOperands(); !IsSafe && IO != EO;
 757          ++IO) {
 758       const MachineOperand &MO = Instr.getOperand(IO);
 759       if (MO.isRegMask() && MO.clobbersPhysReg(ARM64::CPSR)) {
 760         IsSafe = true;
 761         break;
 762       }
 763       if (!MO.isReg() || MO.getReg() != ARM64::CPSR)
 764         continue;
 765       if (MO.isDef()) {
 766         IsSafe = true;
 767         break;
 768       }
 769
 770       // Decode the condition code.
 771       unsigned Opc = Instr.getOpcode();
 772       ARM64CC::CondCode CC;
 773       switch (Opc) {
 774       default:
 775         return false;
 776       case ARM64::Bcc:
 777         CC = (ARM64CC::CondCode)Instr.getOperand(IO - 2).getImm();
 778         break;
 779       case ARM64::CSINVWr:
 780       case ARM64::CSINVXr:
 781       case ARM64::CSINCWr:
 782       case ARM64::CSINCXr:
 783       case ARM64::CSELWr:
 784       case ARM64::CSELXr:
 785       case ARM64::CSNEGWr:
 786       case ARM64::CSNEGXr:
 787       case ARM64::FCSELSrrr:
 788       case ARM64::FCSELDrrr:
 789         CC = (ARM64CC::CondCode)Instr.getOperand(IO - 1).getImm();
 790         break;
 791       }
 792
 793       // It is not safe to remove Compare instruction if Overflow(V) is used.
 794       switch (CC) {
 795       default:
 796         // CPSR can be used multiple times, we should continue.
 797         break;
 798       case ARM64CC::VS:
 799       case ARM64CC::VC:
 800       case ARM64CC::GE:
 801       case ARM64CC::LT:
 802       case ARM64CC::GT:
 803       case ARM64CC::LE:
 804         return false;
 805       }
 806     }
 807   }
 808
 809   // If CPSR is not killed nor re-defined, we should check whether it is
 810   // live-out. If it is live-out, do not optimize.
 811   if (!IsSafe) {
 812     MachineBasicBlock *ParentBlock = CmpInstr->getParent();
 813     for (auto *MBB : ParentBlock->successors())
 814       if (MBB->isLiveIn(ARM64::CPSR))
 815         return false;
 816   }
 817
 818   // Update the instruction to set CPSR.
 819   MI->setDesc(get(NewOpc));
 820   CmpInstr->eraseFromParent();
 821   bool succeeded = UpdateOperandRegClass(MI);
 822   (void)succeeded;
 823   assert(succeeded && "Some operands reg class are incompatible!");
 824   MI->addRegisterDefined(ARM64::CPSR, TRI);
 825   return true;
 826 }
 827
 828 // Return true if this instruction simply sets its single destination register
 829 // to zero. This is equivalent to a register rename of the zero-register.
 830 bool ARM64InstrInfo::isGPRZero(const MachineInstr *MI) const {
 831   switch (MI->getOpcode()) {
 832   default:
 833     break;
 834   case ARM64::MOVZWi:
 835   case ARM64::MOVZXi: // movz Rd, #0 (LSL #0)
 836     if (MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0) {
 837       assert(MI->getDesc().getNumOperands() == 3 &&
 838              MI->getOperand(2).getImm() == 0 && "invalid MOVZi operands");
 839       return true;
 840     }
 841     break;
 842   case ARM64::ANDWri: // and Rd, Rzr, #imm
 843     return MI->getOperand(1).getReg() == ARM64::WZR;
 844   case ARM64::ANDXri:
 845     return MI->getOperand(1).getReg() == ARM64::XZR;
 846   case TargetOpcode::COPY:
 847     return MI->getOperand(1).getReg() == ARM64::WZR;
 848   }
 849   return false;
 850 }
 851
 852 // Return true if this instruction simply renames a general register without
 853 // modifying bits.
 854 bool ARM64InstrInfo::isGPRCopy(const MachineInstr *MI) const {
 855   switch (MI->getOpcode()) {
 856   default:
 857     break;
 858   case TargetOpcode::COPY: {
 859     // GPR32 copies will by lowered to ORRXrs
 860     unsigned DstReg = MI->getOperand(0).getReg();
 861     return (ARM64::GPR32RegClass.contains(DstReg) ||
 862             ARM64::GPR64RegClass.contains(DstReg));
 863   }
 864   case ARM64::ORRXrs: // orr Xd, Xzr, Xm (LSL #0)
 865     if (MI->getOperand(1).getReg() == ARM64::XZR) {
 866       assert(MI->getDesc().getNumOperands() == 4 &&
 867              MI->getOperand(3).getImm() == 0 && "invalid ORRrs operands");
 868       return true;
 869     }
 870   case ARM64::ADDXri: // add Xd, Xn, #0 (LSL #0)
 871     if (MI->getOperand(2).getImm() == 0) {
 872       assert(MI->getDesc().getNumOperands() == 4 &&
 873              MI->getOperand(3).getImm() == 0 && "invalid ADDXri operands");
 874       return true;
 875     }
 876   }
 877   return false;
 878 }
 879
 880 // Return true if this instruction simply renames a general register without
 881 // modifying bits.
 882 bool ARM64InstrInfo::isFPRCopy(const MachineInstr *MI) const {
 883   switch (MI->getOpcode()) {
 884   default:
 885     break;
 886   case TargetOpcode::COPY: {
 887     // FPR64 copies will by lowered to ORR.16b
 888     unsigned DstReg = MI->getOperand(0).getReg();
 889     return (ARM64::FPR64RegClass.contains(DstReg) ||
 890             ARM64::FPR128RegClass.contains(DstReg));
 891   }
 892   case ARM64::ORRv16i8:
 893     if (MI->getOperand(1).getReg() == MI->getOperand(2).getReg()) {
 894       assert(MI->getDesc().getNumOperands() == 3 && MI->getOperand(0).isReg() &&
 895              "invalid ORRv16i8 operands");
 896       return true;
 897     }
 898   }
 899   return false;
 900 }
 901
 902 unsigned ARM64InstrInfo::isLoadFromStackSlot(const MachineInstr *MI,
 903                                              int &FrameIndex) const {
 904   switch (MI->getOpcode()) {
 905   default:
 906     break;
 907   case ARM64::LDRWui:
 908   case ARM64::LDRXui:
 909   case ARM64::LDRBui:
 910   case ARM64::LDRHui:
 911   case ARM64::LDRSui:
 912   case ARM64::LDRDui:
 913   case ARM64::LDRQui:
 914     if (MI->getOperand(0).getSubReg() == 0 && MI->getOperand(1).isFI() &&
 915         MI->getOperand(2).isImm() && MI->getOperand(2).getImm() == 0) {
 916       FrameIndex = MI->getOperand(1).getIndex();
 917       return MI->getOperand(0).getReg();
 918     }
 919     break;
 920   }
 921
 922   return 0;
 923 }
 924
 925 unsigned ARM64InstrInfo::isStoreToStackSlot(const MachineInstr *MI,
 926                                             int &FrameIndex) const {
 927   switch (MI->getOpcode()) {
 928   default:
 929     break;
 930   case ARM64::STRWui:
 931   case ARM64::STRXui:
 932   case ARM64::STRBui:
 933   case ARM64::STRHui:
 934   case ARM64::STRSui:
 935   case ARM64::STRDui:
 936   case ARM64::STRQui:
 937     if (MI->getOperand(0).getSubReg() == 0 && MI->getOperand(1).isFI() &&
 938         MI->getOperand(2).isImm() && MI->getOperand(2).getImm() == 0) {
 939       FrameIndex = MI->getOperand(1).getIndex();
 940       return MI->getOperand(0).getReg();
 941     }
 942     break;
 943   }
 944   return 0;
 945 }
 946
 947 /// Return true if this is load/store scales or extends its register offset.
 948 /// This refers to scaling a dynamic index as opposed to scaled immediates.
 949 /// MI should be a memory op that allows scaled addressing.
 950 bool ARM64InstrInfo::isScaledAddr(const MachineInstr *MI) const {
 951   switch (MI->getOpcode()) {
 952   default:
 953     break;
 954   case ARM64::LDRBBro:
 955   case ARM64::LDRBro:
 956   case ARM64::LDRDro:
 957   case ARM64::LDRHHro:
 958   case ARM64::LDRHro:
 959   case ARM64::LDRQro:
 960   case ARM64::LDRSBWro:
 961   case ARM64::LDRSBXro:
 962   case ARM64::LDRSHWro:
 963   case ARM64::LDRSHXro:
 964   case ARM64::LDRSWro:
 965   case ARM64::LDRSro:
 966   case ARM64::LDRWro:
 967   case ARM64::LDRXro:
 968   case ARM64::STRBBro:
 969   case ARM64::STRBro:
 970   case ARM64::STRDro:
 971   case ARM64::STRHHro:
 972   case ARM64::STRHro:
 973   case ARM64::STRQro:
 974   case ARM64::STRSro:
 975   case ARM64::STRWro:
 976   case ARM64::STRXro:
 977     unsigned Val = MI->getOperand(3).getImm();
 978     ARM64_AM::ExtendType ExtType = ARM64_AM::getMemExtendType(Val);
 979     return (ExtType != ARM64_AM::UXTX) || ARM64_AM::getMemDoShift(Val);
 980   }
 981   return false;
 982 }
 983
 984 /// Check all MachineMemOperands for a hint to suppress pairing.
 985 bool ARM64InstrInfo::isLdStPairSuppressed(const MachineInstr *MI) const {
 986   assert(MOSuppressPair < (1 << MachineMemOperand::MOTargetNumBits) &&
 987          "Too many target MO flags");
 988   for (auto *MM : MI->memoperands()) {
 989     if (MM->getFlags() &
 990         (MOSuppressPair << MachineMemOperand::MOTargetStartBit)) {
 991       return true;
 992     }
 993   }
 994   return false;
 995 }
 996
 997 /// Set a flag on the first MachineMemOperand to suppress pairing.
 998 void ARM64InstrInfo::suppressLdStPair(MachineInstr *MI) const {
 999   if (MI->memoperands_empty())
1000     return;
1001
1002   assert(MOSuppressPair < (1 << MachineMemOperand::MOTargetNumBits) &&
1003          "Too many target MO flags");
1004   (*MI->memoperands_begin())
1005       ->setFlags(MOSuppressPair << MachineMemOperand::MOTargetStartBit);
1006 }
1007
1008 bool ARM64InstrInfo::getLdStBaseRegImmOfs(MachineInstr *LdSt, unsigned &BaseReg,
1009                                           unsigned &Offset,
1010                                           const TargetRegisterInfo *TRI) const {
1011   switch (LdSt->getOpcode()) {
1012   default:
1013     return false;
1014   case ARM64::STRSui:
1015   case ARM64::STRDui:
1016   case ARM64::STRQui:
1017   case ARM64::STRXui:
1018   case ARM64::STRWui:
1019   case ARM64::LDRSui:
1020   case ARM64::LDRDui:
1021   case ARM64::LDRQui:
1022   case ARM64::LDRXui:
1023   case ARM64::LDRWui:
1024     if (!LdSt->getOperand(1).isReg() || !LdSt->getOperand(2).isImm())
1025       return false;
1026     BaseReg = LdSt->getOperand(1).getReg();
1027     MachineFunction &MF = *LdSt->getParent()->getParent();
1028     unsigned Width = getRegClass(LdSt->getDesc(), 0, TRI, MF)->getSize();
1029     Offset = LdSt->getOperand(2).getImm() * Width;
1030     return true;
1031   };
1032 }
1033
1034 /// Detect opportunities for ldp/stp formation.
1035 ///
1036 /// Only called for LdSt for which getLdStBaseRegImmOfs returns true.
1037 bool ARM64InstrInfo::shouldClusterLoads(MachineInstr *FirstLdSt,
1038                                         MachineInstr *SecondLdSt,
1039                                         unsigned NumLoads) const {
1040   // Only cluster up to a single pair.
1041   if (NumLoads > 1)
1042     return false;
1043   if (FirstLdSt->getOpcode() != SecondLdSt->getOpcode())
1044     return false;
1045   // getLdStBaseRegImmOfs guarantees that oper 2 isImm.
1046   unsigned Ofs1 = FirstLdSt->getOperand(2).getImm();
1047   // Allow 6 bits of positive range.
1048   if (Ofs1 > 64)
1049     return false;
1050   // The caller should already have ordered First/SecondLdSt by offset.
1051   unsigned Ofs2 = SecondLdSt->getOperand(2).getImm();
1052   return Ofs1 + 1 == Ofs2;
1053 }
1054
1055 bool ARM64InstrInfo::shouldScheduleAdjacent(MachineInstr *First,
1056                                             MachineInstr *Second) const {
1057   // Cyclone can fuse CMN, CMP followed by Bcc.
1058
1059   // FIXME: B0 can also fuse:
1060   // AND, BIC, ORN, ORR, or EOR (optional S) followed by Bcc or CBZ or CBNZ.
1061   if (Second->getOpcode() != ARM64::Bcc)
1062     return false;
1063   switch (First->getOpcode()) {
1064   default:
1065     return false;
1066   case ARM64::SUBSWri:
1067   case ARM64::ADDSWri:
1068   case ARM64::ANDSWri:
1069   case ARM64::SUBSXri:
1070   case ARM64::ADDSXri:
1071   case ARM64::ANDSXri:
1072     return true;
1073   }
1074 }
1075
1076 MachineInstr *ARM64InstrInfo::emitFrameIndexDebugValue(MachineFunction &MF,
1077                                                        int FrameIx,
1078                                                        uint64_t Offset,
1079                                                        const MDNode *MDPtr,
1080                                                        DebugLoc DL) const {
1081   MachineInstrBuilder MIB = BuildMI(MF, DL, get(ARM64::DBG_VALUE))
1082                                 .addFrameIndex(FrameIx)
1083                                 .addImm(0)
1084                                 .addImm(Offset)
1085                                 .addMetadata(MDPtr);
1086   return &*MIB;
1087 }
1088
1089 static const MachineInstrBuilder &AddSubReg(const MachineInstrBuilder &MIB,
1090                                             unsigned Reg, unsigned SubIdx,
1091                                             unsigned State,
1092                                             const TargetRegisterInfo *TRI) {
1093   if (!SubIdx)
1094     return MIB.addReg(Reg, State);
1095
1096   if (TargetRegisterInfo::isPhysicalRegister(Reg))
1097     return MIB.addReg(TRI->getSubReg(Reg, SubIdx), State);
1098   return MIB.addReg(Reg, State, SubIdx);
1099 }
1100
1101 static bool forwardCopyWillClobberTuple(unsigned DestReg, unsigned SrcReg,
1102                                         unsigned NumRegs) {
1103   // We really want the positive remainder mod 32 here, that happens to be
1104   // easily obtainable with a mask.
1105   return ((DestReg - SrcReg) & 0x1f) < NumRegs;
1106 }
1107
1108 void ARM64InstrInfo::copyPhysRegTuple(MachineBasicBlock &MBB,
1109                                       MachineBasicBlock::iterator I,
1110                                       DebugLoc DL, unsigned DestReg,
1111                                       unsigned SrcReg, bool KillSrc,
1112                                       unsigned Opcode,
1113                                       llvm::ArrayRef<unsigned> Indices) const {
1114   assert(getSubTarget().hasNEON() &&
1115          "Unexpected register copy without NEON");
1116   const TargetRegisterInfo *TRI = &getRegisterInfo();
1117   uint16_t DestEncoding = TRI->getEncodingValue(DestReg);
1118   uint16_t SrcEncoding = TRI->getEncodingValue(SrcReg);
1119   unsigned NumRegs = Indices.size();
1120
1121   int SubReg = 0, End = NumRegs, Incr = 1;
1122   if (forwardCopyWillClobberTuple(DestEncoding, SrcEncoding, NumRegs)) {
1123     SubReg = NumRegs - 1;
1124     End = -1;
1125     Incr = -1;
1126   }
1127
1128   for (; SubReg != End; SubReg += Incr) {
1129     const MachineInstrBuilder &MIB = BuildMI(MBB, I, DL, get(Opcode));
1130     AddSubReg(MIB, DestReg, Indices[SubReg], RegState::Define, TRI);
1131     AddSubReg(MIB, SrcReg, Indices[SubReg], 0, TRI);
1132     AddSubReg(MIB, SrcReg, Indices[SubReg], getKillRegState(KillSrc), TRI);
1133   }
1134 }
1135
1136 void ARM64InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
1137                                  MachineBasicBlock::iterator I, DebugLoc DL,
1138                                  unsigned DestReg, unsigned SrcReg,
1139                                  bool KillSrc) const {
1140   if (ARM64::GPR32spRegClass.contains(DestReg) &&
1141       (ARM64::GPR32spRegClass.contains(SrcReg) || SrcReg == ARM64::WZR)) {
1142     const TargetRegisterInfo *TRI = &getRegisterInfo();
1143
1144     if (DestReg == ARM64::WSP || SrcReg == ARM64::WSP) {
1145       // If either operand is WSP, expand to ADD #0.
1146       if (Subtarget.hasZeroCycleRegMove()) {
1147         // Cyclone recognizes "ADD Xd, Xn, #0" as a zero-cycle register move.
1148         unsigned DestRegX = TRI->getMatchingSuperReg(DestReg, ARM64::sub_32,
1149                                                      &ARM64::GPR64spRegClass);
1150         unsigned SrcRegX = TRI->getMatchingSuperReg(SrcReg, ARM64::sub_32,
1151                                                     &ARM64::GPR64spRegClass);
1152         // This instruction is reading and writing X registers.  This may upset
1153         // the register scavenger and machine verifier, so we need to indicate
1154         // that we are reading an undefined value from SrcRegX, but a proper
1155         // value from SrcReg.
1156         BuildMI(MBB, I, DL, get(ARM64::ADDXri), DestRegX)
1157             .addReg(SrcRegX, RegState::Undef)
1158             .addImm(0)
1159             .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, 0))
1160             .addReg(SrcReg, RegState::Implicit | getKillRegState(KillSrc));
1161       } else {
1162         BuildMI(MBB, I, DL, get(ARM64::ADDWri), DestReg)
1163             .addReg(SrcReg, getKillRegState(KillSrc))
1164             .addImm(0)
1165             .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, 0));
1166       }
1167     } else if (SrcReg == ARM64::WZR && Subtarget.hasZeroCycleZeroing()) {
1168       BuildMI(MBB, I, DL, get(ARM64::MOVZWi), DestReg).addImm(0).addImm(
1169           ARM64_AM::getShifterImm(ARM64_AM::LSL, 0));
1170     } else {
1171       if (Subtarget.hasZeroCycleRegMove()) {
1172         // Cyclone recognizes "ORR Xd, XZR, Xm" as a zero-cycle register move.
1173         unsigned DestRegX = TRI->getMatchingSuperReg(DestReg, ARM64::sub_32,
1174                                                      &ARM64::GPR64spRegClass);
1175         unsigned SrcRegX = TRI->getMatchingSuperReg(SrcReg, ARM64::sub_32,
1176                                                     &ARM64::GPR64spRegClass);
1177         // This instruction is reading and writing X registers.  This may upset
1178         // the register scavenger and machine verifier, so we need to indicate
1179         // that we are reading an undefined value from SrcRegX, but a proper
1180         // value from SrcReg.
1181         BuildMI(MBB, I, DL, get(ARM64::ORRXrr), DestRegX)
1182             .addReg(ARM64::XZR)
1183             .addReg(SrcRegX, RegState::Undef)
1184             .addReg(SrcReg, RegState::Implicit | getKillRegState(KillSrc));
1185       } else {
1186         // Otherwise, expand to ORR WZR.
1187         BuildMI(MBB, I, DL, get(ARM64::ORRWrr), DestReg)
1188             .addReg(ARM64::WZR)
1189             .addReg(SrcReg, getKillRegState(KillSrc));
1190       }
1191     }
1192     return;
1193   }
1194
1195   if (ARM64::GPR64spRegClass.contains(DestReg) &&
1196       (ARM64::GPR64spRegClass.contains(SrcReg) || SrcReg == ARM64::XZR)) {
1197     if (DestReg == ARM64::SP || SrcReg == ARM64::SP) {
1198       // If either operand is SP, expand to ADD #0.
1199       BuildMI(MBB, I, DL, get(ARM64::ADDXri), DestReg)
1200           .addReg(SrcReg, getKillRegState(KillSrc))
1201           .addImm(0)
1202           .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, 0));
1203     } else if (SrcReg == ARM64::XZR && Subtarget.hasZeroCycleZeroing()) {
1204       BuildMI(MBB, I, DL, get(ARM64::MOVZXi), DestReg).addImm(0).addImm(
1205           ARM64_AM::getShifterImm(ARM64_AM::LSL, 0));
1206     } else {
1207       // Otherwise, expand to ORR XZR.
1208       BuildMI(MBB, I, DL, get(ARM64::ORRXrr), DestReg)
1209           .addReg(ARM64::XZR)
1210           .addReg(SrcReg, getKillRegState(KillSrc));
1211     }
1212     return;
1213   }
1214
1215   // Copy a DDDD register quad by copying the individual sub-registers.
1216   if (ARM64::DDDDRegClass.contains(DestReg) &&
1217       ARM64::DDDDRegClass.contains(SrcReg)) {
1218     static const unsigned Indices[] = { ARM64::dsub0, ARM64::dsub1,
1219                                         ARM64::dsub2, ARM64::dsub3 };
1220     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv8i8,
1221                      Indices);
1222     return;
1223   }
1224
1225   // Copy a DDD register triple by copying the individual sub-registers.
1226   if (ARM64::DDDRegClass.contains(DestReg) &&
1227       ARM64::DDDRegClass.contains(SrcReg)) {
1228     static const unsigned Indices[] = { ARM64::dsub0, ARM64::dsub1,
1229                                         ARM64::dsub2 };
1230     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv8i8,
1231                      Indices);
1232     return;
1233   }
1234
1235   // Copy a DD register pair by copying the individual sub-registers.
1236   if (ARM64::DDRegClass.contains(DestReg) &&
1237       ARM64::DDRegClass.contains(SrcReg)) {
1238     static const unsigned Indices[] = { ARM64::dsub0, ARM64::dsub1 };
1239     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv8i8,
1240                      Indices);
1241     return;
1242   }
1243
1244   // Copy a QQQQ register quad by copying the individual sub-registers.
1245   if (ARM64::QQQQRegClass.contains(DestReg) &&
1246       ARM64::QQQQRegClass.contains(SrcReg)) {
1247     static const unsigned Indices[] = { ARM64::qsub0, ARM64::qsub1,
1248                                         ARM64::qsub2, ARM64::qsub3 };
1249     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv16i8,
1250                      Indices);
1251     return;
1252   }
1253
1254   // Copy a QQQ register triple by copying the individual sub-registers.
1255   if (ARM64::QQQRegClass.contains(DestReg) &&
1256       ARM64::QQQRegClass.contains(SrcReg)) {
1257     static const unsigned Indices[] = { ARM64::qsub0, ARM64::qsub1,
1258                                         ARM64::qsub2 };
1259     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv16i8,
1260                      Indices);
1261     return;
1262   }
1263
1264   // Copy a QQ register pair by copying the individual sub-registers.
1265   if (ARM64::QQRegClass.contains(DestReg) &&
1266       ARM64::QQRegClass.contains(SrcReg)) {
1267     static const unsigned Indices[] = { ARM64::qsub0, ARM64::qsub1 };
1268     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv16i8,
1269                      Indices);
1270     return;
1271   }
1272
1273   if (ARM64::FPR128RegClass.contains(DestReg) &&
1274       ARM64::FPR128RegClass.contains(SrcReg)) {
1275     if(getSubTarget().hasNEON()) {
1276       BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1277           SrcReg, getKillRegState(KillSrc));
1278     } else {
1279       BuildMI(MBB, I, DL, get(ARM64::STRQpre))
1280         .addReg(SrcReg, getKillRegState(KillSrc))
1281         .addReg(ARM64::SP)
1282         .addImm(-16);
1283       BuildMI(MBB, I, DL, get(ARM64::LDRQpre))
1284         .addReg(DestReg, RegState::Define)
1285         .addReg(ARM64::SP)
1286         .addImm(16);
1287     }
1288     return;
1289   }
1290
1291   if (ARM64::FPR64RegClass.contains(DestReg) &&
1292       ARM64::FPR64RegClass.contains(SrcReg)) {
1293     if(getSubTarget().hasNEON()) {
1294       DestReg =
1295           RI.getMatchingSuperReg(DestReg, ARM64::dsub, &ARM64::FPR128RegClass);
1296       SrcReg =
1297           RI.getMatchingSuperReg(SrcReg, ARM64::dsub, &ARM64::FPR128RegClass);
1298       BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1299           SrcReg, getKillRegState(KillSrc));
1300     } else {
1301       BuildMI(MBB, I, DL, get(ARM64::FMOVDr), DestReg)
1302           .addReg(SrcReg, getKillRegState(KillSrc));
1303     }
1304     return;
1305   }
1306
1307   if (ARM64::FPR32RegClass.contains(DestReg) &&
1308       ARM64::FPR32RegClass.contains(SrcReg)) {
1309     if(getSubTarget().hasNEON()) {
1310       DestReg =
1311           RI.getMatchingSuperReg(DestReg, ARM64::ssub, &ARM64::FPR128RegClass);
1312       SrcReg =
1313           RI.getMatchingSuperReg(SrcReg, ARM64::ssub, &ARM64::FPR128RegClass);
1314       BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1315           SrcReg, getKillRegState(KillSrc));
1316     } else {
1317       BuildMI(MBB, I, DL, get(ARM64::FMOVSr), DestReg)
1318           .addReg(SrcReg, getKillRegState(KillSrc));
1319     }
1320     return;
1321   }
1322
1323   if (ARM64::FPR16RegClass.contains(DestReg) &&
1324       ARM64::FPR16RegClass.contains(SrcReg)) {
1325     if(getSubTarget().hasNEON()) {
1326       DestReg =
1327           RI.getMatchingSuperReg(DestReg, ARM64::hsub, &ARM64::FPR128RegClass);
1328       SrcReg =
1329           RI.getMatchingSuperReg(SrcReg, ARM64::hsub, &ARM64::FPR128RegClass);
1330       BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1331           SrcReg, getKillRegState(KillSrc));
1332     } else {
1333       DestReg =
1334           RI.getMatchingSuperReg(DestReg, ARM64::hsub, &ARM64::FPR32RegClass);
1335       SrcReg =
1336           RI.getMatchingSuperReg(SrcReg, ARM64::hsub, &ARM64::FPR32RegClass);
1337       BuildMI(MBB, I, DL, get(ARM64::FMOVSr), DestReg)
1338           .addReg(SrcReg, getKillRegState(KillSrc));
1339     }
1340     return;
1341   }
1342
1343   if (ARM64::FPR8RegClass.contains(DestReg) &&
1344       ARM64::FPR8RegClass.contains(SrcReg)) {
1345     if(getSubTarget().hasNEON()) {
1346       DestReg =
1347           RI.getMatchingSuperReg(DestReg, ARM64::bsub, &ARM64::FPR128RegClass);
1348       SrcReg =
1349           RI.getMatchingSuperReg(SrcReg, ARM64::bsub, &ARM64::FPR128RegClass);
1350       BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1351           SrcReg, getKillRegState(KillSrc));
1352     } else {
1353       DestReg =
1354           RI.getMatchingSuperReg(DestReg, ARM64::bsub, &ARM64::FPR32RegClass);
1355       SrcReg =
1356           RI.getMatchingSuperReg(SrcReg, ARM64::bsub, &ARM64::FPR32RegClass);
1357       BuildMI(MBB, I, DL, get(ARM64::FMOVSr), DestReg)
1358           .addReg(SrcReg, getKillRegState(KillSrc));
1359     }
1360     return;
1361   }
1362
1363   // Copies between GPR64 and FPR64.
1364   if (ARM64::FPR64RegClass.contains(DestReg) &&
1365       ARM64::GPR64RegClass.contains(SrcReg)) {
1366     BuildMI(MBB, I, DL, get(ARM64::FMOVXDr), DestReg)
1367         .addReg(SrcReg, getKillRegState(KillSrc));
1368     return;
1369   }
1370   if (ARM64::GPR64RegClass.contains(DestReg) &&
1371       ARM64::FPR64RegClass.contains(SrcReg)) {
1372     BuildMI(MBB, I, DL, get(ARM64::FMOVDXr), DestReg)
1373         .addReg(SrcReg, getKillRegState(KillSrc));
1374     return;
1375   }
1376   // Copies between GPR32 and FPR32.
1377   if (ARM64::FPR32RegClass.contains(DestReg) &&
1378       ARM64::GPR32RegClass.contains(SrcReg)) {
1379     BuildMI(MBB, I, DL, get(ARM64::FMOVWSr), DestReg)
1380         .addReg(SrcReg, getKillRegState(KillSrc));
1381     return;
1382   }
1383   if (ARM64::GPR32RegClass.contains(DestReg) &&
1384       ARM64::FPR32RegClass.contains(SrcReg)) {
1385     BuildMI(MBB, I, DL, get(ARM64::FMOVSWr), DestReg)
1386         .addReg(SrcReg, getKillRegState(KillSrc));
1387     return;
1388   }
1389
1390   assert(0 && "unimplemented reg-to-reg copy");
1391 }
1392
1393 void ARM64InstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
1394                                          MachineBasicBlock::iterator MBBI,
1395                                          unsigned SrcReg, bool isKill, int FI,
1396                                          const TargetRegisterClass *RC,
1397                                          const TargetRegisterInfo *TRI) const {
1398   DebugLoc DL;
1399   if (MBBI != MBB.end())
1400     DL = MBBI->getDebugLoc();
1401   MachineFunction &MF = *MBB.getParent();
1402   MachineFrameInfo &MFI = *MF.getFrameInfo();
1403   unsigned Align = MFI.getObjectAlignment(FI);
1404
1405   MachinePointerInfo PtrInfo(PseudoSourceValue::getFixedStack(FI));
1406   MachineMemOperand *MMO = MF.getMachineMemOperand(
1407       PtrInfo, MachineMemOperand::MOStore, MFI.getObjectSize(FI), Align);
1408   unsigned Opc = 0;
1409   bool Offset = true;
1410   switch (RC->getSize()) {
1411   case 1:
1412     if (ARM64::FPR8RegClass.hasSubClassEq(RC))
1413       Opc = ARM64::STRBui;
1414     break;
1415   case 2:
1416     if (ARM64::FPR16RegClass.hasSubClassEq(RC))
1417       Opc = ARM64::STRHui;
1418     break;
1419   case 4:
1420     if (ARM64::GPR32allRegClass.hasSubClassEq(RC)) {
1421       Opc = ARM64::STRWui;
1422       if (TargetRegisterInfo::isVirtualRegister(SrcReg))
1423         MF.getRegInfo().constrainRegClass(SrcReg, &ARM64::GPR32RegClass);
1424       else
1425         assert(SrcReg != ARM64::WSP);
1426     } else if (ARM64::FPR32RegClass.hasSubClassEq(RC))
1427       Opc = ARM64::STRSui;
1428     break;
1429   case 8:
1430     if (ARM64::GPR64allRegClass.hasSubClassEq(RC)) {
1431       Opc = ARM64::STRXui;
1432       if (TargetRegisterInfo::isVirtualRegister(SrcReg))
1433         MF.getRegInfo().constrainRegClass(SrcReg, &ARM64::GPR64RegClass);
1434       else
1435         assert(SrcReg != ARM64::SP);
1436     } else if (ARM64::FPR64RegClass.hasSubClassEq(RC))
1437       Opc = ARM64::STRDui;
1438     break;
1439   case 16:
1440     if (ARM64::FPR128RegClass.hasSubClassEq(RC))
1441       Opc = ARM64::STRQui;
1442     else if (ARM64::DDRegClass.hasSubClassEq(RC)) {
1443       assert(getSubTarget().hasNEON() &&
1444              "Unexpected register store without NEON");
1445       Opc = ARM64::ST1Twov1d, Offset = false;
1446     }
1447     break;
1448   case 24:
1449     if (ARM64::DDDRegClass.hasSubClassEq(RC)) {
1450       assert(getSubTarget().hasNEON() &&
1451              "Unexpected register store without NEON");
1452       Opc = ARM64::ST1Threev1d, Offset = false;
1453     }
1454     break;
1455   case 32:
1456     if (ARM64::DDDDRegClass.hasSubClassEq(RC)) {
1457       assert(getSubTarget().hasNEON() &&
1458              "Unexpected register store without NEON");
1459       Opc = ARM64::ST1Fourv1d, Offset = false;
1460     } else if (ARM64::QQRegClass.hasSubClassEq(RC)) {
1461       assert(getSubTarget().hasNEON() &&
1462              "Unexpected register store without NEON");
1463       Opc = ARM64::ST1Twov2d, Offset = false;
1464     }
1465     break;
1466   case 48:
1467     if (ARM64::QQQRegClass.hasSubClassEq(RC)) {
1468       assert(getSubTarget().hasNEON() &&
1469              "Unexpected register store without NEON");
1470       Opc = ARM64::ST1Threev2d, Offset = false;
1471     }
1472     break;
1473   case 64:
1474     if (ARM64::QQQQRegClass.hasSubClassEq(RC)) {
1475       assert(getSubTarget().hasNEON() &&
1476              "Unexpected register store without NEON");
1477       Opc = ARM64::ST1Fourv2d, Offset = false;
1478     }
1479     break;
1480   }
1481   assert(Opc && "Unknown register class");
1482
1483   const MachineInstrBuilder &MI = BuildMI(MBB, MBBI, DL, get(Opc))
1484                                       .addReg(SrcReg, getKillRegState(isKill))
1485                                       .addFrameIndex(FI);
1486
1487   if (Offset)
1488     MI.addImm(0);
1489   MI.addMemOperand(MMO);
1490 }
1491
1492 void ARM64InstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
1493                                           MachineBasicBlock::iterator MBBI,
1494                                           unsigned DestReg, int FI,
1495                                           const TargetRegisterClass *RC,
1496                                           const TargetRegisterInfo *TRI) const {
1497   DebugLoc DL;
1498   if (MBBI != MBB.end())
1499     DL = MBBI->getDebugLoc();
1500   MachineFunction &MF = *MBB.getParent();
1501   MachineFrameInfo &MFI = *MF.getFrameInfo();
1502   unsigned Align = MFI.getObjectAlignment(FI);
1503   MachinePointerInfo PtrInfo(PseudoSourceValue::getFixedStack(FI));
1504   MachineMemOperand *MMO = MF.getMachineMemOperand(
1505       PtrInfo, MachineMemOperand::MOLoad, MFI.getObjectSize(FI), Align);
1506
1507   unsigned Opc = 0;
1508   bool Offset = true;
1509   switch (RC->getSize()) {
1510   case 1:
1511     if (ARM64::FPR8RegClass.hasSubClassEq(RC))
1512       Opc = ARM64::LDRBui;
1513     break;
1514   case 2:
1515     if (ARM64::FPR16RegClass.hasSubClassEq(RC))
1516       Opc = ARM64::LDRHui;
1517     break;
1518   case 4:
1519     if (ARM64::GPR32allRegClass.hasSubClassEq(RC)) {
1520       Opc = ARM64::LDRWui;
1521       if (TargetRegisterInfo::isVirtualRegister(DestReg))
1522         MF.getRegInfo().constrainRegClass(DestReg, &ARM64::GPR32RegClass);
1523       else
1524         assert(DestReg != ARM64::WSP);
1525     } else if (ARM64::FPR32RegClass.hasSubClassEq(RC))
1526       Opc = ARM64::LDRSui;
1527     break;
1528   case 8:
1529     if (ARM64::GPR64allRegClass.hasSubClassEq(RC)) {
1530       Opc = ARM64::LDRXui;
1531       if (TargetRegisterInfo::isVirtualRegister(DestReg))
1532         MF.getRegInfo().constrainRegClass(DestReg, &ARM64::GPR64RegClass);
1533       else
1534         assert(DestReg != ARM64::SP);
1535     } else if (ARM64::FPR64RegClass.hasSubClassEq(RC))
1536       Opc = ARM64::LDRDui;
1537     break;
1538   case 16:
1539     if (ARM64::FPR128RegClass.hasSubClassEq(RC))
1540       Opc = ARM64::LDRQui;
1541     else if (ARM64::DDRegClass.hasSubClassEq(RC)) {
1542       assert(getSubTarget().hasNEON() &&
1543              "Unexpected register load without NEON");
1544       Opc = ARM64::LD1Twov1d, Offset = false;
1545     }
1546     break;
1547   case 24:
1548     if (ARM64::DDDRegClass.hasSubClassEq(RC)) {
1549       assert(getSubTarget().hasNEON() &&
1550              "Unexpected register load without NEON");
1551       Opc = ARM64::LD1Threev1d, Offset = false;
1552     }
1553     break;
1554   case 32:
1555     if (ARM64::DDDDRegClass.hasSubClassEq(RC)) {
1556       assert(getSubTarget().hasNEON() &&
1557              "Unexpected register load without NEON");
1558       Opc = ARM64::LD1Fourv1d, Offset = false;
1559     } else if (ARM64::QQRegClass.hasSubClassEq(RC)) {
1560       assert(getSubTarget().hasNEON() &&
1561              "Unexpected register load without NEON");
1562       Opc = ARM64::LD1Twov2d, Offset = false;
1563     }
1564     break;
1565   case 48:
1566     if (ARM64::QQQRegClass.hasSubClassEq(RC)) {
1567       assert(getSubTarget().hasNEON() &&
1568              "Unexpected register load without NEON");
1569       Opc = ARM64::LD1Threev2d, Offset = false;
1570     }
1571     break;
1572   case 64:
1573     if (ARM64::QQQQRegClass.hasSubClassEq(RC)) {
1574       assert(getSubTarget().hasNEON() &&
1575              "Unexpected register load without NEON");
1576       Opc = ARM64::LD1Fourv2d, Offset = false;
1577     }
1578     break;
1579   }
1580   assert(Opc && "Unknown register class");
1581
1582   const MachineInstrBuilder &MI = BuildMI(MBB, MBBI, DL, get(Opc))
1583                                       .addReg(DestReg, getDefRegState(true))
1584                                       .addFrameIndex(FI);
1585   if (Offset)
1586     MI.addImm(0);
1587   MI.addMemOperand(MMO);
1588 }
1589
1590 void llvm::emitFrameOffset(MachineBasicBlock &MBB,
1591                            MachineBasicBlock::iterator MBBI, DebugLoc DL,
1592                            unsigned DestReg, unsigned SrcReg, int Offset,
1593                            const ARM64InstrInfo *TII, MachineInstr::MIFlag Flag,
1594                            bool SetCPSR) {
1595   if (DestReg == SrcReg && Offset == 0)
1596     return;
1597
1598   bool isSub = Offset < 0;
1599   if (isSub)
1600     Offset = -Offset;
1601
1602   // FIXME: If the offset won't fit in 24-bits, compute the offset into a
1603   // scratch register.  If DestReg is a virtual register, use it as the
1604   // scratch register; otherwise, create a new virtual register (to be
1605   // replaced by the scavenger at the end of PEI).  That case can be optimized
1606   // slightly if DestReg is SP which is always 16-byte aligned, so the scratch
1607   // register can be loaded with offset%8 and the add/sub can use an extending
1608   // instruction with LSL#3.
1609   // Currently the function handles any offsets but generates a poor sequence
1610   // of code.
1611   //  assert(Offset < (1 << 24) && "unimplemented reg plus immediate");
1612
1613   unsigned Opc;
1614   if (SetCPSR)
1615     Opc = isSub ? ARM64::SUBSXri : ARM64::ADDSXri;
1616   else
1617     Opc = isSub ? ARM64::SUBXri : ARM64::ADDXri;
1618   const unsigned MaxEncoding = 0xfff;
1619   const unsigned ShiftSize = 12;
1620   const unsigned MaxEncodableValue = MaxEncoding << ShiftSize;
1621   while (((unsigned)Offset) >= (1 << ShiftSize)) {
1622     unsigned ThisVal;
1623     if (((unsigned)Offset) > MaxEncodableValue) {
1624       ThisVal = MaxEncodableValue;
1625     } else {
1626       ThisVal = Offset & MaxEncodableValue;
1627     }
1628     assert((ThisVal >> ShiftSize) <= MaxEncoding &&
1629            "Encoding cannot handle value that big");
1630     BuildMI(MBB, MBBI, DL, TII->get(Opc), DestReg)
1631         .addReg(SrcReg)
1632         .addImm(ThisVal >> ShiftSize)
1633         .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, ShiftSize))
1634         .setMIFlag(Flag);
1635
1636     SrcReg = DestReg;
1637     Offset -= ThisVal;
1638     if (Offset == 0)
1639       return;
1640   }
1641   BuildMI(MBB, MBBI, DL, TII->get(Opc), DestReg)
1642       .addReg(SrcReg)
1643       .addImm(Offset)
1644       .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, 0))
1645       .setMIFlag(Flag);
1646 }
1647
1648 MachineInstr *
1649 ARM64InstrInfo::foldMemoryOperandImpl(MachineFunction &MF, MachineInstr *MI,
1650                                       const SmallVectorImpl<unsigned> &Ops,
1651                                       int FrameIndex) const {
1652   // This is a bit of a hack. Consider this instruction:
1653   //
1654   //   %vreg0<def> = COPY %SP; GPR64all:%vreg0
1655   //
1656   // We explicitly chose GPR64all for the virtual register so such a copy might
1657   // be eliminated by RegisterCoalescer. However, that may not be possible, and
1658   // %vreg0 may even spill. We can't spill %SP, and since it is in the GPR64all
1659   // register class, TargetInstrInfo::foldMemoryOperand() is going to try.
1660   //
1661   // To prevent that, we are going to constrain the %vreg0 register class here.
1662   //
1663   // <rdar://problem/11522048>
1664   //
1665   if (MI->isCopy()) {
1666     unsigned DstReg = MI->getOperand(0).getReg();
1667     unsigned SrcReg = MI->getOperand(1).getReg();
1668     if (SrcReg == ARM64::SP && TargetRegisterInfo::isVirtualRegister(DstReg)) {
1669       MF.getRegInfo().constrainRegClass(DstReg, &ARM64::GPR64RegClass);
1670       return 0;
1671     }
1672     if (DstReg == ARM64::SP && TargetRegisterInfo::isVirtualRegister(SrcReg)) {
1673       MF.getRegInfo().constrainRegClass(SrcReg, &ARM64::GPR64RegClass);
1674       return 0;
1675     }
1676   }
1677
1678   // Cannot fold.
1679   return 0;
1680 }
1681
1682 int llvm::isARM64FrameOffsetLegal(const MachineInstr &MI, int &Offset,
1683                                   bool *OutUseUnscaledOp,
1684                                   unsigned *OutUnscaledOp,
1685                                   int *EmittableOffset) {
1686   int Scale = 1;
1687   bool IsSigned = false;
1688   // The ImmIdx should be changed case by case if it is not 2.
1689   unsigned ImmIdx = 2;
1690   unsigned UnscaledOp = 0;
1691   // Set output values in case of early exit.
1692   if (EmittableOffset)
1693     *EmittableOffset = 0;
1694   if (OutUseUnscaledOp)
1695     *OutUseUnscaledOp = false;
1696   if (OutUnscaledOp)
1697     *OutUnscaledOp = 0;
1698   switch (MI.getOpcode()) {
1699   default:
1700     assert(0 && "unhandled opcode in rewriteARM64FrameIndex");
1701   // Vector spills/fills can't take an immediate offset.
1702   case ARM64::LD1Twov2d:
1703   case ARM64::LD1Threev2d:
1704   case ARM64::LD1Fourv2d:
1705   case ARM64::LD1Twov1d:
1706   case ARM64::LD1Threev1d:
1707   case ARM64::LD1Fourv1d:
1708   case ARM64::ST1Twov2d:
1709   case ARM64::ST1Threev2d:
1710   case ARM64::ST1Fourv2d:
1711   case ARM64::ST1Twov1d:
1712   case ARM64::ST1Threev1d:
1713   case ARM64::ST1Fourv1d:
1714     return ARM64FrameOffsetCannotUpdate;
1715   case ARM64::PRFMui:
1716     Scale = 8;
1717     UnscaledOp = ARM64::PRFUMi;
1718     break;
1719   case ARM64::LDRXui:
1720     Scale = 8;
1721     UnscaledOp = ARM64::LDURXi;
1722     break;
1723   case ARM64::LDRWui:
1724     Scale = 4;
1725     UnscaledOp = ARM64::LDURWi;
1726     break;
1727   case ARM64::LDRBui:
1728     Scale = 1;
1729     UnscaledOp = ARM64::LDURBi;
1730     break;
1731   case ARM64::LDRHui:
1732     Scale = 2;
1733     UnscaledOp = ARM64::LDURHi;
1734     break;
1735   case ARM64::LDRSui:
1736     Scale = 4;
1737     UnscaledOp = ARM64::LDURSi;
1738     break;
1739   case ARM64::LDRDui:
1740     Scale = 8;
1741     UnscaledOp = ARM64::LDURDi;
1742     break;
1743   case ARM64::LDRQui:
1744     Scale = 16;
1745     UnscaledOp = ARM64::LDURQi;
1746     break;
1747   case ARM64::LDRBBui:
1748     Scale = 1;
1749     UnscaledOp = ARM64::LDURBBi;
1750     break;
1751   case ARM64::LDRHHui:
1752     Scale = 2;
1753     UnscaledOp = ARM64::LDURHHi;
1754     break;
1755   case ARM64::LDRSBXui:
1756     Scale = 1;
1757     UnscaledOp = ARM64::LDURSBXi;
1758     break;
1759   case ARM64::LDRSBWui:
1760     Scale = 1;
1761     UnscaledOp = ARM64::LDURSBWi;
1762     break;
1763   case ARM64::LDRSHXui:
1764     Scale = 2;
1765     UnscaledOp = ARM64::LDURSHXi;
1766     break;
1767   case ARM64::LDRSHWui:
1768     Scale = 2;
1769     UnscaledOp = ARM64::LDURSHWi;
1770     break;
1771   case ARM64::LDRSWui:
1772     Scale = 4;
1773     UnscaledOp = ARM64::LDURSWi;
1774     break;
1775
1776   case ARM64::STRXui:
1777     Scale = 8;
1778     UnscaledOp = ARM64::STURXi;
1779     break;
1780   case ARM64::STRWui:
1781     Scale = 4;
1782     UnscaledOp = ARM64::STURWi;
1783     break;
1784   case ARM64::STRBui:
1785     Scale = 1;
1786     UnscaledOp = ARM64::STURBi;
1787     break;
1788   case ARM64::STRHui:
1789     Scale = 2;
1790     UnscaledOp = ARM64::STURHi;
1791     break;
1792   case ARM64::STRSui:
1793     Scale = 4;
1794     UnscaledOp = ARM64::STURSi;
1795     break;
1796   case ARM64::STRDui:
1797     Scale = 8;
1798     UnscaledOp = ARM64::STURDi;
1799     break;
1800   case ARM64::STRQui:
1801     Scale = 16;
1802     UnscaledOp = ARM64::STURQi;
1803     break;
1804   case ARM64::STRBBui:
1805     Scale = 1;
1806     UnscaledOp = ARM64::STURBBi;
1807     break;
1808   case ARM64::STRHHui:
1809     Scale = 2;
1810     UnscaledOp = ARM64::STURHHi;
1811     break;
1812
1813   case ARM64::LDPXi:
1814   case ARM64::LDPDi:
1815   case ARM64::STPXi:
1816   case ARM64::STPDi:
1817     IsSigned = true;
1818     Scale = 8;
1819     break;
1820   case ARM64::LDPQi:
1821   case ARM64::STPQi:
1822     IsSigned = true;
1823     Scale = 16;
1824     break;
1825   case ARM64::LDPWi:
1826   case ARM64::LDPSi:
1827   case ARM64::STPWi:
1828   case ARM64::STPSi:
1829     IsSigned = true;
1830     Scale = 4;
1831     break;
1832
1833   case ARM64::LDURXi:
1834   case ARM64::LDURWi:
1835   case ARM64::LDURBi:
1836   case ARM64::LDURHi:
1837   case ARM64::LDURSi:
1838   case ARM64::LDURDi:
1839   case ARM64::LDURQi:
1840   case ARM64::LDURHHi:
1841   case ARM64::LDURBBi:
1842   case ARM64::LDURSBXi:
1843   case ARM64::LDURSBWi:
1844   case ARM64::LDURSHXi:
1845   case ARM64::LDURSHWi:
1846   case ARM64::LDURSWi:
1847   case ARM64::STURXi:
1848   case ARM64::STURWi:
1849   case ARM64::STURBi:
1850   case ARM64::STURHi:
1851   case ARM64::STURSi:
1852   case ARM64::STURDi:
1853   case ARM64::STURQi:
1854   case ARM64::STURBBi:
1855   case ARM64::STURHHi:
1856     Scale = 1;
1857     break;
1858   }
1859
1860   Offset += MI.getOperand(ImmIdx).getImm() * Scale;
1861
1862   bool useUnscaledOp = false;
1863   // If the offset doesn't match the scale, we rewrite the instruction to
1864   // use the unscaled instruction instead. Likewise, if we have a negative
1865   // offset (and have an unscaled op to use).
1866   if ((Offset & (Scale - 1)) != 0 || (Offset < 0 && UnscaledOp != 0))
1867     useUnscaledOp = true;
1868
1869   // Use an unscaled addressing mode if the instruction has a negative offset
1870   // (or if the instruction is already using an unscaled addressing mode).
1871   unsigned MaskBits;
1872   if (IsSigned) {
1873     // ldp/stp instructions.
1874     MaskBits = 7;
1875     Offset /= Scale;
1876   } else if (UnscaledOp == 0 || useUnscaledOp) {
1877     MaskBits = 9;
1878     IsSigned = true;
1879     Scale = 1;
1880   } else {
1881     MaskBits = 12;
1882     IsSigned = false;
1883     Offset /= Scale;
1884   }
1885
1886   // Attempt to fold address computation.
1887   int MaxOff = (1 << (MaskBits - IsSigned)) - 1;
1888   int MinOff = (IsSigned ? (-MaxOff - 1) : 0);
1889   if (Offset >= MinOff && Offset <= MaxOff) {
1890     if (EmittableOffset)
1891       *EmittableOffset = Offset;
1892     Offset = 0;
1893   } else {
1894     int NewOff = Offset < 0 ? MinOff : MaxOff;
1895     if (EmittableOffset)
1896       *EmittableOffset = NewOff;
1897     Offset = (Offset - NewOff) * Scale;
1898   }
1899   if (OutUseUnscaledOp)
1900     *OutUseUnscaledOp = useUnscaledOp;
1901   if (OutUnscaledOp)
1902     *OutUnscaledOp = UnscaledOp;
1903   return ARM64FrameOffsetCanUpdate |
1904          (Offset == 0 ? ARM64FrameOffsetIsLegal : 0);
1905 }
1906
1907 bool llvm::rewriteARM64FrameIndex(MachineInstr &MI, unsigned FrameRegIdx,
1908                                   unsigned FrameReg, int &Offset,
1909                                   const ARM64InstrInfo *TII) {
1910   unsigned Opcode = MI.getOpcode();
1911   unsigned ImmIdx = FrameRegIdx + 1;
1912
1913   if (Opcode == ARM64::ADDSXri || Opcode == ARM64::ADDXri) {
1914     Offset += MI.getOperand(ImmIdx).getImm();
1915     emitFrameOffset(*MI.getParent(), MI, MI.getDebugLoc(),
1916                     MI.getOperand(0).getReg(), FrameReg, Offset, TII,
1917                     MachineInstr::NoFlags, (Opcode == ARM64::ADDSXri));
1918     MI.eraseFromParent();
1919     Offset = 0;
1920     return true;
1921   }
1922
1923   int NewOffset;
1924   unsigned UnscaledOp;
1925   bool UseUnscaledOp;
1926   int Status = isARM64FrameOffsetLegal(MI, Offset, &UseUnscaledOp, &UnscaledOp,
1927                                        &NewOffset);
1928   if (Status & ARM64FrameOffsetCanUpdate) {
1929     if (Status & ARM64FrameOffsetIsLegal)
1930       // Replace the FrameIndex with FrameReg.
1931       MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
1932     if (UseUnscaledOp)
1933       MI.setDesc(TII->get(UnscaledOp));
1934
1935     MI.getOperand(ImmIdx).ChangeToImmediate(NewOffset);
1936     return Offset == 0;
1937   }
1938
1939   return false;
1940 }
1941
1942 void ARM64InstrInfo::getNoopForMachoTarget(MCInst &NopInst) const {
1943   NopInst.setOpcode(ARM64::HINT);
1944   NopInst.addOperand(MCOperand::CreateImm(0));
1945 }