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 #define GET_INSTRINFO_CTOR_DTOR
  27 #include "ARM64GenInstrInfo.inc"
  28
  29 using namespace llvm;
  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::ANDSWri:
 571   case ARM64::SUBSXri:
 572   case ARM64::ADDSXri:
 573   case ARM64::ANDSXri:
 574     SrcReg = MI->getOperand(1).getReg();
 575     SrcReg2 = 0;
 576     CmpMask = ~0;
 577     CmpValue = MI->getOperand(2).getImm();
 578     return true;
 579   }
 580
 581   return false;
 582 }
 583
 584 static bool UpdateOperandRegClass(MachineInstr *Instr) {
 585   MachineBasicBlock *MBB = Instr->getParent();
 586   assert(MBB && "Can't get MachineBasicBlock here");
 587   MachineFunction *MF = MBB->getParent();
 588   assert(MF && "Can't get MachineFunction here");
 589   const TargetMachine *TM = &MF->getTarget();
 590   const TargetInstrInfo *TII = TM->getInstrInfo();
 591   const TargetRegisterInfo *TRI = TM->getRegisterInfo();
 592   MachineRegisterInfo *MRI = &MF->getRegInfo();
 593
 594   for (unsigned OpIdx = 0, EndIdx = Instr->getNumOperands(); OpIdx < EndIdx;
 595        ++OpIdx) {
 596     MachineOperand &MO = Instr->getOperand(OpIdx);
 597     const TargetRegisterClass *OpRegCstraints =
 598         Instr->getRegClassConstraint(OpIdx, TII, TRI);
 599
 600     // If there's no constraint, there's nothing to do.
 601     if (!OpRegCstraints)
 602       continue;
 603     // If the operand is a frame index, there's nothing to do here.
 604     // A frame index operand will resolve correctly during PEI.
 605     if (MO.isFI())
 606       continue;
 607
 608     assert(MO.isReg() &&
 609            "Operand has register constraints without being a register!");
 610
 611     unsigned Reg = MO.getReg();
 612     if (TargetRegisterInfo::isPhysicalRegister(Reg)) {
 613       if (!OpRegCstraints->contains(Reg))
 614         return false;
 615     } else if (!OpRegCstraints->hasSubClassEq(MRI->getRegClass(Reg)) &&
 616                !MRI->constrainRegClass(Reg, OpRegCstraints))
 617       return false;
 618   }
 619
 620   return true;
 621 }
 622
 623 /// optimizeCompareInstr - Convert the instruction supplying the argument to the
 624 /// comparison into one that sets the zero bit in the flags register.
 625 bool ARM64InstrInfo::optimizeCompareInstr(
 626     MachineInstr *CmpInstr, unsigned SrcReg, unsigned SrcReg2, int CmpMask,
 627     int CmpValue, const MachineRegisterInfo *MRI) const {
 628
 629   // Replace SUBSWrr with SUBWrr if CPSR is not used.
 630   int Cmp_CPSR = CmpInstr->findRegisterDefOperandIdx(ARM64::CPSR, true);
 631   if (Cmp_CPSR != -1) {
 632     unsigned NewOpc;
 633     switch (CmpInstr->getOpcode()) {
 634     default:
 635       return false;
 636     case ARM64::ADDSWrr:      NewOpc = ARM64::ADDWrr; break;
 637     case ARM64::ADDSWri:      NewOpc = ARM64::ADDWri; break;
 638     case ARM64::ADDSWrs:      NewOpc = ARM64::ADDWrs; break;
 639     case ARM64::ADDSWrx:      NewOpc = ARM64::ADDWrx; break;
 640     case ARM64::ADDSXrr:      NewOpc = ARM64::ADDXrr; break;
 641     case ARM64::ADDSXri:      NewOpc = ARM64::ADDXri; break;
 642     case ARM64::ADDSXrs:      NewOpc = ARM64::ADDXrs; break;
 643     case ARM64::ADDSXrx:      NewOpc = ARM64::ADDXrx; break;
 644     case ARM64::SUBSWrr:      NewOpc = ARM64::SUBWrr; break;
 645     case ARM64::SUBSWri:      NewOpc = ARM64::SUBWri; break;
 646     case ARM64::SUBSWrs:      NewOpc = ARM64::SUBWrs; break;
 647     case ARM64::SUBSWrx:      NewOpc = ARM64::SUBWrx; break;
 648     case ARM64::SUBSXrr:      NewOpc = ARM64::SUBXrr; break;
 649     case ARM64::SUBSXri:      NewOpc = ARM64::SUBXri; break;
 650     case ARM64::SUBSXrs:      NewOpc = ARM64::SUBXrs; break;
 651     case ARM64::SUBSXrx:      NewOpc = ARM64::SUBXrx; break;
 652     }
 653
 654     const MCInstrDesc &MCID = get(NewOpc);
 655     CmpInstr->setDesc(MCID);
 656     CmpInstr->RemoveOperand(Cmp_CPSR);
 657     bool succeeded = UpdateOperandRegClass(CmpInstr);
 658     (void)succeeded;
 659     assert(succeeded && "Some operands reg class are incompatible!");
 660     return true;
 661   }
 662
 663   // Continue only if we have a "ri" where immediate is zero.
 664   if (CmpValue != 0 || SrcReg2 != 0)
 665     return false;
 666
 667   // CmpInstr is a Compare instruction if destination register is not used.
 668   if (!MRI->use_nodbg_empty(CmpInstr->getOperand(0).getReg()))
 669     return false;
 670
 671   // Get the unique definition of SrcReg.
 672   MachineInstr *MI = MRI->getUniqueVRegDef(SrcReg);
 673   if (!MI)
 674     return false;
 675
 676   // We iterate backward, starting from the instruction before CmpInstr and
 677   // stop when reaching the definition of the source register or done with the
 678   // basic block, to check whether CPSR is used or modified in between.
 679   MachineBasicBlock::iterator I = CmpInstr, E = MI,
 680                               B = CmpInstr->getParent()->begin();
 681
 682   // Early exit if CmpInstr is at the beginning of the BB.
 683   if (I == B)
 684     return false;
 685
 686   // Check whether the definition of SrcReg is in the same basic block as
 687   // Compare. If not, we can't optimize away the Compare.
 688   if (MI->getParent() != CmpInstr->getParent())
 689     return false;
 690
 691   // Check that CPSR isn't set between the comparison instruction and the one we
 692   // want to change.
 693   const TargetRegisterInfo *TRI = &getRegisterInfo();
 694   for (--I; I != E; --I) {
 695     const MachineInstr &Instr = *I;
 696
 697     if (Instr.modifiesRegister(ARM64::CPSR, TRI) ||
 698         Instr.readsRegister(ARM64::CPSR, TRI))
 699       // This instruction modifies or uses CPSR after the one we want to
 700       // change. We can't do this transformation.
 701       return false;
 702     if (I == B)
 703       // The 'and' is below the comparison instruction.
 704       return false;
 705   }
 706
 707   unsigned NewOpc = MI->getOpcode();
 708   switch (MI->getOpcode()) {
 709   default:
 710     return false;
 711   case ARM64::ADDSWrr:
 712   case ARM64::ADDSWri:
 713   case ARM64::ADDSXrr:
 714   case ARM64::ADDSXri:
 715   case ARM64::SUBSWrr:
 716   case ARM64::SUBSWri:
 717   case ARM64::SUBSXrr:
 718   case ARM64::SUBSXri:
 719     break;
 720   case ARM64::ADDWrr:    NewOpc = ARM64::ADDSWrr; break;
 721   case ARM64::ADDWri:    NewOpc = ARM64::ADDSWri; break;
 722   case ARM64::ADDXrr:    NewOpc = ARM64::ADDSXrr; break;
 723   case ARM64::ADDXri:    NewOpc = ARM64::ADDSXri; break;
 724   case ARM64::ADCWr:     NewOpc = ARM64::ADCSWr; break;
 725   case ARM64::ADCXr:     NewOpc = ARM64::ADCSXr; break;
 726   case ARM64::SUBWrr:    NewOpc = ARM64::SUBSWrr; break;
 727   case ARM64::SUBWri:    NewOpc = ARM64::SUBSWri; break;
 728   case ARM64::SUBXrr:    NewOpc = ARM64::SUBSXrr; break;
 729   case ARM64::SUBXri:    NewOpc = ARM64::SUBSXri; break;
 730   case ARM64::SBCWr:     NewOpc = ARM64::SBCSWr; break;
 731   case ARM64::SBCXr:     NewOpc = ARM64::SBCSXr; break;
 732   case ARM64::ANDWri:    NewOpc = ARM64::ANDSWri; break;
 733   case ARM64::ANDXri:    NewOpc = ARM64::ANDSXri; break;
 734   }
 735
 736   // Scan forward for the use of CPSR.
 737   // When checking against MI: if it's a conditional code requires
 738   // checking of V bit, then this is not safe to do.
 739   // It is safe to remove CmpInstr if CPSR is redefined or killed.
 740   // If we are done with the basic block, we need to check whether CPSR is
 741   // live-out.
 742   bool IsSafe = false;
 743   for (MachineBasicBlock::iterator I = CmpInstr,
 744                                    E = CmpInstr->getParent()->end();
 745        !IsSafe && ++I != E;) {
 746     const MachineInstr &Instr = *I;
 747     for (unsigned IO = 0, EO = Instr.getNumOperands(); !IsSafe && IO != EO;
 748          ++IO) {
 749       const MachineOperand &MO = Instr.getOperand(IO);
 750       if (MO.isRegMask() && MO.clobbersPhysReg(ARM64::CPSR)) {
 751         IsSafe = true;
 752         break;
 753       }
 754       if (!MO.isReg() || MO.getReg() != ARM64::CPSR)
 755         continue;
 756       if (MO.isDef()) {
 757         IsSafe = true;
 758         break;
 759       }
 760
 761       // Decode the condition code.
 762       unsigned Opc = Instr.getOpcode();
 763       ARM64CC::CondCode CC;
 764       switch (Opc) {
 765       default:
 766         return false;
 767       case ARM64::Bcc:
 768         CC = (ARM64CC::CondCode)Instr.getOperand(IO - 2).getImm();
 769         break;
 770       case ARM64::CSINVWr:
 771       case ARM64::CSINVXr:
 772       case ARM64::CSINCWr:
 773       case ARM64::CSINCXr:
 774       case ARM64::CSELWr:
 775       case ARM64::CSELXr:
 776       case ARM64::CSNEGWr:
 777       case ARM64::CSNEGXr:
 778         CC = (ARM64CC::CondCode)Instr.getOperand(IO - 1).getImm();
 779         break;
 780       }
 781
 782       // It is not safe to remove Compare instruction if Overflow(V) is used.
 783       switch (CC) {
 784       default:
 785         // CPSR can be used multiple times, we should continue.
 786         break;
 787       case ARM64CC::VS:
 788       case ARM64CC::VC:
 789       case ARM64CC::GE:
 790       case ARM64CC::LT:
 791       case ARM64CC::GT:
 792       case ARM64CC::LE:
 793         return false;
 794       }
 795     }
 796   }
 797
 798   // If CPSR is not killed nor re-defined, we should check whether it is
 799   // live-out. If it is live-out, do not optimize.
 800   if (!IsSafe) {
 801     MachineBasicBlock *MBB = CmpInstr->getParent();
 802     for (MachineBasicBlock::succ_iterator SI = MBB->succ_begin(),
 803                                           SE = MBB->succ_end();
 804          SI != SE; ++SI)
 805       if ((*SI)->isLiveIn(ARM64::CPSR))
 806         return false;
 807   }
 808
 809   // Update the instruction to set CPSR.
 810   MI->setDesc(get(NewOpc));
 811   CmpInstr->eraseFromParent();
 812   bool succeeded = UpdateOperandRegClass(MI);
 813   (void)succeeded;
 814   assert(succeeded && "Some operands reg class are incompatible!");
 815   MI->addRegisterDefined(ARM64::CPSR, TRI);
 816   return true;
 817 }
 818
 819 // Return true if this instruction simply sets its single destination register
 820 // to zero. This is equivalent to a register rename of the zero-register.
 821 bool ARM64InstrInfo::isGPRZero(const MachineInstr *MI) const {
 822   switch (MI->getOpcode()) {
 823   default:
 824     break;
 825   case ARM64::MOVZWi:
 826   case ARM64::MOVZXi: // movz Rd, #0 (LSL #0)
 827     if (MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0) {
 828       assert(MI->getDesc().getNumOperands() == 3 &&
 829              MI->getOperand(2).getImm() == 0 && "invalid MOVZi operands");
 830       return true;
 831     }
 832     break;
 833   case ARM64::ANDWri: // and Rd, Rzr, #imm
 834     return MI->getOperand(1).getReg() == ARM64::WZR;
 835   case ARM64::ANDXri:
 836     return MI->getOperand(1).getReg() == ARM64::XZR;
 837   case TargetOpcode::COPY:
 838     return MI->getOperand(1).getReg() == ARM64::WZR;
 839   }
 840   return false;
 841 }
 842
 843 // Return true if this instruction simply renames a general register without
 844 // modifying bits.
 845 bool ARM64InstrInfo::isGPRCopy(const MachineInstr *MI) const {
 846   switch (MI->getOpcode()) {
 847   default:
 848     break;
 849   case TargetOpcode::COPY: {
 850     // GPR32 copies will by lowered to ORRXrs
 851     unsigned DstReg = MI->getOperand(0).getReg();
 852     return (ARM64::GPR32RegClass.contains(DstReg) ||
 853             ARM64::GPR64RegClass.contains(DstReg));
 854   }
 855   case ARM64::ORRXrs: // orr Xd, Xzr, Xm (LSL #0)
 856     if (MI->getOperand(1).getReg() == ARM64::XZR) {
 857       assert(MI->getDesc().getNumOperands() == 4 &&
 858              MI->getOperand(3).getImm() == 0 && "invalid ORRrs operands");
 859       return true;
 860     }
 861   case ARM64::ADDXri: // add Xd, Xn, #0 (LSL #0)
 862     if (MI->getOperand(2).getImm() == 0) {
 863       assert(MI->getDesc().getNumOperands() == 4 &&
 864              MI->getOperand(3).getImm() == 0 && "invalid ADDXri operands");
 865       return true;
 866     }
 867   }
 868   return false;
 869 }
 870
 871 // Return true if this instruction simply renames a general register without
 872 // modifying bits.
 873 bool ARM64InstrInfo::isFPRCopy(const MachineInstr *MI) const {
 874   switch (MI->getOpcode()) {
 875   default:
 876     break;
 877   case TargetOpcode::COPY: {
 878     // FPR64 copies will by lowered to ORR.16b
 879     unsigned DstReg = MI->getOperand(0).getReg();
 880     return (ARM64::FPR64RegClass.contains(DstReg) ||
 881             ARM64::FPR128RegClass.contains(DstReg));
 882   }
 883   case ARM64::ORRv16i8:
 884     if (MI->getOperand(1).getReg() == MI->getOperand(2).getReg()) {
 885       assert(MI->getDesc().getNumOperands() == 3 && MI->getOperand(0).isReg() &&
 886              "invalid ORRv16i8 operands");
 887       return true;
 888     }
 889   }
 890   return false;
 891 }
 892
 893 unsigned ARM64InstrInfo::isLoadFromStackSlot(const MachineInstr *MI,
 894                                              int &FrameIndex) const {
 895   switch (MI->getOpcode()) {
 896   default:
 897     break;
 898   case ARM64::LDRWui:
 899   case ARM64::LDRXui:
 900   case ARM64::LDRBui:
 901   case ARM64::LDRHui:
 902   case ARM64::LDRSui:
 903   case ARM64::LDRDui:
 904   case ARM64::LDRQui:
 905     if (MI->getOperand(0).getSubReg() == 0 && MI->getOperand(1).isFI() &&
 906         MI->getOperand(2).isImm() && MI->getOperand(2).getImm() == 0) {
 907       FrameIndex = MI->getOperand(1).getIndex();
 908       return MI->getOperand(0).getReg();
 909     }
 910     break;
 911   }
 912
 913   return 0;
 914 }
 915
 916 unsigned ARM64InstrInfo::isStoreToStackSlot(const MachineInstr *MI,
 917                                             int &FrameIndex) const {
 918   switch (MI->getOpcode()) {
 919   default:
 920     break;
 921   case ARM64::STRWui:
 922   case ARM64::STRXui:
 923   case ARM64::STRBui:
 924   case ARM64::STRHui:
 925   case ARM64::STRSui:
 926   case ARM64::STRDui:
 927   case ARM64::STRQui:
 928     if (MI->getOperand(0).getSubReg() == 0 && MI->getOperand(1).isFI() &&
 929         MI->getOperand(2).isImm() && MI->getOperand(2).getImm() == 0) {
 930       FrameIndex = MI->getOperand(1).getIndex();
 931       return MI->getOperand(0).getReg();
 932     }
 933     break;
 934   }
 935   return 0;
 936 }
 937
 938 /// Return true if this is load/store scales or extends its register offset.
 939 /// This refers to scaling a dynamic index as opposed to scaled immediates.
 940 /// MI should be a memory op that allows scaled addressing.
 941 bool ARM64InstrInfo::isScaledAddr(const MachineInstr *MI) const {
 942   switch (MI->getOpcode()) {
 943   default:
 944     break;
 945   case ARM64::LDRBBro:
 946   case ARM64::LDRBro:
 947   case ARM64::LDRDro:
 948   case ARM64::LDRHHro:
 949   case ARM64::LDRHro:
 950   case ARM64::LDRQro:
 951   case ARM64::LDRSBWro:
 952   case ARM64::LDRSBXro:
 953   case ARM64::LDRSHWro:
 954   case ARM64::LDRSHXro:
 955   case ARM64::LDRSWro:
 956   case ARM64::LDRSro:
 957   case ARM64::LDRWro:
 958   case ARM64::LDRXro:
 959   case ARM64::STRBBro:
 960   case ARM64::STRBro:
 961   case ARM64::STRDro:
 962   case ARM64::STRHHro:
 963   case ARM64::STRHro:
 964   case ARM64::STRQro:
 965   case ARM64::STRSro:
 966   case ARM64::STRWro:
 967   case ARM64::STRXro:
 968     unsigned Val = MI->getOperand(3).getImm();
 969     ARM64_AM::ExtendType ExtType = ARM64_AM::getMemExtendType(Val);
 970     return (ExtType != ARM64_AM::UXTX) || ARM64_AM::getMemDoShift(Val);
 971   }
 972   return false;
 973 }
 974
 975 /// Check all MachineMemOperands for a hint to suppress pairing.
 976 bool ARM64InstrInfo::isLdStPairSuppressed(const MachineInstr *MI) const {
 977   assert(MOSuppressPair < (1 << MachineMemOperand::MOTargetNumBits) &&
 978          "Too many target MO flags");
 979   for (MachineInstr::mmo_iterator MM = MI->memoperands_begin(),
 980                                   E = MI->memoperands_end();
 981        MM != E; ++MM) {
 982
 983     if ((*MM)->getFlags() &
 984         (MOSuppressPair << MachineMemOperand::MOTargetStartBit)) {
 985       return true;
 986     }
 987   }
 988   return false;
 989 }
 990
 991 /// Set a flag on the first MachineMemOperand to suppress pairing.
 992 void ARM64InstrInfo::suppressLdStPair(MachineInstr *MI) const {
 993   if (MI->memoperands_empty())
 994     return;
 995
 996   assert(MOSuppressPair < (1 << MachineMemOperand::MOTargetNumBits) &&
 997          "Too many target MO flags");
 998   (*MI->memoperands_begin())
 999       ->setFlags(MOSuppressPair << MachineMemOperand::MOTargetStartBit);
1000 }
1001
1002 bool ARM64InstrInfo::getLdStBaseRegImmOfs(MachineInstr *LdSt, unsigned &BaseReg,
1003                                           unsigned &Offset,
1004                                           const TargetRegisterInfo *TRI) const {
1005   switch (LdSt->getOpcode()) {
1006   default:
1007     return false;
1008   case ARM64::STRSui:
1009   case ARM64::STRDui:
1010   case ARM64::STRQui:
1011   case ARM64::STRXui:
1012   case ARM64::STRWui:
1013   case ARM64::LDRSui:
1014   case ARM64::LDRDui:
1015   case ARM64::LDRQui:
1016   case ARM64::LDRXui:
1017   case ARM64::LDRWui:
1018     if (!LdSt->getOperand(1).isReg() || !LdSt->getOperand(2).isImm())
1019       return false;
1020     BaseReg = LdSt->getOperand(1).getReg();
1021     MachineFunction &MF = *LdSt->getParent()->getParent();
1022     unsigned Width = getRegClass(LdSt->getDesc(), 0, TRI, MF)->getSize();
1023     Offset = LdSt->getOperand(2).getImm() * Width;
1024     return true;
1025   };
1026 }
1027
1028 /// Detect opportunities for ldp/stp formation.
1029 ///
1030 /// Only called for LdSt for which getLdStBaseRegImmOfs returns true.
1031 bool ARM64InstrInfo::shouldClusterLoads(MachineInstr *FirstLdSt,
1032                                         MachineInstr *SecondLdSt,
1033                                         unsigned NumLoads) const {
1034   // Only cluster up to a single pair.
1035   if (NumLoads > 1)
1036     return false;
1037   if (FirstLdSt->getOpcode() != SecondLdSt->getOpcode())
1038     return false;
1039   // getLdStBaseRegImmOfs guarantees that oper 2 isImm.
1040   unsigned Ofs1 = FirstLdSt->getOperand(2).getImm();
1041   // Allow 6 bits of positive range.
1042   if (Ofs1 > 64)
1043     return false;
1044   // The caller should already have ordered First/SecondLdSt by offset.
1045   unsigned Ofs2 = SecondLdSt->getOperand(2).getImm();
1046   return Ofs1 + 1 == Ofs2;
1047 }
1048
1049 bool ARM64InstrInfo::shouldScheduleAdjacent(MachineInstr *First,
1050                                             MachineInstr *Second) const {
1051   // Cyclone can fuse CMN, CMP followed by Bcc.
1052
1053   // FIXME: B0 can also fuse:
1054   // AND, BIC, ORN, ORR, or EOR (optional S) followed by Bcc or CBZ or CBNZ.
1055   if (Second->getOpcode() != ARM64::Bcc)
1056     return false;
1057   switch (First->getOpcode()) {
1058   default:
1059     return false;
1060   case ARM64::SUBSWri:
1061   case ARM64::ADDSWri:
1062   case ARM64::ANDSWri:
1063   case ARM64::SUBSXri:
1064   case ARM64::ADDSXri:
1065   case ARM64::ANDSXri:
1066     return true;
1067   }
1068 }
1069
1070 MachineInstr *ARM64InstrInfo::emitFrameIndexDebugValue(MachineFunction &MF,
1071                                                        int FrameIx,
1072                                                        uint64_t Offset,
1073                                                        const MDNode *MDPtr,
1074                                                        DebugLoc DL) const {
1075   MachineInstrBuilder MIB = BuildMI(MF, DL, get(ARM64::DBG_VALUE))
1076                                 .addFrameIndex(FrameIx)
1077                                 .addImm(0)
1078                                 .addImm(Offset)
1079                                 .addMetadata(MDPtr);
1080   return &*MIB;
1081 }
1082
1083 static const MachineInstrBuilder &AddSubReg(const MachineInstrBuilder &MIB,
1084                                             unsigned Reg, unsigned SubIdx,
1085                                             unsigned State,
1086                                             const TargetRegisterInfo *TRI) {
1087   if (!SubIdx)
1088     return MIB.addReg(Reg, State);
1089
1090   if (TargetRegisterInfo::isPhysicalRegister(Reg))
1091     return MIB.addReg(TRI->getSubReg(Reg, SubIdx), State);
1092   return MIB.addReg(Reg, State, SubIdx);
1093 }
1094
1095 static bool forwardCopyWillClobberTuple(unsigned DestReg, unsigned SrcReg,
1096                                         unsigned NumRegs) {
1097   // We really want the positive remainder mod 32 here, that happens to be
1098   // easily obtainable with a mask.
1099   return ((DestReg - SrcReg) & 0x1f) < NumRegs;
1100 }
1101
1102 void ARM64InstrInfo::copyPhysRegTuple(MachineBasicBlock &MBB,
1103                                       MachineBasicBlock::iterator I,
1104                                       DebugLoc DL, unsigned DestReg,
1105                                       unsigned SrcReg, bool KillSrc,
1106                                       unsigned Opcode,
1107                                       llvm::ArrayRef<unsigned> Indices) const {
1108   const TargetRegisterInfo *TRI = &getRegisterInfo();
1109   uint16_t DestEncoding = TRI->getEncodingValue(DestReg);
1110   uint16_t SrcEncoding = TRI->getEncodingValue(SrcReg);
1111   unsigned NumRegs = Indices.size();
1112
1113   int SubReg = 0, End = NumRegs, Incr = 1;
1114   if (forwardCopyWillClobberTuple(DestEncoding, SrcEncoding, NumRegs)) {
1115     SubReg = NumRegs - 1;
1116     End = -1;
1117     Incr = -1;
1118   }
1119
1120   for (; SubReg != End; SubReg += Incr) {
1121     const MachineInstrBuilder &MIB = BuildMI(MBB, I, DL, get(Opcode));
1122     AddSubReg(MIB, DestReg, Indices[SubReg], RegState::Define, TRI);
1123     AddSubReg(MIB, SrcReg, Indices[SubReg], 0, TRI);
1124     AddSubReg(MIB, SrcReg, Indices[SubReg], getKillRegState(KillSrc), TRI);
1125   }
1126 }
1127
1128 void ARM64InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
1129                                  MachineBasicBlock::iterator I, DebugLoc DL,
1130                                  unsigned DestReg, unsigned SrcReg,
1131                                  bool KillSrc) const {
1132   if (ARM64::GPR32spRegClass.contains(DestReg) &&
1133       (ARM64::GPR32spRegClass.contains(SrcReg) || SrcReg == ARM64::WZR)) {
1134     const TargetRegisterInfo *TRI = &getRegisterInfo();
1135
1136     if (DestReg == ARM64::WSP || SrcReg == ARM64::WSP) {
1137       // If either operand is WSP, expand to ADD #0.
1138       if (Subtarget.hasZeroCycleRegMove()) {
1139         // Cyclone recognizes "ADD Xd, Xn, #0" as a zero-cycle register move.
1140         unsigned DestRegX = TRI->getMatchingSuperReg(DestReg, ARM64::sub_32,
1141                                                      &ARM64::GPR64spRegClass);
1142         unsigned SrcRegX = TRI->getMatchingSuperReg(SrcReg, ARM64::sub_32,
1143                                                     &ARM64::GPR64spRegClass);
1144         // This instruction is reading and writing X registers.  This may upset
1145         // the register scavenger and machine verifier, so we need to indicate
1146         // that we are reading an undefined value from SrcRegX, but a proper
1147         // value from SrcReg.
1148         BuildMI(MBB, I, DL, get(ARM64::ADDXri), DestRegX)
1149             .addReg(SrcRegX, RegState::Undef)
1150             .addImm(0)
1151             .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, 0))
1152             .addReg(SrcReg, RegState::Implicit | getKillRegState(KillSrc));
1153       } else {
1154         BuildMI(MBB, I, DL, get(ARM64::ADDWri), DestReg)
1155             .addReg(SrcReg, getKillRegState(KillSrc))
1156             .addImm(0)
1157             .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, 0));
1158       }
1159     } else if (SrcReg == ARM64::WZR && Subtarget.hasZeroCycleZeroing()) {
1160       BuildMI(MBB, I, DL, get(ARM64::MOVZWi), DestReg).addImm(0).addImm(
1161           ARM64_AM::getShifterImm(ARM64_AM::LSL, 0));
1162     } else {
1163       if (Subtarget.hasZeroCycleRegMove()) {
1164         // Cyclone recognizes "ORR Xd, XZR, Xm" as a zero-cycle register move.
1165         unsigned DestRegX = TRI->getMatchingSuperReg(DestReg, ARM64::sub_32,
1166                                                      &ARM64::GPR64spRegClass);
1167         unsigned SrcRegX = TRI->getMatchingSuperReg(SrcReg, ARM64::sub_32,
1168                                                     &ARM64::GPR64spRegClass);
1169         // This instruction is reading and writing X registers.  This may upset
1170         // the register scavenger and machine verifier, so we need to indicate
1171         // that we are reading an undefined value from SrcRegX, but a proper
1172         // value from SrcReg.
1173         BuildMI(MBB, I, DL, get(ARM64::ORRXrr), DestRegX)
1174             .addReg(ARM64::XZR)
1175             .addReg(SrcRegX, RegState::Undef)
1176             .addReg(SrcReg, RegState::Implicit | getKillRegState(KillSrc));
1177       } else {
1178         // Otherwise, expand to ORR WZR.
1179         BuildMI(MBB, I, DL, get(ARM64::ORRWrr), DestReg)
1180             .addReg(ARM64::WZR)
1181             .addReg(SrcReg, getKillRegState(KillSrc));
1182       }
1183     }
1184     return;
1185   }
1186
1187   if (ARM64::GPR64spRegClass.contains(DestReg) &&
1188       (ARM64::GPR64spRegClass.contains(SrcReg) || SrcReg == ARM64::XZR)) {
1189     if (DestReg == ARM64::SP || SrcReg == ARM64::SP) {
1190       // If either operand is SP, expand to ADD #0.
1191       BuildMI(MBB, I, DL, get(ARM64::ADDXri), DestReg)
1192           .addReg(SrcReg, getKillRegState(KillSrc))
1193           .addImm(0)
1194           .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, 0));
1195     } else if (SrcReg == ARM64::XZR && Subtarget.hasZeroCycleZeroing()) {
1196       BuildMI(MBB, I, DL, get(ARM64::MOVZXi), DestReg).addImm(0).addImm(
1197           ARM64_AM::getShifterImm(ARM64_AM::LSL, 0));
1198     } else {
1199       // Otherwise, expand to ORR XZR.
1200       BuildMI(MBB, I, DL, get(ARM64::ORRXrr), DestReg)
1201           .addReg(ARM64::XZR)
1202           .addReg(SrcReg, getKillRegState(KillSrc));
1203     }
1204     return;
1205   }
1206
1207   // Copy a DDDD register quad by copying the individual sub-registers.
1208   if (ARM64::DDDDRegClass.contains(DestReg) &&
1209       ARM64::DDDDRegClass.contains(SrcReg)) {
1210     static const unsigned Indices[] = { ARM64::dsub0, ARM64::dsub1,
1211                                         ARM64::dsub2, ARM64::dsub3 };
1212     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv8i8,
1213                      Indices);
1214     return;
1215   }
1216
1217   // Copy a DDD register triple by copying the individual sub-registers.
1218   if (ARM64::DDDRegClass.contains(DestReg) &&
1219       ARM64::DDDRegClass.contains(SrcReg)) {
1220     static const unsigned Indices[] = { ARM64::dsub0, ARM64::dsub1,
1221                                         ARM64::dsub2 };
1222     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv8i8,
1223                      Indices);
1224     return;
1225   }
1226
1227   // Copy a DD register pair by copying the individual sub-registers.
1228   if (ARM64::DDRegClass.contains(DestReg) &&
1229       ARM64::DDRegClass.contains(SrcReg)) {
1230     static const unsigned Indices[] = { ARM64::dsub0, ARM64::dsub1 };
1231     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv8i8,
1232                      Indices);
1233     return;
1234   }
1235
1236   // Copy a QQQQ register quad by copying the individual sub-registers.
1237   if (ARM64::QQQQRegClass.contains(DestReg) &&
1238       ARM64::QQQQRegClass.contains(SrcReg)) {
1239     static const unsigned Indices[] = { ARM64::qsub0, ARM64::qsub1,
1240                                         ARM64::qsub2, ARM64::qsub3 };
1241     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv16i8,
1242                      Indices);
1243     return;
1244   }
1245
1246   // Copy a QQQ register triple by copying the individual sub-registers.
1247   if (ARM64::QQQRegClass.contains(DestReg) &&
1248       ARM64::QQQRegClass.contains(SrcReg)) {
1249     static const unsigned Indices[] = { ARM64::qsub0, ARM64::qsub1,
1250                                         ARM64::qsub2 };
1251     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv16i8,
1252                      Indices);
1253     return;
1254   }
1255
1256   // Copy a QQ register pair by copying the individual sub-registers.
1257   if (ARM64::QQRegClass.contains(DestReg) &&
1258       ARM64::QQRegClass.contains(SrcReg)) {
1259     static const unsigned Indices[] = { ARM64::qsub0, ARM64::qsub1 };
1260     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv16i8,
1261                      Indices);
1262     return;
1263   }
1264
1265   if (ARM64::FPR128RegClass.contains(DestReg) &&
1266       ARM64::FPR128RegClass.contains(SrcReg)) {
1267     BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1268         SrcReg, getKillRegState(KillSrc));
1269     return;
1270   }
1271
1272   if (ARM64::FPR64RegClass.contains(DestReg) &&
1273       ARM64::FPR64RegClass.contains(SrcReg)) {
1274     DestReg =
1275         RI.getMatchingSuperReg(DestReg, ARM64::dsub, &ARM64::FPR128RegClass);
1276     SrcReg =
1277         RI.getMatchingSuperReg(SrcReg, ARM64::dsub, &ARM64::FPR128RegClass);
1278     BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1279         SrcReg, getKillRegState(KillSrc));
1280     return;
1281   }
1282
1283   if (ARM64::FPR32RegClass.contains(DestReg) &&
1284       ARM64::FPR32RegClass.contains(SrcReg)) {
1285     DestReg =
1286         RI.getMatchingSuperReg(DestReg, ARM64::ssub, &ARM64::FPR128RegClass);
1287     SrcReg =
1288         RI.getMatchingSuperReg(SrcReg, ARM64::ssub, &ARM64::FPR128RegClass);
1289     BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1290         SrcReg, getKillRegState(KillSrc));
1291     return;
1292   }
1293
1294   if (ARM64::FPR16RegClass.contains(DestReg) &&
1295       ARM64::FPR16RegClass.contains(SrcReg)) {
1296     DestReg =
1297         RI.getMatchingSuperReg(DestReg, ARM64::hsub, &ARM64::FPR128RegClass);
1298     SrcReg =
1299         RI.getMatchingSuperReg(SrcReg, ARM64::hsub, &ARM64::FPR128RegClass);
1300     BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1301         SrcReg, getKillRegState(KillSrc));
1302     return;
1303   }
1304
1305   if (ARM64::FPR8RegClass.contains(DestReg) &&
1306       ARM64::FPR8RegClass.contains(SrcReg)) {
1307     DestReg =
1308         RI.getMatchingSuperReg(DestReg, ARM64::bsub, &ARM64::FPR128RegClass);
1309     SrcReg =
1310         RI.getMatchingSuperReg(SrcReg, ARM64::bsub, &ARM64::FPR128RegClass);
1311     BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1312         SrcReg, getKillRegState(KillSrc));
1313     return;
1314   }
1315
1316   // Copies between GPR64 and FPR64.
1317   if (ARM64::FPR64RegClass.contains(DestReg) &&
1318       ARM64::GPR64RegClass.contains(SrcReg)) {
1319     BuildMI(MBB, I, DL, get(ARM64::FMOVXDr), DestReg)
1320         .addReg(SrcReg, getKillRegState(KillSrc));
1321     return;
1322   }
1323   if (ARM64::GPR64RegClass.contains(DestReg) &&
1324       ARM64::FPR64RegClass.contains(SrcReg)) {
1325     BuildMI(MBB, I, DL, get(ARM64::FMOVDXr), DestReg)
1326         .addReg(SrcReg, getKillRegState(KillSrc));
1327     return;
1328   }
1329   // Copies between GPR32 and FPR32.
1330   if (ARM64::FPR32RegClass.contains(DestReg) &&
1331       ARM64::GPR32RegClass.contains(SrcReg)) {
1332     BuildMI(MBB, I, DL, get(ARM64::FMOVWSr), DestReg)
1333         .addReg(SrcReg, getKillRegState(KillSrc));
1334     return;
1335   }
1336   if (ARM64::GPR32RegClass.contains(DestReg) &&
1337       ARM64::FPR32RegClass.contains(SrcReg)) {
1338     BuildMI(MBB, I, DL, get(ARM64::FMOVSWr), DestReg)
1339         .addReg(SrcReg, getKillRegState(KillSrc));
1340     return;
1341   }
1342
1343   assert(0 && "unimplemented reg-to-reg copy");
1344 }
1345
1346 void ARM64InstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
1347                                          MachineBasicBlock::iterator MBBI,
1348                                          unsigned SrcReg, bool isKill, int FI,
1349                                          const TargetRegisterClass *RC,
1350                                          const TargetRegisterInfo *TRI) const {
1351   DebugLoc DL;
1352   if (MBBI != MBB.end())
1353     DL = MBBI->getDebugLoc();
1354   MachineFunction &MF = *MBB.getParent();
1355   MachineFrameInfo &MFI = *MF.getFrameInfo();
1356   unsigned Align = MFI.getObjectAlignment(FI);
1357
1358   MachinePointerInfo PtrInfo(PseudoSourceValue::getFixedStack(FI));
1359   MachineMemOperand *MMO = MF.getMachineMemOperand(
1360       PtrInfo, MachineMemOperand::MOStore, MFI.getObjectSize(FI), Align);
1361   unsigned Opc = 0;
1362   bool Offset = true;
1363   switch (RC->getSize()) {
1364   case 1:
1365     if (ARM64::FPR8RegClass.hasSubClassEq(RC))
1366       Opc = ARM64::STRBui;
1367     break;
1368   case 2:
1369     if (ARM64::FPR16RegClass.hasSubClassEq(RC))
1370       Opc = ARM64::STRHui;
1371     break;
1372   case 4:
1373     if (ARM64::GPR32allRegClass.hasSubClassEq(RC)) {
1374       Opc = ARM64::STRWui;
1375       if (TargetRegisterInfo::isVirtualRegister(SrcReg))
1376         MF.getRegInfo().constrainRegClass(SrcReg, &ARM64::GPR32RegClass);
1377       else
1378         assert(SrcReg != ARM64::WSP);
1379     } else if (ARM64::FPR32RegClass.hasSubClassEq(RC))
1380       Opc = ARM64::STRSui;
1381     break;
1382   case 8:
1383     if (ARM64::GPR64allRegClass.hasSubClassEq(RC)) {
1384       Opc = ARM64::STRXui;
1385       if (TargetRegisterInfo::isVirtualRegister(SrcReg))
1386         MF.getRegInfo().constrainRegClass(SrcReg, &ARM64::GPR64RegClass);
1387       else
1388         assert(SrcReg != ARM64::SP);
1389     } else if (ARM64::FPR64RegClass.hasSubClassEq(RC))
1390       Opc = ARM64::STRDui;
1391     break;
1392   case 16:
1393     if (ARM64::FPR128RegClass.hasSubClassEq(RC))
1394       Opc = ARM64::STRQui;
1395     else if (ARM64::DDRegClass.hasSubClassEq(RC))
1396       Opc = ARM64::ST1Twov1d, Offset = false;
1397     break;
1398   case 24:
1399     if (ARM64::DDDRegClass.hasSubClassEq(RC))
1400       Opc = ARM64::ST1Threev1d, Offset = false;
1401     break;
1402   case 32:
1403     if (ARM64::DDDDRegClass.hasSubClassEq(RC))
1404       Opc = ARM64::ST1Fourv1d, Offset = false;
1405     else if (ARM64::QQRegClass.hasSubClassEq(RC))
1406       Opc = ARM64::ST1Twov2d, Offset = false;
1407     break;
1408   case 48:
1409     if (ARM64::QQQRegClass.hasSubClassEq(RC))
1410       Opc = ARM64::ST1Threev2d, Offset = false;
1411     break;
1412   case 64:
1413     if (ARM64::QQQQRegClass.hasSubClassEq(RC))
1414       Opc = ARM64::ST1Fourv2d, Offset = false;
1415     break;
1416   }
1417   assert(Opc && "Unknown register class");
1418
1419   const MachineInstrBuilder &MI = BuildMI(MBB, MBBI, DL, get(Opc))
1420                                       .addReg(SrcReg, getKillRegState(isKill))
1421                                       .addFrameIndex(FI);
1422
1423   if (Offset)
1424     MI.addImm(0);
1425   MI.addMemOperand(MMO);
1426 }
1427
1428 void ARM64InstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
1429                                           MachineBasicBlock::iterator MBBI,
1430                                           unsigned DestReg, int FI,
1431                                           const TargetRegisterClass *RC,
1432                                           const TargetRegisterInfo *TRI) const {
1433   DebugLoc DL;
1434   if (MBBI != MBB.end())
1435     DL = MBBI->getDebugLoc();
1436   MachineFunction &MF = *MBB.getParent();
1437   MachineFrameInfo &MFI = *MF.getFrameInfo();
1438   unsigned Align = MFI.getObjectAlignment(FI);
1439   MachinePointerInfo PtrInfo(PseudoSourceValue::getFixedStack(FI));
1440   MachineMemOperand *MMO = MF.getMachineMemOperand(
1441       PtrInfo, MachineMemOperand::MOLoad, MFI.getObjectSize(FI), Align);
1442
1443   unsigned Opc = 0;
1444   bool Offset = true;
1445   switch (RC->getSize()) {
1446   case 1:
1447     if (ARM64::FPR8RegClass.hasSubClassEq(RC))
1448       Opc = ARM64::LDRBui;
1449     break;
1450   case 2:
1451     if (ARM64::FPR16RegClass.hasSubClassEq(RC))
1452       Opc = ARM64::LDRHui;
1453     break;
1454   case 4:
1455     if (ARM64::GPR32allRegClass.hasSubClassEq(RC)) {
1456       Opc = ARM64::LDRWui;
1457       if (TargetRegisterInfo::isVirtualRegister(DestReg))
1458         MF.getRegInfo().constrainRegClass(DestReg, &ARM64::GPR32RegClass);
1459       else
1460         assert(DestReg != ARM64::WSP);
1461     } else if (ARM64::FPR32RegClass.hasSubClassEq(RC))
1462       Opc = ARM64::LDRSui;
1463     break;
1464   case 8:
1465     if (ARM64::GPR64allRegClass.hasSubClassEq(RC)) {
1466       Opc = ARM64::LDRXui;
1467       if (TargetRegisterInfo::isVirtualRegister(DestReg))
1468         MF.getRegInfo().constrainRegClass(DestReg, &ARM64::GPR64RegClass);
1469       else
1470         assert(DestReg != ARM64::SP);
1471     } else if (ARM64::FPR64RegClass.hasSubClassEq(RC))
1472       Opc = ARM64::LDRDui;
1473     break;
1474   case 16:
1475     if (ARM64::FPR128RegClass.hasSubClassEq(RC))
1476       Opc = ARM64::LDRQui;
1477     else if (ARM64::DDRegClass.hasSubClassEq(RC))
1478       Opc = ARM64::LD1Twov1d, Offset = false;
1479     break;
1480   case 24:
1481     if (ARM64::DDDRegClass.hasSubClassEq(RC))
1482       Opc = ARM64::LD1Threev1d, Offset = false;
1483     break;
1484   case 32:
1485     if (ARM64::DDDDRegClass.hasSubClassEq(RC))
1486       Opc = ARM64::LD1Fourv1d, Offset = false;
1487     else if (ARM64::QQRegClass.hasSubClassEq(RC))
1488       Opc = ARM64::LD1Twov2d, Offset = false;
1489     break;
1490   case 48:
1491     if (ARM64::QQQRegClass.hasSubClassEq(RC))
1492       Opc = ARM64::LD1Threev2d, Offset = false;
1493     break;
1494   case 64:
1495     if (ARM64::QQQQRegClass.hasSubClassEq(RC))
1496       Opc = ARM64::LD1Fourv2d, Offset = false;
1497     break;
1498   }
1499   assert(Opc && "Unknown register class");
1500
1501   const MachineInstrBuilder &MI = BuildMI(MBB, MBBI, DL, get(Opc))
1502                                       .addReg(DestReg, getDefRegState(true))
1503                                       .addFrameIndex(FI);
1504   if (Offset)
1505     MI.addImm(0);
1506   MI.addMemOperand(MMO);
1507 }
1508
1509 void llvm::emitFrameOffset(MachineBasicBlock &MBB,
1510                            MachineBasicBlock::iterator MBBI, DebugLoc DL,
1511                            unsigned DestReg, unsigned SrcReg, int Offset,
1512                            const ARM64InstrInfo *TII, MachineInstr::MIFlag Flag,
1513                            bool SetCPSR) {
1514   if (DestReg == SrcReg && Offset == 0)
1515     return;
1516
1517   bool isSub = Offset < 0;
1518   if (isSub)
1519     Offset = -Offset;
1520
1521   // FIXME: If the offset won't fit in 24-bits, compute the offset into a
1522   // scratch register.  If DestReg is a virtual register, use it as the
1523   // scratch register; otherwise, create a new virtual register (to be
1524   // replaced by the scavenger at the end of PEI).  That case can be optimized
1525   // slightly if DestReg is SP which is always 16-byte aligned, so the scratch
1526   // register can be loaded with offset%8 and the add/sub can use an extending
1527   // instruction with LSL#3.
1528   // Currently the function handles any offsets but generates a poor sequence
1529   // of code.
1530   //  assert(Offset < (1 << 24) && "unimplemented reg plus immediate");
1531
1532   unsigned Opc;
1533   if (SetCPSR)
1534     Opc = isSub ? ARM64::SUBSXri : ARM64::ADDSXri;
1535   else
1536     Opc = isSub ? ARM64::SUBXri : ARM64::ADDXri;
1537   const unsigned MaxEncoding = 0xfff;
1538   const unsigned ShiftSize = 12;
1539   const unsigned MaxEncodableValue = MaxEncoding << ShiftSize;
1540   while (((unsigned)Offset) >= (1 << ShiftSize)) {
1541     unsigned ThisVal;
1542     if (((unsigned)Offset) > MaxEncodableValue) {
1543       ThisVal = MaxEncodableValue;
1544     } else {
1545       ThisVal = Offset & MaxEncodableValue;
1546     }
1547     assert((ThisVal >> ShiftSize) <= MaxEncoding &&
1548            "Encoding cannot handle value that big");
1549     BuildMI(MBB, MBBI, DL, TII->get(Opc), DestReg)
1550         .addReg(SrcReg)
1551         .addImm(ThisVal >> ShiftSize)
1552         .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, ShiftSize))
1553         .setMIFlag(Flag);
1554
1555     SrcReg = DestReg;
1556     Offset -= ThisVal;
1557     if (Offset == 0)
1558       return;
1559   }
1560   BuildMI(MBB, MBBI, DL, TII->get(Opc), DestReg)
1561       .addReg(SrcReg)
1562       .addImm(Offset)
1563       .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, 0))
1564       .setMIFlag(Flag);
1565 }
1566
1567 MachineInstr *
1568 ARM64InstrInfo::foldMemoryOperandImpl(MachineFunction &MF, MachineInstr *MI,
1569                                       const SmallVectorImpl<unsigned> &Ops,
1570                                       int FrameIndex) const {
1571   // This is a bit of a hack. Consider this instruction:
1572   //
1573   //   %vreg0<def> = COPY %SP; GPR64all:%vreg0
1574   //
1575   // We explicitly chose GPR64all for the virtual register so such a copy might
1576   // be eliminated by RegisterCoalescer. However, that may not be possible, and
1577   // %vreg0 may even spill. We can't spill %SP, and since it is in the GPR64all
1578   // register class, TargetInstrInfo::foldMemoryOperand() is going to try.
1579   //
1580   // To prevent that, we are going to constrain the %vreg0 register class here.
1581   //
1582   // <rdar://problem/11522048>
1583   //
1584   if (MI->isCopy()) {
1585     unsigned DstReg = MI->getOperand(0).getReg();
1586     unsigned SrcReg = MI->getOperand(1).getReg();
1587     if (SrcReg == ARM64::SP && TargetRegisterInfo::isVirtualRegister(DstReg)) {
1588       MF.getRegInfo().constrainRegClass(DstReg, &ARM64::GPR64RegClass);
1589       return 0;
1590     }
1591     if (DstReg == ARM64::SP && TargetRegisterInfo::isVirtualRegister(SrcReg)) {
1592       MF.getRegInfo().constrainRegClass(SrcReg, &ARM64::GPR64RegClass);
1593       return 0;
1594     }
1595   }
1596
1597   // Cannot fold.
1598   return 0;
1599 }
1600
1601 int llvm::isARM64FrameOffsetLegal(const MachineInstr &MI, int &Offset,
1602                                   bool *OutUseUnscaledOp,
1603                                   unsigned *OutUnscaledOp,
1604                                   int *EmittableOffset) {
1605   int Scale = 1;
1606   bool IsSigned = false;
1607   // The ImmIdx should be changed case by case if it is not 2.
1608   unsigned ImmIdx = 2;
1609   unsigned UnscaledOp = 0;
1610   // Set output values in case of early exit.
1611   if (EmittableOffset)
1612     *EmittableOffset = 0;
1613   if (OutUseUnscaledOp)
1614     *OutUseUnscaledOp = false;
1615   if (OutUnscaledOp)
1616     *OutUnscaledOp = 0;
1617   switch (MI.getOpcode()) {
1618   default:
1619     assert(0 && "unhandled opcode in rewriteARM64FrameIndex");
1620   // Vector spills/fills can't take an immediate offset.
1621   case ARM64::LD1Twov2d:
1622   case ARM64::LD1Threev2d:
1623   case ARM64::LD1Fourv2d:
1624   case ARM64::LD1Twov1d:
1625   case ARM64::LD1Threev1d:
1626   case ARM64::LD1Fourv1d:
1627   case ARM64::ST1Twov2d:
1628   case ARM64::ST1Threev2d:
1629   case ARM64::ST1Fourv2d:
1630   case ARM64::ST1Twov1d:
1631   case ARM64::ST1Threev1d:
1632   case ARM64::ST1Fourv1d:
1633     return ARM64FrameOffsetCannotUpdate;
1634   case ARM64::PRFMui:
1635     Scale = 8;
1636     UnscaledOp = ARM64::PRFUMi;
1637     break;
1638   case ARM64::LDRXui:
1639     Scale = 8;
1640     UnscaledOp = ARM64::LDURXi;
1641     break;
1642   case ARM64::LDRWui:
1643     Scale = 4;
1644     UnscaledOp = ARM64::LDURWi;
1645     break;
1646   case ARM64::LDRBui:
1647     Scale = 1;
1648     UnscaledOp = ARM64::LDURBi;
1649     break;
1650   case ARM64::LDRHui:
1651     Scale = 2;
1652     UnscaledOp = ARM64::LDURHi;
1653     break;
1654   case ARM64::LDRSui:
1655     Scale = 4;
1656     UnscaledOp = ARM64::LDURSi;
1657     break;
1658   case ARM64::LDRDui:
1659     Scale = 8;
1660     UnscaledOp = ARM64::LDURDi;
1661     break;
1662   case ARM64::LDRQui:
1663     Scale = 16;
1664     UnscaledOp = ARM64::LDURQi;
1665     break;
1666   case ARM64::LDRBBui:
1667     Scale = 1;
1668     UnscaledOp = ARM64::LDURBBi;
1669     break;
1670   case ARM64::LDRHHui:
1671     Scale = 2;
1672     UnscaledOp = ARM64::LDURHHi;
1673     break;
1674   case ARM64::LDRSBXui:
1675     Scale = 1;
1676     UnscaledOp = ARM64::LDURSBXi;
1677     break;
1678   case ARM64::LDRSBWui:
1679     Scale = 1;
1680     UnscaledOp = ARM64::LDURSBWi;
1681     break;
1682   case ARM64::LDRSHXui:
1683     Scale = 2;
1684     UnscaledOp = ARM64::LDURSHXi;
1685     break;
1686   case ARM64::LDRSHWui:
1687     Scale = 2;
1688     UnscaledOp = ARM64::LDURSHWi;
1689     break;
1690   case ARM64::LDRSWui:
1691     Scale = 4;
1692     UnscaledOp = ARM64::LDURSWi;
1693     break;
1694
1695   case ARM64::STRXui:
1696     Scale = 8;
1697     UnscaledOp = ARM64::STURXi;
1698     break;
1699   case ARM64::STRWui:
1700     Scale = 4;
1701     UnscaledOp = ARM64::STURWi;
1702     break;
1703   case ARM64::STRBui:
1704     Scale = 1;
1705     UnscaledOp = ARM64::STURBi;
1706     break;
1707   case ARM64::STRHui:
1708     Scale = 2;
1709     UnscaledOp = ARM64::STURHi;
1710     break;
1711   case ARM64::STRSui:
1712     Scale = 4;
1713     UnscaledOp = ARM64::STURSi;
1714     break;
1715   case ARM64::STRDui:
1716     Scale = 8;
1717     UnscaledOp = ARM64::STURDi;
1718     break;
1719   case ARM64::STRQui:
1720     Scale = 16;
1721     UnscaledOp = ARM64::STURQi;
1722     break;
1723   case ARM64::STRBBui:
1724     Scale = 1;
1725     UnscaledOp = ARM64::STURBBi;
1726     break;
1727   case ARM64::STRHHui:
1728     Scale = 2;
1729     UnscaledOp = ARM64::STURHHi;
1730     break;
1731
1732   case ARM64::LDPXi:
1733   case ARM64::LDPDi:
1734   case ARM64::STPXi:
1735   case ARM64::STPDi:
1736     IsSigned = true;
1737     Scale = 8;
1738     break;
1739   case ARM64::LDPQi:
1740   case ARM64::STPQi:
1741     IsSigned = true;
1742     Scale = 16;
1743     break;
1744   case ARM64::LDPWi:
1745   case ARM64::LDPSi:
1746   case ARM64::STPWi:
1747   case ARM64::STPSi:
1748     IsSigned = true;
1749     Scale = 4;
1750     break;
1751
1752   case ARM64::LDURXi:
1753   case ARM64::LDURWi:
1754   case ARM64::LDURBi:
1755   case ARM64::LDURHi:
1756   case ARM64::LDURSi:
1757   case ARM64::LDURDi:
1758   case ARM64::LDURQi:
1759   case ARM64::LDURHHi:
1760   case ARM64::LDURBBi:
1761   case ARM64::LDURSBXi:
1762   case ARM64::LDURSBWi:
1763   case ARM64::LDURSHXi:
1764   case ARM64::LDURSHWi:
1765   case ARM64::LDURSWi:
1766   case ARM64::STURXi:
1767   case ARM64::STURWi:
1768   case ARM64::STURBi:
1769   case ARM64::STURHi:
1770   case ARM64::STURSi:
1771   case ARM64::STURDi:
1772   case ARM64::STURQi:
1773   case ARM64::STURBBi:
1774   case ARM64::STURHHi:
1775     Scale = 1;
1776     break;
1777   }
1778
1779   Offset += MI.getOperand(ImmIdx).getImm() * Scale;
1780
1781   bool useUnscaledOp = false;
1782   // If the offset doesn't match the scale, we rewrite the instruction to
1783   // use the unscaled instruction instead. Likewise, if we have a negative
1784   // offset (and have an unscaled op to use).
1785   if ((Offset & (Scale - 1)) != 0 || (Offset < 0 && UnscaledOp != 0))
1786     useUnscaledOp = true;
1787
1788   // Use an unscaled addressing mode if the instruction has a negative offset
1789   // (or if the instruction is already using an unscaled addressing mode).
1790   unsigned MaskBits;
1791   if (IsSigned) {
1792     // ldp/stp instructions.
1793     MaskBits = 7;
1794     Offset /= Scale;
1795   } else if (UnscaledOp == 0 || useUnscaledOp) {
1796     MaskBits = 9;
1797     IsSigned = true;
1798     Scale = 1;
1799   } else {
1800     MaskBits = 12;
1801     IsSigned = false;
1802     Offset /= Scale;
1803   }
1804
1805   // Attempt to fold address computation.
1806   int MaxOff = (1 << (MaskBits - IsSigned)) - 1;
1807   int MinOff = (IsSigned ? (-MaxOff - 1) : 0);
1808   if (Offset >= MinOff && Offset <= MaxOff) {
1809     if (EmittableOffset)
1810       *EmittableOffset = Offset;
1811     Offset = 0;
1812   } else {
1813     int NewOff = Offset < 0 ? MinOff : MaxOff;
1814     if (EmittableOffset)
1815       *EmittableOffset = NewOff;
1816     Offset = (Offset - NewOff) * Scale;
1817   }
1818   if (OutUseUnscaledOp)
1819     *OutUseUnscaledOp = useUnscaledOp;
1820   if (OutUnscaledOp)
1821     *OutUnscaledOp = UnscaledOp;
1822   return ARM64FrameOffsetCanUpdate |
1823          (Offset == 0 ? ARM64FrameOffsetIsLegal : 0);
1824 }
1825
1826 bool llvm::rewriteARM64FrameIndex(MachineInstr &MI, unsigned FrameRegIdx,
1827                                   unsigned FrameReg, int &Offset,
1828                                   const ARM64InstrInfo *TII) {
1829   unsigned Opcode = MI.getOpcode();
1830   unsigned ImmIdx = FrameRegIdx + 1;
1831
1832   if (Opcode == ARM64::ADDSXri || Opcode == ARM64::ADDXri) {
1833     Offset += MI.getOperand(ImmIdx).getImm();
1834     emitFrameOffset(*MI.getParent(), MI, MI.getDebugLoc(),
1835                     MI.getOperand(0).getReg(), FrameReg, Offset, TII,
1836                     MachineInstr::NoFlags, (Opcode == ARM64::ADDSXri));
1837     MI.eraseFromParent();
1838     Offset = 0;
1839     return true;
1840   }
1841
1842   int NewOffset;
1843   unsigned UnscaledOp;
1844   bool UseUnscaledOp;
1845   int Status = isARM64FrameOffsetLegal(MI, Offset, &UseUnscaledOp, &UnscaledOp,
1846                                        &NewOffset);
1847   if (Status & ARM64FrameOffsetCanUpdate) {
1848     if (Status & ARM64FrameOffsetIsLegal)
1849       // Replace the FrameIndex with FrameReg.
1850       MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
1851     if (UseUnscaledOp)
1852       MI.setDesc(TII->get(UnscaledOp));
1853
1854     MI.getOperand(ImmIdx).ChangeToImmediate(NewOffset);
1855     return Offset == 0;
1856   }
1857
1858   return false;
1859 }
1860
1861 void ARM64InstrInfo::getNoopForMachoTarget(MCInst &NopInst) const {
1862   NopInst.setOpcode(ARM64::HINT);
1863   NopInst.addOperand(MCOperand::CreateImm(0));
1864 }