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::LDRBBroW:
1043   case ARM64::LDRBroW:
1044   case ARM64::LDRDroW:
1045   case ARM64::LDRHHroW:
1046   case ARM64::LDRHroW:
1047   case ARM64::LDRQroW:
1048   case ARM64::LDRSBWroW:
1049   case ARM64::LDRSBXroW:
1050   case ARM64::LDRSHWroW:
1051   case ARM64::LDRSHXroW:
1052   case ARM64::LDRSWroW:
1053   case ARM64::LDRSroW:
1054   case ARM64::LDRWroW:
1055   case ARM64::LDRXroW:
1056   case ARM64::STRBBroW:
1057   case ARM64::STRBroW:
1058   case ARM64::STRDroW:
1059   case ARM64::STRHHroW:
1060   case ARM64::STRHroW:
1061   case ARM64::STRQroW:
1062   case ARM64::STRSroW:
1063   case ARM64::STRWroW:
1064   case ARM64::STRXroW:
1065   case ARM64::LDRBBroX:
1066   case ARM64::LDRBroX:
1067   case ARM64::LDRDroX:
1068   case ARM64::LDRHHroX:
1069   case ARM64::LDRHroX:
1070   case ARM64::LDRQroX:
1071   case ARM64::LDRSBWroX:
1072   case ARM64::LDRSBXroX:
1073   case ARM64::LDRSHWroX:
1074   case ARM64::LDRSHXroX:
1075   case ARM64::LDRSWroX:
1076   case ARM64::LDRSroX:
1077   case ARM64::LDRWroX:
1078   case ARM64::LDRXroX:
1079   case ARM64::STRBBroX:
1080   case ARM64::STRBroX:
1081   case ARM64::STRDroX:
1082   case ARM64::STRHHroX:
1083   case ARM64::STRHroX:
1084   case ARM64::STRQroX:
1085   case ARM64::STRSroX:
1086   case ARM64::STRWroX:
1087   case ARM64::STRXroX:
1088
1089     unsigned Val = MI->getOperand(3).getImm();
1090     ARM64_AM::ShiftExtendType ExtType = ARM64_AM::getMemExtendType(Val);
1091     return (ExtType != ARM64_AM::UXTX) || ARM64_AM::getMemDoShift(Val);
1092   }
1093   return false;
1094 }
1095
1096 /// Check all MachineMemOperands for a hint to suppress pairing.
1097 bool ARM64InstrInfo::isLdStPairSuppressed(const MachineInstr *MI) const {
1098   assert(MOSuppressPair < (1 << MachineMemOperand::MOTargetNumBits) &&
1099          "Too many target MO flags");
1100   for (auto *MM : MI->memoperands()) {
1101     if (MM->getFlags() &
1102         (MOSuppressPair << MachineMemOperand::MOTargetStartBit)) {
1103       return true;
1104     }
1105   }
1106   return false;
1107 }
1108
1109 /// Set a flag on the first MachineMemOperand to suppress pairing.
1110 void ARM64InstrInfo::suppressLdStPair(MachineInstr *MI) const {
1111   if (MI->memoperands_empty())
1112     return;
1113
1114   assert(MOSuppressPair < (1 << MachineMemOperand::MOTargetNumBits) &&
1115          "Too many target MO flags");
1116   (*MI->memoperands_begin())
1117       ->setFlags(MOSuppressPair << MachineMemOperand::MOTargetStartBit);
1118 }
1119
1120 bool ARM64InstrInfo::getLdStBaseRegImmOfs(MachineInstr *LdSt, unsigned &BaseReg,
1121                                           unsigned &Offset,
1122                                           const TargetRegisterInfo *TRI) const {
1123   switch (LdSt->getOpcode()) {
1124   default:
1125     return false;
1126   case ARM64::STRSui:
1127   case ARM64::STRDui:
1128   case ARM64::STRQui:
1129   case ARM64::STRXui:
1130   case ARM64::STRWui:
1131   case ARM64::LDRSui:
1132   case ARM64::LDRDui:
1133   case ARM64::LDRQui:
1134   case ARM64::LDRXui:
1135   case ARM64::LDRWui:
1136     if (!LdSt->getOperand(1).isReg() || !LdSt->getOperand(2).isImm())
1137       return false;
1138     BaseReg = LdSt->getOperand(1).getReg();
1139     MachineFunction &MF = *LdSt->getParent()->getParent();
1140     unsigned Width = getRegClass(LdSt->getDesc(), 0, TRI, MF)->getSize();
1141     Offset = LdSt->getOperand(2).getImm() * Width;
1142     return true;
1143   };
1144 }
1145
1146 /// Detect opportunities for ldp/stp formation.
1147 ///
1148 /// Only called for LdSt for which getLdStBaseRegImmOfs returns true.
1149 bool ARM64InstrInfo::shouldClusterLoads(MachineInstr *FirstLdSt,
1150                                         MachineInstr *SecondLdSt,
1151                                         unsigned NumLoads) const {
1152   // Only cluster up to a single pair.
1153   if (NumLoads > 1)
1154     return false;
1155   if (FirstLdSt->getOpcode() != SecondLdSt->getOpcode())
1156     return false;
1157   // getLdStBaseRegImmOfs guarantees that oper 2 isImm.
1158   unsigned Ofs1 = FirstLdSt->getOperand(2).getImm();
1159   // Allow 6 bits of positive range.
1160   if (Ofs1 > 64)
1161     return false;
1162   // The caller should already have ordered First/SecondLdSt by offset.
1163   unsigned Ofs2 = SecondLdSt->getOperand(2).getImm();
1164   return Ofs1 + 1 == Ofs2;
1165 }
1166
1167 bool ARM64InstrInfo::shouldScheduleAdjacent(MachineInstr *First,
1168                                             MachineInstr *Second) const {
1169   // Cyclone can fuse CMN, CMP followed by Bcc.
1170
1171   // FIXME: B0 can also fuse:
1172   // AND, BIC, ORN, ORR, or EOR (optional S) followed by Bcc or CBZ or CBNZ.
1173   if (Second->getOpcode() != ARM64::Bcc)
1174     return false;
1175   switch (First->getOpcode()) {
1176   default:
1177     return false;
1178   case ARM64::SUBSWri:
1179   case ARM64::ADDSWri:
1180   case ARM64::ANDSWri:
1181   case ARM64::SUBSXri:
1182   case ARM64::ADDSXri:
1183   case ARM64::ANDSXri:
1184     return true;
1185   }
1186 }
1187
1188 MachineInstr *ARM64InstrInfo::emitFrameIndexDebugValue(MachineFunction &MF,
1189                                                        int FrameIx,
1190                                                        uint64_t Offset,
1191                                                        const MDNode *MDPtr,
1192                                                        DebugLoc DL) const {
1193   MachineInstrBuilder MIB = BuildMI(MF, DL, get(ARM64::DBG_VALUE))
1194                                 .addFrameIndex(FrameIx)
1195                                 .addImm(0)
1196                                 .addImm(Offset)
1197                                 .addMetadata(MDPtr);
1198   return &*MIB;
1199 }
1200
1201 static const MachineInstrBuilder &AddSubReg(const MachineInstrBuilder &MIB,
1202                                             unsigned Reg, unsigned SubIdx,
1203                                             unsigned State,
1204                                             const TargetRegisterInfo *TRI) {
1205   if (!SubIdx)
1206     return MIB.addReg(Reg, State);
1207
1208   if (TargetRegisterInfo::isPhysicalRegister(Reg))
1209     return MIB.addReg(TRI->getSubReg(Reg, SubIdx), State);
1210   return MIB.addReg(Reg, State, SubIdx);
1211 }
1212
1213 static bool forwardCopyWillClobberTuple(unsigned DestReg, unsigned SrcReg,
1214                                         unsigned NumRegs) {
1215   // We really want the positive remainder mod 32 here, that happens to be
1216   // easily obtainable with a mask.
1217   return ((DestReg - SrcReg) & 0x1f) < NumRegs;
1218 }
1219
1220 void ARM64InstrInfo::copyPhysRegTuple(MachineBasicBlock &MBB,
1221                                       MachineBasicBlock::iterator I,
1222                                       DebugLoc DL, unsigned DestReg,
1223                                       unsigned SrcReg, bool KillSrc,
1224                                       unsigned Opcode,
1225                                       llvm::ArrayRef<unsigned> Indices) const {
1226   assert(getSubTarget().hasNEON() &&
1227          "Unexpected register copy without NEON");
1228   const TargetRegisterInfo *TRI = &getRegisterInfo();
1229   uint16_t DestEncoding = TRI->getEncodingValue(DestReg);
1230   uint16_t SrcEncoding = TRI->getEncodingValue(SrcReg);
1231   unsigned NumRegs = Indices.size();
1232
1233   int SubReg = 0, End = NumRegs, Incr = 1;
1234   if (forwardCopyWillClobberTuple(DestEncoding, SrcEncoding, NumRegs)) {
1235     SubReg = NumRegs - 1;
1236     End = -1;
1237     Incr = -1;
1238   }
1239
1240   for (; SubReg != End; SubReg += Incr) {
1241     const MachineInstrBuilder &MIB = BuildMI(MBB, I, DL, get(Opcode));
1242     AddSubReg(MIB, DestReg, Indices[SubReg], RegState::Define, TRI);
1243     AddSubReg(MIB, SrcReg, Indices[SubReg], 0, TRI);
1244     AddSubReg(MIB, SrcReg, Indices[SubReg], getKillRegState(KillSrc), TRI);
1245   }
1246 }
1247
1248 void ARM64InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
1249                                  MachineBasicBlock::iterator I, DebugLoc DL,
1250                                  unsigned DestReg, unsigned SrcReg,
1251                                  bool KillSrc) const {
1252   if (ARM64::GPR32spRegClass.contains(DestReg) &&
1253       (ARM64::GPR32spRegClass.contains(SrcReg) || SrcReg == ARM64::WZR)) {
1254     const TargetRegisterInfo *TRI = &getRegisterInfo();
1255
1256     if (DestReg == ARM64::WSP || SrcReg == ARM64::WSP) {
1257       // If either operand is WSP, expand to ADD #0.
1258       if (Subtarget.hasZeroCycleRegMove()) {
1259         // Cyclone recognizes "ADD Xd, Xn, #0" as a zero-cycle register move.
1260         unsigned DestRegX = TRI->getMatchingSuperReg(DestReg, ARM64::sub_32,
1261                                                      &ARM64::GPR64spRegClass);
1262         unsigned SrcRegX = TRI->getMatchingSuperReg(SrcReg, ARM64::sub_32,
1263                                                     &ARM64::GPR64spRegClass);
1264         // This instruction is reading and writing X registers.  This may upset
1265         // the register scavenger and machine verifier, so we need to indicate
1266         // that we are reading an undefined value from SrcRegX, but a proper
1267         // value from SrcReg.
1268         BuildMI(MBB, I, DL, get(ARM64::ADDXri), DestRegX)
1269             .addReg(SrcRegX, RegState::Undef)
1270             .addImm(0)
1271             .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, 0))
1272             .addReg(SrcReg, RegState::Implicit | getKillRegState(KillSrc));
1273       } else {
1274         BuildMI(MBB, I, DL, get(ARM64::ADDWri), DestReg)
1275             .addReg(SrcReg, getKillRegState(KillSrc))
1276             .addImm(0)
1277             .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, 0));
1278       }
1279     } else if (SrcReg == ARM64::WZR && Subtarget.hasZeroCycleZeroing()) {
1280       BuildMI(MBB, I, DL, get(ARM64::MOVZWi), DestReg).addImm(0).addImm(
1281           ARM64_AM::getShifterImm(ARM64_AM::LSL, 0));
1282     } else {
1283       if (Subtarget.hasZeroCycleRegMove()) {
1284         // Cyclone recognizes "ORR Xd, XZR, Xm" as a zero-cycle register move.
1285         unsigned DestRegX = TRI->getMatchingSuperReg(DestReg, ARM64::sub_32,
1286                                                      &ARM64::GPR64spRegClass);
1287         unsigned SrcRegX = TRI->getMatchingSuperReg(SrcReg, ARM64::sub_32,
1288                                                     &ARM64::GPR64spRegClass);
1289         // This instruction is reading and writing X registers.  This may upset
1290         // the register scavenger and machine verifier, so we need to indicate
1291         // that we are reading an undefined value from SrcRegX, but a proper
1292         // value from SrcReg.
1293         BuildMI(MBB, I, DL, get(ARM64::ORRXrr), DestRegX)
1294             .addReg(ARM64::XZR)
1295             .addReg(SrcRegX, RegState::Undef)
1296             .addReg(SrcReg, RegState::Implicit | getKillRegState(KillSrc));
1297       } else {
1298         // Otherwise, expand to ORR WZR.
1299         BuildMI(MBB, I, DL, get(ARM64::ORRWrr), DestReg)
1300             .addReg(ARM64::WZR)
1301             .addReg(SrcReg, getKillRegState(KillSrc));
1302       }
1303     }
1304     return;
1305   }
1306
1307   if (ARM64::GPR64spRegClass.contains(DestReg) &&
1308       (ARM64::GPR64spRegClass.contains(SrcReg) || SrcReg == ARM64::XZR)) {
1309     if (DestReg == ARM64::SP || SrcReg == ARM64::SP) {
1310       // If either operand is SP, expand to ADD #0.
1311       BuildMI(MBB, I, DL, get(ARM64::ADDXri), DestReg)
1312           .addReg(SrcReg, getKillRegState(KillSrc))
1313           .addImm(0)
1314           .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, 0));
1315     } else if (SrcReg == ARM64::XZR && Subtarget.hasZeroCycleZeroing()) {
1316       BuildMI(MBB, I, DL, get(ARM64::MOVZXi), DestReg).addImm(0).addImm(
1317           ARM64_AM::getShifterImm(ARM64_AM::LSL, 0));
1318     } else {
1319       // Otherwise, expand to ORR XZR.
1320       BuildMI(MBB, I, DL, get(ARM64::ORRXrr), DestReg)
1321           .addReg(ARM64::XZR)
1322           .addReg(SrcReg, getKillRegState(KillSrc));
1323     }
1324     return;
1325   }
1326
1327   // Copy a DDDD register quad by copying the individual sub-registers.
1328   if (ARM64::DDDDRegClass.contains(DestReg) &&
1329       ARM64::DDDDRegClass.contains(SrcReg)) {
1330     static const unsigned Indices[] = { ARM64::dsub0, ARM64::dsub1,
1331                                         ARM64::dsub2, ARM64::dsub3 };
1332     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv8i8,
1333                      Indices);
1334     return;
1335   }
1336
1337   // Copy a DDD register triple by copying the individual sub-registers.
1338   if (ARM64::DDDRegClass.contains(DestReg) &&
1339       ARM64::DDDRegClass.contains(SrcReg)) {
1340     static const unsigned Indices[] = { ARM64::dsub0, ARM64::dsub1,
1341                                         ARM64::dsub2 };
1342     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv8i8,
1343                      Indices);
1344     return;
1345   }
1346
1347   // Copy a DD register pair by copying the individual sub-registers.
1348   if (ARM64::DDRegClass.contains(DestReg) &&
1349       ARM64::DDRegClass.contains(SrcReg)) {
1350     static const unsigned Indices[] = { ARM64::dsub0, ARM64::dsub1 };
1351     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv8i8,
1352                      Indices);
1353     return;
1354   }
1355
1356   // Copy a QQQQ register quad by copying the individual sub-registers.
1357   if (ARM64::QQQQRegClass.contains(DestReg) &&
1358       ARM64::QQQQRegClass.contains(SrcReg)) {
1359     static const unsigned Indices[] = { ARM64::qsub0, ARM64::qsub1,
1360                                         ARM64::qsub2, ARM64::qsub3 };
1361     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv16i8,
1362                      Indices);
1363     return;
1364   }
1365
1366   // Copy a QQQ register triple by copying the individual sub-registers.
1367   if (ARM64::QQQRegClass.contains(DestReg) &&
1368       ARM64::QQQRegClass.contains(SrcReg)) {
1369     static const unsigned Indices[] = { ARM64::qsub0, ARM64::qsub1,
1370                                         ARM64::qsub2 };
1371     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv16i8,
1372                      Indices);
1373     return;
1374   }
1375
1376   // Copy a QQ register pair by copying the individual sub-registers.
1377   if (ARM64::QQRegClass.contains(DestReg) &&
1378       ARM64::QQRegClass.contains(SrcReg)) {
1379     static const unsigned Indices[] = { ARM64::qsub0, ARM64::qsub1 };
1380     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, ARM64::ORRv16i8,
1381                      Indices);
1382     return;
1383   }
1384
1385   if (ARM64::FPR128RegClass.contains(DestReg) &&
1386       ARM64::FPR128RegClass.contains(SrcReg)) {
1387     if(getSubTarget().hasNEON()) {
1388       BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1389           SrcReg, getKillRegState(KillSrc));
1390     } else {
1391       BuildMI(MBB, I, DL, get(ARM64::STRQpre))
1392         .addReg(ARM64::SP, RegState::Define)
1393         .addReg(SrcReg, getKillRegState(KillSrc))
1394         .addReg(ARM64::SP)
1395         .addImm(-16);
1396       BuildMI(MBB, I, DL, get(ARM64::LDRQpre))
1397         .addReg(ARM64::SP, RegState::Define)
1398         .addReg(DestReg, RegState::Define)
1399         .addReg(ARM64::SP)
1400         .addImm(16);
1401     }
1402     return;
1403   }
1404
1405   if (ARM64::FPR64RegClass.contains(DestReg) &&
1406       ARM64::FPR64RegClass.contains(SrcReg)) {
1407     if(getSubTarget().hasNEON()) {
1408       DestReg =
1409           RI.getMatchingSuperReg(DestReg, ARM64::dsub, &ARM64::FPR128RegClass);
1410       SrcReg =
1411           RI.getMatchingSuperReg(SrcReg, ARM64::dsub, &ARM64::FPR128RegClass);
1412       BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1413           SrcReg, getKillRegState(KillSrc));
1414     } else {
1415       BuildMI(MBB, I, DL, get(ARM64::FMOVDr), DestReg)
1416           .addReg(SrcReg, getKillRegState(KillSrc));
1417     }
1418     return;
1419   }
1420
1421   if (ARM64::FPR32RegClass.contains(DestReg) &&
1422       ARM64::FPR32RegClass.contains(SrcReg)) {
1423     if(getSubTarget().hasNEON()) {
1424       DestReg =
1425           RI.getMatchingSuperReg(DestReg, ARM64::ssub, &ARM64::FPR128RegClass);
1426       SrcReg =
1427           RI.getMatchingSuperReg(SrcReg, ARM64::ssub, &ARM64::FPR128RegClass);
1428       BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1429           SrcReg, getKillRegState(KillSrc));
1430     } else {
1431       BuildMI(MBB, I, DL, get(ARM64::FMOVSr), DestReg)
1432           .addReg(SrcReg, getKillRegState(KillSrc));
1433     }
1434     return;
1435   }
1436
1437   if (ARM64::FPR16RegClass.contains(DestReg) &&
1438       ARM64::FPR16RegClass.contains(SrcReg)) {
1439     if(getSubTarget().hasNEON()) {
1440       DestReg =
1441           RI.getMatchingSuperReg(DestReg, ARM64::hsub, &ARM64::FPR128RegClass);
1442       SrcReg =
1443           RI.getMatchingSuperReg(SrcReg, ARM64::hsub, &ARM64::FPR128RegClass);
1444       BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1445           SrcReg, getKillRegState(KillSrc));
1446     } else {
1447       DestReg =
1448           RI.getMatchingSuperReg(DestReg, ARM64::hsub, &ARM64::FPR32RegClass);
1449       SrcReg =
1450           RI.getMatchingSuperReg(SrcReg, ARM64::hsub, &ARM64::FPR32RegClass);
1451       BuildMI(MBB, I, DL, get(ARM64::FMOVSr), DestReg)
1452           .addReg(SrcReg, getKillRegState(KillSrc));
1453     }
1454     return;
1455   }
1456
1457   if (ARM64::FPR8RegClass.contains(DestReg) &&
1458       ARM64::FPR8RegClass.contains(SrcReg)) {
1459     if(getSubTarget().hasNEON()) {
1460       DestReg =
1461           RI.getMatchingSuperReg(DestReg, ARM64::bsub, &ARM64::FPR128RegClass);
1462       SrcReg =
1463           RI.getMatchingSuperReg(SrcReg, ARM64::bsub, &ARM64::FPR128RegClass);
1464       BuildMI(MBB, I, DL, get(ARM64::ORRv16i8), DestReg).addReg(SrcReg).addReg(
1465           SrcReg, getKillRegState(KillSrc));
1466     } else {
1467       DestReg =
1468           RI.getMatchingSuperReg(DestReg, ARM64::bsub, &ARM64::FPR32RegClass);
1469       SrcReg =
1470           RI.getMatchingSuperReg(SrcReg, ARM64::bsub, &ARM64::FPR32RegClass);
1471       BuildMI(MBB, I, DL, get(ARM64::FMOVSr), DestReg)
1472           .addReg(SrcReg, getKillRegState(KillSrc));
1473     }
1474     return;
1475   }
1476
1477   // Copies between GPR64 and FPR64.
1478   if (ARM64::FPR64RegClass.contains(DestReg) &&
1479       ARM64::GPR64RegClass.contains(SrcReg)) {
1480     BuildMI(MBB, I, DL, get(ARM64::FMOVXDr), DestReg)
1481         .addReg(SrcReg, getKillRegState(KillSrc));
1482     return;
1483   }
1484   if (ARM64::GPR64RegClass.contains(DestReg) &&
1485       ARM64::FPR64RegClass.contains(SrcReg)) {
1486     BuildMI(MBB, I, DL, get(ARM64::FMOVDXr), DestReg)
1487         .addReg(SrcReg, getKillRegState(KillSrc));
1488     return;
1489   }
1490   // Copies between GPR32 and FPR32.
1491   if (ARM64::FPR32RegClass.contains(DestReg) &&
1492       ARM64::GPR32RegClass.contains(SrcReg)) {
1493     BuildMI(MBB, I, DL, get(ARM64::FMOVWSr), DestReg)
1494         .addReg(SrcReg, getKillRegState(KillSrc));
1495     return;
1496   }
1497   if (ARM64::GPR32RegClass.contains(DestReg) &&
1498       ARM64::FPR32RegClass.contains(SrcReg)) {
1499     BuildMI(MBB, I, DL, get(ARM64::FMOVSWr), DestReg)
1500         .addReg(SrcReg, getKillRegState(KillSrc));
1501     return;
1502   }
1503
1504   assert(0 && "unimplemented reg-to-reg copy");
1505 }
1506
1507 void ARM64InstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
1508                                          MachineBasicBlock::iterator MBBI,
1509                                          unsigned SrcReg, bool isKill, int FI,
1510                                          const TargetRegisterClass *RC,
1511                                          const TargetRegisterInfo *TRI) const {
1512   DebugLoc DL;
1513   if (MBBI != MBB.end())
1514     DL = MBBI->getDebugLoc();
1515   MachineFunction &MF = *MBB.getParent();
1516   MachineFrameInfo &MFI = *MF.getFrameInfo();
1517   unsigned Align = MFI.getObjectAlignment(FI);
1518
1519   MachinePointerInfo PtrInfo(PseudoSourceValue::getFixedStack(FI));
1520   MachineMemOperand *MMO = MF.getMachineMemOperand(
1521       PtrInfo, MachineMemOperand::MOStore, MFI.getObjectSize(FI), Align);
1522   unsigned Opc = 0;
1523   bool Offset = true;
1524   switch (RC->getSize()) {
1525   case 1:
1526     if (ARM64::FPR8RegClass.hasSubClassEq(RC))
1527       Opc = ARM64::STRBui;
1528     break;
1529   case 2:
1530     if (ARM64::FPR16RegClass.hasSubClassEq(RC))
1531       Opc = ARM64::STRHui;
1532     break;
1533   case 4:
1534     if (ARM64::GPR32allRegClass.hasSubClassEq(RC)) {
1535       Opc = ARM64::STRWui;
1536       if (TargetRegisterInfo::isVirtualRegister(SrcReg))
1537         MF.getRegInfo().constrainRegClass(SrcReg, &ARM64::GPR32RegClass);
1538       else
1539         assert(SrcReg != ARM64::WSP);
1540     } else if (ARM64::FPR32RegClass.hasSubClassEq(RC))
1541       Opc = ARM64::STRSui;
1542     break;
1543   case 8:
1544     if (ARM64::GPR64allRegClass.hasSubClassEq(RC)) {
1545       Opc = ARM64::STRXui;
1546       if (TargetRegisterInfo::isVirtualRegister(SrcReg))
1547         MF.getRegInfo().constrainRegClass(SrcReg, &ARM64::GPR64RegClass);
1548       else
1549         assert(SrcReg != ARM64::SP);
1550     } else if (ARM64::FPR64RegClass.hasSubClassEq(RC))
1551       Opc = ARM64::STRDui;
1552     break;
1553   case 16:
1554     if (ARM64::FPR128RegClass.hasSubClassEq(RC))
1555       Opc = ARM64::STRQui;
1556     else if (ARM64::DDRegClass.hasSubClassEq(RC)) {
1557       assert(getSubTarget().hasNEON() &&
1558              "Unexpected register store without NEON");
1559       Opc = ARM64::ST1Twov1d, Offset = false;
1560     }
1561     break;
1562   case 24:
1563     if (ARM64::DDDRegClass.hasSubClassEq(RC)) {
1564       assert(getSubTarget().hasNEON() &&
1565              "Unexpected register store without NEON");
1566       Opc = ARM64::ST1Threev1d, Offset = false;
1567     }
1568     break;
1569   case 32:
1570     if (ARM64::DDDDRegClass.hasSubClassEq(RC)) {
1571       assert(getSubTarget().hasNEON() &&
1572              "Unexpected register store without NEON");
1573       Opc = ARM64::ST1Fourv1d, Offset = false;
1574     } else if (ARM64::QQRegClass.hasSubClassEq(RC)) {
1575       assert(getSubTarget().hasNEON() &&
1576              "Unexpected register store without NEON");
1577       Opc = ARM64::ST1Twov2d, Offset = false;
1578     }
1579     break;
1580   case 48:
1581     if (ARM64::QQQRegClass.hasSubClassEq(RC)) {
1582       assert(getSubTarget().hasNEON() &&
1583              "Unexpected register store without NEON");
1584       Opc = ARM64::ST1Threev2d, Offset = false;
1585     }
1586     break;
1587   case 64:
1588     if (ARM64::QQQQRegClass.hasSubClassEq(RC)) {
1589       assert(getSubTarget().hasNEON() &&
1590              "Unexpected register store without NEON");
1591       Opc = ARM64::ST1Fourv2d, Offset = false;
1592     }
1593     break;
1594   }
1595   assert(Opc && "Unknown register class");
1596
1597   const MachineInstrBuilder &MI = BuildMI(MBB, MBBI, DL, get(Opc))
1598                                       .addReg(SrcReg, getKillRegState(isKill))
1599                                       .addFrameIndex(FI);
1600
1601   if (Offset)
1602     MI.addImm(0);
1603   MI.addMemOperand(MMO);
1604 }
1605
1606 void ARM64InstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
1607                                           MachineBasicBlock::iterator MBBI,
1608                                           unsigned DestReg, int FI,
1609                                           const TargetRegisterClass *RC,
1610                                           const TargetRegisterInfo *TRI) const {
1611   DebugLoc DL;
1612   if (MBBI != MBB.end())
1613     DL = MBBI->getDebugLoc();
1614   MachineFunction &MF = *MBB.getParent();
1615   MachineFrameInfo &MFI = *MF.getFrameInfo();
1616   unsigned Align = MFI.getObjectAlignment(FI);
1617   MachinePointerInfo PtrInfo(PseudoSourceValue::getFixedStack(FI));
1618   MachineMemOperand *MMO = MF.getMachineMemOperand(
1619       PtrInfo, MachineMemOperand::MOLoad, MFI.getObjectSize(FI), Align);
1620
1621   unsigned Opc = 0;
1622   bool Offset = true;
1623   switch (RC->getSize()) {
1624   case 1:
1625     if (ARM64::FPR8RegClass.hasSubClassEq(RC))
1626       Opc = ARM64::LDRBui;
1627     break;
1628   case 2:
1629     if (ARM64::FPR16RegClass.hasSubClassEq(RC))
1630       Opc = ARM64::LDRHui;
1631     break;
1632   case 4:
1633     if (ARM64::GPR32allRegClass.hasSubClassEq(RC)) {
1634       Opc = ARM64::LDRWui;
1635       if (TargetRegisterInfo::isVirtualRegister(DestReg))
1636         MF.getRegInfo().constrainRegClass(DestReg, &ARM64::GPR32RegClass);
1637       else
1638         assert(DestReg != ARM64::WSP);
1639     } else if (ARM64::FPR32RegClass.hasSubClassEq(RC))
1640       Opc = ARM64::LDRSui;
1641     break;
1642   case 8:
1643     if (ARM64::GPR64allRegClass.hasSubClassEq(RC)) {
1644       Opc = ARM64::LDRXui;
1645       if (TargetRegisterInfo::isVirtualRegister(DestReg))
1646         MF.getRegInfo().constrainRegClass(DestReg, &ARM64::GPR64RegClass);
1647       else
1648         assert(DestReg != ARM64::SP);
1649     } else if (ARM64::FPR64RegClass.hasSubClassEq(RC))
1650       Opc = ARM64::LDRDui;
1651     break;
1652   case 16:
1653     if (ARM64::FPR128RegClass.hasSubClassEq(RC))
1654       Opc = ARM64::LDRQui;
1655     else if (ARM64::DDRegClass.hasSubClassEq(RC)) {
1656       assert(getSubTarget().hasNEON() &&
1657              "Unexpected register load without NEON");
1658       Opc = ARM64::LD1Twov1d, Offset = false;
1659     }
1660     break;
1661   case 24:
1662     if (ARM64::DDDRegClass.hasSubClassEq(RC)) {
1663       assert(getSubTarget().hasNEON() &&
1664              "Unexpected register load without NEON");
1665       Opc = ARM64::LD1Threev1d, Offset = false;
1666     }
1667     break;
1668   case 32:
1669     if (ARM64::DDDDRegClass.hasSubClassEq(RC)) {
1670       assert(getSubTarget().hasNEON() &&
1671              "Unexpected register load without NEON");
1672       Opc = ARM64::LD1Fourv1d, Offset = false;
1673     } else if (ARM64::QQRegClass.hasSubClassEq(RC)) {
1674       assert(getSubTarget().hasNEON() &&
1675              "Unexpected register load without NEON");
1676       Opc = ARM64::LD1Twov2d, Offset = false;
1677     }
1678     break;
1679   case 48:
1680     if (ARM64::QQQRegClass.hasSubClassEq(RC)) {
1681       assert(getSubTarget().hasNEON() &&
1682              "Unexpected register load without NEON");
1683       Opc = ARM64::LD1Threev2d, Offset = false;
1684     }
1685     break;
1686   case 64:
1687     if (ARM64::QQQQRegClass.hasSubClassEq(RC)) {
1688       assert(getSubTarget().hasNEON() &&
1689              "Unexpected register load without NEON");
1690       Opc = ARM64::LD1Fourv2d, Offset = false;
1691     }
1692     break;
1693   }
1694   assert(Opc && "Unknown register class");
1695
1696   const MachineInstrBuilder &MI = BuildMI(MBB, MBBI, DL, get(Opc))
1697                                       .addReg(DestReg, getDefRegState(true))
1698                                       .addFrameIndex(FI);
1699   if (Offset)
1700     MI.addImm(0);
1701   MI.addMemOperand(MMO);
1702 }
1703
1704 void llvm::emitFrameOffset(MachineBasicBlock &MBB,
1705                            MachineBasicBlock::iterator MBBI, DebugLoc DL,
1706                            unsigned DestReg, unsigned SrcReg, int Offset,
1707                            const ARM64InstrInfo *TII, MachineInstr::MIFlag Flag,
1708                            bool SetNZCV) {
1709   if (DestReg == SrcReg && Offset == 0)
1710     return;
1711
1712   bool isSub = Offset < 0;
1713   if (isSub)
1714     Offset = -Offset;
1715
1716   // FIXME: If the offset won't fit in 24-bits, compute the offset into a
1717   // scratch register.  If DestReg is a virtual register, use it as the
1718   // scratch register; otherwise, create a new virtual register (to be
1719   // replaced by the scavenger at the end of PEI).  That case can be optimized
1720   // slightly if DestReg is SP which is always 16-byte aligned, so the scratch
1721   // register can be loaded with offset%8 and the add/sub can use an extending
1722   // instruction with LSL#3.
1723   // Currently the function handles any offsets but generates a poor sequence
1724   // of code.
1725   //  assert(Offset < (1 << 24) && "unimplemented reg plus immediate");
1726
1727   unsigned Opc;
1728   if (SetNZCV)
1729     Opc = isSub ? ARM64::SUBSXri : ARM64::ADDSXri;
1730   else
1731     Opc = isSub ? ARM64::SUBXri : ARM64::ADDXri;
1732   const unsigned MaxEncoding = 0xfff;
1733   const unsigned ShiftSize = 12;
1734   const unsigned MaxEncodableValue = MaxEncoding << ShiftSize;
1735   while (((unsigned)Offset) >= (1 << ShiftSize)) {
1736     unsigned ThisVal;
1737     if (((unsigned)Offset) > MaxEncodableValue) {
1738       ThisVal = MaxEncodableValue;
1739     } else {
1740       ThisVal = Offset & MaxEncodableValue;
1741     }
1742     assert((ThisVal >> ShiftSize) <= MaxEncoding &&
1743            "Encoding cannot handle value that big");
1744     BuildMI(MBB, MBBI, DL, TII->get(Opc), DestReg)
1745         .addReg(SrcReg)
1746         .addImm(ThisVal >> ShiftSize)
1747         .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, ShiftSize))
1748         .setMIFlag(Flag);
1749
1750     SrcReg = DestReg;
1751     Offset -= ThisVal;
1752     if (Offset == 0)
1753       return;
1754   }
1755   BuildMI(MBB, MBBI, DL, TII->get(Opc), DestReg)
1756       .addReg(SrcReg)
1757       .addImm(Offset)
1758       .addImm(ARM64_AM::getShifterImm(ARM64_AM::LSL, 0))
1759       .setMIFlag(Flag);
1760 }
1761
1762 MachineInstr *
1763 ARM64InstrInfo::foldMemoryOperandImpl(MachineFunction &MF, MachineInstr *MI,
1764                                       const SmallVectorImpl<unsigned> &Ops,
1765                                       int FrameIndex) const {
1766   // This is a bit of a hack. Consider this instruction:
1767   //
1768   //   %vreg0<def> = COPY %SP; GPR64all:%vreg0
1769   //
1770   // We explicitly chose GPR64all for the virtual register so such a copy might
1771   // be eliminated by RegisterCoalescer. However, that may not be possible, and
1772   // %vreg0 may even spill. We can't spill %SP, and since it is in the GPR64all
1773   // register class, TargetInstrInfo::foldMemoryOperand() is going to try.
1774   //
1775   // To prevent that, we are going to constrain the %vreg0 register class here.
1776   //
1777   // <rdar://problem/11522048>
1778   //
1779   if (MI->isCopy()) {
1780     unsigned DstReg = MI->getOperand(0).getReg();
1781     unsigned SrcReg = MI->getOperand(1).getReg();
1782     if (SrcReg == ARM64::SP && TargetRegisterInfo::isVirtualRegister(DstReg)) {
1783       MF.getRegInfo().constrainRegClass(DstReg, &ARM64::GPR64RegClass);
1784       return nullptr;
1785     }
1786     if (DstReg == ARM64::SP && TargetRegisterInfo::isVirtualRegister(SrcReg)) {
1787       MF.getRegInfo().constrainRegClass(SrcReg, &ARM64::GPR64RegClass);
1788       return nullptr;
1789     }
1790   }
1791
1792   // Cannot fold.
1793   return nullptr;
1794 }
1795
1796 int llvm::isARM64FrameOffsetLegal(const MachineInstr &MI, int &Offset,
1797                                   bool *OutUseUnscaledOp,
1798                                   unsigned *OutUnscaledOp,
1799                                   int *EmittableOffset) {
1800   int Scale = 1;
1801   bool IsSigned = false;
1802   // The ImmIdx should be changed case by case if it is not 2.
1803   unsigned ImmIdx = 2;
1804   unsigned UnscaledOp = 0;
1805   // Set output values in case of early exit.
1806   if (EmittableOffset)
1807     *EmittableOffset = 0;
1808   if (OutUseUnscaledOp)
1809     *OutUseUnscaledOp = false;
1810   if (OutUnscaledOp)
1811     *OutUnscaledOp = 0;
1812   switch (MI.getOpcode()) {
1813   default:
1814     assert(0 && "unhandled opcode in rewriteARM64FrameIndex");
1815   // Vector spills/fills can't take an immediate offset.
1816   case ARM64::LD1Twov2d:
1817   case ARM64::LD1Threev2d:
1818   case ARM64::LD1Fourv2d:
1819   case ARM64::LD1Twov1d:
1820   case ARM64::LD1Threev1d:
1821   case ARM64::LD1Fourv1d:
1822   case ARM64::ST1Twov2d:
1823   case ARM64::ST1Threev2d:
1824   case ARM64::ST1Fourv2d:
1825   case ARM64::ST1Twov1d:
1826   case ARM64::ST1Threev1d:
1827   case ARM64::ST1Fourv1d:
1828     return ARM64FrameOffsetCannotUpdate;
1829   case ARM64::PRFMui:
1830     Scale = 8;
1831     UnscaledOp = ARM64::PRFUMi;
1832     break;
1833   case ARM64::LDRXui:
1834     Scale = 8;
1835     UnscaledOp = ARM64::LDURXi;
1836     break;
1837   case ARM64::LDRWui:
1838     Scale = 4;
1839     UnscaledOp = ARM64::LDURWi;
1840     break;
1841   case ARM64::LDRBui:
1842     Scale = 1;
1843     UnscaledOp = ARM64::LDURBi;
1844     break;
1845   case ARM64::LDRHui:
1846     Scale = 2;
1847     UnscaledOp = ARM64::LDURHi;
1848     break;
1849   case ARM64::LDRSui:
1850     Scale = 4;
1851     UnscaledOp = ARM64::LDURSi;
1852     break;
1853   case ARM64::LDRDui:
1854     Scale = 8;
1855     UnscaledOp = ARM64::LDURDi;
1856     break;
1857   case ARM64::LDRQui:
1858     Scale = 16;
1859     UnscaledOp = ARM64::LDURQi;
1860     break;
1861   case ARM64::LDRBBui:
1862     Scale = 1;
1863     UnscaledOp = ARM64::LDURBBi;
1864     break;
1865   case ARM64::LDRHHui:
1866     Scale = 2;
1867     UnscaledOp = ARM64::LDURHHi;
1868     break;
1869   case ARM64::LDRSBXui:
1870     Scale = 1;
1871     UnscaledOp = ARM64::LDURSBXi;
1872     break;
1873   case ARM64::LDRSBWui:
1874     Scale = 1;
1875     UnscaledOp = ARM64::LDURSBWi;
1876     break;
1877   case ARM64::LDRSHXui:
1878     Scale = 2;
1879     UnscaledOp = ARM64::LDURSHXi;
1880     break;
1881   case ARM64::LDRSHWui:
1882     Scale = 2;
1883     UnscaledOp = ARM64::LDURSHWi;
1884     break;
1885   case ARM64::LDRSWui:
1886     Scale = 4;
1887     UnscaledOp = ARM64::LDURSWi;
1888     break;
1889
1890   case ARM64::STRXui:
1891     Scale = 8;
1892     UnscaledOp = ARM64::STURXi;
1893     break;
1894   case ARM64::STRWui:
1895     Scale = 4;
1896     UnscaledOp = ARM64::STURWi;
1897     break;
1898   case ARM64::STRBui:
1899     Scale = 1;
1900     UnscaledOp = ARM64::STURBi;
1901     break;
1902   case ARM64::STRHui:
1903     Scale = 2;
1904     UnscaledOp = ARM64::STURHi;
1905     break;
1906   case ARM64::STRSui:
1907     Scale = 4;
1908     UnscaledOp = ARM64::STURSi;
1909     break;
1910   case ARM64::STRDui:
1911     Scale = 8;
1912     UnscaledOp = ARM64::STURDi;
1913     break;
1914   case ARM64::STRQui:
1915     Scale = 16;
1916     UnscaledOp = ARM64::STURQi;
1917     break;
1918   case ARM64::STRBBui:
1919     Scale = 1;
1920     UnscaledOp = ARM64::STURBBi;
1921     break;
1922   case ARM64::STRHHui:
1923     Scale = 2;
1924     UnscaledOp = ARM64::STURHHi;
1925     break;
1926
1927   case ARM64::LDPXi:
1928   case ARM64::LDPDi:
1929   case ARM64::STPXi:
1930   case ARM64::STPDi:
1931     IsSigned = true;
1932     Scale = 8;
1933     break;
1934   case ARM64::LDPQi:
1935   case ARM64::STPQi:
1936     IsSigned = true;
1937     Scale = 16;
1938     break;
1939   case ARM64::LDPWi:
1940   case ARM64::LDPSi:
1941   case ARM64::STPWi:
1942   case ARM64::STPSi:
1943     IsSigned = true;
1944     Scale = 4;
1945     break;
1946
1947   case ARM64::LDURXi:
1948   case ARM64::LDURWi:
1949   case ARM64::LDURBi:
1950   case ARM64::LDURHi:
1951   case ARM64::LDURSi:
1952   case ARM64::LDURDi:
1953   case ARM64::LDURQi:
1954   case ARM64::LDURHHi:
1955   case ARM64::LDURBBi:
1956   case ARM64::LDURSBXi:
1957   case ARM64::LDURSBWi:
1958   case ARM64::LDURSHXi:
1959   case ARM64::LDURSHWi:
1960   case ARM64::LDURSWi:
1961   case ARM64::STURXi:
1962   case ARM64::STURWi:
1963   case ARM64::STURBi:
1964   case ARM64::STURHi:
1965   case ARM64::STURSi:
1966   case ARM64::STURDi:
1967   case ARM64::STURQi:
1968   case ARM64::STURBBi:
1969   case ARM64::STURHHi:
1970     Scale = 1;
1971     break;
1972   }
1973
1974   Offset += MI.getOperand(ImmIdx).getImm() * Scale;
1975
1976   bool useUnscaledOp = false;
1977   // If the offset doesn't match the scale, we rewrite the instruction to
1978   // use the unscaled instruction instead. Likewise, if we have a negative
1979   // offset (and have an unscaled op to use).
1980   if ((Offset & (Scale - 1)) != 0 || (Offset < 0 && UnscaledOp != 0))
1981     useUnscaledOp = true;
1982
1983   // Use an unscaled addressing mode if the instruction has a negative offset
1984   // (or if the instruction is already using an unscaled addressing mode).
1985   unsigned MaskBits;
1986   if (IsSigned) {
1987     // ldp/stp instructions.
1988     MaskBits = 7;
1989     Offset /= Scale;
1990   } else if (UnscaledOp == 0 || useUnscaledOp) {
1991     MaskBits = 9;
1992     IsSigned = true;
1993     Scale = 1;
1994   } else {
1995     MaskBits = 12;
1996     IsSigned = false;
1997     Offset /= Scale;
1998   }
1999
2000   // Attempt to fold address computation.
2001   int MaxOff = (1 << (MaskBits - IsSigned)) - 1;
2002   int MinOff = (IsSigned ? (-MaxOff - 1) : 0);
2003   if (Offset >= MinOff && Offset <= MaxOff) {
2004     if (EmittableOffset)
2005       *EmittableOffset = Offset;
2006     Offset = 0;
2007   } else {
2008     int NewOff = Offset < 0 ? MinOff : MaxOff;
2009     if (EmittableOffset)
2010       *EmittableOffset = NewOff;
2011     Offset = (Offset - NewOff) * Scale;
2012   }
2013   if (OutUseUnscaledOp)
2014     *OutUseUnscaledOp = useUnscaledOp;
2015   if (OutUnscaledOp)
2016     *OutUnscaledOp = UnscaledOp;
2017   return ARM64FrameOffsetCanUpdate |
2018          (Offset == 0 ? ARM64FrameOffsetIsLegal : 0);
2019 }
2020
2021 bool llvm::rewriteARM64FrameIndex(MachineInstr &MI, unsigned FrameRegIdx,
2022                                   unsigned FrameReg, int &Offset,
2023                                   const ARM64InstrInfo *TII) {
2024   unsigned Opcode = MI.getOpcode();
2025   unsigned ImmIdx = FrameRegIdx + 1;
2026
2027   if (Opcode == ARM64::ADDSXri || Opcode == ARM64::ADDXri) {
2028     Offset += MI.getOperand(ImmIdx).getImm();
2029     emitFrameOffset(*MI.getParent(), MI, MI.getDebugLoc(),
2030                     MI.getOperand(0).getReg(), FrameReg, Offset, TII,
2031                     MachineInstr::NoFlags, (Opcode == ARM64::ADDSXri));
2032     MI.eraseFromParent();
2033     Offset = 0;
2034     return true;
2035   }
2036
2037   int NewOffset;
2038   unsigned UnscaledOp;
2039   bool UseUnscaledOp;
2040   int Status = isARM64FrameOffsetLegal(MI, Offset, &UseUnscaledOp, &UnscaledOp,
2041                                        &NewOffset);
2042   if (Status & ARM64FrameOffsetCanUpdate) {
2043     if (Status & ARM64FrameOffsetIsLegal)
2044       // Replace the FrameIndex with FrameReg.
2045       MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
2046     if (UseUnscaledOp)
2047       MI.setDesc(TII->get(UnscaledOp));
2048
2049     MI.getOperand(ImmIdx).ChangeToImmediate(NewOffset);
2050     return Offset == 0;
2051   }
2052
2053   return false;
2054 }
2055
2056 void ARM64InstrInfo::getNoopForMachoTarget(MCInst &NopInst) const {
2057   NopInst.setOpcode(ARM64::HINT);
2058   NopInst.addOperand(MCOperand::CreateImm(0));
2059 }