lib/Target/AArch64/AArch64InstrInfo.cpp

   1 //===- AArch64InstrInfo.cpp - AArch64 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 AArch64 implementation of the TargetInstrInfo class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "AArch64InstrInfo.h"
  15 #include "AArch64MachineCombinerPattern.h"
  16 #include "AArch64Subtarget.h"
  17 #include "MCTargetDesc/AArch64AddressingModes.h"
  18 #include "llvm/CodeGen/MachineFrameInfo.h"
  19 #include "llvm/CodeGen/MachineInstrBuilder.h"
  20 #include "llvm/CodeGen/MachineMemOperand.h"
  21 #include "llvm/CodeGen/MachineRegisterInfo.h"
  22 #include "llvm/CodeGen/PseudoSourceValue.h"
  23 #include "llvm/MC/MCInst.h"
  24 #include "llvm/Support/ErrorHandling.h"
  25 #include "llvm/Support/TargetRegistry.h"
  26
  27 using namespace llvm;
  28
  29 #define GET_INSTRINFO_CTOR_DTOR
  30 #include "AArch64GenInstrInfo.inc"
  31
  32 AArch64InstrInfo::AArch64InstrInfo(const AArch64Subtarget &STI)
  33     : AArch64GenInstrInfo(AArch64::ADJCALLSTACKDOWN, AArch64::ADJCALLSTACKUP),
  34       RI(STI.getTargetTriple()), Subtarget(STI) {}
  35
  36 /// GetInstSize - Return the number of bytes of code the specified
  37 /// instruction may be.  This returns the maximum number of bytes.
  38 unsigned AArch64InstrInfo::GetInstSizeInBytes(const MachineInstr *MI) const {
  39   const MachineBasicBlock &MBB = *MI->getParent();
  40   const MachineFunction *MF = MBB.getParent();
  41   const MCAsmInfo *MAI = MF->getTarget().getMCAsmInfo();
  42
  43   if (MI->getOpcode() == AArch64::INLINEASM)
  44     return getInlineAsmLength(MI->getOperand(0).getSymbolName(), *MAI);
  45
  46   const MCInstrDesc &Desc = MI->getDesc();
  47   switch (Desc.getOpcode()) {
  48   default:
  49     // Anything not explicitly designated otherwise is a nomal 4-byte insn.
  50     return 4;
  51   case TargetOpcode::DBG_VALUE:
  52   case TargetOpcode::EH_LABEL:
  53   case TargetOpcode::IMPLICIT_DEF:
  54   case TargetOpcode::KILL:
  55     return 0;
  56   }
  57
  58   llvm_unreachable("GetInstSizeInBytes()- Unable to determin insn size");
  59 }
  60
  61 static void parseCondBranch(MachineInstr *LastInst, MachineBasicBlock *&Target,
  62                             SmallVectorImpl<MachineOperand> &Cond) {
  63   // Block ends with fall-through condbranch.
  64   switch (LastInst->getOpcode()) {
  65   default:
  66     llvm_unreachable("Unknown branch instruction?");
  67   case AArch64::Bcc:
  68     Target = LastInst->getOperand(1).getMBB();
  69     Cond.push_back(LastInst->getOperand(0));
  70     break;
  71   case AArch64::CBZW:
  72   case AArch64::CBZX:
  73   case AArch64::CBNZW:
  74   case AArch64::CBNZX:
  75     Target = LastInst->getOperand(1).getMBB();
  76     Cond.push_back(MachineOperand::CreateImm(-1));
  77     Cond.push_back(MachineOperand::CreateImm(LastInst->getOpcode()));
  78     Cond.push_back(LastInst->getOperand(0));
  79     break;
  80   case AArch64::TBZW:
  81   case AArch64::TBZX:
  82   case AArch64::TBNZW:
  83   case AArch64::TBNZX:
  84     Target = LastInst->getOperand(2).getMBB();
  85     Cond.push_back(MachineOperand::CreateImm(-1));
  86     Cond.push_back(MachineOperand::CreateImm(LastInst->getOpcode()));
  87     Cond.push_back(LastInst->getOperand(0));
  88     Cond.push_back(LastInst->getOperand(1));
  89   }
  90 }
  91
  92 // Branch analysis.
  93 bool AArch64InstrInfo::AnalyzeBranch(MachineBasicBlock &MBB,
  94                                    MachineBasicBlock *&TBB,
  95                                    MachineBasicBlock *&FBB,
  96                                    SmallVectorImpl<MachineOperand> &Cond,
  97                                    bool AllowModify) const {
  98   // If the block has no terminators, it just falls into the block after it.
  99   MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
 100   if (I == MBB.end())
 101     return false;
 102
 103   if (!isUnpredicatedTerminator(I))
 104     return false;
 105
 106   // Get the last instruction in the block.
 107   MachineInstr *LastInst = I;
 108
 109   // If there is only one terminator instruction, process it.
 110   unsigned LastOpc = LastInst->getOpcode();
 111   if (I == MBB.begin() || !isUnpredicatedTerminator(--I)) {
 112     if (isUncondBranchOpcode(LastOpc)) {
 113       TBB = LastInst->getOperand(0).getMBB();
 114       return false;
 115     }
 116     if (isCondBranchOpcode(LastOpc)) {
 117       // Block ends with fall-through condbranch.
 118       parseCondBranch(LastInst, TBB, Cond);
 119       return false;
 120     }
 121     return true; // Can't handle indirect branch.
 122   }
 123
 124   // Get the instruction before it if it is a terminator.
 125   MachineInstr *SecondLastInst = I;
 126   unsigned SecondLastOpc = SecondLastInst->getOpcode();
 127
 128   // If AllowModify is true and the block ends with two or more unconditional
 129   // branches, delete all but the first unconditional branch.
 130   if (AllowModify && isUncondBranchOpcode(LastOpc)) {
 131     while (isUncondBranchOpcode(SecondLastOpc)) {
 132       LastInst->eraseFromParent();
 133       LastInst = SecondLastInst;
 134       LastOpc = LastInst->getOpcode();
 135       if (I == MBB.begin() || !isUnpredicatedTerminator(--I)) {
 136         // Return now the only terminator is an unconditional branch.
 137         TBB = LastInst->getOperand(0).getMBB();
 138         return false;
 139       } else {
 140         SecondLastInst = I;
 141         SecondLastOpc = SecondLastInst->getOpcode();
 142       }
 143     }
 144   }
 145
 146   // If there are three terminators, we don't know what sort of block this is.
 147   if (SecondLastInst && I != MBB.begin() && isUnpredicatedTerminator(--I))
 148     return true;
 149
 150   // If the block ends with a B and a Bcc, handle it.
 151   if (isCondBranchOpcode(SecondLastOpc) && isUncondBranchOpcode(LastOpc)) {
 152     parseCondBranch(SecondLastInst, TBB, Cond);
 153     FBB = LastInst->getOperand(0).getMBB();
 154     return false;
 155   }
 156
 157   // If the block ends with two unconditional branches, handle it.  The second
 158   // one is not executed, so remove it.
 159   if (isUncondBranchOpcode(SecondLastOpc) && isUncondBranchOpcode(LastOpc)) {
 160     TBB = SecondLastInst->getOperand(0).getMBB();
 161     I = LastInst;
 162     if (AllowModify)
 163       I->eraseFromParent();
 164     return false;
 165   }
 166
 167   // ...likewise if it ends with an indirect branch followed by an unconditional
 168   // branch.
 169   if (isIndirectBranchOpcode(SecondLastOpc) && isUncondBranchOpcode(LastOpc)) {
 170     I = LastInst;
 171     if (AllowModify)
 172       I->eraseFromParent();
 173     return true;
 174   }
 175
 176   // Otherwise, can't handle this.
 177   return true;
 178 }
 179
 180 bool AArch64InstrInfo::ReverseBranchCondition(
 181     SmallVectorImpl<MachineOperand> &Cond) const {
 182   if (Cond[0].getImm() != -1) {
 183     // Regular Bcc
 184     AArch64CC::CondCode CC = (AArch64CC::CondCode)(int)Cond[0].getImm();
 185     Cond[0].setImm(AArch64CC::getInvertedCondCode(CC));
 186   } else {
 187     // Folded compare-and-branch
 188     switch (Cond[1].getImm()) {
 189     default:
 190       llvm_unreachable("Unknown conditional branch!");
 191     case AArch64::CBZW:
 192       Cond[1].setImm(AArch64::CBNZW);
 193       break;
 194     case AArch64::CBNZW:
 195       Cond[1].setImm(AArch64::CBZW);
 196       break;
 197     case AArch64::CBZX:
 198       Cond[1].setImm(AArch64::CBNZX);
 199       break;
 200     case AArch64::CBNZX:
 201       Cond[1].setImm(AArch64::CBZX);
 202       break;
 203     case AArch64::TBZW:
 204       Cond[1].setImm(AArch64::TBNZW);
 205       break;
 206     case AArch64::TBNZW:
 207       Cond[1].setImm(AArch64::TBZW);
 208       break;
 209     case AArch64::TBZX:
 210       Cond[1].setImm(AArch64::TBNZX);
 211       break;
 212     case AArch64::TBNZX:
 213       Cond[1].setImm(AArch64::TBZX);
 214       break;
 215     }
 216   }
 217
 218   return false;
 219 }
 220
 221 unsigned AArch64InstrInfo::RemoveBranch(MachineBasicBlock &MBB) const {
 222   MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
 223   if (I == MBB.end())
 224     return 0;
 225
 226   if (!isUncondBranchOpcode(I->getOpcode()) &&
 227       !isCondBranchOpcode(I->getOpcode()))
 228     return 0;
 229
 230   // Remove the branch.
 231   I->eraseFromParent();
 232
 233   I = MBB.end();
 234
 235   if (I == MBB.begin())
 236     return 1;
 237   --I;
 238   if (!isCondBranchOpcode(I->getOpcode()))
 239     return 1;
 240
 241   // Remove the branch.
 242   I->eraseFromParent();
 243   return 2;
 244 }
 245
 246 void AArch64InstrInfo::instantiateCondBranch(
 247     MachineBasicBlock &MBB, DebugLoc DL, MachineBasicBlock *TBB,
 248     ArrayRef<MachineOperand> Cond) const {
 249   if (Cond[0].getImm() != -1) {
 250     // Regular Bcc
 251     BuildMI(&MBB, DL, get(AArch64::Bcc)).addImm(Cond[0].getImm()).addMBB(TBB);
 252   } else {
 253     // Folded compare-and-branch
 254     // Note that we use addOperand instead of addReg to keep the flags.
 255     const MachineInstrBuilder MIB =
 256         BuildMI(&MBB, DL, get(Cond[1].getImm())).addOperand(Cond[2]);
 257     if (Cond.size() > 3)
 258       MIB.addImm(Cond[3].getImm());
 259     MIB.addMBB(TBB);
 260   }
 261 }
 262
 263 unsigned AArch64InstrInfo::InsertBranch(
 264     MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB,
 265     ArrayRef<MachineOperand> Cond, DebugLoc DL) const {
 266   // Shouldn't be a fall through.
 267   assert(TBB && "InsertBranch must not be told to insert a fallthrough");
 268
 269   if (!FBB) {
 270     if (Cond.empty()) // Unconditional branch?
 271       BuildMI(&MBB, DL, get(AArch64::B)).addMBB(TBB);
 272     else
 273       instantiateCondBranch(MBB, DL, TBB, Cond);
 274     return 1;
 275   }
 276
 277   // Two-way conditional branch.
 278   instantiateCondBranch(MBB, DL, TBB, Cond);
 279   BuildMI(&MBB, DL, get(AArch64::B)).addMBB(FBB);
 280   return 2;
 281 }
 282
 283 // Find the original register that VReg is copied from.
 284 static unsigned removeCopies(const MachineRegisterInfo &MRI, unsigned VReg) {
 285   while (TargetRegisterInfo::isVirtualRegister(VReg)) {
 286     const MachineInstr *DefMI = MRI.getVRegDef(VReg);
 287     if (!DefMI->isFullCopy())
 288       return VReg;
 289     VReg = DefMI->getOperand(1).getReg();
 290   }
 291   return VReg;
 292 }
 293
 294 // Determine if VReg is defined by an instruction that can be folded into a
 295 // csel instruction. If so, return the folded opcode, and the replacement
 296 // register.
 297 static unsigned canFoldIntoCSel(const MachineRegisterInfo &MRI, unsigned VReg,
 298                                 unsigned *NewVReg = nullptr) {
 299   VReg = removeCopies(MRI, VReg);
 300   if (!TargetRegisterInfo::isVirtualRegister(VReg))
 301     return 0;
 302
 303   bool Is64Bit = AArch64::GPR64allRegClass.hasSubClassEq(MRI.getRegClass(VReg));
 304   const MachineInstr *DefMI = MRI.getVRegDef(VReg);
 305   unsigned Opc = 0;
 306   unsigned SrcOpNum = 0;
 307   switch (DefMI->getOpcode()) {
 308   case AArch64::ADDSXri:
 309   case AArch64::ADDSWri:
 310     // if NZCV is used, do not fold.
 311     if (DefMI->findRegisterDefOperandIdx(AArch64::NZCV, true) == -1)
 312       return 0;
 313   // fall-through to ADDXri and ADDWri.
 314   case AArch64::ADDXri:
 315   case AArch64::ADDWri:
 316     // add x, 1 -> csinc.
 317     if (!DefMI->getOperand(2).isImm() || DefMI->getOperand(2).getImm() != 1 ||
 318         DefMI->getOperand(3).getImm() != 0)
 319       return 0;
 320     SrcOpNum = 1;
 321     Opc = Is64Bit ? AArch64::CSINCXr : AArch64::CSINCWr;
 322     break;
 323
 324   case AArch64::ORNXrr:
 325   case AArch64::ORNWrr: {
 326     // not x -> csinv, represented as orn dst, xzr, src.
 327     unsigned ZReg = removeCopies(MRI, DefMI->getOperand(1).getReg());
 328     if (ZReg != AArch64::XZR && ZReg != AArch64::WZR)
 329       return 0;
 330     SrcOpNum = 2;
 331     Opc = Is64Bit ? AArch64::CSINVXr : AArch64::CSINVWr;
 332     break;
 333   }
 334
 335   case AArch64::SUBSXrr:
 336   case AArch64::SUBSWrr:
 337     // if NZCV is used, do not fold.
 338     if (DefMI->findRegisterDefOperandIdx(AArch64::NZCV, true) == -1)
 339       return 0;
 340   // fall-through to SUBXrr and SUBWrr.
 341   case AArch64::SUBXrr:
 342   case AArch64::SUBWrr: {
 343     // neg x -> csneg, represented as sub dst, xzr, src.
 344     unsigned ZReg = removeCopies(MRI, DefMI->getOperand(1).getReg());
 345     if (ZReg != AArch64::XZR && ZReg != AArch64::WZR)
 346       return 0;
 347     SrcOpNum = 2;
 348     Opc = Is64Bit ? AArch64::CSNEGXr : AArch64::CSNEGWr;
 349     break;
 350   }
 351   default:
 352     return 0;
 353   }
 354   assert(Opc && SrcOpNum && "Missing parameters");
 355
 356   if (NewVReg)
 357     *NewVReg = DefMI->getOperand(SrcOpNum).getReg();
 358   return Opc;
 359 }
 360
 361 bool AArch64InstrInfo::canInsertSelect(
 362     const MachineBasicBlock &MBB, ArrayRef<MachineOperand> Cond,
 363     unsigned TrueReg, unsigned FalseReg, int &CondCycles, int &TrueCycles,
 364     int &FalseCycles) const {
 365   // Check register classes.
 366   const MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
 367   const TargetRegisterClass *RC =
 368       RI.getCommonSubClass(MRI.getRegClass(TrueReg), MRI.getRegClass(FalseReg));
 369   if (!RC)
 370     return false;
 371
 372   // Expanding cbz/tbz requires an extra cycle of latency on the condition.
 373   unsigned ExtraCondLat = Cond.size() != 1;
 374
 375   // GPRs are handled by csel.
 376   // FIXME: Fold in x+1, -x, and ~x when applicable.
 377   if (AArch64::GPR64allRegClass.hasSubClassEq(RC) ||
 378       AArch64::GPR32allRegClass.hasSubClassEq(RC)) {
 379     // Single-cycle csel, csinc, csinv, and csneg.
 380     CondCycles = 1 + ExtraCondLat;
 381     TrueCycles = FalseCycles = 1;
 382     if (canFoldIntoCSel(MRI, TrueReg))
 383       TrueCycles = 0;
 384     else if (canFoldIntoCSel(MRI, FalseReg))
 385       FalseCycles = 0;
 386     return true;
 387   }
 388
 389   // Scalar floating point is handled by fcsel.
 390   // FIXME: Form fabs, fmin, and fmax when applicable.
 391   if (AArch64::FPR64RegClass.hasSubClassEq(RC) ||
 392       AArch64::FPR32RegClass.hasSubClassEq(RC)) {
 393     CondCycles = 5 + ExtraCondLat;
 394     TrueCycles = FalseCycles = 2;
 395     return true;
 396   }
 397
 398   // Can't do vectors.
 399   return false;
 400 }
 401
 402 void AArch64InstrInfo::insertSelect(MachineBasicBlock &MBB,
 403                                     MachineBasicBlock::iterator I, DebugLoc DL,
 404                                     unsigned DstReg,
 405                                     ArrayRef<MachineOperand> Cond,
 406                                     unsigned TrueReg, unsigned FalseReg) const {
 407   MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
 408
 409   // Parse the condition code, see parseCondBranch() above.
 410   AArch64CC::CondCode CC;
 411   switch (Cond.size()) {
 412   default:
 413     llvm_unreachable("Unknown condition opcode in Cond");
 414   case 1: // b.cc
 415     CC = AArch64CC::CondCode(Cond[0].getImm());
 416     break;
 417   case 3: { // cbz/cbnz
 418     // We must insert a compare against 0.
 419     bool Is64Bit;
 420     switch (Cond[1].getImm()) {
 421     default:
 422       llvm_unreachable("Unknown branch opcode in Cond");
 423     case AArch64::CBZW:
 424       Is64Bit = 0;
 425       CC = AArch64CC::EQ;
 426       break;
 427     case AArch64::CBZX:
 428       Is64Bit = 1;
 429       CC = AArch64CC::EQ;
 430       break;
 431     case AArch64::CBNZW:
 432       Is64Bit = 0;
 433       CC = AArch64CC::NE;
 434       break;
 435     case AArch64::CBNZX:
 436       Is64Bit = 1;
 437       CC = AArch64CC::NE;
 438       break;
 439     }
 440     unsigned SrcReg = Cond[2].getReg();
 441     if (Is64Bit) {
 442       // cmp reg, #0 is actually subs xzr, reg, #0.
 443       MRI.constrainRegClass(SrcReg, &AArch64::GPR64spRegClass);
 444       BuildMI(MBB, I, DL, get(AArch64::SUBSXri), AArch64::XZR)
 445           .addReg(SrcReg)
 446           .addImm(0)
 447           .addImm(0);
 448     } else {
 449       MRI.constrainRegClass(SrcReg, &AArch64::GPR32spRegClass);
 450       BuildMI(MBB, I, DL, get(AArch64::SUBSWri), AArch64::WZR)
 451           .addReg(SrcReg)
 452           .addImm(0)
 453           .addImm(0);
 454     }
 455     break;
 456   }
 457   case 4: { // tbz/tbnz
 458     // We must insert a tst instruction.
 459     switch (Cond[1].getImm()) {
 460     default:
 461       llvm_unreachable("Unknown branch opcode in Cond");
 462     case AArch64::TBZW:
 463     case AArch64::TBZX:
 464       CC = AArch64CC::EQ;
 465       break;
 466     case AArch64::TBNZW:
 467     case AArch64::TBNZX:
 468       CC = AArch64CC::NE;
 469       break;
 470     }
 471     // cmp reg, #foo is actually ands xzr, reg, #1<<foo.
 472     if (Cond[1].getImm() == AArch64::TBZW || Cond[1].getImm() == AArch64::TBNZW)
 473       BuildMI(MBB, I, DL, get(AArch64::ANDSWri), AArch64::WZR)
 474           .addReg(Cond[2].getReg())
 475           .addImm(
 476               AArch64_AM::encodeLogicalImmediate(1ull << Cond[3].getImm(), 32));
 477     else
 478       BuildMI(MBB, I, DL, get(AArch64::ANDSXri), AArch64::XZR)
 479           .addReg(Cond[2].getReg())
 480           .addImm(
 481               AArch64_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, &AArch64::GPR64RegClass)) {
 490     RC = &AArch64::GPR64RegClass;
 491     Opc = AArch64::CSELXr;
 492     TryFold = true;
 493   } else if (MRI.constrainRegClass(DstReg, &AArch64::GPR32RegClass)) {
 494     RC = &AArch64::GPR32RegClass;
 495     Opc = AArch64::CSELWr;
 496     TryFold = true;
 497   } else if (MRI.constrainRegClass(DstReg, &AArch64::FPR64RegClass)) {
 498     RC = &AArch64::FPR64RegClass;
 499     Opc = AArch64::FCSELDrrr;
 500   } else if (MRI.constrainRegClass(DstReg, &AArch64::FPR32RegClass)) {
 501     RC = &AArch64::FPR32RegClass;
 502     Opc = AArch64::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 = AArch64CC::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 /// Returns true if a MOVi32imm or MOVi64imm can be expanded to an  ORRxx.
 537 static bool canBeExpandedToORR(const MachineInstr *MI, unsigned BitSize) {
 538   uint64_t Imm = MI->getOperand(1).getImm();
 539   uint64_t UImm = Imm << (64 - BitSize) >> (64 - BitSize);
 540   uint64_t Encoding;
 541   return AArch64_AM::processLogicalImmediate(UImm, BitSize, Encoding);
 542 }
 543
 544 // FIXME: this implementation should be micro-architecture dependent, so a
 545 // micro-architecture target hook should be introduced here in future.
 546 bool AArch64InstrInfo::isAsCheapAsAMove(const MachineInstr *MI) const {
 547   if (!Subtarget.isCortexA57() && !Subtarget.isCortexA53())
 548     return MI->isAsCheapAsAMove();
 549
 550   switch (MI->getOpcode()) {
 551   default:
 552     return false;
 553
 554   // add/sub on register without shift
 555   case AArch64::ADDWri:
 556   case AArch64::ADDXri:
 557   case AArch64::SUBWri:
 558   case AArch64::SUBXri:
 559     return (MI->getOperand(3).getImm() == 0);
 560
 561   // logical ops on immediate
 562   case AArch64::ANDWri:
 563   case AArch64::ANDXri:
 564   case AArch64::EORWri:
 565   case AArch64::EORXri:
 566   case AArch64::ORRWri:
 567   case AArch64::ORRXri:
 568     return true;
 569
 570   // logical ops on register without shift
 571   case AArch64::ANDWrr:
 572   case AArch64::ANDXrr:
 573   case AArch64::BICWrr:
 574   case AArch64::BICXrr:
 575   case AArch64::EONWrr:
 576   case AArch64::EONXrr:
 577   case AArch64::EORWrr:
 578   case AArch64::EORXrr:
 579   case AArch64::ORNWrr:
 580   case AArch64::ORNXrr:
 581   case AArch64::ORRWrr:
 582   case AArch64::ORRXrr:
 583     return true;
 584   // If MOVi32imm or MOVi64imm can be expanded into ORRWri or
 585   // ORRXri, it is as cheap as MOV
 586   case AArch64::MOVi32imm:
 587     return canBeExpandedToORR(MI, 32);
 588   case AArch64::MOVi64imm:
 589     return canBeExpandedToORR(MI, 64);
 590   }
 591
 592   llvm_unreachable("Unknown opcode to check as cheap as a move!");
 593 }
 594
 595 bool AArch64InstrInfo::isCoalescableExtInstr(const MachineInstr &MI,
 596                                              unsigned &SrcReg, unsigned &DstReg,
 597                                              unsigned &SubIdx) const {
 598   switch (MI.getOpcode()) {
 599   default:
 600     return false;
 601   case AArch64::SBFMXri: // aka sxtw
 602   case AArch64::UBFMXri: // aka uxtw
 603     // Check for the 32 -> 64 bit extension case, these instructions can do
 604     // much more.
 605     if (MI.getOperand(2).getImm() != 0 || MI.getOperand(3).getImm() != 31)
 606       return false;
 607     // This is a signed or unsigned 32 -> 64 bit extension.
 608     SrcReg = MI.getOperand(1).getReg();
 609     DstReg = MI.getOperand(0).getReg();
 610     SubIdx = AArch64::sub_32;
 611     return true;
 612   }
 613 }
 614
 615 bool
 616 AArch64InstrInfo::areMemAccessesTriviallyDisjoint(MachineInstr *MIa,
 617                                                   MachineInstr *MIb,
 618                                                   AliasAnalysis *AA) const {
 619   const TargetRegisterInfo *TRI = &getRegisterInfo();
 620   unsigned BaseRegA = 0, BaseRegB = 0;
 621   int OffsetA = 0, OffsetB = 0;
 622   int WidthA = 0, WidthB = 0;
 623
 624   assert(MIa && MIa->mayLoadOrStore() && "MIa must be a load or store.");
 625   assert(MIb && MIb->mayLoadOrStore() && "MIb must be a load or store.");
 626
 627   if (MIa->hasUnmodeledSideEffects() || MIb->hasUnmodeledSideEffects() ||
 628       MIa->hasOrderedMemoryRef() || MIb->hasOrderedMemoryRef())
 629     return false;
 630
 631   // Retrieve the base register, offset from the base register and width. Width
 632   // is the size of memory that is being loaded/stored (e.g. 1, 2, 4, 8).  If
 633   // base registers are identical, and the offset of a lower memory access +
 634   // the width doesn't overlap the offset of a higher memory access,
 635   // then the memory accesses are different.
 636   if (getMemOpBaseRegImmOfsWidth(MIa, BaseRegA, OffsetA, WidthA, TRI) &&
 637       getMemOpBaseRegImmOfsWidth(MIb, BaseRegB, OffsetB, WidthB, TRI)) {
 638     if (BaseRegA == BaseRegB) {
 639       int LowOffset = OffsetA < OffsetB ? OffsetA : OffsetB;
 640       int HighOffset = OffsetA < OffsetB ? OffsetB : OffsetA;
 641       int LowWidth = (LowOffset == OffsetA) ? WidthA : WidthB;
 642       if (LowOffset + LowWidth <= HighOffset)
 643         return true;
 644     }
 645   }
 646   return false;
 647 }
 648
 649 /// analyzeCompare - For a comparison instruction, return the source registers
 650 /// in SrcReg and SrcReg2, and the value it compares against in CmpValue.
 651 /// Return true if the comparison instruction can be analyzed.
 652 bool AArch64InstrInfo::analyzeCompare(const MachineInstr *MI, unsigned &SrcReg,
 653                                       unsigned &SrcReg2, int &CmpMask,
 654                                       int &CmpValue) const {
 655   switch (MI->getOpcode()) {
 656   default:
 657     break;
 658   case AArch64::SUBSWrr:
 659   case AArch64::SUBSWrs:
 660   case AArch64::SUBSWrx:
 661   case AArch64::SUBSXrr:
 662   case AArch64::SUBSXrs:
 663   case AArch64::SUBSXrx:
 664   case AArch64::ADDSWrr:
 665   case AArch64::ADDSWrs:
 666   case AArch64::ADDSWrx:
 667   case AArch64::ADDSXrr:
 668   case AArch64::ADDSXrs:
 669   case AArch64::ADDSXrx:
 670     // Replace SUBSWrr with SUBWrr if NZCV is not used.
 671     SrcReg = MI->getOperand(1).getReg();
 672     SrcReg2 = MI->getOperand(2).getReg();
 673     CmpMask = ~0;
 674     CmpValue = 0;
 675     return true;
 676   case AArch64::SUBSWri:
 677   case AArch64::ADDSWri:
 678   case AArch64::SUBSXri:
 679   case AArch64::ADDSXri:
 680     SrcReg = MI->getOperand(1).getReg();
 681     SrcReg2 = 0;
 682     CmpMask = ~0;
 683     // FIXME: In order to convert CmpValue to 0 or 1
 684     CmpValue = (MI->getOperand(2).getImm() != 0);
 685     return true;
 686   case AArch64::ANDSWri:
 687   case AArch64::ANDSXri:
 688     // ANDS does not use the same encoding scheme as the others xxxS
 689     // instructions.
 690     SrcReg = MI->getOperand(1).getReg();
 691     SrcReg2 = 0;
 692     CmpMask = ~0;
 693     // FIXME:The return val type of decodeLogicalImmediate is uint64_t,
 694     // while the type of CmpValue is int. When converting uint64_t to int,
 695     // the high 32 bits of uint64_t will be lost.
 696     // In fact it causes a bug in spec2006-483.xalancbmk
 697     // CmpValue is only used to compare with zero in OptimizeCompareInstr
 698     CmpValue = (AArch64_AM::decodeLogicalImmediate(
 699                     MI->getOperand(2).getImm(),
 700                     MI->getOpcode() == AArch64::ANDSWri ? 32 : 64) != 0);
 701     return true;
 702   }
 703
 704   return false;
 705 }
 706
 707 static bool UpdateOperandRegClass(MachineInstr *Instr) {
 708   MachineBasicBlock *MBB = Instr->getParent();
 709   assert(MBB && "Can't get MachineBasicBlock here");
 710   MachineFunction *MF = MBB->getParent();
 711   assert(MF && "Can't get MachineFunction here");
 712   const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
 713   const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo();
 714   MachineRegisterInfo *MRI = &MF->getRegInfo();
 715
 716   for (unsigned OpIdx = 0, EndIdx = Instr->getNumOperands(); OpIdx < EndIdx;
 717        ++OpIdx) {
 718     MachineOperand &MO = Instr->getOperand(OpIdx);
 719     const TargetRegisterClass *OpRegCstraints =
 720         Instr->getRegClassConstraint(OpIdx, TII, TRI);
 721
 722     // If there's no constraint, there's nothing to do.
 723     if (!OpRegCstraints)
 724       continue;
 725     // If the operand is a frame index, there's nothing to do here.
 726     // A frame index operand will resolve correctly during PEI.
 727     if (MO.isFI())
 728       continue;
 729
 730     assert(MO.isReg() &&
 731            "Operand has register constraints without being a register!");
 732
 733     unsigned Reg = MO.getReg();
 734     if (TargetRegisterInfo::isPhysicalRegister(Reg)) {
 735       if (!OpRegCstraints->contains(Reg))
 736         return false;
 737     } else if (!OpRegCstraints->hasSubClassEq(MRI->getRegClass(Reg)) &&
 738                !MRI->constrainRegClass(Reg, OpRegCstraints))
 739       return false;
 740   }
 741
 742   return true;
 743 }
 744
 745 /// \brief Return the opcode that does not set flags when possible - otherwise
 746 /// return the original opcode. The caller is responsible to do the actual
 747 /// substitution and legality checking.
 748 static unsigned convertFlagSettingOpcode(const MachineInstr *MI) {
 749   // Don't convert all compare instructions, because for some the zero register
 750   // encoding becomes the sp register.
 751   bool MIDefinesZeroReg = false;
 752   if (MI->definesRegister(AArch64::WZR) || MI->definesRegister(AArch64::XZR))
 753     MIDefinesZeroReg = true;
 754
 755   switch (MI->getOpcode()) {
 756   default:
 757     return MI->getOpcode();
 758   case AArch64::ADDSWrr:
 759     return AArch64::ADDWrr;
 760   case AArch64::ADDSWri:
 761     return MIDefinesZeroReg ? AArch64::ADDSWri : AArch64::ADDWri;
 762   case AArch64::ADDSWrs:
 763     return MIDefinesZeroReg ? AArch64::ADDSWrs : AArch64::ADDWrs;
 764   case AArch64::ADDSWrx:
 765     return AArch64::ADDWrx;
 766   case AArch64::ADDSXrr:
 767     return AArch64::ADDXrr;
 768   case AArch64::ADDSXri:
 769     return MIDefinesZeroReg ? AArch64::ADDSXri : AArch64::ADDXri;
 770   case AArch64::ADDSXrs:
 771     return MIDefinesZeroReg ? AArch64::ADDSXrs : AArch64::ADDXrs;
 772   case AArch64::ADDSXrx:
 773     return AArch64::ADDXrx;
 774   case AArch64::SUBSWrr:
 775     return AArch64::SUBWrr;
 776   case AArch64::SUBSWri:
 777     return MIDefinesZeroReg ? AArch64::SUBSWri : AArch64::SUBWri;
 778   case AArch64::SUBSWrs:
 779     return MIDefinesZeroReg ? AArch64::SUBSWrs : AArch64::SUBWrs;
 780   case AArch64::SUBSWrx:
 781     return AArch64::SUBWrx;
 782   case AArch64::SUBSXrr:
 783     return AArch64::SUBXrr;
 784   case AArch64::SUBSXri:
 785     return MIDefinesZeroReg ? AArch64::SUBSXri : AArch64::SUBXri;
 786   case AArch64::SUBSXrs:
 787     return MIDefinesZeroReg ? AArch64::SUBSXrs : AArch64::SUBXrs;
 788   case AArch64::SUBSXrx:
 789     return AArch64::SUBXrx;
 790   }
 791 }
 792
 793 /// True when condition code could be modified on the instruction
 794 /// trace starting at from and ending at to.
 795 static bool modifiesConditionCode(MachineInstr *From, MachineInstr *To,
 796                                   const bool CheckOnlyCCWrites,
 797                                   const TargetRegisterInfo *TRI) {
 798   // We iterate backward starting \p To until we hit \p From
 799   MachineBasicBlock::iterator I = To, E = From, B = To->getParent()->begin();
 800
 801   // Early exit if To is at the beginning of the BB.
 802   if (I == B)
 803     return true;
 804
 805   // Check whether the definition of SrcReg is in the same basic block as
 806   // Compare. If not, assume the condition code gets modified on some path.
 807   if (To->getParent() != From->getParent())
 808     return true;
 809
 810   // Check that NZCV isn't set on the trace.
 811   for (--I; I != E; --I) {
 812     const MachineInstr &Instr = *I;
 813
 814     if (Instr.modifiesRegister(AArch64::NZCV, TRI) ||
 815         (!CheckOnlyCCWrites && Instr.readsRegister(AArch64::NZCV, TRI)))
 816       // This instruction modifies or uses NZCV after the one we want to
 817       // change.
 818       return true;
 819     if (I == B)
 820       // We currently don't allow the instruction trace to cross basic
 821       // block boundaries
 822       return true;
 823   }
 824   return false;
 825 }
 826 /// optimizeCompareInstr - Convert the instruction supplying the argument to the
 827 /// comparison into one that sets the zero bit in the flags register.
 828 bool AArch64InstrInfo::optimizeCompareInstr(
 829     MachineInstr *CmpInstr, unsigned SrcReg, unsigned SrcReg2, int CmpMask,
 830     int CmpValue, const MachineRegisterInfo *MRI) const {
 831
 832   // Replace SUBSWrr with SUBWrr if NZCV is not used.
 833   int Cmp_NZCV = CmpInstr->findRegisterDefOperandIdx(AArch64::NZCV, true);
 834   if (Cmp_NZCV != -1) {
 835     if (CmpInstr->definesRegister(AArch64::WZR) ||
 836         CmpInstr->definesRegister(AArch64::XZR)) {
 837       CmpInstr->eraseFromParent();
 838       return true;
 839     }
 840     unsigned Opc = CmpInstr->getOpcode();
 841     unsigned NewOpc = convertFlagSettingOpcode(CmpInstr);
 842     if (NewOpc == Opc)
 843       return false;
 844     const MCInstrDesc &MCID = get(NewOpc);
 845     CmpInstr->setDesc(MCID);
 846     CmpInstr->RemoveOperand(Cmp_NZCV);
 847     bool succeeded = UpdateOperandRegClass(CmpInstr);
 848     (void)succeeded;
 849     assert(succeeded && "Some operands reg class are incompatible!");
 850     return true;
 851   }
 852
 853   // Continue only if we have a "ri" where immediate is zero.
 854   // FIXME:CmpValue has already been converted to 0 or 1 in analyzeCompare
 855   // function.
 856   assert((CmpValue == 0 || CmpValue == 1) && "CmpValue must be 0 or 1!");
 857   if (CmpValue != 0 || SrcReg2 != 0)
 858     return false;
 859
 860   // CmpInstr is a Compare instruction if destination register is not used.
 861   if (!MRI->use_nodbg_empty(CmpInstr->getOperand(0).getReg()))
 862     return false;
 863
 864   // Get the unique definition of SrcReg.
 865   MachineInstr *MI = MRI->getUniqueVRegDef(SrcReg);
 866   if (!MI)
 867     return false;
 868
 869   bool CheckOnlyCCWrites = false;
 870   const TargetRegisterInfo *TRI = &getRegisterInfo();
 871   if (modifiesConditionCode(MI, CmpInstr, CheckOnlyCCWrites, TRI))
 872     return false;
 873
 874   unsigned NewOpc = MI->getOpcode();
 875   switch (MI->getOpcode()) {
 876   default:
 877     return false;
 878   case AArch64::ADDSWrr:
 879   case AArch64::ADDSWri:
 880   case AArch64::ADDSXrr:
 881   case AArch64::ADDSXri:
 882   case AArch64::SUBSWrr:
 883   case AArch64::SUBSWri:
 884   case AArch64::SUBSXrr:
 885   case AArch64::SUBSXri:
 886     break;
 887   case AArch64::ADDWrr:    NewOpc = AArch64::ADDSWrr; break;
 888   case AArch64::ADDWri:    NewOpc = AArch64::ADDSWri; break;
 889   case AArch64::ADDXrr:    NewOpc = AArch64::ADDSXrr; break;
 890   case AArch64::ADDXri:    NewOpc = AArch64::ADDSXri; break;
 891   case AArch64::ADCWr:     NewOpc = AArch64::ADCSWr; break;
 892   case AArch64::ADCXr:     NewOpc = AArch64::ADCSXr; break;
 893   case AArch64::SUBWrr:    NewOpc = AArch64::SUBSWrr; break;
 894   case AArch64::SUBWri:    NewOpc = AArch64::SUBSWri; break;
 895   case AArch64::SUBXrr:    NewOpc = AArch64::SUBSXrr; break;
 896   case AArch64::SUBXri:    NewOpc = AArch64::SUBSXri; break;
 897   case AArch64::SBCWr:     NewOpc = AArch64::SBCSWr; break;
 898   case AArch64::SBCXr:     NewOpc = AArch64::SBCSXr; break;
 899   case AArch64::ANDWri:    NewOpc = AArch64::ANDSWri; break;
 900   case AArch64::ANDXri:    NewOpc = AArch64::ANDSXri; break;
 901   }
 902
 903   // Scan forward for the use of NZCV.
 904   // When checking against MI: if it's a conditional code requires
 905   // checking of V bit, then this is not safe to do.
 906   // It is safe to remove CmpInstr if NZCV is redefined or killed.
 907   // If we are done with the basic block, we need to check whether NZCV is
 908   // live-out.
 909   bool IsSafe = false;
 910   for (MachineBasicBlock::iterator I = CmpInstr,
 911                                    E = CmpInstr->getParent()->end();
 912        !IsSafe && ++I != E;) {
 913     const MachineInstr &Instr = *I;
 914     for (unsigned IO = 0, EO = Instr.getNumOperands(); !IsSafe && IO != EO;
 915          ++IO) {
 916       const MachineOperand &MO = Instr.getOperand(IO);
 917       if (MO.isRegMask() && MO.clobbersPhysReg(AArch64::NZCV)) {
 918         IsSafe = true;
 919         break;
 920       }
 921       if (!MO.isReg() || MO.getReg() != AArch64::NZCV)
 922         continue;
 923       if (MO.isDef()) {
 924         IsSafe = true;
 925         break;
 926       }
 927
 928       // Decode the condition code.
 929       unsigned Opc = Instr.getOpcode();
 930       AArch64CC::CondCode CC;
 931       switch (Opc) {
 932       default:
 933         return false;
 934       case AArch64::Bcc:
 935         CC = (AArch64CC::CondCode)Instr.getOperand(IO - 2).getImm();
 936         break;
 937       case AArch64::CSINVWr:
 938       case AArch64::CSINVXr:
 939       case AArch64::CSINCWr:
 940       case AArch64::CSINCXr:
 941       case AArch64::CSELWr:
 942       case AArch64::CSELXr:
 943       case AArch64::CSNEGWr:
 944       case AArch64::CSNEGXr:
 945       case AArch64::FCSELSrrr:
 946       case AArch64::FCSELDrrr:
 947         CC = (AArch64CC::CondCode)Instr.getOperand(IO - 1).getImm();
 948         break;
 949       }
 950
 951       // It is not safe to remove Compare instruction if Overflow(V) is used.
 952       switch (CC) {
 953       default:
 954         // NZCV can be used multiple times, we should continue.
 955         break;
 956       case AArch64CC::VS:
 957       case AArch64CC::VC:
 958       case AArch64CC::GE:
 959       case AArch64CC::LT:
 960       case AArch64CC::GT:
 961       case AArch64CC::LE:
 962         return false;
 963       }
 964     }
 965   }
 966
 967   // If NZCV is not killed nor re-defined, we should check whether it is
 968   // live-out. If it is live-out, do not optimize.
 969   if (!IsSafe) {
 970     MachineBasicBlock *ParentBlock = CmpInstr->getParent();
 971     for (auto *MBB : ParentBlock->successors())
 972       if (MBB->isLiveIn(AArch64::NZCV))
 973         return false;
 974   }
 975
 976   // Update the instruction to set NZCV.
 977   MI->setDesc(get(NewOpc));
 978   CmpInstr->eraseFromParent();
 979   bool succeeded = UpdateOperandRegClass(MI);
 980   (void)succeeded;
 981   assert(succeeded && "Some operands reg class are incompatible!");
 982   MI->addRegisterDefined(AArch64::NZCV, TRI);
 983   return true;
 984 }
 985
 986 bool
 987 AArch64InstrInfo::expandPostRAPseudo(MachineBasicBlock::iterator MI) const {
 988   if (MI->getOpcode() != TargetOpcode::LOAD_STACK_GUARD)
 989     return false;
 990
 991   MachineBasicBlock &MBB = *MI->getParent();
 992   DebugLoc DL = MI->getDebugLoc();
 993   unsigned Reg = MI->getOperand(0).getReg();
 994   const GlobalValue *GV =
 995       cast<GlobalValue>((*MI->memoperands_begin())->getValue());
 996   const TargetMachine &TM = MBB.getParent()->getTarget();
 997   unsigned char OpFlags = Subtarget.ClassifyGlobalReference(GV, TM);
 998   const unsigned char MO_NC = AArch64II::MO_NC;
 999
1000   if ((OpFlags & AArch64II::MO_GOT) != 0) {
1001     BuildMI(MBB, MI, DL, get(AArch64::LOADgot), Reg)
1002         .addGlobalAddress(GV, 0, AArch64II::MO_GOT);
1003     BuildMI(MBB, MI, DL, get(AArch64::LDRXui), Reg)
1004         .addReg(Reg, RegState::Kill).addImm(0)
1005         .addMemOperand(*MI->memoperands_begin());
1006   } else if (TM.getCodeModel() == CodeModel::Large) {
1007     BuildMI(MBB, MI, DL, get(AArch64::MOVZXi), Reg)
1008         .addGlobalAddress(GV, 0, AArch64II::MO_G3).addImm(48);
1009     BuildMI(MBB, MI, DL, get(AArch64::MOVKXi), Reg)
1010         .addReg(Reg, RegState::Kill)
1011         .addGlobalAddress(GV, 0, AArch64II::MO_G2 | MO_NC).addImm(32);
1012     BuildMI(MBB, MI, DL, get(AArch64::MOVKXi), Reg)
1013         .addReg(Reg, RegState::Kill)
1014         .addGlobalAddress(GV, 0, AArch64II::MO_G1 | MO_NC).addImm(16);
1015     BuildMI(MBB, MI, DL, get(AArch64::MOVKXi), Reg)
1016         .addReg(Reg, RegState::Kill)
1017         .addGlobalAddress(GV, 0, AArch64II::MO_G0 | MO_NC).addImm(0);
1018     BuildMI(MBB, MI, DL, get(AArch64::LDRXui), Reg)
1019         .addReg(Reg, RegState::Kill).addImm(0)
1020         .addMemOperand(*MI->memoperands_begin());
1021   } else {
1022     BuildMI(MBB, MI, DL, get(AArch64::ADRP), Reg)
1023         .addGlobalAddress(GV, 0, OpFlags | AArch64II::MO_PAGE);
1024     unsigned char LoFlags = OpFlags | AArch64II::MO_PAGEOFF | MO_NC;
1025     BuildMI(MBB, MI, DL, get(AArch64::LDRXui), Reg)
1026         .addReg(Reg, RegState::Kill)
1027         .addGlobalAddress(GV, 0, LoFlags)
1028         .addMemOperand(*MI->memoperands_begin());
1029   }
1030
1031   MBB.erase(MI);
1032
1033   return true;
1034 }
1035
1036 /// Return true if this is this instruction has a non-zero immediate
1037 bool AArch64InstrInfo::hasShiftedReg(const MachineInstr *MI) const {
1038   switch (MI->getOpcode()) {
1039   default:
1040     break;
1041   case AArch64::ADDSWrs:
1042   case AArch64::ADDSXrs:
1043   case AArch64::ADDWrs:
1044   case AArch64::ADDXrs:
1045   case AArch64::ANDSWrs:
1046   case AArch64::ANDSXrs:
1047   case AArch64::ANDWrs:
1048   case AArch64::ANDXrs:
1049   case AArch64::BICSWrs:
1050   case AArch64::BICSXrs:
1051   case AArch64::BICWrs:
1052   case AArch64::BICXrs:
1053   case AArch64::CRC32Brr:
1054   case AArch64::CRC32CBrr:
1055   case AArch64::CRC32CHrr:
1056   case AArch64::CRC32CWrr:
1057   case AArch64::CRC32CXrr:
1058   case AArch64::CRC32Hrr:
1059   case AArch64::CRC32Wrr:
1060   case AArch64::CRC32Xrr:
1061   case AArch64::EONWrs:
1062   case AArch64::EONXrs:
1063   case AArch64::EORWrs:
1064   case AArch64::EORXrs:
1065   case AArch64::ORNWrs:
1066   case AArch64::ORNXrs:
1067   case AArch64::ORRWrs:
1068   case AArch64::ORRXrs:
1069   case AArch64::SUBSWrs:
1070   case AArch64::SUBSXrs:
1071   case AArch64::SUBWrs:
1072   case AArch64::SUBXrs:
1073     if (MI->getOperand(3).isImm()) {
1074       unsigned val = MI->getOperand(3).getImm();
1075       return (val != 0);
1076     }
1077     break;
1078   }
1079   return false;
1080 }
1081
1082 /// Return true if this is this instruction has a non-zero immediate
1083 bool AArch64InstrInfo::hasExtendedReg(const MachineInstr *MI) const {
1084   switch (MI->getOpcode()) {
1085   default:
1086     break;
1087   case AArch64::ADDSWrx:
1088   case AArch64::ADDSXrx:
1089   case AArch64::ADDSXrx64:
1090   case AArch64::ADDWrx:
1091   case AArch64::ADDXrx:
1092   case AArch64::ADDXrx64:
1093   case AArch64::SUBSWrx:
1094   case AArch64::SUBSXrx:
1095   case AArch64::SUBSXrx64:
1096   case AArch64::SUBWrx:
1097   case AArch64::SUBXrx:
1098   case AArch64::SUBXrx64:
1099     if (MI->getOperand(3).isImm()) {
1100       unsigned val = MI->getOperand(3).getImm();
1101       return (val != 0);
1102     }
1103     break;
1104   }
1105
1106   return false;
1107 }
1108
1109 // Return true if this instruction simply sets its single destination register
1110 // to zero. This is equivalent to a register rename of the zero-register.
1111 bool AArch64InstrInfo::isGPRZero(const MachineInstr *MI) const {
1112   switch (MI->getOpcode()) {
1113   default:
1114     break;
1115   case AArch64::MOVZWi:
1116   case AArch64::MOVZXi: // movz Rd, #0 (LSL #0)
1117     if (MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0) {
1118       assert(MI->getDesc().getNumOperands() == 3 &&
1119              MI->getOperand(2).getImm() == 0 && "invalid MOVZi operands");
1120       return true;
1121     }
1122     break;
1123   case AArch64::ANDWri: // and Rd, Rzr, #imm
1124     return MI->getOperand(1).getReg() == AArch64::WZR;
1125   case AArch64::ANDXri:
1126     return MI->getOperand(1).getReg() == AArch64::XZR;
1127   case TargetOpcode::COPY:
1128     return MI->getOperand(1).getReg() == AArch64::WZR;
1129   }
1130   return false;
1131 }
1132
1133 // Return true if this instruction simply renames a general register without
1134 // modifying bits.
1135 bool AArch64InstrInfo::isGPRCopy(const MachineInstr *MI) const {
1136   switch (MI->getOpcode()) {
1137   default:
1138     break;
1139   case TargetOpcode::COPY: {
1140     // GPR32 copies will by lowered to ORRXrs
1141     unsigned DstReg = MI->getOperand(0).getReg();
1142     return (AArch64::GPR32RegClass.contains(DstReg) ||
1143             AArch64::GPR64RegClass.contains(DstReg));
1144   }
1145   case AArch64::ORRXrs: // orr Xd, Xzr, Xm (LSL #0)
1146     if (MI->getOperand(1).getReg() == AArch64::XZR) {
1147       assert(MI->getDesc().getNumOperands() == 4 &&
1148              MI->getOperand(3).getImm() == 0 && "invalid ORRrs operands");
1149       return true;
1150     }
1151     break;
1152   case AArch64::ADDXri: // add Xd, Xn, #0 (LSL #0)
1153     if (MI->getOperand(2).getImm() == 0) {
1154       assert(MI->getDesc().getNumOperands() == 4 &&
1155              MI->getOperand(3).getImm() == 0 && "invalid ADDXri operands");
1156       return true;
1157     }
1158     break;
1159   }
1160   return false;
1161 }
1162
1163 // Return true if this instruction simply renames a general register without
1164 // modifying bits.
1165 bool AArch64InstrInfo::isFPRCopy(const MachineInstr *MI) const {
1166   switch (MI->getOpcode()) {
1167   default:
1168     break;
1169   case TargetOpcode::COPY: {
1170     // FPR64 copies will by lowered to ORR.16b
1171     unsigned DstReg = MI->getOperand(0).getReg();
1172     return (AArch64::FPR64RegClass.contains(DstReg) ||
1173             AArch64::FPR128RegClass.contains(DstReg));
1174   }
1175   case AArch64::ORRv16i8:
1176     if (MI->getOperand(1).getReg() == MI->getOperand(2).getReg()) {
1177       assert(MI->getDesc().getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1178              "invalid ORRv16i8 operands");
1179       return true;
1180     }
1181     break;
1182   }
1183   return false;
1184 }
1185
1186 unsigned AArch64InstrInfo::isLoadFromStackSlot(const MachineInstr *MI,
1187                                                int &FrameIndex) const {
1188   switch (MI->getOpcode()) {
1189   default:
1190     break;
1191   case AArch64::LDRWui:
1192   case AArch64::LDRXui:
1193   case AArch64::LDRBui:
1194   case AArch64::LDRHui:
1195   case AArch64::LDRSui:
1196   case AArch64::LDRDui:
1197   case AArch64::LDRQui:
1198     if (MI->getOperand(0).getSubReg() == 0 && MI->getOperand(1).isFI() &&
1199         MI->getOperand(2).isImm() && MI->getOperand(2).getImm() == 0) {
1200       FrameIndex = MI->getOperand(1).getIndex();
1201       return MI->getOperand(0).getReg();
1202     }
1203     break;
1204   }
1205
1206   return 0;
1207 }
1208
1209 unsigned AArch64InstrInfo::isStoreToStackSlot(const MachineInstr *MI,
1210                                               int &FrameIndex) const {
1211   switch (MI->getOpcode()) {
1212   default:
1213     break;
1214   case AArch64::STRWui:
1215   case AArch64::STRXui:
1216   case AArch64::STRBui:
1217   case AArch64::STRHui:
1218   case AArch64::STRSui:
1219   case AArch64::STRDui:
1220   case AArch64::STRQui:
1221     if (MI->getOperand(0).getSubReg() == 0 && MI->getOperand(1).isFI() &&
1222         MI->getOperand(2).isImm() && MI->getOperand(2).getImm() == 0) {
1223       FrameIndex = MI->getOperand(1).getIndex();
1224       return MI->getOperand(0).getReg();
1225     }
1226     break;
1227   }
1228   return 0;
1229 }
1230
1231 /// Return true if this is load/store scales or extends its register offset.
1232 /// This refers to scaling a dynamic index as opposed to scaled immediates.
1233 /// MI should be a memory op that allows scaled addressing.
1234 bool AArch64InstrInfo::isScaledAddr(const MachineInstr *MI) const {
1235   switch (MI->getOpcode()) {
1236   default:
1237     break;
1238   case AArch64::LDRBBroW:
1239   case AArch64::LDRBroW:
1240   case AArch64::LDRDroW:
1241   case AArch64::LDRHHroW:
1242   case AArch64::LDRHroW:
1243   case AArch64::LDRQroW:
1244   case AArch64::LDRSBWroW:
1245   case AArch64::LDRSBXroW:
1246   case AArch64::LDRSHWroW:
1247   case AArch64::LDRSHXroW:
1248   case AArch64::LDRSWroW:
1249   case AArch64::LDRSroW:
1250   case AArch64::LDRWroW:
1251   case AArch64::LDRXroW:
1252   case AArch64::STRBBroW:
1253   case AArch64::STRBroW:
1254   case AArch64::STRDroW:
1255   case AArch64::STRHHroW:
1256   case AArch64::STRHroW:
1257   case AArch64::STRQroW:
1258   case AArch64::STRSroW:
1259   case AArch64::STRWroW:
1260   case AArch64::STRXroW:
1261   case AArch64::LDRBBroX:
1262   case AArch64::LDRBroX:
1263   case AArch64::LDRDroX:
1264   case AArch64::LDRHHroX:
1265   case AArch64::LDRHroX:
1266   case AArch64::LDRQroX:
1267   case AArch64::LDRSBWroX:
1268   case AArch64::LDRSBXroX:
1269   case AArch64::LDRSHWroX:
1270   case AArch64::LDRSHXroX:
1271   case AArch64::LDRSWroX:
1272   case AArch64::LDRSroX:
1273   case AArch64::LDRWroX:
1274   case AArch64::LDRXroX:
1275   case AArch64::STRBBroX:
1276   case AArch64::STRBroX:
1277   case AArch64::STRDroX:
1278   case AArch64::STRHHroX:
1279   case AArch64::STRHroX:
1280   case AArch64::STRQroX:
1281   case AArch64::STRSroX:
1282   case AArch64::STRWroX:
1283   case AArch64::STRXroX:
1284
1285     unsigned Val = MI->getOperand(3).getImm();
1286     AArch64_AM::ShiftExtendType ExtType = AArch64_AM::getMemExtendType(Val);
1287     return (ExtType != AArch64_AM::UXTX) || AArch64_AM::getMemDoShift(Val);
1288   }
1289   return false;
1290 }
1291
1292 /// Check all MachineMemOperands for a hint to suppress pairing.
1293 bool AArch64InstrInfo::isLdStPairSuppressed(const MachineInstr *MI) const {
1294   assert(MOSuppressPair < (1 << MachineMemOperand::MOTargetNumBits) &&
1295          "Too many target MO flags");
1296   for (auto *MM : MI->memoperands()) {
1297     if (MM->getFlags() &
1298         (MOSuppressPair << MachineMemOperand::MOTargetStartBit)) {
1299       return true;
1300     }
1301   }
1302   return false;
1303 }
1304
1305 /// Set a flag on the first MachineMemOperand to suppress pairing.
1306 void AArch64InstrInfo::suppressLdStPair(MachineInstr *MI) const {
1307   if (MI->memoperands_empty())
1308     return;
1309
1310   assert(MOSuppressPair < (1 << MachineMemOperand::MOTargetNumBits) &&
1311          "Too many target MO flags");
1312   (*MI->memoperands_begin())
1313       ->setFlags(MOSuppressPair << MachineMemOperand::MOTargetStartBit);
1314 }
1315
1316 bool
1317 AArch64InstrInfo::getMemOpBaseRegImmOfs(MachineInstr *LdSt, unsigned &BaseReg,
1318                                         unsigned &Offset,
1319                                         const TargetRegisterInfo *TRI) const {
1320   switch (LdSt->getOpcode()) {
1321   default:
1322     return false;
1323   case AArch64::STRSui:
1324   case AArch64::STRDui:
1325   case AArch64::STRQui:
1326   case AArch64::STRXui:
1327   case AArch64::STRWui:
1328   case AArch64::LDRSui:
1329   case AArch64::LDRDui:
1330   case AArch64::LDRQui:
1331   case AArch64::LDRXui:
1332   case AArch64::LDRWui:
1333     if (!LdSt->getOperand(1).isReg() || !LdSt->getOperand(2).isImm())
1334       return false;
1335     BaseReg = LdSt->getOperand(1).getReg();
1336     MachineFunction &MF = *LdSt->getParent()->getParent();
1337     unsigned Width = getRegClass(LdSt->getDesc(), 0, TRI, MF)->getSize();
1338     Offset = LdSt->getOperand(2).getImm() * Width;
1339     return true;
1340   };
1341 }
1342
1343 bool AArch64InstrInfo::getMemOpBaseRegImmOfsWidth(
1344     MachineInstr *LdSt, unsigned &BaseReg, int &Offset, int &Width,
1345     const TargetRegisterInfo *TRI) const {
1346   // Handle only loads/stores with base register followed by immediate offset.
1347   if (LdSt->getNumOperands() != 3)
1348     return false;
1349   if (!LdSt->getOperand(1).isReg() || !LdSt->getOperand(2).isImm())
1350     return false;
1351
1352   // Offset is calculated as the immediate operand multiplied by the scaling factor.
1353   // Unscaled instructions have scaling factor set to 1.
1354   int Scale = 0;
1355   switch (LdSt->getOpcode()) {
1356   default:
1357     return false;
1358   case AArch64::LDURQi:
1359   case AArch64::STURQi:
1360     Width = 16;
1361     Scale = 1;
1362     break;
1363   case AArch64::LDURXi:
1364   case AArch64::LDURDi:
1365   case AArch64::STURXi:
1366   case AArch64::STURDi:
1367     Width = 8;
1368     Scale = 1;
1369     break;
1370   case AArch64::LDURWi:
1371   case AArch64::LDURSi:
1372   case AArch64::LDURSWi:
1373   case AArch64::STURWi:
1374   case AArch64::STURSi:
1375     Width = 4;
1376     Scale = 1;
1377     break;
1378   case AArch64::LDURHi:
1379   case AArch64::LDURHHi:
1380   case AArch64::LDURSHXi:
1381   case AArch64::LDURSHWi:
1382   case AArch64::STURHi:
1383   case AArch64::STURHHi:
1384     Width = 2;
1385     Scale = 1;
1386     break;
1387   case AArch64::LDURBi:
1388   case AArch64::LDURBBi:
1389   case AArch64::LDURSBXi:
1390   case AArch64::LDURSBWi:
1391   case AArch64::STURBi:
1392   case AArch64::STURBBi:
1393     Width = 1;
1394     Scale = 1;
1395     break;
1396   case AArch64::LDRXui:
1397   case AArch64::STRXui:
1398     Scale = Width = 8;
1399     break;
1400   case AArch64::LDRWui:
1401   case AArch64::STRWui:
1402     Scale = Width = 4;
1403     break;
1404   case AArch64::LDRBui:
1405   case AArch64::STRBui:
1406     Scale = Width = 1;
1407     break;
1408   case AArch64::LDRHui:
1409   case AArch64::STRHui:
1410     Scale = Width = 2;
1411     break;
1412   case AArch64::LDRSui:
1413   case AArch64::STRSui:
1414     Scale = Width = 4;
1415     break;
1416   case AArch64::LDRDui:
1417   case AArch64::STRDui:
1418     Scale = Width = 8;
1419     break;
1420   case AArch64::LDRQui:
1421   case AArch64::STRQui:
1422     Scale = Width = 16;
1423     break;
1424   case AArch64::LDRBBui:
1425   case AArch64::STRBBui:
1426     Scale = Width = 1;
1427     break;
1428   case AArch64::LDRHHui:
1429   case AArch64::STRHHui:
1430     Scale = Width = 2;
1431     break;
1432   };
1433
1434   BaseReg = LdSt->getOperand(1).getReg();
1435   Offset = LdSt->getOperand(2).getImm() * Scale;
1436   return true;
1437 }
1438
1439 /// Detect opportunities for ldp/stp formation.
1440 ///
1441 /// Only called for LdSt for which getMemOpBaseRegImmOfs returns true.
1442 bool AArch64InstrInfo::shouldClusterLoads(MachineInstr *FirstLdSt,
1443                                           MachineInstr *SecondLdSt,
1444                                           unsigned NumLoads) const {
1445   // Only cluster up to a single pair.
1446   if (NumLoads > 1)
1447     return false;
1448   if (FirstLdSt->getOpcode() != SecondLdSt->getOpcode())
1449     return false;
1450   // getMemOpBaseRegImmOfs guarantees that oper 2 isImm.
1451   unsigned Ofs1 = FirstLdSt->getOperand(2).getImm();
1452   // Allow 6 bits of positive range.
1453   if (Ofs1 > 64)
1454     return false;
1455   // The caller should already have ordered First/SecondLdSt by offset.
1456   unsigned Ofs2 = SecondLdSt->getOperand(2).getImm();
1457   return Ofs1 + 1 == Ofs2;
1458 }
1459
1460 bool AArch64InstrInfo::shouldScheduleAdjacent(MachineInstr *First,
1461                                               MachineInstr *Second) const {
1462   if (Subtarget.isCyclone()) {
1463     // Cyclone can fuse CMN, CMP, TST followed by Bcc.
1464     unsigned SecondOpcode = Second->getOpcode();
1465     if (SecondOpcode == AArch64::Bcc) {
1466       switch (First->getOpcode()) {
1467       default:
1468         return false;
1469       case AArch64::SUBSWri:
1470       case AArch64::ADDSWri:
1471       case AArch64::ANDSWri:
1472       case AArch64::SUBSXri:
1473       case AArch64::ADDSXri:
1474       case AArch64::ANDSXri:
1475         return true;
1476       }
1477     }
1478     // Cyclone B0 also supports ALU operations followed by CBZ/CBNZ.
1479     if (SecondOpcode == AArch64::CBNZW || SecondOpcode == AArch64::CBNZX ||
1480         SecondOpcode == AArch64::CBZW || SecondOpcode == AArch64::CBZX) {
1481       switch (First->getOpcode()) {
1482       default:
1483         return false;
1484       case AArch64::ADDWri:
1485       case AArch64::ADDXri:
1486       case AArch64::ANDWri:
1487       case AArch64::ANDXri:
1488       case AArch64::EORWri:
1489       case AArch64::EORXri:
1490       case AArch64::ORRWri:
1491       case AArch64::ORRXri:
1492       case AArch64::SUBWri:
1493       case AArch64::SUBXri:
1494         return true;
1495       }
1496     }
1497   }
1498   return false;
1499 }
1500
1501 MachineInstr *AArch64InstrInfo::emitFrameIndexDebugValue(
1502     MachineFunction &MF, int FrameIx, uint64_t Offset, const MDNode *Var,
1503     const MDNode *Expr, DebugLoc DL) const {
1504   MachineInstrBuilder MIB = BuildMI(MF, DL, get(AArch64::DBG_VALUE))
1505                                 .addFrameIndex(FrameIx)
1506                                 .addImm(0)
1507                                 .addImm(Offset)
1508                                 .addMetadata(Var)
1509                                 .addMetadata(Expr);
1510   return &*MIB;
1511 }
1512
1513 static const MachineInstrBuilder &AddSubReg(const MachineInstrBuilder &MIB,
1514                                             unsigned Reg, unsigned SubIdx,
1515                                             unsigned State,
1516                                             const TargetRegisterInfo *TRI) {
1517   if (!SubIdx)
1518     return MIB.addReg(Reg, State);
1519
1520   if (TargetRegisterInfo::isPhysicalRegister(Reg))
1521     return MIB.addReg(TRI->getSubReg(Reg, SubIdx), State);
1522   return MIB.addReg(Reg, State, SubIdx);
1523 }
1524
1525 static bool forwardCopyWillClobberTuple(unsigned DestReg, unsigned SrcReg,
1526                                         unsigned NumRegs) {
1527   // We really want the positive remainder mod 32 here, that happens to be
1528   // easily obtainable with a mask.
1529   return ((DestReg - SrcReg) & 0x1f) < NumRegs;
1530 }
1531
1532 void AArch64InstrInfo::copyPhysRegTuple(
1533     MachineBasicBlock &MBB, MachineBasicBlock::iterator I, DebugLoc DL,
1534     unsigned DestReg, unsigned SrcReg, bool KillSrc, unsigned Opcode,
1535     llvm::ArrayRef<unsigned> Indices) const {
1536   assert(Subtarget.hasNEON() &&
1537          "Unexpected register copy without NEON");
1538   const TargetRegisterInfo *TRI = &getRegisterInfo();
1539   uint16_t DestEncoding = TRI->getEncodingValue(DestReg);
1540   uint16_t SrcEncoding = TRI->getEncodingValue(SrcReg);
1541   unsigned NumRegs = Indices.size();
1542
1543   int SubReg = 0, End = NumRegs, Incr = 1;
1544   if (forwardCopyWillClobberTuple(DestEncoding, SrcEncoding, NumRegs)) {
1545     SubReg = NumRegs - 1;
1546     End = -1;
1547     Incr = -1;
1548   }
1549
1550   for (; SubReg != End; SubReg += Incr) {
1551     const MachineInstrBuilder MIB = BuildMI(MBB, I, DL, get(Opcode));
1552     AddSubReg(MIB, DestReg, Indices[SubReg], RegState::Define, TRI);
1553     AddSubReg(MIB, SrcReg, Indices[SubReg], 0, TRI);
1554     AddSubReg(MIB, SrcReg, Indices[SubReg], getKillRegState(KillSrc), TRI);
1555   }
1556 }
1557
1558 void AArch64InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
1559                                    MachineBasicBlock::iterator I, DebugLoc DL,
1560                                    unsigned DestReg, unsigned SrcReg,
1561                                    bool KillSrc) const {
1562   if (AArch64::GPR32spRegClass.contains(DestReg) &&
1563       (AArch64::GPR32spRegClass.contains(SrcReg) || SrcReg == AArch64::WZR)) {
1564     const TargetRegisterInfo *TRI = &getRegisterInfo();
1565
1566     if (DestReg == AArch64::WSP || SrcReg == AArch64::WSP) {
1567       // If either operand is WSP, expand to ADD #0.
1568       if (Subtarget.hasZeroCycleRegMove()) {
1569         // Cyclone recognizes "ADD Xd, Xn, #0" as a zero-cycle register move.
1570         unsigned DestRegX = TRI->getMatchingSuperReg(DestReg, AArch64::sub_32,
1571                                                      &AArch64::GPR64spRegClass);
1572         unsigned SrcRegX = TRI->getMatchingSuperReg(SrcReg, AArch64::sub_32,
1573                                                     &AArch64::GPR64spRegClass);
1574         // This instruction is reading and writing X registers.  This may upset
1575         // the register scavenger and machine verifier, so we need to indicate
1576         // that we are reading an undefined value from SrcRegX, but a proper
1577         // value from SrcReg.
1578         BuildMI(MBB, I, DL, get(AArch64::ADDXri), DestRegX)
1579             .addReg(SrcRegX, RegState::Undef)
1580             .addImm(0)
1581             .addImm(AArch64_AM::getShifterImm(AArch64_AM::LSL, 0))
1582             .addReg(SrcReg, RegState::Implicit | getKillRegState(KillSrc));
1583       } else {
1584         BuildMI(MBB, I, DL, get(AArch64::ADDWri), DestReg)
1585             .addReg(SrcReg, getKillRegState(KillSrc))
1586             .addImm(0)
1587             .addImm(AArch64_AM::getShifterImm(AArch64_AM::LSL, 0));
1588       }
1589     } else if (SrcReg == AArch64::WZR && Subtarget.hasZeroCycleZeroing()) {
1590       BuildMI(MBB, I, DL, get(AArch64::MOVZWi), DestReg).addImm(0).addImm(
1591           AArch64_AM::getShifterImm(AArch64_AM::LSL, 0));
1592     } else {
1593       if (Subtarget.hasZeroCycleRegMove()) {
1594         // Cyclone recognizes "ORR Xd, XZR, Xm" as a zero-cycle register move.
1595         unsigned DestRegX = TRI->getMatchingSuperReg(DestReg, AArch64::sub_32,
1596                                                      &AArch64::GPR64spRegClass);
1597         unsigned SrcRegX = TRI->getMatchingSuperReg(SrcReg, AArch64::sub_32,
1598                                                     &AArch64::GPR64spRegClass);
1599         // This instruction is reading and writing X registers.  This may upset
1600         // the register scavenger and machine verifier, so we need to indicate
1601         // that we are reading an undefined value from SrcRegX, but a proper
1602         // value from SrcReg.
1603         BuildMI(MBB, I, DL, get(AArch64::ORRXrr), DestRegX)
1604             .addReg(AArch64::XZR)
1605             .addReg(SrcRegX, RegState::Undef)
1606             .addReg(SrcReg, RegState::Implicit | getKillRegState(KillSrc));
1607       } else {
1608         // Otherwise, expand to ORR WZR.
1609         BuildMI(MBB, I, DL, get(AArch64::ORRWrr), DestReg)
1610             .addReg(AArch64::WZR)
1611             .addReg(SrcReg, getKillRegState(KillSrc));
1612       }
1613     }
1614     return;
1615   }
1616
1617   if (AArch64::GPR64spRegClass.contains(DestReg) &&
1618       (AArch64::GPR64spRegClass.contains(SrcReg) || SrcReg == AArch64::XZR)) {
1619     if (DestReg == AArch64::SP || SrcReg == AArch64::SP) {
1620       // If either operand is SP, expand to ADD #0.
1621       BuildMI(MBB, I, DL, get(AArch64::ADDXri), DestReg)
1622           .addReg(SrcReg, getKillRegState(KillSrc))
1623           .addImm(0)
1624           .addImm(AArch64_AM::getShifterImm(AArch64_AM::LSL, 0));
1625     } else if (SrcReg == AArch64::XZR && Subtarget.hasZeroCycleZeroing()) {
1626       BuildMI(MBB, I, DL, get(AArch64::MOVZXi), DestReg).addImm(0).addImm(
1627           AArch64_AM::getShifterImm(AArch64_AM::LSL, 0));
1628     } else {
1629       // Otherwise, expand to ORR XZR.
1630       BuildMI(MBB, I, DL, get(AArch64::ORRXrr), DestReg)
1631           .addReg(AArch64::XZR)
1632           .addReg(SrcReg, getKillRegState(KillSrc));
1633     }
1634     return;
1635   }
1636
1637   // Copy a DDDD register quad by copying the individual sub-registers.
1638   if (AArch64::DDDDRegClass.contains(DestReg) &&
1639       AArch64::DDDDRegClass.contains(SrcReg)) {
1640     static const unsigned Indices[] = { AArch64::dsub0, AArch64::dsub1,
1641                                         AArch64::dsub2, AArch64::dsub3 };
1642     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, AArch64::ORRv8i8,
1643                      Indices);
1644     return;
1645   }
1646
1647   // Copy a DDD register triple by copying the individual sub-registers.
1648   if (AArch64::DDDRegClass.contains(DestReg) &&
1649       AArch64::DDDRegClass.contains(SrcReg)) {
1650     static const unsigned Indices[] = { AArch64::dsub0, AArch64::dsub1,
1651                                         AArch64::dsub2 };
1652     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, AArch64::ORRv8i8,
1653                      Indices);
1654     return;
1655   }
1656
1657   // Copy a DD register pair by copying the individual sub-registers.
1658   if (AArch64::DDRegClass.contains(DestReg) &&
1659       AArch64::DDRegClass.contains(SrcReg)) {
1660     static const unsigned Indices[] = { AArch64::dsub0, AArch64::dsub1 };
1661     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, AArch64::ORRv8i8,
1662                      Indices);
1663     return;
1664   }
1665
1666   // Copy a QQQQ register quad by copying the individual sub-registers.
1667   if (AArch64::QQQQRegClass.contains(DestReg) &&
1668       AArch64::QQQQRegClass.contains(SrcReg)) {
1669     static const unsigned Indices[] = { AArch64::qsub0, AArch64::qsub1,
1670                                         AArch64::qsub2, AArch64::qsub3 };
1671     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, AArch64::ORRv16i8,
1672                      Indices);
1673     return;
1674   }
1675
1676   // Copy a QQQ register triple by copying the individual sub-registers.
1677   if (AArch64::QQQRegClass.contains(DestReg) &&
1678       AArch64::QQQRegClass.contains(SrcReg)) {
1679     static const unsigned Indices[] = { AArch64::qsub0, AArch64::qsub1,
1680                                         AArch64::qsub2 };
1681     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, AArch64::ORRv16i8,
1682                      Indices);
1683     return;
1684   }
1685
1686   // Copy a QQ register pair by copying the individual sub-registers.
1687   if (AArch64::QQRegClass.contains(DestReg) &&
1688       AArch64::QQRegClass.contains(SrcReg)) {
1689     static const unsigned Indices[] = { AArch64::qsub0, AArch64::qsub1 };
1690     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, AArch64::ORRv16i8,
1691                      Indices);
1692     return;
1693   }
1694
1695   if (AArch64::FPR128RegClass.contains(DestReg) &&
1696       AArch64::FPR128RegClass.contains(SrcReg)) {
1697     if(Subtarget.hasNEON()) {
1698       BuildMI(MBB, I, DL, get(AArch64::ORRv16i8), DestReg)
1699           .addReg(SrcReg)
1700           .addReg(SrcReg, getKillRegState(KillSrc));
1701     } else {
1702       BuildMI(MBB, I, DL, get(AArch64::STRQpre))
1703         .addReg(AArch64::SP, RegState::Define)
1704         .addReg(SrcReg, getKillRegState(KillSrc))
1705         .addReg(AArch64::SP)
1706         .addImm(-16);
1707       BuildMI(MBB, I, DL, get(AArch64::LDRQpre))
1708         .addReg(AArch64::SP, RegState::Define)
1709         .addReg(DestReg, RegState::Define)
1710         .addReg(AArch64::SP)
1711         .addImm(16);
1712     }
1713     return;
1714   }
1715
1716   if (AArch64::FPR64RegClass.contains(DestReg) &&
1717       AArch64::FPR64RegClass.contains(SrcReg)) {
1718     if(Subtarget.hasNEON()) {
1719       DestReg = RI.getMatchingSuperReg(DestReg, AArch64::dsub,
1720                                        &AArch64::FPR128RegClass);
1721       SrcReg = RI.getMatchingSuperReg(SrcReg, AArch64::dsub,
1722                                       &AArch64::FPR128RegClass);
1723       BuildMI(MBB, I, DL, get(AArch64::ORRv16i8), DestReg)
1724           .addReg(SrcReg)
1725           .addReg(SrcReg, getKillRegState(KillSrc));
1726     } else {
1727       BuildMI(MBB, I, DL, get(AArch64::FMOVDr), DestReg)
1728           .addReg(SrcReg, getKillRegState(KillSrc));
1729     }
1730     return;
1731   }
1732
1733   if (AArch64::FPR32RegClass.contains(DestReg) &&
1734       AArch64::FPR32RegClass.contains(SrcReg)) {
1735     if(Subtarget.hasNEON()) {
1736       DestReg = RI.getMatchingSuperReg(DestReg, AArch64::ssub,
1737                                        &AArch64::FPR128RegClass);
1738       SrcReg = RI.getMatchingSuperReg(SrcReg, AArch64::ssub,
1739                                       &AArch64::FPR128RegClass);
1740       BuildMI(MBB, I, DL, get(AArch64::ORRv16i8), DestReg)
1741           .addReg(SrcReg)
1742           .addReg(SrcReg, getKillRegState(KillSrc));
1743     } else {
1744       BuildMI(MBB, I, DL, get(AArch64::FMOVSr), DestReg)
1745           .addReg(SrcReg, getKillRegState(KillSrc));
1746     }
1747     return;
1748   }
1749
1750   if (AArch64::FPR16RegClass.contains(DestReg) &&
1751       AArch64::FPR16RegClass.contains(SrcReg)) {
1752     if(Subtarget.hasNEON()) {
1753       DestReg = RI.getMatchingSuperReg(DestReg, AArch64::hsub,
1754                                        &AArch64::FPR128RegClass);
1755       SrcReg = RI.getMatchingSuperReg(SrcReg, AArch64::hsub,
1756                                       &AArch64::FPR128RegClass);
1757       BuildMI(MBB, I, DL, get(AArch64::ORRv16i8), DestReg)
1758           .addReg(SrcReg)
1759           .addReg(SrcReg, getKillRegState(KillSrc));
1760     } else {
1761       DestReg = RI.getMatchingSuperReg(DestReg, AArch64::hsub,
1762                                        &AArch64::FPR32RegClass);
1763       SrcReg = RI.getMatchingSuperReg(SrcReg, AArch64::hsub,
1764                                       &AArch64::FPR32RegClass);
1765       BuildMI(MBB, I, DL, get(AArch64::FMOVSr), DestReg)
1766           .addReg(SrcReg, getKillRegState(KillSrc));
1767     }
1768     return;
1769   }
1770
1771   if (AArch64::FPR8RegClass.contains(DestReg) &&
1772       AArch64::FPR8RegClass.contains(SrcReg)) {
1773     if(Subtarget.hasNEON()) {
1774       DestReg = RI.getMatchingSuperReg(DestReg, AArch64::bsub,
1775                                        &AArch64::FPR128RegClass);
1776       SrcReg = RI.getMatchingSuperReg(SrcReg, AArch64::bsub,
1777                                       &AArch64::FPR128RegClass);
1778       BuildMI(MBB, I, DL, get(AArch64::ORRv16i8), DestReg)
1779           .addReg(SrcReg)
1780           .addReg(SrcReg, getKillRegState(KillSrc));
1781     } else {
1782       DestReg = RI.getMatchingSuperReg(DestReg, AArch64::bsub,
1783                                        &AArch64::FPR32RegClass);
1784       SrcReg = RI.getMatchingSuperReg(SrcReg, AArch64::bsub,
1785                                       &AArch64::FPR32RegClass);
1786       BuildMI(MBB, I, DL, get(AArch64::FMOVSr), DestReg)
1787           .addReg(SrcReg, getKillRegState(KillSrc));
1788     }
1789     return;
1790   }
1791
1792   // Copies between GPR64 and FPR64.
1793   if (AArch64::FPR64RegClass.contains(DestReg) &&
1794       AArch64::GPR64RegClass.contains(SrcReg)) {
1795     BuildMI(MBB, I, DL, get(AArch64::FMOVXDr), DestReg)
1796         .addReg(SrcReg, getKillRegState(KillSrc));
1797     return;
1798   }
1799   if (AArch64::GPR64RegClass.contains(DestReg) &&
1800       AArch64::FPR64RegClass.contains(SrcReg)) {
1801     BuildMI(MBB, I, DL, get(AArch64::FMOVDXr), DestReg)
1802         .addReg(SrcReg, getKillRegState(KillSrc));
1803     return;
1804   }
1805   // Copies between GPR32 and FPR32.
1806   if (AArch64::FPR32RegClass.contains(DestReg) &&
1807       AArch64::GPR32RegClass.contains(SrcReg)) {
1808     BuildMI(MBB, I, DL, get(AArch64::FMOVWSr), DestReg)
1809         .addReg(SrcReg, getKillRegState(KillSrc));
1810     return;
1811   }
1812   if (AArch64::GPR32RegClass.contains(DestReg) &&
1813       AArch64::FPR32RegClass.contains(SrcReg)) {
1814     BuildMI(MBB, I, DL, get(AArch64::FMOVSWr), DestReg)
1815         .addReg(SrcReg, getKillRegState(KillSrc));
1816     return;
1817   }
1818
1819   if (DestReg == AArch64::NZCV) {
1820     assert(AArch64::GPR64RegClass.contains(SrcReg) && "Invalid NZCV copy");
1821     BuildMI(MBB, I, DL, get(AArch64::MSR))
1822       .addImm(AArch64SysReg::NZCV)
1823       .addReg(SrcReg, getKillRegState(KillSrc))
1824       .addReg(AArch64::NZCV, RegState::Implicit | RegState::Define);
1825     return;
1826   }
1827
1828   if (SrcReg == AArch64::NZCV) {
1829     assert(AArch64::GPR64RegClass.contains(DestReg) && "Invalid NZCV copy");
1830     BuildMI(MBB, I, DL, get(AArch64::MRS))
1831       .addReg(DestReg)
1832       .addImm(AArch64SysReg::NZCV)
1833       .addReg(AArch64::NZCV, RegState::Implicit | getKillRegState(KillSrc));
1834     return;
1835   }
1836
1837   llvm_unreachable("unimplemented reg-to-reg copy");
1838 }
1839
1840 void AArch64InstrInfo::storeRegToStackSlot(
1841     MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned SrcReg,
1842     bool isKill, int FI, const TargetRegisterClass *RC,
1843     const TargetRegisterInfo *TRI) const {
1844   DebugLoc DL;
1845   if (MBBI != MBB.end())
1846     DL = MBBI->getDebugLoc();
1847   MachineFunction &MF = *MBB.getParent();
1848   MachineFrameInfo &MFI = *MF.getFrameInfo();
1849   unsigned Align = MFI.getObjectAlignment(FI);
1850
1851   MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(MF, FI);
1852   MachineMemOperand *MMO = MF.getMachineMemOperand(
1853       PtrInfo, MachineMemOperand::MOStore, MFI.getObjectSize(FI), Align);
1854   unsigned Opc = 0;
1855   bool Offset = true;
1856   switch (RC->getSize()) {
1857   case 1:
1858     if (AArch64::FPR8RegClass.hasSubClassEq(RC))
1859       Opc = AArch64::STRBui;
1860     break;
1861   case 2:
1862     if (AArch64::FPR16RegClass.hasSubClassEq(RC))
1863       Opc = AArch64::STRHui;
1864     break;
1865   case 4:
1866     if (AArch64::GPR32allRegClass.hasSubClassEq(RC)) {
1867       Opc = AArch64::STRWui;
1868       if (TargetRegisterInfo::isVirtualRegister(SrcReg))
1869         MF.getRegInfo().constrainRegClass(SrcReg, &AArch64::GPR32RegClass);
1870       else
1871         assert(SrcReg != AArch64::WSP);
1872     } else if (AArch64::FPR32RegClass.hasSubClassEq(RC))
1873       Opc = AArch64::STRSui;
1874     break;
1875   case 8:
1876     if (AArch64::GPR64allRegClass.hasSubClassEq(RC)) {
1877       Opc = AArch64::STRXui;
1878       if (TargetRegisterInfo::isVirtualRegister(SrcReg))
1879         MF.getRegInfo().constrainRegClass(SrcReg, &AArch64::GPR64RegClass);
1880       else
1881         assert(SrcReg != AArch64::SP);
1882     } else if (AArch64::FPR64RegClass.hasSubClassEq(RC))
1883       Opc = AArch64::STRDui;
1884     break;
1885   case 16:
1886     if (AArch64::FPR128RegClass.hasSubClassEq(RC))
1887       Opc = AArch64::STRQui;
1888     else if (AArch64::DDRegClass.hasSubClassEq(RC)) {
1889       assert(Subtarget.hasNEON() &&
1890              "Unexpected register store without NEON");
1891       Opc = AArch64::ST1Twov1d, Offset = false;
1892     }
1893     break;
1894   case 24:
1895     if (AArch64::DDDRegClass.hasSubClassEq(RC)) {
1896       assert(Subtarget.hasNEON() &&
1897              "Unexpected register store without NEON");
1898       Opc = AArch64::ST1Threev1d, Offset = false;
1899     }
1900     break;
1901   case 32:
1902     if (AArch64::DDDDRegClass.hasSubClassEq(RC)) {
1903       assert(Subtarget.hasNEON() &&
1904              "Unexpected register store without NEON");
1905       Opc = AArch64::ST1Fourv1d, Offset = false;
1906     } else if (AArch64::QQRegClass.hasSubClassEq(RC)) {
1907       assert(Subtarget.hasNEON() &&
1908              "Unexpected register store without NEON");
1909       Opc = AArch64::ST1Twov2d, Offset = false;
1910     }
1911     break;
1912   case 48:
1913     if (AArch64::QQQRegClass.hasSubClassEq(RC)) {
1914       assert(Subtarget.hasNEON() &&
1915              "Unexpected register store without NEON");
1916       Opc = AArch64::ST1Threev2d, Offset = false;
1917     }
1918     break;
1919   case 64:
1920     if (AArch64::QQQQRegClass.hasSubClassEq(RC)) {
1921       assert(Subtarget.hasNEON() &&
1922              "Unexpected register store without NEON");
1923       Opc = AArch64::ST1Fourv2d, Offset = false;
1924     }
1925     break;
1926   }
1927   assert(Opc && "Unknown register class");
1928
1929   const MachineInstrBuilder MI = BuildMI(MBB, MBBI, DL, get(Opc))
1930                                       .addReg(SrcReg, getKillRegState(isKill))
1931                                       .addFrameIndex(FI);
1932
1933   if (Offset)
1934     MI.addImm(0);
1935   MI.addMemOperand(MMO);
1936 }
1937
1938 void AArch64InstrInfo::loadRegFromStackSlot(
1939     MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned DestReg,
1940     int FI, const TargetRegisterClass *RC,
1941     const TargetRegisterInfo *TRI) const {
1942   DebugLoc DL;
1943   if (MBBI != MBB.end())
1944     DL = MBBI->getDebugLoc();
1945   MachineFunction &MF = *MBB.getParent();
1946   MachineFrameInfo &MFI = *MF.getFrameInfo();
1947   unsigned Align = MFI.getObjectAlignment(FI);
1948   MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(MF, FI);
1949   MachineMemOperand *MMO = MF.getMachineMemOperand(
1950       PtrInfo, MachineMemOperand::MOLoad, MFI.getObjectSize(FI), Align);
1951
1952   unsigned Opc = 0;
1953   bool Offset = true;
1954   switch (RC->getSize()) {
1955   case 1:
1956     if (AArch64::FPR8RegClass.hasSubClassEq(RC))
1957       Opc = AArch64::LDRBui;
1958     break;
1959   case 2:
1960     if (AArch64::FPR16RegClass.hasSubClassEq(RC))
1961       Opc = AArch64::LDRHui;
1962     break;
1963   case 4:
1964     if (AArch64::GPR32allRegClass.hasSubClassEq(RC)) {
1965       Opc = AArch64::LDRWui;
1966       if (TargetRegisterInfo::isVirtualRegister(DestReg))
1967         MF.getRegInfo().constrainRegClass(DestReg, &AArch64::GPR32RegClass);
1968       else
1969         assert(DestReg != AArch64::WSP);
1970     } else if (AArch64::FPR32RegClass.hasSubClassEq(RC))
1971       Opc = AArch64::LDRSui;
1972     break;
1973   case 8:
1974     if (AArch64::GPR64allRegClass.hasSubClassEq(RC)) {
1975       Opc = AArch64::LDRXui;
1976       if (TargetRegisterInfo::isVirtualRegister(DestReg))
1977         MF.getRegInfo().constrainRegClass(DestReg, &AArch64::GPR64RegClass);
1978       else
1979         assert(DestReg != AArch64::SP);
1980     } else if (AArch64::FPR64RegClass.hasSubClassEq(RC))
1981       Opc = AArch64::LDRDui;
1982     break;
1983   case 16:
1984     if (AArch64::FPR128RegClass.hasSubClassEq(RC))
1985       Opc = AArch64::LDRQui;
1986     else if (AArch64::DDRegClass.hasSubClassEq(RC)) {
1987       assert(Subtarget.hasNEON() &&
1988              "Unexpected register load without NEON");
1989       Opc = AArch64::LD1Twov1d, Offset = false;
1990     }
1991     break;
1992   case 24:
1993     if (AArch64::DDDRegClass.hasSubClassEq(RC)) {
1994       assert(Subtarget.hasNEON() &&
1995              "Unexpected register load without NEON");
1996       Opc = AArch64::LD1Threev1d, Offset = false;
1997     }
1998     break;
1999   case 32:
2000     if (AArch64::DDDDRegClass.hasSubClassEq(RC)) {
2001       assert(Subtarget.hasNEON() &&
2002              "Unexpected register load without NEON");
2003       Opc = AArch64::LD1Fourv1d, Offset = false;
2004     } else if (AArch64::QQRegClass.hasSubClassEq(RC)) {
2005       assert(Subtarget.hasNEON() &&
2006              "Unexpected register load without NEON");
2007       Opc = AArch64::LD1Twov2d, Offset = false;
2008     }
2009     break;
2010   case 48:
2011     if (AArch64::QQQRegClass.hasSubClassEq(RC)) {
2012       assert(Subtarget.hasNEON() &&
2013              "Unexpected register load without NEON");
2014       Opc = AArch64::LD1Threev2d, Offset = false;
2015     }
2016     break;
2017   case 64:
2018     if (AArch64::QQQQRegClass.hasSubClassEq(RC)) {
2019       assert(Subtarget.hasNEON() &&
2020              "Unexpected register load without NEON");
2021       Opc = AArch64::LD1Fourv2d, Offset = false;
2022     }
2023     break;
2024   }
2025   assert(Opc && "Unknown register class");
2026
2027   const MachineInstrBuilder MI = BuildMI(MBB, MBBI, DL, get(Opc))
2028                                       .addReg(DestReg, getDefRegState(true))
2029                                       .addFrameIndex(FI);
2030   if (Offset)
2031     MI.addImm(0);
2032   MI.addMemOperand(MMO);
2033 }
2034
2035 void llvm::emitFrameOffset(MachineBasicBlock &MBB,
2036                            MachineBasicBlock::iterator MBBI, DebugLoc DL,
2037                            unsigned DestReg, unsigned SrcReg, int Offset,
2038                            const TargetInstrInfo *TII,
2039                            MachineInstr::MIFlag Flag, bool SetNZCV) {
2040   if (DestReg == SrcReg && Offset == 0)
2041     return;
2042
2043   bool isSub = Offset < 0;
2044   if (isSub)
2045     Offset = -Offset;
2046
2047   // FIXME: If the offset won't fit in 24-bits, compute the offset into a
2048   // scratch register.  If DestReg is a virtual register, use it as the
2049   // scratch register; otherwise, create a new virtual register (to be
2050   // replaced by the scavenger at the end of PEI).  That case can be optimized
2051   // slightly if DestReg is SP which is always 16-byte aligned, so the scratch
2052   // register can be loaded with offset%8 and the add/sub can use an extending
2053   // instruction with LSL#3.
2054   // Currently the function handles any offsets but generates a poor sequence
2055   // of code.
2056   //  assert(Offset < (1 << 24) && "unimplemented reg plus immediate");
2057
2058   unsigned Opc;
2059   if (SetNZCV)
2060     Opc = isSub ? AArch64::SUBSXri : AArch64::ADDSXri;
2061   else
2062     Opc = isSub ? AArch64::SUBXri : AArch64::ADDXri;
2063   const unsigned MaxEncoding = 0xfff;
2064   const unsigned ShiftSize = 12;
2065   const unsigned MaxEncodableValue = MaxEncoding << ShiftSize;
2066   while (((unsigned)Offset) >= (1 << ShiftSize)) {
2067     unsigned ThisVal;
2068     if (((unsigned)Offset) > MaxEncodableValue) {
2069       ThisVal = MaxEncodableValue;
2070     } else {
2071       ThisVal = Offset & MaxEncodableValue;
2072     }
2073     assert((ThisVal >> ShiftSize) <= MaxEncoding &&
2074            "Encoding cannot handle value that big");
2075     BuildMI(MBB, MBBI, DL, TII->get(Opc), DestReg)
2076         .addReg(SrcReg)
2077         .addImm(ThisVal >> ShiftSize)
2078         .addImm(AArch64_AM::getShifterImm(AArch64_AM::LSL, ShiftSize))
2079         .setMIFlag(Flag);
2080
2081     SrcReg = DestReg;
2082     Offset -= ThisVal;
2083     if (Offset == 0)
2084       return;
2085   }
2086   BuildMI(MBB, MBBI, DL, TII->get(Opc), DestReg)
2087       .addReg(SrcReg)
2088       .addImm(Offset)
2089       .addImm(AArch64_AM::getShifterImm(AArch64_AM::LSL, 0))
2090       .setMIFlag(Flag);
2091 }
2092
2093 MachineInstr *AArch64InstrInfo::foldMemoryOperandImpl(
2094     MachineFunction &MF, MachineInstr *MI, ArrayRef<unsigned> Ops,
2095     MachineBasicBlock::iterator InsertPt, int FrameIndex) const {
2096   // This is a bit of a hack. Consider this instruction:
2097   //
2098   //   %vreg0<def> = COPY %SP; GPR64all:%vreg0
2099   //
2100   // We explicitly chose GPR64all for the virtual register so such a copy might
2101   // be eliminated by RegisterCoalescer. However, that may not be possible, and
2102   // %vreg0 may even spill. We can't spill %SP, and since it is in the GPR64all
2103   // register class, TargetInstrInfo::foldMemoryOperand() is going to try.
2104   //
2105   // To prevent that, we are going to constrain the %vreg0 register class here.
2106   //
2107   // <rdar://problem/11522048>
2108   //
2109   if (MI->isCopy()) {
2110     unsigned DstReg = MI->getOperand(0).getReg();
2111     unsigned SrcReg = MI->getOperand(1).getReg();
2112     if (SrcReg == AArch64::SP &&
2113         TargetRegisterInfo::isVirtualRegister(DstReg)) {
2114       MF.getRegInfo().constrainRegClass(DstReg, &AArch64::GPR64RegClass);
2115       return nullptr;
2116     }
2117     if (DstReg == AArch64::SP &&
2118         TargetRegisterInfo::isVirtualRegister(SrcReg)) {
2119       MF.getRegInfo().constrainRegClass(SrcReg, &AArch64::GPR64RegClass);
2120       return nullptr;
2121     }
2122   }
2123
2124   // Cannot fold.
2125   return nullptr;
2126 }
2127
2128 int llvm::isAArch64FrameOffsetLegal(const MachineInstr &MI, int &Offset,
2129                                     bool *OutUseUnscaledOp,
2130                                     unsigned *OutUnscaledOp,
2131                                     int *EmittableOffset) {
2132   int Scale = 1;
2133   bool IsSigned = false;
2134   // The ImmIdx should be changed case by case if it is not 2.
2135   unsigned ImmIdx = 2;
2136   unsigned UnscaledOp = 0;
2137   // Set output values in case of early exit.
2138   if (EmittableOffset)
2139     *EmittableOffset = 0;
2140   if (OutUseUnscaledOp)
2141     *OutUseUnscaledOp = false;
2142   if (OutUnscaledOp)
2143     *OutUnscaledOp = 0;
2144   switch (MI.getOpcode()) {
2145   default:
2146     llvm_unreachable("unhandled opcode in rewriteAArch64FrameIndex");
2147   // Vector spills/fills can't take an immediate offset.
2148   case AArch64::LD1Twov2d:
2149   case AArch64::LD1Threev2d:
2150   case AArch64::LD1Fourv2d:
2151   case AArch64::LD1Twov1d:
2152   case AArch64::LD1Threev1d:
2153   case AArch64::LD1Fourv1d:
2154   case AArch64::ST1Twov2d:
2155   case AArch64::ST1Threev2d:
2156   case AArch64::ST1Fourv2d:
2157   case AArch64::ST1Twov1d:
2158   case AArch64::ST1Threev1d:
2159   case AArch64::ST1Fourv1d:
2160     return AArch64FrameOffsetCannotUpdate;
2161   case AArch64::PRFMui:
2162     Scale = 8;
2163     UnscaledOp = AArch64::PRFUMi;
2164     break;
2165   case AArch64::LDRXui:
2166     Scale = 8;
2167     UnscaledOp = AArch64::LDURXi;
2168     break;
2169   case AArch64::LDRWui:
2170     Scale = 4;
2171     UnscaledOp = AArch64::LDURWi;
2172     break;
2173   case AArch64::LDRBui:
2174     Scale = 1;
2175     UnscaledOp = AArch64::LDURBi;
2176     break;
2177   case AArch64::LDRHui:
2178     Scale = 2;
2179     UnscaledOp = AArch64::LDURHi;
2180     break;
2181   case AArch64::LDRSui:
2182     Scale = 4;
2183     UnscaledOp = AArch64::LDURSi;
2184     break;
2185   case AArch64::LDRDui:
2186     Scale = 8;
2187     UnscaledOp = AArch64::LDURDi;
2188     break;
2189   case AArch64::LDRQui:
2190     Scale = 16;
2191     UnscaledOp = AArch64::LDURQi;
2192     break;
2193   case AArch64::LDRBBui:
2194     Scale = 1;
2195     UnscaledOp = AArch64::LDURBBi;
2196     break;
2197   case AArch64::LDRHHui:
2198     Scale = 2;
2199     UnscaledOp = AArch64::LDURHHi;
2200     break;
2201   case AArch64::LDRSBXui:
2202     Scale = 1;
2203     UnscaledOp = AArch64::LDURSBXi;
2204     break;
2205   case AArch64::LDRSBWui:
2206     Scale = 1;
2207     UnscaledOp = AArch64::LDURSBWi;
2208     break;
2209   case AArch64::LDRSHXui:
2210     Scale = 2;
2211     UnscaledOp = AArch64::LDURSHXi;
2212     break;
2213   case AArch64::LDRSHWui:
2214     Scale = 2;
2215     UnscaledOp = AArch64::LDURSHWi;
2216     break;
2217   case AArch64::LDRSWui:
2218     Scale = 4;
2219     UnscaledOp = AArch64::LDURSWi;
2220     break;
2221
2222   case AArch64::STRXui:
2223     Scale = 8;
2224     UnscaledOp = AArch64::STURXi;
2225     break;
2226   case AArch64::STRWui:
2227     Scale = 4;
2228     UnscaledOp = AArch64::STURWi;
2229     break;
2230   case AArch64::STRBui:
2231     Scale = 1;
2232     UnscaledOp = AArch64::STURBi;
2233     break;
2234   case AArch64::STRHui:
2235     Scale = 2;
2236     UnscaledOp = AArch64::STURHi;
2237     break;
2238   case AArch64::STRSui:
2239     Scale = 4;
2240     UnscaledOp = AArch64::STURSi;
2241     break;
2242   case AArch64::STRDui:
2243     Scale = 8;
2244     UnscaledOp = AArch64::STURDi;
2245     break;
2246   case AArch64::STRQui:
2247     Scale = 16;
2248     UnscaledOp = AArch64::STURQi;
2249     break;
2250   case AArch64::STRBBui:
2251     Scale = 1;
2252     UnscaledOp = AArch64::STURBBi;
2253     break;
2254   case AArch64::STRHHui:
2255     Scale = 2;
2256     UnscaledOp = AArch64::STURHHi;
2257     break;
2258
2259   case AArch64::LDPXi:
2260   case AArch64::LDPDi:
2261   case AArch64::STPXi:
2262   case AArch64::STPDi:
2263   case AArch64::LDNPXi:
2264   case AArch64::LDNPDi:
2265   case AArch64::STNPXi:
2266   case AArch64::STNPDi:
2267     ImmIdx = 3;
2268     IsSigned = true;
2269     Scale = 8;
2270     break;
2271   case AArch64::LDPQi:
2272   case AArch64::STPQi:
2273   case AArch64::LDNPQi:
2274   case AArch64::STNPQi:
2275     ImmIdx = 3;
2276     IsSigned = true;
2277     Scale = 16;
2278     break;
2279   case AArch64::LDPWi:
2280   case AArch64::LDPSi:
2281   case AArch64::STPWi:
2282   case AArch64::STPSi:
2283   case AArch64::LDNPWi:
2284   case AArch64::LDNPSi:
2285   case AArch64::STNPWi:
2286   case AArch64::STNPSi:
2287     ImmIdx = 3;
2288     IsSigned = true;
2289     Scale = 4;
2290     break;
2291
2292   case AArch64::LDURXi:
2293   case AArch64::LDURWi:
2294   case AArch64::LDURBi:
2295   case AArch64::LDURHi:
2296   case AArch64::LDURSi:
2297   case AArch64::LDURDi:
2298   case AArch64::LDURQi:
2299   case AArch64::LDURHHi:
2300   case AArch64::LDURBBi:
2301   case AArch64::LDURSBXi:
2302   case AArch64::LDURSBWi:
2303   case AArch64::LDURSHXi:
2304   case AArch64::LDURSHWi:
2305   case AArch64::LDURSWi:
2306   case AArch64::STURXi:
2307   case AArch64::STURWi:
2308   case AArch64::STURBi:
2309   case AArch64::STURHi:
2310   case AArch64::STURSi:
2311   case AArch64::STURDi:
2312   case AArch64::STURQi:
2313   case AArch64::STURBBi:
2314   case AArch64::STURHHi:
2315     Scale = 1;
2316     break;
2317   }
2318
2319   Offset += MI.getOperand(ImmIdx).getImm() * Scale;
2320
2321   bool useUnscaledOp = false;
2322   // If the offset doesn't match the scale, we rewrite the instruction to
2323   // use the unscaled instruction instead. Likewise, if we have a negative
2324   // offset (and have an unscaled op to use).
2325   if ((Offset & (Scale - 1)) != 0 || (Offset < 0 && UnscaledOp != 0))
2326     useUnscaledOp = true;
2327
2328   // Use an unscaled addressing mode if the instruction has a negative offset
2329   // (or if the instruction is already using an unscaled addressing mode).
2330   unsigned MaskBits;
2331   if (IsSigned) {
2332     // ldp/stp instructions.
2333     MaskBits = 7;
2334     Offset /= Scale;
2335   } else if (UnscaledOp == 0 || useUnscaledOp) {
2336     MaskBits = 9;
2337     IsSigned = true;
2338     Scale = 1;
2339   } else {
2340     MaskBits = 12;
2341     IsSigned = false;
2342     Offset /= Scale;
2343   }
2344
2345   // Attempt to fold address computation.
2346   int MaxOff = (1 << (MaskBits - IsSigned)) - 1;
2347   int MinOff = (IsSigned ? (-MaxOff - 1) : 0);
2348   if (Offset >= MinOff && Offset <= MaxOff) {
2349     if (EmittableOffset)
2350       *EmittableOffset = Offset;
2351     Offset = 0;
2352   } else {
2353     int NewOff = Offset < 0 ? MinOff : MaxOff;
2354     if (EmittableOffset)
2355       *EmittableOffset = NewOff;
2356     Offset = (Offset - NewOff) * Scale;
2357   }
2358   if (OutUseUnscaledOp)
2359     *OutUseUnscaledOp = useUnscaledOp;
2360   if (OutUnscaledOp)
2361     *OutUnscaledOp = UnscaledOp;
2362   return AArch64FrameOffsetCanUpdate |
2363          (Offset == 0 ? AArch64FrameOffsetIsLegal : 0);
2364 }
2365
2366 bool llvm::rewriteAArch64FrameIndex(MachineInstr &MI, unsigned FrameRegIdx,
2367                                     unsigned FrameReg, int &Offset,
2368                                     const AArch64InstrInfo *TII) {
2369   unsigned Opcode = MI.getOpcode();
2370   unsigned ImmIdx = FrameRegIdx + 1;
2371
2372   if (Opcode == AArch64::ADDSXri || Opcode == AArch64::ADDXri) {
2373     Offset += MI.getOperand(ImmIdx).getImm();
2374     emitFrameOffset(*MI.getParent(), MI, MI.getDebugLoc(),
2375                     MI.getOperand(0).getReg(), FrameReg, Offset, TII,
2376                     MachineInstr::NoFlags, (Opcode == AArch64::ADDSXri));
2377     MI.eraseFromParent();
2378     Offset = 0;
2379     return true;
2380   }
2381
2382   int NewOffset;
2383   unsigned UnscaledOp;
2384   bool UseUnscaledOp;
2385   int Status = isAArch64FrameOffsetLegal(MI, Offset, &UseUnscaledOp,
2386                                          &UnscaledOp, &NewOffset);
2387   if (Status & AArch64FrameOffsetCanUpdate) {
2388     if (Status & AArch64FrameOffsetIsLegal)
2389       // Replace the FrameIndex with FrameReg.
2390       MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
2391     if (UseUnscaledOp)
2392       MI.setDesc(TII->get(UnscaledOp));
2393
2394     MI.getOperand(ImmIdx).ChangeToImmediate(NewOffset);
2395     return Offset == 0;
2396   }
2397
2398   return false;
2399 }
2400
2401 void AArch64InstrInfo::getNoopForMachoTarget(MCInst &NopInst) const {
2402   NopInst.setOpcode(AArch64::HINT);
2403   NopInst.addOperand(MCOperand::createImm(0));
2404 }
2405 /// useMachineCombiner - return true when a target supports MachineCombiner
2406 bool AArch64InstrInfo::useMachineCombiner() const {
2407   // AArch64 supports the combiner
2408   return true;
2409 }
2410 //
2411 // True when Opc sets flag
2412 static bool isCombineInstrSettingFlag(unsigned Opc) {
2413   switch (Opc) {
2414   case AArch64::ADDSWrr:
2415   case AArch64::ADDSWri:
2416   case AArch64::ADDSXrr:
2417   case AArch64::ADDSXri:
2418   case AArch64::SUBSWrr:
2419   case AArch64::SUBSXrr:
2420   // Note: MSUB Wd,Wn,Wm,Wi -> Wd = Wi - WnxWm, not Wd=WnxWm - Wi.
2421   case AArch64::SUBSWri:
2422   case AArch64::SUBSXri:
2423     return true;
2424   default:
2425     break;
2426   }
2427   return false;
2428 }
2429 //
2430 // 32b Opcodes that can be combined with a MUL
2431 static bool isCombineInstrCandidate32(unsigned Opc) {
2432   switch (Opc) {
2433   case AArch64::ADDWrr:
2434   case AArch64::ADDWri:
2435   case AArch64::SUBWrr:
2436   case AArch64::ADDSWrr:
2437   case AArch64::ADDSWri:
2438   case AArch64::SUBSWrr:
2439   // Note: MSUB Wd,Wn,Wm,Wi -> Wd = Wi - WnxWm, not Wd=WnxWm - Wi.
2440   case AArch64::SUBWri:
2441   case AArch64::SUBSWri:
2442     return true;
2443   default:
2444     break;
2445   }
2446   return false;
2447 }
2448 //
2449 // 64b Opcodes that can be combined with a MUL
2450 static bool isCombineInstrCandidate64(unsigned Opc) {
2451   switch (Opc) {
2452   case AArch64::ADDXrr:
2453   case AArch64::ADDXri:
2454   case AArch64::SUBXrr:
2455   case AArch64::ADDSXrr:
2456   case AArch64::ADDSXri:
2457   case AArch64::SUBSXrr:
2458   // Note: MSUB Wd,Wn,Wm,Wi -> Wd = Wi - WnxWm, not Wd=WnxWm - Wi.
2459   case AArch64::SUBXri:
2460   case AArch64::SUBSXri:
2461     return true;
2462   default:
2463     break;
2464   }
2465   return false;
2466 }
2467 //
2468 // Opcodes that can be combined with a MUL
2469 static bool isCombineInstrCandidate(unsigned Opc) {
2470   return (isCombineInstrCandidate32(Opc) || isCombineInstrCandidate64(Opc));
2471 }
2472
2473 static bool canCombineWithMUL(MachineBasicBlock &MBB, MachineOperand &MO,
2474                               unsigned MulOpc, unsigned ZeroReg) {
2475   MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
2476   MachineInstr *MI = nullptr;
2477   // We need a virtual register definition.
2478   if (MO.isReg() && TargetRegisterInfo::isVirtualRegister(MO.getReg()))
2479     MI = MRI.getUniqueVRegDef(MO.getReg());
2480   // And it needs to be in the trace (otherwise, it won't have a depth).
2481   if (!MI || MI->getParent() != &MBB || (unsigned)MI->getOpcode() != MulOpc)
2482     return false;
2483
2484   assert(MI->getNumOperands() >= 4 && MI->getOperand(0).isReg() &&
2485          MI->getOperand(1).isReg() && MI->getOperand(2).isReg() &&
2486          MI->getOperand(3).isReg() && "MAdd/MSub must have a least 4 regs");
2487
2488   // The third input reg must be zero.
2489   if (MI->getOperand(3).getReg() != ZeroReg)
2490     return false;
2491
2492   // Must only used by the user we combine with.
2493   if (!MRI.hasOneNonDBGUse(MI->getOperand(0).getReg()))
2494     return false;
2495
2496   return true;
2497 }
2498
2499 /// Return true when there is potentially a faster code sequence
2500 /// for an instruction chain ending in \p Root. All potential patterns are
2501 /// listed
2502 /// in the \p Pattern vector. Pattern should be sorted in priority order since
2503 /// the pattern evaluator stops checking as soon as it finds a faster sequence.
2504
2505 bool AArch64InstrInfo::getMachineCombinerPatterns(
2506     MachineInstr &Root,
2507     SmallVectorImpl<MachineCombinerPattern::MC_PATTERN> &Patterns) const {
2508   unsigned Opc = Root.getOpcode();
2509   MachineBasicBlock &MBB = *Root.getParent();
2510   bool Found = false;
2511
2512   if (!isCombineInstrCandidate(Opc))
2513     return 0;
2514   if (isCombineInstrSettingFlag(Opc)) {
2515     int Cmp_NZCV = Root.findRegisterDefOperandIdx(AArch64::NZCV, true);
2516     // When NZCV is live bail out.
2517     if (Cmp_NZCV == -1)
2518       return 0;
2519     unsigned NewOpc = convertFlagSettingOpcode(&Root);
2520     // When opcode can't change bail out.
2521     // CHECKME: do we miss any cases for opcode conversion?
2522     if (NewOpc == Opc)
2523       return 0;
2524     Opc = NewOpc;
2525   }
2526
2527   switch (Opc) {
2528   default:
2529     break;
2530   case AArch64::ADDWrr:
2531     assert(Root.getOperand(1).isReg() && Root.getOperand(2).isReg() &&
2532            "ADDWrr does not have register operands");
2533     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDWrrr,
2534                           AArch64::WZR)) {
2535       Patterns.push_back(MachineCombinerPattern::MC_MULADDW_OP1);
2536       Found = true;
2537     }
2538     if (canCombineWithMUL(MBB, Root.getOperand(2), AArch64::MADDWrrr,
2539                           AArch64::WZR)) {
2540       Patterns.push_back(MachineCombinerPattern::MC_MULADDW_OP2);
2541       Found = true;
2542     }
2543     break;
2544   case AArch64::ADDXrr:
2545     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDXrrr,
2546                           AArch64::XZR)) {
2547       Patterns.push_back(MachineCombinerPattern::MC_MULADDX_OP1);
2548       Found = true;
2549     }
2550     if (canCombineWithMUL(MBB, Root.getOperand(2), AArch64::MADDXrrr,
2551                           AArch64::XZR)) {
2552       Patterns.push_back(MachineCombinerPattern::MC_MULADDX_OP2);
2553       Found = true;
2554     }
2555     break;
2556   case AArch64::SUBWrr:
2557     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDWrrr,
2558                           AArch64::WZR)) {
2559       Patterns.push_back(MachineCombinerPattern::MC_MULSUBW_OP1);
2560       Found = true;
2561     }
2562     if (canCombineWithMUL(MBB, Root.getOperand(2), AArch64::MADDWrrr,
2563                           AArch64::WZR)) {
2564       Patterns.push_back(MachineCombinerPattern::MC_MULSUBW_OP2);
2565       Found = true;
2566     }
2567     break;
2568   case AArch64::SUBXrr:
2569     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDXrrr,
2570                           AArch64::XZR)) {
2571       Patterns.push_back(MachineCombinerPattern::MC_MULSUBX_OP1);
2572       Found = true;
2573     }
2574     if (canCombineWithMUL(MBB, Root.getOperand(2), AArch64::MADDXrrr,
2575                           AArch64::XZR)) {
2576       Patterns.push_back(MachineCombinerPattern::MC_MULSUBX_OP2);
2577       Found = true;
2578     }
2579     break;
2580   case AArch64::ADDWri:
2581     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDWrrr,
2582                           AArch64::WZR)) {
2583       Patterns.push_back(MachineCombinerPattern::MC_MULADDWI_OP1);
2584       Found = true;
2585     }
2586     break;
2587   case AArch64::ADDXri:
2588     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDXrrr,
2589                           AArch64::XZR)) {
2590       Patterns.push_back(MachineCombinerPattern::MC_MULADDXI_OP1);
2591       Found = true;
2592     }
2593     break;
2594   case AArch64::SUBWri:
2595     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDWrrr,
2596                           AArch64::WZR)) {
2597       Patterns.push_back(MachineCombinerPattern::MC_MULSUBWI_OP1);
2598       Found = true;
2599     }
2600     break;
2601   case AArch64::SUBXri:
2602     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDXrrr,
2603                           AArch64::XZR)) {
2604       Patterns.push_back(MachineCombinerPattern::MC_MULSUBXI_OP1);
2605       Found = true;
2606     }
2607     break;
2608   }
2609   return Found;
2610 }
2611
2612 /// genMadd - Generate madd instruction and combine mul and add.
2613 /// Example:
2614 ///  MUL I=A,B,0
2615 ///  ADD R,I,C
2616 ///  ==> MADD R,A,B,C
2617 /// \param Root is the ADD instruction
2618 /// \param [out] InsInstrs is a vector of machine instructions and will
2619 /// contain the generated madd instruction
2620 /// \param IdxMulOpd is index of operand in Root that is the result of
2621 /// the MUL. In the example above IdxMulOpd is 1.
2622 /// \param MaddOpc the opcode fo the madd instruction
2623 static MachineInstr *genMadd(MachineFunction &MF, MachineRegisterInfo &MRI,
2624                              const TargetInstrInfo *TII, MachineInstr &Root,
2625                              SmallVectorImpl<MachineInstr *> &InsInstrs,
2626                              unsigned IdxMulOpd, unsigned MaddOpc,
2627                              const TargetRegisterClass *RC) {
2628   assert(IdxMulOpd == 1 || IdxMulOpd == 2);
2629
2630   unsigned IdxOtherOpd = IdxMulOpd == 1 ? 2 : 1;
2631   MachineInstr *MUL = MRI.getUniqueVRegDef(Root.getOperand(IdxMulOpd).getReg());
2632   unsigned ResultReg = Root.getOperand(0).getReg();
2633   unsigned SrcReg0 = MUL->getOperand(1).getReg();
2634   bool Src0IsKill = MUL->getOperand(1).isKill();
2635   unsigned SrcReg1 = MUL->getOperand(2).getReg();
2636   bool Src1IsKill = MUL->getOperand(2).isKill();
2637   unsigned SrcReg2 = Root.getOperand(IdxOtherOpd).getReg();
2638   bool Src2IsKill = Root.getOperand(IdxOtherOpd).isKill();
2639
2640   if (TargetRegisterInfo::isVirtualRegister(ResultReg))
2641     MRI.constrainRegClass(ResultReg, RC);
2642   if (TargetRegisterInfo::isVirtualRegister(SrcReg0))
2643     MRI.constrainRegClass(SrcReg0, RC);
2644   if (TargetRegisterInfo::isVirtualRegister(SrcReg1))
2645     MRI.constrainRegClass(SrcReg1, RC);
2646   if (TargetRegisterInfo::isVirtualRegister(SrcReg2))
2647     MRI.constrainRegClass(SrcReg2, RC);
2648
2649   MachineInstrBuilder MIB = BuildMI(MF, Root.getDebugLoc(), TII->get(MaddOpc),
2650                                     ResultReg)
2651                                 .addReg(SrcReg0, getKillRegState(Src0IsKill))
2652                                 .addReg(SrcReg1, getKillRegState(Src1IsKill))
2653                                 .addReg(SrcReg2, getKillRegState(Src2IsKill));
2654   // Insert the MADD
2655   InsInstrs.push_back(MIB);
2656   return MUL;
2657 }
2658
2659 /// genMaddR - Generate madd instruction and combine mul and add using
2660 /// an extra virtual register
2661 /// Example - an ADD intermediate needs to be stored in a register:
2662 ///   MUL I=A,B,0
2663 ///   ADD R,I,Imm
2664 ///   ==> ORR  V, ZR, Imm
2665 ///   ==> MADD R,A,B,V
2666 /// \param Root is the ADD instruction
2667 /// \param [out] InsInstrs is a vector of machine instructions and will
2668 /// contain the generated madd instruction
2669 /// \param IdxMulOpd is index of operand in Root that is the result of
2670 /// the MUL. In the example above IdxMulOpd is 1.
2671 /// \param MaddOpc the opcode fo the madd instruction
2672 /// \param VR is a virtual register that holds the value of an ADD operand
2673 /// (V in the example above).
2674 static MachineInstr *genMaddR(MachineFunction &MF, MachineRegisterInfo &MRI,
2675                               const TargetInstrInfo *TII, MachineInstr &Root,
2676                               SmallVectorImpl<MachineInstr *> &InsInstrs,
2677                               unsigned IdxMulOpd, unsigned MaddOpc,
2678                               unsigned VR, const TargetRegisterClass *RC) {
2679   assert(IdxMulOpd == 1 || IdxMulOpd == 2);
2680
2681   MachineInstr *MUL = MRI.getUniqueVRegDef(Root.getOperand(IdxMulOpd).getReg());
2682   unsigned ResultReg = Root.getOperand(0).getReg();
2683   unsigned SrcReg0 = MUL->getOperand(1).getReg();
2684   bool Src0IsKill = MUL->getOperand(1).isKill();
2685   unsigned SrcReg1 = MUL->getOperand(2).getReg();
2686   bool Src1IsKill = MUL->getOperand(2).isKill();
2687
2688   if (TargetRegisterInfo::isVirtualRegister(ResultReg))
2689     MRI.constrainRegClass(ResultReg, RC);
2690   if (TargetRegisterInfo::isVirtualRegister(SrcReg0))
2691     MRI.constrainRegClass(SrcReg0, RC);
2692   if (TargetRegisterInfo::isVirtualRegister(SrcReg1))
2693     MRI.constrainRegClass(SrcReg1, RC);
2694   if (TargetRegisterInfo::isVirtualRegister(VR))
2695     MRI.constrainRegClass(VR, RC);
2696
2697   MachineInstrBuilder MIB = BuildMI(MF, Root.getDebugLoc(), TII->get(MaddOpc),
2698                                     ResultReg)
2699                                 .addReg(SrcReg0, getKillRegState(Src0IsKill))
2700                                 .addReg(SrcReg1, getKillRegState(Src1IsKill))
2701                                 .addReg(VR);
2702   // Insert the MADD
2703   InsInstrs.push_back(MIB);
2704   return MUL;
2705 }
2706
2707 /// When getMachineCombinerPatterns() finds potential patterns,
2708 /// this function generates the instructions that could replace the
2709 /// original code sequence
2710 void AArch64InstrInfo::genAlternativeCodeSequence(
2711     MachineInstr &Root, MachineCombinerPattern::MC_PATTERN Pattern,
2712     SmallVectorImpl<MachineInstr *> &InsInstrs,
2713     SmallVectorImpl<MachineInstr *> &DelInstrs,
2714     DenseMap<unsigned, unsigned> &InstrIdxForVirtReg) const {
2715   MachineBasicBlock &MBB = *Root.getParent();
2716   MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
2717   MachineFunction &MF = *MBB.getParent();
2718   const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
2719
2720   MachineInstr *MUL;
2721   const TargetRegisterClass *RC;
2722   unsigned Opc;
2723   switch (Pattern) {
2724   default:
2725     // signal error.
2726     break;
2727   case MachineCombinerPattern::MC_MULADDW_OP1:
2728   case MachineCombinerPattern::MC_MULADDX_OP1:
2729     // MUL I=A,B,0
2730     // ADD R,I,C
2731     // ==> MADD R,A,B,C
2732     // --- Create(MADD);
2733     if (Pattern == MachineCombinerPattern::MC_MULADDW_OP1) {
2734       Opc = AArch64::MADDWrrr;
2735       RC = &AArch64::GPR32RegClass;
2736     } else {
2737       Opc = AArch64::MADDXrrr;
2738       RC = &AArch64::GPR64RegClass;
2739     }
2740     MUL = genMadd(MF, MRI, TII, Root, InsInstrs, 1, Opc, RC);
2741     break;
2742   case MachineCombinerPattern::MC_MULADDW_OP2:
2743   case MachineCombinerPattern::MC_MULADDX_OP2:
2744     // MUL I=A,B,0
2745     // ADD R,C,I
2746     // ==> MADD R,A,B,C
2747     // --- Create(MADD);
2748     if (Pattern == MachineCombinerPattern::MC_MULADDW_OP2) {
2749       Opc = AArch64::MADDWrrr;
2750       RC = &AArch64::GPR32RegClass;
2751     } else {
2752       Opc = AArch64::MADDXrrr;
2753       RC = &AArch64::GPR64RegClass;
2754     }
2755     MUL = genMadd(MF, MRI, TII, Root, InsInstrs, 2, Opc, RC);
2756     break;
2757   case MachineCombinerPattern::MC_MULADDWI_OP1:
2758   case MachineCombinerPattern::MC_MULADDXI_OP1: {
2759     // MUL I=A,B,0
2760     // ADD R,I,Imm
2761     // ==> ORR  V, ZR, Imm
2762     // ==> MADD R,A,B,V
2763     // --- Create(MADD);
2764     const TargetRegisterClass *OrrRC;
2765     unsigned BitSize, OrrOpc, ZeroReg;
2766     if (Pattern == MachineCombinerPattern::MC_MULADDWI_OP1) {
2767       OrrOpc = AArch64::ORRWri;
2768       OrrRC = &AArch64::GPR32spRegClass;
2769       BitSize = 32;
2770       ZeroReg = AArch64::WZR;
2771       Opc = AArch64::MADDWrrr;
2772       RC = &AArch64::GPR32RegClass;
2773     } else {
2774       OrrOpc = AArch64::ORRXri;
2775       OrrRC = &AArch64::GPR64spRegClass;
2776       BitSize = 64;
2777       ZeroReg = AArch64::XZR;
2778       Opc = AArch64::MADDXrrr;
2779       RC = &AArch64::GPR64RegClass;
2780     }
2781     unsigned NewVR = MRI.createVirtualRegister(OrrRC);
2782     uint64_t Imm = Root.getOperand(2).getImm();
2783
2784     if (Root.getOperand(3).isImm()) {
2785       unsigned Val = Root.getOperand(3).getImm();
2786       Imm = Imm << Val;
2787     }
2788     uint64_t UImm = Imm << (64 - BitSize) >> (64 - BitSize);
2789     uint64_t Encoding;
2790     if (AArch64_AM::processLogicalImmediate(UImm, BitSize, Encoding)) {
2791       MachineInstrBuilder MIB1 =
2792           BuildMI(MF, Root.getDebugLoc(), TII->get(OrrOpc), NewVR)
2793               .addReg(ZeroReg)
2794               .addImm(Encoding);
2795       InsInstrs.push_back(MIB1);
2796       InstrIdxForVirtReg.insert(std::make_pair(NewVR, 0));
2797       MUL = genMaddR(MF, MRI, TII, Root, InsInstrs, 1, Opc, NewVR, RC);
2798     }
2799     break;
2800   }
2801   case MachineCombinerPattern::MC_MULSUBW_OP1:
2802   case MachineCombinerPattern::MC_MULSUBX_OP1: {
2803     // MUL I=A,B,0
2804     // SUB R,I, C
2805     // ==> SUB  V, 0, C
2806     // ==> MADD R,A,B,V // = -C + A*B
2807     // --- Create(MADD);
2808     const TargetRegisterClass *SubRC;
2809     unsigned SubOpc, ZeroReg;
2810     if (Pattern == MachineCombinerPattern::MC_MULSUBW_OP1) {
2811       SubOpc = AArch64::SUBWrr;
2812       SubRC = &AArch64::GPR32spRegClass;
2813       ZeroReg = AArch64::WZR;
2814       Opc = AArch64::MADDWrrr;
2815       RC = &AArch64::GPR32RegClass;
2816     } else {
2817       SubOpc = AArch64::SUBXrr;
2818       SubRC = &AArch64::GPR64spRegClass;
2819       ZeroReg = AArch64::XZR;
2820       Opc = AArch64::MADDXrrr;
2821       RC = &AArch64::GPR64RegClass;
2822     }
2823     unsigned NewVR = MRI.createVirtualRegister(SubRC);
2824     // SUB NewVR, 0, C
2825     MachineInstrBuilder MIB1 =
2826         BuildMI(MF, Root.getDebugLoc(), TII->get(SubOpc), NewVR)
2827             .addReg(ZeroReg)
2828             .addOperand(Root.getOperand(2));
2829     InsInstrs.push_back(MIB1);
2830     InstrIdxForVirtReg.insert(std::make_pair(NewVR, 0));
2831     MUL = genMaddR(MF, MRI, TII, Root, InsInstrs, 1, Opc, NewVR, RC);
2832     break;
2833   }
2834   case MachineCombinerPattern::MC_MULSUBW_OP2:
2835   case MachineCombinerPattern::MC_MULSUBX_OP2:
2836     // MUL I=A,B,0
2837     // SUB R,C,I
2838     // ==> MSUB R,A,B,C (computes C - A*B)
2839     // --- Create(MSUB);
2840     if (Pattern == MachineCombinerPattern::MC_MULSUBW_OP2) {
2841       Opc = AArch64::MSUBWrrr;
2842       RC = &AArch64::GPR32RegClass;
2843     } else {
2844       Opc = AArch64::MSUBXrrr;
2845       RC = &AArch64::GPR64RegClass;
2846     }
2847     MUL = genMadd(MF, MRI, TII, Root, InsInstrs, 2, Opc, RC);
2848     break;
2849   case MachineCombinerPattern::MC_MULSUBWI_OP1:
2850   case MachineCombinerPattern::MC_MULSUBXI_OP1: {
2851     // MUL I=A,B,0
2852     // SUB R,I, Imm
2853     // ==> ORR  V, ZR, -Imm
2854     // ==> MADD R,A,B,V // = -Imm + A*B
2855     // --- Create(MADD);
2856     const TargetRegisterClass *OrrRC;
2857     unsigned BitSize, OrrOpc, ZeroReg;
2858     if (Pattern == MachineCombinerPattern::MC_MULSUBWI_OP1) {
2859       OrrOpc = AArch64::ORRWri;
2860       OrrRC = &AArch64::GPR32spRegClass;
2861       BitSize = 32;
2862       ZeroReg = AArch64::WZR;
2863       Opc = AArch64::MADDWrrr;
2864       RC = &AArch64::GPR32RegClass;
2865     } else {
2866       OrrOpc = AArch64::ORRXri;
2867       OrrRC = &AArch64::GPR64spRegClass;
2868       BitSize = 64;
2869       ZeroReg = AArch64::XZR;
2870       Opc = AArch64::MADDXrrr;
2871       RC = &AArch64::GPR64RegClass;
2872     }
2873     unsigned NewVR = MRI.createVirtualRegister(OrrRC);
2874     int Imm = Root.getOperand(2).getImm();
2875     if (Root.getOperand(3).isImm()) {
2876       unsigned Val = Root.getOperand(3).getImm();
2877       Imm = Imm << Val;
2878     }
2879     uint64_t UImm = -Imm << (64 - BitSize) >> (64 - BitSize);
2880     uint64_t Encoding;
2881     if (AArch64_AM::processLogicalImmediate(UImm, BitSize, Encoding)) {
2882       MachineInstrBuilder MIB1 =
2883           BuildMI(MF, Root.getDebugLoc(), TII->get(OrrOpc), NewVR)
2884               .addReg(ZeroReg)
2885               .addImm(Encoding);
2886       InsInstrs.push_back(MIB1);
2887       InstrIdxForVirtReg.insert(std::make_pair(NewVR, 0));
2888       MUL = genMaddR(MF, MRI, TII, Root, InsInstrs, 1, Opc, NewVR, RC);
2889     }
2890     break;
2891   }
2892   } // end switch (Pattern)
2893   // Record MUL and ADD/SUB for deletion
2894   DelInstrs.push_back(MUL);
2895   DelInstrs.push_back(&Root);
2896
2897   return;
2898 }
2899
2900 /// \brief Replace csincr-branch sequence by simple conditional branch
2901 ///
2902 /// Examples:
2903 /// 1.
2904 ///   csinc  w9, wzr, wzr, <condition code>
2905 ///   tbnz   w9, #0, 0x44
2906 /// to
2907 ///   b.<inverted condition code>
2908 ///
2909 /// 2.
2910 ///   csinc w9, wzr, wzr, <condition code>
2911 ///   tbz   w9, #0, 0x44
2912 /// to
2913 ///   b.<condition code>
2914 ///
2915 /// \param  MI Conditional Branch
2916 /// \return True when the simple conditional branch is generated
2917 ///
2918 bool AArch64InstrInfo::optimizeCondBranch(MachineInstr *MI) const {
2919   bool IsNegativeBranch = false;
2920   bool IsTestAndBranch = false;
2921   unsigned TargetBBInMI = 0;
2922   switch (MI->getOpcode()) {
2923   default:
2924     llvm_unreachable("Unknown branch instruction?");
2925   case AArch64::Bcc:
2926     return false;
2927   case AArch64::CBZW:
2928   case AArch64::CBZX:
2929     TargetBBInMI = 1;
2930     break;
2931   case AArch64::CBNZW:
2932   case AArch64::CBNZX:
2933     TargetBBInMI = 1;
2934     IsNegativeBranch = true;
2935     break;
2936   case AArch64::TBZW:
2937   case AArch64::TBZX:
2938     TargetBBInMI = 2;
2939     IsTestAndBranch = true;
2940     break;
2941   case AArch64::TBNZW:
2942   case AArch64::TBNZX:
2943     TargetBBInMI = 2;
2944     IsNegativeBranch = true;
2945     IsTestAndBranch = true;
2946     break;
2947   }
2948   // So we increment a zero register and test for bits other
2949   // than bit 0? Conservatively bail out in case the verifier
2950   // missed this case.
2951   if (IsTestAndBranch && MI->getOperand(1).getImm())
2952     return false;
2953
2954   // Find Definition.
2955   assert(MI->getParent() && "Incomplete machine instruciton\n");
2956   MachineBasicBlock *MBB = MI->getParent();
2957   MachineFunction *MF = MBB->getParent();
2958   MachineRegisterInfo *MRI = &MF->getRegInfo();
2959   unsigned VReg = MI->getOperand(0).getReg();
2960   if (!TargetRegisterInfo::isVirtualRegister(VReg))
2961     return false;
2962
2963   MachineInstr *DefMI = MRI->getVRegDef(VReg);
2964
2965   // Look for CSINC
2966   if (!(DefMI->getOpcode() == AArch64::CSINCWr &&
2967         DefMI->getOperand(1).getReg() == AArch64::WZR &&
2968         DefMI->getOperand(2).getReg() == AArch64::WZR) &&
2969       !(DefMI->getOpcode() == AArch64::CSINCXr &&
2970         DefMI->getOperand(1).getReg() == AArch64::XZR &&
2971         DefMI->getOperand(2).getReg() == AArch64::XZR))
2972     return false;
2973
2974   if (DefMI->findRegisterDefOperandIdx(AArch64::NZCV, true) != -1)
2975     return false;
2976
2977   AArch64CC::CondCode CC =
2978       (AArch64CC::CondCode)DefMI->getOperand(3).getImm();
2979   bool CheckOnlyCCWrites = true;
2980   // Convert only when the condition code is not modified between
2981   // the CSINC and the branch. The CC may be used by other
2982   // instructions in between.
2983   if (modifiesConditionCode(DefMI, MI, CheckOnlyCCWrites, &getRegisterInfo()))
2984     return false;
2985   MachineBasicBlock &RefToMBB = *MBB;
2986   MachineBasicBlock *TBB = MI->getOperand(TargetBBInMI).getMBB();
2987   DebugLoc DL = MI->getDebugLoc();
2988   if (IsNegativeBranch)
2989     CC = AArch64CC::getInvertedCondCode(CC);
2990   BuildMI(RefToMBB, MI, DL, get(AArch64::Bcc)).addImm(CC).addMBB(TBB);
2991   MI->eraseFromParent();
2992   return true;
2993 }
2994
2995 std::pair<unsigned, unsigned>
2996 AArch64InstrInfo::decomposeMachineOperandsTargetFlags(unsigned TF) const {
2997   const unsigned Mask = AArch64II::MO_FRAGMENT;
2998   return std::make_pair(TF & Mask, TF & ~Mask);
2999 }
3000
3001 ArrayRef<std::pair<unsigned, const char *>>
3002 AArch64InstrInfo::getSerializableDirectMachineOperandTargetFlags() const {
3003   using namespace AArch64II;
3004   static const std::pair<unsigned, const char *> TargetFlags[] = {
3005       {MO_PAGE, "aarch64-page"},
3006       {MO_PAGEOFF, "aarch64-pageoff"},
3007       {MO_G3, "aarch64-g3"},
3008       {MO_G2, "aarch64-g2"},
3009       {MO_G1, "aarch64-g1"},
3010       {MO_G0, "aarch64-g0"},
3011       {MO_HI12, "aarch64-hi12"}};
3012   return makeArrayRef(TargetFlags);
3013 }
3014
3015 ArrayRef<std::pair<unsigned, const char *>>
3016 AArch64InstrInfo::getSerializableBitmaskMachineOperandTargetFlags() const {
3017   using namespace AArch64II;
3018   static const std::pair<unsigned, const char *> TargetFlags[] = {
3019       {MO_GOT, "aarch64-got"},
3020       {MO_NC, "aarch64-nc"},
3021       {MO_TLS, "aarch64-tls"},
3022       {MO_CONSTPOOL, "aarch64-constant-pool"}};
3023   return makeArrayRef(TargetFlags);
3024 }