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