lib/Target/ARM64/ARM64InstrInfo.cpp

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