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