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::LDRDui:
1398   case AArch64::STRXui:
1399   case AArch64::STRDui:
1400     Scale = Width = 8;
1401     break;
1402   case AArch64::LDRWui:
1403   case AArch64::LDRSui:
1404   case AArch64::STRWui:
1405   case AArch64::STRSui:
1406     Scale = Width = 4;
1407     break;
1408   case AArch64::LDRBui:
1409   case AArch64::LDRBBui:
1410   case AArch64::STRBui:
1411   case AArch64::STRBBui:
1412     Scale = Width = 1;
1413     break;
1414   case AArch64::LDRHui:
1415   case AArch64::LDRHHui:
1416   case AArch64::STRHui:
1417   case AArch64::STRHHui:
1418     Scale = Width = 2;
1419     break;
1420   case AArch64::LDRQui:
1421   case AArch64::STRQui:
1422     Scale = Width = 16;
1423     break;
1424   };
1425
1426   BaseReg = LdSt->getOperand(1).getReg();
1427   Offset = LdSt->getOperand(2).getImm() * Scale;
1428   return true;
1429 }
1430
1431 /// Detect opportunities for ldp/stp formation.
1432 ///
1433 /// Only called for LdSt for which getMemOpBaseRegImmOfs returns true.
1434 bool AArch64InstrInfo::shouldClusterLoads(MachineInstr *FirstLdSt,
1435                                           MachineInstr *SecondLdSt,
1436                                           unsigned NumLoads) const {
1437   // Only cluster up to a single pair.
1438   if (NumLoads > 1)
1439     return false;
1440   if (FirstLdSt->getOpcode() != SecondLdSt->getOpcode())
1441     return false;
1442   // getMemOpBaseRegImmOfs guarantees that oper 2 isImm.
1443   unsigned Ofs1 = FirstLdSt->getOperand(2).getImm();
1444   // Allow 6 bits of positive range.
1445   if (Ofs1 > 64)
1446     return false;
1447   // The caller should already have ordered First/SecondLdSt by offset.
1448   unsigned Ofs2 = SecondLdSt->getOperand(2).getImm();
1449   return Ofs1 + 1 == Ofs2;
1450 }
1451
1452 bool AArch64InstrInfo::shouldScheduleAdjacent(MachineInstr *First,
1453                                               MachineInstr *Second) const {
1454   if (Subtarget.isCyclone()) {
1455     // Cyclone can fuse CMN, CMP, TST followed by Bcc.
1456     unsigned SecondOpcode = Second->getOpcode();
1457     if (SecondOpcode == AArch64::Bcc) {
1458       switch (First->getOpcode()) {
1459       default:
1460         return false;
1461       case AArch64::SUBSWri:
1462       case AArch64::ADDSWri:
1463       case AArch64::ANDSWri:
1464       case AArch64::SUBSXri:
1465       case AArch64::ADDSXri:
1466       case AArch64::ANDSXri:
1467         return true;
1468       }
1469     }
1470     // Cyclone B0 also supports ALU operations followed by CBZ/CBNZ.
1471     if (SecondOpcode == AArch64::CBNZW || SecondOpcode == AArch64::CBNZX ||
1472         SecondOpcode == AArch64::CBZW || SecondOpcode == AArch64::CBZX) {
1473       switch (First->getOpcode()) {
1474       default:
1475         return false;
1476       case AArch64::ADDWri:
1477       case AArch64::ADDXri:
1478       case AArch64::ANDWri:
1479       case AArch64::ANDXri:
1480       case AArch64::EORWri:
1481       case AArch64::EORXri:
1482       case AArch64::ORRWri:
1483       case AArch64::ORRXri:
1484       case AArch64::SUBWri:
1485       case AArch64::SUBXri:
1486         return true;
1487       }
1488     }
1489   }
1490   return false;
1491 }
1492
1493 MachineInstr *AArch64InstrInfo::emitFrameIndexDebugValue(
1494     MachineFunction &MF, int FrameIx, uint64_t Offset, const MDNode *Var,
1495     const MDNode *Expr, DebugLoc DL) const {
1496   MachineInstrBuilder MIB = BuildMI(MF, DL, get(AArch64::DBG_VALUE))
1497                                 .addFrameIndex(FrameIx)
1498                                 .addImm(0)
1499                                 .addImm(Offset)
1500                                 .addMetadata(Var)
1501                                 .addMetadata(Expr);
1502   return &*MIB;
1503 }
1504
1505 static const MachineInstrBuilder &AddSubReg(const MachineInstrBuilder &MIB,
1506                                             unsigned Reg, unsigned SubIdx,
1507                                             unsigned State,
1508                                             const TargetRegisterInfo *TRI) {
1509   if (!SubIdx)
1510     return MIB.addReg(Reg, State);
1511
1512   if (TargetRegisterInfo::isPhysicalRegister(Reg))
1513     return MIB.addReg(TRI->getSubReg(Reg, SubIdx), State);
1514   return MIB.addReg(Reg, State, SubIdx);
1515 }
1516
1517 static bool forwardCopyWillClobberTuple(unsigned DestReg, unsigned SrcReg,
1518                                         unsigned NumRegs) {
1519   // We really want the positive remainder mod 32 here, that happens to be
1520   // easily obtainable with a mask.
1521   return ((DestReg - SrcReg) & 0x1f) < NumRegs;
1522 }
1523
1524 void AArch64InstrInfo::copyPhysRegTuple(
1525     MachineBasicBlock &MBB, MachineBasicBlock::iterator I, DebugLoc DL,
1526     unsigned DestReg, unsigned SrcReg, bool KillSrc, unsigned Opcode,
1527     llvm::ArrayRef<unsigned> Indices) const {
1528   assert(Subtarget.hasNEON() &&
1529          "Unexpected register copy without NEON");
1530   const TargetRegisterInfo *TRI = &getRegisterInfo();
1531   uint16_t DestEncoding = TRI->getEncodingValue(DestReg);
1532   uint16_t SrcEncoding = TRI->getEncodingValue(SrcReg);
1533   unsigned NumRegs = Indices.size();
1534
1535   int SubReg = 0, End = NumRegs, Incr = 1;
1536   if (forwardCopyWillClobberTuple(DestEncoding, SrcEncoding, NumRegs)) {
1537     SubReg = NumRegs - 1;
1538     End = -1;
1539     Incr = -1;
1540   }
1541
1542   for (; SubReg != End; SubReg += Incr) {
1543     const MachineInstrBuilder MIB = BuildMI(MBB, I, DL, get(Opcode));
1544     AddSubReg(MIB, DestReg, Indices[SubReg], RegState::Define, TRI);
1545     AddSubReg(MIB, SrcReg, Indices[SubReg], 0, TRI);
1546     AddSubReg(MIB, SrcReg, Indices[SubReg], getKillRegState(KillSrc), TRI);
1547   }
1548 }
1549
1550 void AArch64InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
1551                                    MachineBasicBlock::iterator I, DebugLoc DL,
1552                                    unsigned DestReg, unsigned SrcReg,
1553                                    bool KillSrc) const {
1554   if (AArch64::GPR32spRegClass.contains(DestReg) &&
1555       (AArch64::GPR32spRegClass.contains(SrcReg) || SrcReg == AArch64::WZR)) {
1556     const TargetRegisterInfo *TRI = &getRegisterInfo();
1557
1558     if (DestReg == AArch64::WSP || SrcReg == AArch64::WSP) {
1559       // If either operand is WSP, expand to ADD #0.
1560       if (Subtarget.hasZeroCycleRegMove()) {
1561         // Cyclone recognizes "ADD Xd, Xn, #0" as a zero-cycle register move.
1562         unsigned DestRegX = TRI->getMatchingSuperReg(DestReg, AArch64::sub_32,
1563                                                      &AArch64::GPR64spRegClass);
1564         unsigned SrcRegX = TRI->getMatchingSuperReg(SrcReg, AArch64::sub_32,
1565                                                     &AArch64::GPR64spRegClass);
1566         // This instruction is reading and writing X registers.  This may upset
1567         // the register scavenger and machine verifier, so we need to indicate
1568         // that we are reading an undefined value from SrcRegX, but a proper
1569         // value from SrcReg.
1570         BuildMI(MBB, I, DL, get(AArch64::ADDXri), DestRegX)
1571             .addReg(SrcRegX, RegState::Undef)
1572             .addImm(0)
1573             .addImm(AArch64_AM::getShifterImm(AArch64_AM::LSL, 0))
1574             .addReg(SrcReg, RegState::Implicit | getKillRegState(KillSrc));
1575       } else {
1576         BuildMI(MBB, I, DL, get(AArch64::ADDWri), DestReg)
1577             .addReg(SrcReg, getKillRegState(KillSrc))
1578             .addImm(0)
1579             .addImm(AArch64_AM::getShifterImm(AArch64_AM::LSL, 0));
1580       }
1581     } else if (SrcReg == AArch64::WZR && Subtarget.hasZeroCycleZeroing()) {
1582       BuildMI(MBB, I, DL, get(AArch64::MOVZWi), DestReg).addImm(0).addImm(
1583           AArch64_AM::getShifterImm(AArch64_AM::LSL, 0));
1584     } else {
1585       if (Subtarget.hasZeroCycleRegMove()) {
1586         // Cyclone recognizes "ORR Xd, XZR, Xm" as a zero-cycle register move.
1587         unsigned DestRegX = TRI->getMatchingSuperReg(DestReg, AArch64::sub_32,
1588                                                      &AArch64::GPR64spRegClass);
1589         unsigned SrcRegX = TRI->getMatchingSuperReg(SrcReg, AArch64::sub_32,
1590                                                     &AArch64::GPR64spRegClass);
1591         // This instruction is reading and writing X registers.  This may upset
1592         // the register scavenger and machine verifier, so we need to indicate
1593         // that we are reading an undefined value from SrcRegX, but a proper
1594         // value from SrcReg.
1595         BuildMI(MBB, I, DL, get(AArch64::ORRXrr), DestRegX)
1596             .addReg(AArch64::XZR)
1597             .addReg(SrcRegX, RegState::Undef)
1598             .addReg(SrcReg, RegState::Implicit | getKillRegState(KillSrc));
1599       } else {
1600         // Otherwise, expand to ORR WZR.
1601         BuildMI(MBB, I, DL, get(AArch64::ORRWrr), DestReg)
1602             .addReg(AArch64::WZR)
1603             .addReg(SrcReg, getKillRegState(KillSrc));
1604       }
1605     }
1606     return;
1607   }
1608
1609   if (AArch64::GPR64spRegClass.contains(DestReg) &&
1610       (AArch64::GPR64spRegClass.contains(SrcReg) || SrcReg == AArch64::XZR)) {
1611     if (DestReg == AArch64::SP || SrcReg == AArch64::SP) {
1612       // If either operand is SP, expand to ADD #0.
1613       BuildMI(MBB, I, DL, get(AArch64::ADDXri), DestReg)
1614           .addReg(SrcReg, getKillRegState(KillSrc))
1615           .addImm(0)
1616           .addImm(AArch64_AM::getShifterImm(AArch64_AM::LSL, 0));
1617     } else if (SrcReg == AArch64::XZR && Subtarget.hasZeroCycleZeroing()) {
1618       BuildMI(MBB, I, DL, get(AArch64::MOVZXi), DestReg).addImm(0).addImm(
1619           AArch64_AM::getShifterImm(AArch64_AM::LSL, 0));
1620     } else {
1621       // Otherwise, expand to ORR XZR.
1622       BuildMI(MBB, I, DL, get(AArch64::ORRXrr), DestReg)
1623           .addReg(AArch64::XZR)
1624           .addReg(SrcReg, getKillRegState(KillSrc));
1625     }
1626     return;
1627   }
1628
1629   // Copy a DDDD register quad by copying the individual sub-registers.
1630   if (AArch64::DDDDRegClass.contains(DestReg) &&
1631       AArch64::DDDDRegClass.contains(SrcReg)) {
1632     static const unsigned Indices[] = { AArch64::dsub0, AArch64::dsub1,
1633                                         AArch64::dsub2, AArch64::dsub3 };
1634     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, AArch64::ORRv8i8,
1635                      Indices);
1636     return;
1637   }
1638
1639   // Copy a DDD register triple by copying the individual sub-registers.
1640   if (AArch64::DDDRegClass.contains(DestReg) &&
1641       AArch64::DDDRegClass.contains(SrcReg)) {
1642     static const unsigned Indices[] = { AArch64::dsub0, AArch64::dsub1,
1643                                         AArch64::dsub2 };
1644     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, AArch64::ORRv8i8,
1645                      Indices);
1646     return;
1647   }
1648
1649   // Copy a DD register pair by copying the individual sub-registers.
1650   if (AArch64::DDRegClass.contains(DestReg) &&
1651       AArch64::DDRegClass.contains(SrcReg)) {
1652     static const unsigned Indices[] = { AArch64::dsub0, AArch64::dsub1 };
1653     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, AArch64::ORRv8i8,
1654                      Indices);
1655     return;
1656   }
1657
1658   // Copy a QQQQ register quad by copying the individual sub-registers.
1659   if (AArch64::QQQQRegClass.contains(DestReg) &&
1660       AArch64::QQQQRegClass.contains(SrcReg)) {
1661     static const unsigned Indices[] = { AArch64::qsub0, AArch64::qsub1,
1662                                         AArch64::qsub2, AArch64::qsub3 };
1663     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, AArch64::ORRv16i8,
1664                      Indices);
1665     return;
1666   }
1667
1668   // Copy a QQQ register triple by copying the individual sub-registers.
1669   if (AArch64::QQQRegClass.contains(DestReg) &&
1670       AArch64::QQQRegClass.contains(SrcReg)) {
1671     static const unsigned Indices[] = { AArch64::qsub0, AArch64::qsub1,
1672                                         AArch64::qsub2 };
1673     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, AArch64::ORRv16i8,
1674                      Indices);
1675     return;
1676   }
1677
1678   // Copy a QQ register pair by copying the individual sub-registers.
1679   if (AArch64::QQRegClass.contains(DestReg) &&
1680       AArch64::QQRegClass.contains(SrcReg)) {
1681     static const unsigned Indices[] = { AArch64::qsub0, AArch64::qsub1 };
1682     copyPhysRegTuple(MBB, I, DL, DestReg, SrcReg, KillSrc, AArch64::ORRv16i8,
1683                      Indices);
1684     return;
1685   }
1686
1687   if (AArch64::FPR128RegClass.contains(DestReg) &&
1688       AArch64::FPR128RegClass.contains(SrcReg)) {
1689     if(Subtarget.hasNEON()) {
1690       BuildMI(MBB, I, DL, get(AArch64::ORRv16i8), DestReg)
1691           .addReg(SrcReg)
1692           .addReg(SrcReg, getKillRegState(KillSrc));
1693     } else {
1694       BuildMI(MBB, I, DL, get(AArch64::STRQpre))
1695         .addReg(AArch64::SP, RegState::Define)
1696         .addReg(SrcReg, getKillRegState(KillSrc))
1697         .addReg(AArch64::SP)
1698         .addImm(-16);
1699       BuildMI(MBB, I, DL, get(AArch64::LDRQpre))
1700         .addReg(AArch64::SP, RegState::Define)
1701         .addReg(DestReg, RegState::Define)
1702         .addReg(AArch64::SP)
1703         .addImm(16);
1704     }
1705     return;
1706   }
1707
1708   if (AArch64::FPR64RegClass.contains(DestReg) &&
1709       AArch64::FPR64RegClass.contains(SrcReg)) {
1710     if(Subtarget.hasNEON()) {
1711       DestReg = RI.getMatchingSuperReg(DestReg, AArch64::dsub,
1712                                        &AArch64::FPR128RegClass);
1713       SrcReg = RI.getMatchingSuperReg(SrcReg, AArch64::dsub,
1714                                       &AArch64::FPR128RegClass);
1715       BuildMI(MBB, I, DL, get(AArch64::ORRv16i8), DestReg)
1716           .addReg(SrcReg)
1717           .addReg(SrcReg, getKillRegState(KillSrc));
1718     } else {
1719       BuildMI(MBB, I, DL, get(AArch64::FMOVDr), DestReg)
1720           .addReg(SrcReg, getKillRegState(KillSrc));
1721     }
1722     return;
1723   }
1724
1725   if (AArch64::FPR32RegClass.contains(DestReg) &&
1726       AArch64::FPR32RegClass.contains(SrcReg)) {
1727     if(Subtarget.hasNEON()) {
1728       DestReg = RI.getMatchingSuperReg(DestReg, AArch64::ssub,
1729                                        &AArch64::FPR128RegClass);
1730       SrcReg = RI.getMatchingSuperReg(SrcReg, AArch64::ssub,
1731                                       &AArch64::FPR128RegClass);
1732       BuildMI(MBB, I, DL, get(AArch64::ORRv16i8), DestReg)
1733           .addReg(SrcReg)
1734           .addReg(SrcReg, getKillRegState(KillSrc));
1735     } else {
1736       BuildMI(MBB, I, DL, get(AArch64::FMOVSr), DestReg)
1737           .addReg(SrcReg, getKillRegState(KillSrc));
1738     }
1739     return;
1740   }
1741
1742   if (AArch64::FPR16RegClass.contains(DestReg) &&
1743       AArch64::FPR16RegClass.contains(SrcReg)) {
1744     if(Subtarget.hasNEON()) {
1745       DestReg = RI.getMatchingSuperReg(DestReg, AArch64::hsub,
1746                                        &AArch64::FPR128RegClass);
1747       SrcReg = RI.getMatchingSuperReg(SrcReg, AArch64::hsub,
1748                                       &AArch64::FPR128RegClass);
1749       BuildMI(MBB, I, DL, get(AArch64::ORRv16i8), DestReg)
1750           .addReg(SrcReg)
1751           .addReg(SrcReg, getKillRegState(KillSrc));
1752     } else {
1753       DestReg = RI.getMatchingSuperReg(DestReg, AArch64::hsub,
1754                                        &AArch64::FPR32RegClass);
1755       SrcReg = RI.getMatchingSuperReg(SrcReg, AArch64::hsub,
1756                                       &AArch64::FPR32RegClass);
1757       BuildMI(MBB, I, DL, get(AArch64::FMOVSr), DestReg)
1758           .addReg(SrcReg, getKillRegState(KillSrc));
1759     }
1760     return;
1761   }
1762
1763   if (AArch64::FPR8RegClass.contains(DestReg) &&
1764       AArch64::FPR8RegClass.contains(SrcReg)) {
1765     if(Subtarget.hasNEON()) {
1766       DestReg = RI.getMatchingSuperReg(DestReg, AArch64::bsub,
1767                                        &AArch64::FPR128RegClass);
1768       SrcReg = RI.getMatchingSuperReg(SrcReg, AArch64::bsub,
1769                                       &AArch64::FPR128RegClass);
1770       BuildMI(MBB, I, DL, get(AArch64::ORRv16i8), DestReg)
1771           .addReg(SrcReg)
1772           .addReg(SrcReg, getKillRegState(KillSrc));
1773     } else {
1774       DestReg = RI.getMatchingSuperReg(DestReg, AArch64::bsub,
1775                                        &AArch64::FPR32RegClass);
1776       SrcReg = RI.getMatchingSuperReg(SrcReg, AArch64::bsub,
1777                                       &AArch64::FPR32RegClass);
1778       BuildMI(MBB, I, DL, get(AArch64::FMOVSr), DestReg)
1779           .addReg(SrcReg, getKillRegState(KillSrc));
1780     }
1781     return;
1782   }
1783
1784   // Copies between GPR64 and FPR64.
1785   if (AArch64::FPR64RegClass.contains(DestReg) &&
1786       AArch64::GPR64RegClass.contains(SrcReg)) {
1787     BuildMI(MBB, I, DL, get(AArch64::FMOVXDr), DestReg)
1788         .addReg(SrcReg, getKillRegState(KillSrc));
1789     return;
1790   }
1791   if (AArch64::GPR64RegClass.contains(DestReg) &&
1792       AArch64::FPR64RegClass.contains(SrcReg)) {
1793     BuildMI(MBB, I, DL, get(AArch64::FMOVDXr), DestReg)
1794         .addReg(SrcReg, getKillRegState(KillSrc));
1795     return;
1796   }
1797   // Copies between GPR32 and FPR32.
1798   if (AArch64::FPR32RegClass.contains(DestReg) &&
1799       AArch64::GPR32RegClass.contains(SrcReg)) {
1800     BuildMI(MBB, I, DL, get(AArch64::FMOVWSr), DestReg)
1801         .addReg(SrcReg, getKillRegState(KillSrc));
1802     return;
1803   }
1804   if (AArch64::GPR32RegClass.contains(DestReg) &&
1805       AArch64::FPR32RegClass.contains(SrcReg)) {
1806     BuildMI(MBB, I, DL, get(AArch64::FMOVSWr), DestReg)
1807         .addReg(SrcReg, getKillRegState(KillSrc));
1808     return;
1809   }
1810
1811   if (DestReg == AArch64::NZCV) {
1812     assert(AArch64::GPR64RegClass.contains(SrcReg) && "Invalid NZCV copy");
1813     BuildMI(MBB, I, DL, get(AArch64::MSR))
1814       .addImm(AArch64SysReg::NZCV)
1815       .addReg(SrcReg, getKillRegState(KillSrc))
1816       .addReg(AArch64::NZCV, RegState::Implicit | RegState::Define);
1817     return;
1818   }
1819
1820   if (SrcReg == AArch64::NZCV) {
1821     assert(AArch64::GPR64RegClass.contains(DestReg) && "Invalid NZCV copy");
1822     BuildMI(MBB, I, DL, get(AArch64::MRS))
1823       .addReg(DestReg)
1824       .addImm(AArch64SysReg::NZCV)
1825       .addReg(AArch64::NZCV, RegState::Implicit | getKillRegState(KillSrc));
1826     return;
1827   }
1828
1829   llvm_unreachable("unimplemented reg-to-reg copy");
1830 }
1831
1832 void AArch64InstrInfo::storeRegToStackSlot(
1833     MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned SrcReg,
1834     bool isKill, int FI, const TargetRegisterClass *RC,
1835     const TargetRegisterInfo *TRI) const {
1836   DebugLoc DL;
1837   if (MBBI != MBB.end())
1838     DL = MBBI->getDebugLoc();
1839   MachineFunction &MF = *MBB.getParent();
1840   MachineFrameInfo &MFI = *MF.getFrameInfo();
1841   unsigned Align = MFI.getObjectAlignment(FI);
1842
1843   MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(MF, FI);
1844   MachineMemOperand *MMO = MF.getMachineMemOperand(
1845       PtrInfo, MachineMemOperand::MOStore, MFI.getObjectSize(FI), Align);
1846   unsigned Opc = 0;
1847   bool Offset = true;
1848   switch (RC->getSize()) {
1849   case 1:
1850     if (AArch64::FPR8RegClass.hasSubClassEq(RC))
1851       Opc = AArch64::STRBui;
1852     break;
1853   case 2:
1854     if (AArch64::FPR16RegClass.hasSubClassEq(RC))
1855       Opc = AArch64::STRHui;
1856     break;
1857   case 4:
1858     if (AArch64::GPR32allRegClass.hasSubClassEq(RC)) {
1859       Opc = AArch64::STRWui;
1860       if (TargetRegisterInfo::isVirtualRegister(SrcReg))
1861         MF.getRegInfo().constrainRegClass(SrcReg, &AArch64::GPR32RegClass);
1862       else
1863         assert(SrcReg != AArch64::WSP);
1864     } else if (AArch64::FPR32RegClass.hasSubClassEq(RC))
1865       Opc = AArch64::STRSui;
1866     break;
1867   case 8:
1868     if (AArch64::GPR64allRegClass.hasSubClassEq(RC)) {
1869       Opc = AArch64::STRXui;
1870       if (TargetRegisterInfo::isVirtualRegister(SrcReg))
1871         MF.getRegInfo().constrainRegClass(SrcReg, &AArch64::GPR64RegClass);
1872       else
1873         assert(SrcReg != AArch64::SP);
1874     } else if (AArch64::FPR64RegClass.hasSubClassEq(RC))
1875       Opc = AArch64::STRDui;
1876     break;
1877   case 16:
1878     if (AArch64::FPR128RegClass.hasSubClassEq(RC))
1879       Opc = AArch64::STRQui;
1880     else if (AArch64::DDRegClass.hasSubClassEq(RC)) {
1881       assert(Subtarget.hasNEON() &&
1882              "Unexpected register store without NEON");
1883       Opc = AArch64::ST1Twov1d, Offset = false;
1884     }
1885     break;
1886   case 24:
1887     if (AArch64::DDDRegClass.hasSubClassEq(RC)) {
1888       assert(Subtarget.hasNEON() &&
1889              "Unexpected register store without NEON");
1890       Opc = AArch64::ST1Threev1d, Offset = false;
1891     }
1892     break;
1893   case 32:
1894     if (AArch64::DDDDRegClass.hasSubClassEq(RC)) {
1895       assert(Subtarget.hasNEON() &&
1896              "Unexpected register store without NEON");
1897       Opc = AArch64::ST1Fourv1d, Offset = false;
1898     } else if (AArch64::QQRegClass.hasSubClassEq(RC)) {
1899       assert(Subtarget.hasNEON() &&
1900              "Unexpected register store without NEON");
1901       Opc = AArch64::ST1Twov2d, Offset = false;
1902     }
1903     break;
1904   case 48:
1905     if (AArch64::QQQRegClass.hasSubClassEq(RC)) {
1906       assert(Subtarget.hasNEON() &&
1907              "Unexpected register store without NEON");
1908       Opc = AArch64::ST1Threev2d, Offset = false;
1909     }
1910     break;
1911   case 64:
1912     if (AArch64::QQQQRegClass.hasSubClassEq(RC)) {
1913       assert(Subtarget.hasNEON() &&
1914              "Unexpected register store without NEON");
1915       Opc = AArch64::ST1Fourv2d, Offset = false;
1916     }
1917     break;
1918   }
1919   assert(Opc && "Unknown register class");
1920
1921   const MachineInstrBuilder MI = BuildMI(MBB, MBBI, DL, get(Opc))
1922                                       .addReg(SrcReg, getKillRegState(isKill))
1923                                       .addFrameIndex(FI);
1924
1925   if (Offset)
1926     MI.addImm(0);
1927   MI.addMemOperand(MMO);
1928 }
1929
1930 void AArch64InstrInfo::loadRegFromStackSlot(
1931     MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, unsigned DestReg,
1932     int FI, const TargetRegisterClass *RC,
1933     const TargetRegisterInfo *TRI) const {
1934   DebugLoc DL;
1935   if (MBBI != MBB.end())
1936     DL = MBBI->getDebugLoc();
1937   MachineFunction &MF = *MBB.getParent();
1938   MachineFrameInfo &MFI = *MF.getFrameInfo();
1939   unsigned Align = MFI.getObjectAlignment(FI);
1940   MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(MF, FI);
1941   MachineMemOperand *MMO = MF.getMachineMemOperand(
1942       PtrInfo, MachineMemOperand::MOLoad, MFI.getObjectSize(FI), Align);
1943
1944   unsigned Opc = 0;
1945   bool Offset = true;
1946   switch (RC->getSize()) {
1947   case 1:
1948     if (AArch64::FPR8RegClass.hasSubClassEq(RC))
1949       Opc = AArch64::LDRBui;
1950     break;
1951   case 2:
1952     if (AArch64::FPR16RegClass.hasSubClassEq(RC))
1953       Opc = AArch64::LDRHui;
1954     break;
1955   case 4:
1956     if (AArch64::GPR32allRegClass.hasSubClassEq(RC)) {
1957       Opc = AArch64::LDRWui;
1958       if (TargetRegisterInfo::isVirtualRegister(DestReg))
1959         MF.getRegInfo().constrainRegClass(DestReg, &AArch64::GPR32RegClass);
1960       else
1961         assert(DestReg != AArch64::WSP);
1962     } else if (AArch64::FPR32RegClass.hasSubClassEq(RC))
1963       Opc = AArch64::LDRSui;
1964     break;
1965   case 8:
1966     if (AArch64::GPR64allRegClass.hasSubClassEq(RC)) {
1967       Opc = AArch64::LDRXui;
1968       if (TargetRegisterInfo::isVirtualRegister(DestReg))
1969         MF.getRegInfo().constrainRegClass(DestReg, &AArch64::GPR64RegClass);
1970       else
1971         assert(DestReg != AArch64::SP);
1972     } else if (AArch64::FPR64RegClass.hasSubClassEq(RC))
1973       Opc = AArch64::LDRDui;
1974     break;
1975   case 16:
1976     if (AArch64::FPR128RegClass.hasSubClassEq(RC))
1977       Opc = AArch64::LDRQui;
1978     else if (AArch64::DDRegClass.hasSubClassEq(RC)) {
1979       assert(Subtarget.hasNEON() &&
1980              "Unexpected register load without NEON");
1981       Opc = AArch64::LD1Twov1d, Offset = false;
1982     }
1983     break;
1984   case 24:
1985     if (AArch64::DDDRegClass.hasSubClassEq(RC)) {
1986       assert(Subtarget.hasNEON() &&
1987              "Unexpected register load without NEON");
1988       Opc = AArch64::LD1Threev1d, Offset = false;
1989     }
1990     break;
1991   case 32:
1992     if (AArch64::DDDDRegClass.hasSubClassEq(RC)) {
1993       assert(Subtarget.hasNEON() &&
1994              "Unexpected register load without NEON");
1995       Opc = AArch64::LD1Fourv1d, Offset = false;
1996     } else if (AArch64::QQRegClass.hasSubClassEq(RC)) {
1997       assert(Subtarget.hasNEON() &&
1998              "Unexpected register load without NEON");
1999       Opc = AArch64::LD1Twov2d, Offset = false;
2000     }
2001     break;
2002   case 48:
2003     if (AArch64::QQQRegClass.hasSubClassEq(RC)) {
2004       assert(Subtarget.hasNEON() &&
2005              "Unexpected register load without NEON");
2006       Opc = AArch64::LD1Threev2d, Offset = false;
2007     }
2008     break;
2009   case 64:
2010     if (AArch64::QQQQRegClass.hasSubClassEq(RC)) {
2011       assert(Subtarget.hasNEON() &&
2012              "Unexpected register load without NEON");
2013       Opc = AArch64::LD1Fourv2d, Offset = false;
2014     }
2015     break;
2016   }
2017   assert(Opc && "Unknown register class");
2018
2019   const MachineInstrBuilder MI = BuildMI(MBB, MBBI, DL, get(Opc))
2020                                       .addReg(DestReg, getDefRegState(true))
2021                                       .addFrameIndex(FI);
2022   if (Offset)
2023     MI.addImm(0);
2024   MI.addMemOperand(MMO);
2025 }
2026
2027 void llvm::emitFrameOffset(MachineBasicBlock &MBB,
2028                            MachineBasicBlock::iterator MBBI, DebugLoc DL,
2029                            unsigned DestReg, unsigned SrcReg, int Offset,
2030                            const TargetInstrInfo *TII,
2031                            MachineInstr::MIFlag Flag, bool SetNZCV) {
2032   if (DestReg == SrcReg && Offset == 0)
2033     return;
2034
2035   bool isSub = Offset < 0;
2036   if (isSub)
2037     Offset = -Offset;
2038
2039   // FIXME: If the offset won't fit in 24-bits, compute the offset into a
2040   // scratch register.  If DestReg is a virtual register, use it as the
2041   // scratch register; otherwise, create a new virtual register (to be
2042   // replaced by the scavenger at the end of PEI).  That case can be optimized
2043   // slightly if DestReg is SP which is always 16-byte aligned, so the scratch
2044   // register can be loaded with offset%8 and the add/sub can use an extending
2045   // instruction with LSL#3.
2046   // Currently the function handles any offsets but generates a poor sequence
2047   // of code.
2048   //  assert(Offset < (1 << 24) && "unimplemented reg plus immediate");
2049
2050   unsigned Opc;
2051   if (SetNZCV)
2052     Opc = isSub ? AArch64::SUBSXri : AArch64::ADDSXri;
2053   else
2054     Opc = isSub ? AArch64::SUBXri : AArch64::ADDXri;
2055   const unsigned MaxEncoding = 0xfff;
2056   const unsigned ShiftSize = 12;
2057   const unsigned MaxEncodableValue = MaxEncoding << ShiftSize;
2058   while (((unsigned)Offset) >= (1 << ShiftSize)) {
2059     unsigned ThisVal;
2060     if (((unsigned)Offset) > MaxEncodableValue) {
2061       ThisVal = MaxEncodableValue;
2062     } else {
2063       ThisVal = Offset & MaxEncodableValue;
2064     }
2065     assert((ThisVal >> ShiftSize) <= MaxEncoding &&
2066            "Encoding cannot handle value that big");
2067     BuildMI(MBB, MBBI, DL, TII->get(Opc), DestReg)
2068         .addReg(SrcReg)
2069         .addImm(ThisVal >> ShiftSize)
2070         .addImm(AArch64_AM::getShifterImm(AArch64_AM::LSL, ShiftSize))
2071         .setMIFlag(Flag);
2072
2073     SrcReg = DestReg;
2074     Offset -= ThisVal;
2075     if (Offset == 0)
2076       return;
2077   }
2078   BuildMI(MBB, MBBI, DL, TII->get(Opc), DestReg)
2079       .addReg(SrcReg)
2080       .addImm(Offset)
2081       .addImm(AArch64_AM::getShifterImm(AArch64_AM::LSL, 0))
2082       .setMIFlag(Flag);
2083 }
2084
2085 MachineInstr *AArch64InstrInfo::foldMemoryOperandImpl(
2086     MachineFunction &MF, MachineInstr *MI, ArrayRef<unsigned> Ops,
2087     MachineBasicBlock::iterator InsertPt, int FrameIndex) const {
2088   // This is a bit of a hack. Consider this instruction:
2089   //
2090   //   %vreg0<def> = COPY %SP; GPR64all:%vreg0
2091   //
2092   // We explicitly chose GPR64all for the virtual register so such a copy might
2093   // be eliminated by RegisterCoalescer. However, that may not be possible, and
2094   // %vreg0 may even spill. We can't spill %SP, and since it is in the GPR64all
2095   // register class, TargetInstrInfo::foldMemoryOperand() is going to try.
2096   //
2097   // To prevent that, we are going to constrain the %vreg0 register class here.
2098   //
2099   // <rdar://problem/11522048>
2100   //
2101   if (MI->isCopy()) {
2102     unsigned DstReg = MI->getOperand(0).getReg();
2103     unsigned SrcReg = MI->getOperand(1).getReg();
2104     if (SrcReg == AArch64::SP &&
2105         TargetRegisterInfo::isVirtualRegister(DstReg)) {
2106       MF.getRegInfo().constrainRegClass(DstReg, &AArch64::GPR64RegClass);
2107       return nullptr;
2108     }
2109     if (DstReg == AArch64::SP &&
2110         TargetRegisterInfo::isVirtualRegister(SrcReg)) {
2111       MF.getRegInfo().constrainRegClass(SrcReg, &AArch64::GPR64RegClass);
2112       return nullptr;
2113     }
2114   }
2115
2116   // Cannot fold.
2117   return nullptr;
2118 }
2119
2120 int llvm::isAArch64FrameOffsetLegal(const MachineInstr &MI, int &Offset,
2121                                     bool *OutUseUnscaledOp,
2122                                     unsigned *OutUnscaledOp,
2123                                     int *EmittableOffset) {
2124   int Scale = 1;
2125   bool IsSigned = false;
2126   // The ImmIdx should be changed case by case if it is not 2.
2127   unsigned ImmIdx = 2;
2128   unsigned UnscaledOp = 0;
2129   // Set output values in case of early exit.
2130   if (EmittableOffset)
2131     *EmittableOffset = 0;
2132   if (OutUseUnscaledOp)
2133     *OutUseUnscaledOp = false;
2134   if (OutUnscaledOp)
2135     *OutUnscaledOp = 0;
2136   switch (MI.getOpcode()) {
2137   default:
2138     llvm_unreachable("unhandled opcode in rewriteAArch64FrameIndex");
2139   // Vector spills/fills can't take an immediate offset.
2140   case AArch64::LD1Twov2d:
2141   case AArch64::LD1Threev2d:
2142   case AArch64::LD1Fourv2d:
2143   case AArch64::LD1Twov1d:
2144   case AArch64::LD1Threev1d:
2145   case AArch64::LD1Fourv1d:
2146   case AArch64::ST1Twov2d:
2147   case AArch64::ST1Threev2d:
2148   case AArch64::ST1Fourv2d:
2149   case AArch64::ST1Twov1d:
2150   case AArch64::ST1Threev1d:
2151   case AArch64::ST1Fourv1d:
2152     return AArch64FrameOffsetCannotUpdate;
2153   case AArch64::PRFMui:
2154     Scale = 8;
2155     UnscaledOp = AArch64::PRFUMi;
2156     break;
2157   case AArch64::LDRXui:
2158     Scale = 8;
2159     UnscaledOp = AArch64::LDURXi;
2160     break;
2161   case AArch64::LDRWui:
2162     Scale = 4;
2163     UnscaledOp = AArch64::LDURWi;
2164     break;
2165   case AArch64::LDRBui:
2166     Scale = 1;
2167     UnscaledOp = AArch64::LDURBi;
2168     break;
2169   case AArch64::LDRHui:
2170     Scale = 2;
2171     UnscaledOp = AArch64::LDURHi;
2172     break;
2173   case AArch64::LDRSui:
2174     Scale = 4;
2175     UnscaledOp = AArch64::LDURSi;
2176     break;
2177   case AArch64::LDRDui:
2178     Scale = 8;
2179     UnscaledOp = AArch64::LDURDi;
2180     break;
2181   case AArch64::LDRQui:
2182     Scale = 16;
2183     UnscaledOp = AArch64::LDURQi;
2184     break;
2185   case AArch64::LDRBBui:
2186     Scale = 1;
2187     UnscaledOp = AArch64::LDURBBi;
2188     break;
2189   case AArch64::LDRHHui:
2190     Scale = 2;
2191     UnscaledOp = AArch64::LDURHHi;
2192     break;
2193   case AArch64::LDRSBXui:
2194     Scale = 1;
2195     UnscaledOp = AArch64::LDURSBXi;
2196     break;
2197   case AArch64::LDRSBWui:
2198     Scale = 1;
2199     UnscaledOp = AArch64::LDURSBWi;
2200     break;
2201   case AArch64::LDRSHXui:
2202     Scale = 2;
2203     UnscaledOp = AArch64::LDURSHXi;
2204     break;
2205   case AArch64::LDRSHWui:
2206     Scale = 2;
2207     UnscaledOp = AArch64::LDURSHWi;
2208     break;
2209   case AArch64::LDRSWui:
2210     Scale = 4;
2211     UnscaledOp = AArch64::LDURSWi;
2212     break;
2213
2214   case AArch64::STRXui:
2215     Scale = 8;
2216     UnscaledOp = AArch64::STURXi;
2217     break;
2218   case AArch64::STRWui:
2219     Scale = 4;
2220     UnscaledOp = AArch64::STURWi;
2221     break;
2222   case AArch64::STRBui:
2223     Scale = 1;
2224     UnscaledOp = AArch64::STURBi;
2225     break;
2226   case AArch64::STRHui:
2227     Scale = 2;
2228     UnscaledOp = AArch64::STURHi;
2229     break;
2230   case AArch64::STRSui:
2231     Scale = 4;
2232     UnscaledOp = AArch64::STURSi;
2233     break;
2234   case AArch64::STRDui:
2235     Scale = 8;
2236     UnscaledOp = AArch64::STURDi;
2237     break;
2238   case AArch64::STRQui:
2239     Scale = 16;
2240     UnscaledOp = AArch64::STURQi;
2241     break;
2242   case AArch64::STRBBui:
2243     Scale = 1;
2244     UnscaledOp = AArch64::STURBBi;
2245     break;
2246   case AArch64::STRHHui:
2247     Scale = 2;
2248     UnscaledOp = AArch64::STURHHi;
2249     break;
2250
2251   case AArch64::LDPXi:
2252   case AArch64::LDPDi:
2253   case AArch64::STPXi:
2254   case AArch64::STPDi:
2255   case AArch64::LDNPXi:
2256   case AArch64::LDNPDi:
2257   case AArch64::STNPXi:
2258   case AArch64::STNPDi:
2259     ImmIdx = 3;
2260     IsSigned = true;
2261     Scale = 8;
2262     break;
2263   case AArch64::LDPQi:
2264   case AArch64::STPQi:
2265   case AArch64::LDNPQi:
2266   case AArch64::STNPQi:
2267     ImmIdx = 3;
2268     IsSigned = true;
2269     Scale = 16;
2270     break;
2271   case AArch64::LDPWi:
2272   case AArch64::LDPSi:
2273   case AArch64::STPWi:
2274   case AArch64::STPSi:
2275   case AArch64::LDNPWi:
2276   case AArch64::LDNPSi:
2277   case AArch64::STNPWi:
2278   case AArch64::STNPSi:
2279     ImmIdx = 3;
2280     IsSigned = true;
2281     Scale = 4;
2282     break;
2283
2284   case AArch64::LDURXi:
2285   case AArch64::LDURWi:
2286   case AArch64::LDURBi:
2287   case AArch64::LDURHi:
2288   case AArch64::LDURSi:
2289   case AArch64::LDURDi:
2290   case AArch64::LDURQi:
2291   case AArch64::LDURHHi:
2292   case AArch64::LDURBBi:
2293   case AArch64::LDURSBXi:
2294   case AArch64::LDURSBWi:
2295   case AArch64::LDURSHXi:
2296   case AArch64::LDURSHWi:
2297   case AArch64::LDURSWi:
2298   case AArch64::STURXi:
2299   case AArch64::STURWi:
2300   case AArch64::STURBi:
2301   case AArch64::STURHi:
2302   case AArch64::STURSi:
2303   case AArch64::STURDi:
2304   case AArch64::STURQi:
2305   case AArch64::STURBBi:
2306   case AArch64::STURHHi:
2307     Scale = 1;
2308     break;
2309   }
2310
2311   Offset += MI.getOperand(ImmIdx).getImm() * Scale;
2312
2313   bool useUnscaledOp = false;
2314   // If the offset doesn't match the scale, we rewrite the instruction to
2315   // use the unscaled instruction instead. Likewise, if we have a negative
2316   // offset (and have an unscaled op to use).
2317   if ((Offset & (Scale - 1)) != 0 || (Offset < 0 && UnscaledOp != 0))
2318     useUnscaledOp = true;
2319
2320   // Use an unscaled addressing mode if the instruction has a negative offset
2321   // (or if the instruction is already using an unscaled addressing mode).
2322   unsigned MaskBits;
2323   if (IsSigned) {
2324     // ldp/stp instructions.
2325     MaskBits = 7;
2326     Offset /= Scale;
2327   } else if (UnscaledOp == 0 || useUnscaledOp) {
2328     MaskBits = 9;
2329     IsSigned = true;
2330     Scale = 1;
2331   } else {
2332     MaskBits = 12;
2333     IsSigned = false;
2334     Offset /= Scale;
2335   }
2336
2337   // Attempt to fold address computation.
2338   int MaxOff = (1 << (MaskBits - IsSigned)) - 1;
2339   int MinOff = (IsSigned ? (-MaxOff - 1) : 0);
2340   if (Offset >= MinOff && Offset <= MaxOff) {
2341     if (EmittableOffset)
2342       *EmittableOffset = Offset;
2343     Offset = 0;
2344   } else {
2345     int NewOff = Offset < 0 ? MinOff : MaxOff;
2346     if (EmittableOffset)
2347       *EmittableOffset = NewOff;
2348     Offset = (Offset - NewOff) * Scale;
2349   }
2350   if (OutUseUnscaledOp)
2351     *OutUseUnscaledOp = useUnscaledOp;
2352   if (OutUnscaledOp)
2353     *OutUnscaledOp = UnscaledOp;
2354   return AArch64FrameOffsetCanUpdate |
2355          (Offset == 0 ? AArch64FrameOffsetIsLegal : 0);
2356 }
2357
2358 bool llvm::rewriteAArch64FrameIndex(MachineInstr &MI, unsigned FrameRegIdx,
2359                                     unsigned FrameReg, int &Offset,
2360                                     const AArch64InstrInfo *TII) {
2361   unsigned Opcode = MI.getOpcode();
2362   unsigned ImmIdx = FrameRegIdx + 1;
2363
2364   if (Opcode == AArch64::ADDSXri || Opcode == AArch64::ADDXri) {
2365     Offset += MI.getOperand(ImmIdx).getImm();
2366     emitFrameOffset(*MI.getParent(), MI, MI.getDebugLoc(),
2367                     MI.getOperand(0).getReg(), FrameReg, Offset, TII,
2368                     MachineInstr::NoFlags, (Opcode == AArch64::ADDSXri));
2369     MI.eraseFromParent();
2370     Offset = 0;
2371     return true;
2372   }
2373
2374   int NewOffset;
2375   unsigned UnscaledOp;
2376   bool UseUnscaledOp;
2377   int Status = isAArch64FrameOffsetLegal(MI, Offset, &UseUnscaledOp,
2378                                          &UnscaledOp, &NewOffset);
2379   if (Status & AArch64FrameOffsetCanUpdate) {
2380     if (Status & AArch64FrameOffsetIsLegal)
2381       // Replace the FrameIndex with FrameReg.
2382       MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
2383     if (UseUnscaledOp)
2384       MI.setDesc(TII->get(UnscaledOp));
2385
2386     MI.getOperand(ImmIdx).ChangeToImmediate(NewOffset);
2387     return Offset == 0;
2388   }
2389
2390   return false;
2391 }
2392
2393 void AArch64InstrInfo::getNoopForMachoTarget(MCInst &NopInst) const {
2394   NopInst.setOpcode(AArch64::HINT);
2395   NopInst.addOperand(MCOperand::createImm(0));
2396 }
2397 /// useMachineCombiner - return true when a target supports MachineCombiner
2398 bool AArch64InstrInfo::useMachineCombiner() const {
2399   // AArch64 supports the combiner
2400   return true;
2401 }
2402 //
2403 // True when Opc sets flag
2404 static bool isCombineInstrSettingFlag(unsigned Opc) {
2405   switch (Opc) {
2406   case AArch64::ADDSWrr:
2407   case AArch64::ADDSWri:
2408   case AArch64::ADDSXrr:
2409   case AArch64::ADDSXri:
2410   case AArch64::SUBSWrr:
2411   case AArch64::SUBSXrr:
2412   // Note: MSUB Wd,Wn,Wm,Wi -> Wd = Wi - WnxWm, not Wd=WnxWm - Wi.
2413   case AArch64::SUBSWri:
2414   case AArch64::SUBSXri:
2415     return true;
2416   default:
2417     break;
2418   }
2419   return false;
2420 }
2421 //
2422 // 32b Opcodes that can be combined with a MUL
2423 static bool isCombineInstrCandidate32(unsigned Opc) {
2424   switch (Opc) {
2425   case AArch64::ADDWrr:
2426   case AArch64::ADDWri:
2427   case AArch64::SUBWrr:
2428   case AArch64::ADDSWrr:
2429   case AArch64::ADDSWri:
2430   case AArch64::SUBSWrr:
2431   // Note: MSUB Wd,Wn,Wm,Wi -> Wd = Wi - WnxWm, not Wd=WnxWm - Wi.
2432   case AArch64::SUBWri:
2433   case AArch64::SUBSWri:
2434     return true;
2435   default:
2436     break;
2437   }
2438   return false;
2439 }
2440 //
2441 // 64b Opcodes that can be combined with a MUL
2442 static bool isCombineInstrCandidate64(unsigned Opc) {
2443   switch (Opc) {
2444   case AArch64::ADDXrr:
2445   case AArch64::ADDXri:
2446   case AArch64::SUBXrr:
2447   case AArch64::ADDSXrr:
2448   case AArch64::ADDSXri:
2449   case AArch64::SUBSXrr:
2450   // Note: MSUB Wd,Wn,Wm,Wi -> Wd = Wi - WnxWm, not Wd=WnxWm - Wi.
2451   case AArch64::SUBXri:
2452   case AArch64::SUBSXri:
2453     return true;
2454   default:
2455     break;
2456   }
2457   return false;
2458 }
2459 //
2460 // Opcodes that can be combined with a MUL
2461 static bool isCombineInstrCandidate(unsigned Opc) {
2462   return (isCombineInstrCandidate32(Opc) || isCombineInstrCandidate64(Opc));
2463 }
2464
2465 static bool canCombineWithMUL(MachineBasicBlock &MBB, MachineOperand &MO,
2466                               unsigned MulOpc, unsigned ZeroReg) {
2467   MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
2468   MachineInstr *MI = nullptr;
2469   // We need a virtual register definition.
2470   if (MO.isReg() && TargetRegisterInfo::isVirtualRegister(MO.getReg()))
2471     MI = MRI.getUniqueVRegDef(MO.getReg());
2472   // And it needs to be in the trace (otherwise, it won't have a depth).
2473   if (!MI || MI->getParent() != &MBB || (unsigned)MI->getOpcode() != MulOpc)
2474     return false;
2475
2476   assert(MI->getNumOperands() >= 4 && MI->getOperand(0).isReg() &&
2477          MI->getOperand(1).isReg() && MI->getOperand(2).isReg() &&
2478          MI->getOperand(3).isReg() && "MAdd/MSub must have a least 4 regs");
2479
2480   // The third input reg must be zero.
2481   if (MI->getOperand(3).getReg() != ZeroReg)
2482     return false;
2483
2484   // Must only used by the user we combine with.
2485   if (!MRI.hasOneNonDBGUse(MI->getOperand(0).getReg()))
2486     return false;
2487
2488   return true;
2489 }
2490
2491 /// Return true when there is potentially a faster code sequence
2492 /// for an instruction chain ending in \p Root. All potential patterns are
2493 /// listed
2494 /// in the \p Pattern vector. Pattern should be sorted in priority order since
2495 /// the pattern evaluator stops checking as soon as it finds a faster sequence.
2496
2497 bool AArch64InstrInfo::getMachineCombinerPatterns(
2498     MachineInstr &Root,
2499     SmallVectorImpl<MachineCombinerPattern::MC_PATTERN> &Patterns) const {
2500   unsigned Opc = Root.getOpcode();
2501   MachineBasicBlock &MBB = *Root.getParent();
2502   bool Found = false;
2503
2504   if (!isCombineInstrCandidate(Opc))
2505     return 0;
2506   if (isCombineInstrSettingFlag(Opc)) {
2507     int Cmp_NZCV = Root.findRegisterDefOperandIdx(AArch64::NZCV, true);
2508     // When NZCV is live bail out.
2509     if (Cmp_NZCV == -1)
2510       return 0;
2511     unsigned NewOpc = convertFlagSettingOpcode(&Root);
2512     // When opcode can't change bail out.
2513     // CHECKME: do we miss any cases for opcode conversion?
2514     if (NewOpc == Opc)
2515       return 0;
2516     Opc = NewOpc;
2517   }
2518
2519   switch (Opc) {
2520   default:
2521     break;
2522   case AArch64::ADDWrr:
2523     assert(Root.getOperand(1).isReg() && Root.getOperand(2).isReg() &&
2524            "ADDWrr does not have register operands");
2525     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDWrrr,
2526                           AArch64::WZR)) {
2527       Patterns.push_back(MachineCombinerPattern::MC_MULADDW_OP1);
2528       Found = true;
2529     }
2530     if (canCombineWithMUL(MBB, Root.getOperand(2), AArch64::MADDWrrr,
2531                           AArch64::WZR)) {
2532       Patterns.push_back(MachineCombinerPattern::MC_MULADDW_OP2);
2533       Found = true;
2534     }
2535     break;
2536   case AArch64::ADDXrr:
2537     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDXrrr,
2538                           AArch64::XZR)) {
2539       Patterns.push_back(MachineCombinerPattern::MC_MULADDX_OP1);
2540       Found = true;
2541     }
2542     if (canCombineWithMUL(MBB, Root.getOperand(2), AArch64::MADDXrrr,
2543                           AArch64::XZR)) {
2544       Patterns.push_back(MachineCombinerPattern::MC_MULADDX_OP2);
2545       Found = true;
2546     }
2547     break;
2548   case AArch64::SUBWrr:
2549     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDWrrr,
2550                           AArch64::WZR)) {
2551       Patterns.push_back(MachineCombinerPattern::MC_MULSUBW_OP1);
2552       Found = true;
2553     }
2554     if (canCombineWithMUL(MBB, Root.getOperand(2), AArch64::MADDWrrr,
2555                           AArch64::WZR)) {
2556       Patterns.push_back(MachineCombinerPattern::MC_MULSUBW_OP2);
2557       Found = true;
2558     }
2559     break;
2560   case AArch64::SUBXrr:
2561     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDXrrr,
2562                           AArch64::XZR)) {
2563       Patterns.push_back(MachineCombinerPattern::MC_MULSUBX_OP1);
2564       Found = true;
2565     }
2566     if (canCombineWithMUL(MBB, Root.getOperand(2), AArch64::MADDXrrr,
2567                           AArch64::XZR)) {
2568       Patterns.push_back(MachineCombinerPattern::MC_MULSUBX_OP2);
2569       Found = true;
2570     }
2571     break;
2572   case AArch64::ADDWri:
2573     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDWrrr,
2574                           AArch64::WZR)) {
2575       Patterns.push_back(MachineCombinerPattern::MC_MULADDWI_OP1);
2576       Found = true;
2577     }
2578     break;
2579   case AArch64::ADDXri:
2580     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDXrrr,
2581                           AArch64::XZR)) {
2582       Patterns.push_back(MachineCombinerPattern::MC_MULADDXI_OP1);
2583       Found = true;
2584     }
2585     break;
2586   case AArch64::SUBWri:
2587     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDWrrr,
2588                           AArch64::WZR)) {
2589       Patterns.push_back(MachineCombinerPattern::MC_MULSUBWI_OP1);
2590       Found = true;
2591     }
2592     break;
2593   case AArch64::SUBXri:
2594     if (canCombineWithMUL(MBB, Root.getOperand(1), AArch64::MADDXrrr,
2595                           AArch64::XZR)) {
2596       Patterns.push_back(MachineCombinerPattern::MC_MULSUBXI_OP1);
2597       Found = true;
2598     }
2599     break;
2600   }
2601   return Found;
2602 }
2603
2604 /// genMadd - Generate madd instruction and combine mul and add.
2605 /// Example:
2606 ///  MUL I=A,B,0
2607 ///  ADD R,I,C
2608 ///  ==> MADD R,A,B,C
2609 /// \param Root is the ADD instruction
2610 /// \param [out] InsInstrs is a vector of machine instructions and will
2611 /// contain the generated madd instruction
2612 /// \param IdxMulOpd is index of operand in Root that is the result of
2613 /// the MUL. In the example above IdxMulOpd is 1.
2614 /// \param MaddOpc the opcode fo the madd instruction
2615 static MachineInstr *genMadd(MachineFunction &MF, MachineRegisterInfo &MRI,
2616                              const TargetInstrInfo *TII, MachineInstr &Root,
2617                              SmallVectorImpl<MachineInstr *> &InsInstrs,
2618                              unsigned IdxMulOpd, unsigned MaddOpc,
2619                              const TargetRegisterClass *RC) {
2620   assert(IdxMulOpd == 1 || IdxMulOpd == 2);
2621
2622   unsigned IdxOtherOpd = IdxMulOpd == 1 ? 2 : 1;
2623   MachineInstr *MUL = MRI.getUniqueVRegDef(Root.getOperand(IdxMulOpd).getReg());
2624   unsigned ResultReg = Root.getOperand(0).getReg();
2625   unsigned SrcReg0 = MUL->getOperand(1).getReg();
2626   bool Src0IsKill = MUL->getOperand(1).isKill();
2627   unsigned SrcReg1 = MUL->getOperand(2).getReg();
2628   bool Src1IsKill = MUL->getOperand(2).isKill();
2629   unsigned SrcReg2 = Root.getOperand(IdxOtherOpd).getReg();
2630   bool Src2IsKill = Root.getOperand(IdxOtherOpd).isKill();
2631
2632   if (TargetRegisterInfo::isVirtualRegister(ResultReg))
2633     MRI.constrainRegClass(ResultReg, RC);
2634   if (TargetRegisterInfo::isVirtualRegister(SrcReg0))
2635     MRI.constrainRegClass(SrcReg0, RC);
2636   if (TargetRegisterInfo::isVirtualRegister(SrcReg1))
2637     MRI.constrainRegClass(SrcReg1, RC);
2638   if (TargetRegisterInfo::isVirtualRegister(SrcReg2))
2639     MRI.constrainRegClass(SrcReg2, RC);
2640
2641   MachineInstrBuilder MIB = BuildMI(MF, Root.getDebugLoc(), TII->get(MaddOpc),
2642                                     ResultReg)
2643                                 .addReg(SrcReg0, getKillRegState(Src0IsKill))
2644                                 .addReg(SrcReg1, getKillRegState(Src1IsKill))
2645                                 .addReg(SrcReg2, getKillRegState(Src2IsKill));
2646   // Insert the MADD
2647   InsInstrs.push_back(MIB);
2648   return MUL;
2649 }
2650
2651 /// genMaddR - Generate madd instruction and combine mul and add using
2652 /// an extra virtual register
2653 /// Example - an ADD intermediate needs to be stored in a register:
2654 ///   MUL I=A,B,0
2655 ///   ADD R,I,Imm
2656 ///   ==> ORR  V, ZR, Imm
2657 ///   ==> MADD R,A,B,V
2658 /// \param Root is the ADD instruction
2659 /// \param [out] InsInstrs is a vector of machine instructions and will
2660 /// contain the generated madd instruction
2661 /// \param IdxMulOpd is index of operand in Root that is the result of
2662 /// the MUL. In the example above IdxMulOpd is 1.
2663 /// \param MaddOpc the opcode fo the madd instruction
2664 /// \param VR is a virtual register that holds the value of an ADD operand
2665 /// (V in the example above).
2666 static MachineInstr *genMaddR(MachineFunction &MF, MachineRegisterInfo &MRI,
2667                               const TargetInstrInfo *TII, MachineInstr &Root,
2668                               SmallVectorImpl<MachineInstr *> &InsInstrs,
2669                               unsigned IdxMulOpd, unsigned MaddOpc,
2670                               unsigned VR, const TargetRegisterClass *RC) {
2671   assert(IdxMulOpd == 1 || IdxMulOpd == 2);
2672
2673   MachineInstr *MUL = MRI.getUniqueVRegDef(Root.getOperand(IdxMulOpd).getReg());
2674   unsigned ResultReg = Root.getOperand(0).getReg();
2675   unsigned SrcReg0 = MUL->getOperand(1).getReg();
2676   bool Src0IsKill = MUL->getOperand(1).isKill();
2677   unsigned SrcReg1 = MUL->getOperand(2).getReg();
2678   bool Src1IsKill = MUL->getOperand(2).isKill();
2679
2680   if (TargetRegisterInfo::isVirtualRegister(ResultReg))
2681     MRI.constrainRegClass(ResultReg, RC);
2682   if (TargetRegisterInfo::isVirtualRegister(SrcReg0))
2683     MRI.constrainRegClass(SrcReg0, RC);
2684   if (TargetRegisterInfo::isVirtualRegister(SrcReg1))
2685     MRI.constrainRegClass(SrcReg1, RC);
2686   if (TargetRegisterInfo::isVirtualRegister(VR))
2687     MRI.constrainRegClass(VR, RC);
2688
2689   MachineInstrBuilder MIB = BuildMI(MF, Root.getDebugLoc(), TII->get(MaddOpc),
2690                                     ResultReg)
2691                                 .addReg(SrcReg0, getKillRegState(Src0IsKill))
2692                                 .addReg(SrcReg1, getKillRegState(Src1IsKill))
2693                                 .addReg(VR);
2694   // Insert the MADD
2695   InsInstrs.push_back(MIB);
2696   return MUL;
2697 }
2698
2699 /// When getMachineCombinerPatterns() finds potential patterns,
2700 /// this function generates the instructions that could replace the
2701 /// original code sequence
2702 void AArch64InstrInfo::genAlternativeCodeSequence(
2703     MachineInstr &Root, MachineCombinerPattern::MC_PATTERN Pattern,
2704     SmallVectorImpl<MachineInstr *> &InsInstrs,
2705     SmallVectorImpl<MachineInstr *> &DelInstrs,
2706     DenseMap<unsigned, unsigned> &InstrIdxForVirtReg) const {
2707   MachineBasicBlock &MBB = *Root.getParent();
2708   MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
2709   MachineFunction &MF = *MBB.getParent();
2710   const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
2711
2712   MachineInstr *MUL;
2713   const TargetRegisterClass *RC;
2714   unsigned Opc;
2715   switch (Pattern) {
2716   default:
2717     // signal error.
2718     break;
2719   case MachineCombinerPattern::MC_MULADDW_OP1:
2720   case MachineCombinerPattern::MC_MULADDX_OP1:
2721     // MUL I=A,B,0
2722     // ADD R,I,C
2723     // ==> MADD R,A,B,C
2724     // --- Create(MADD);
2725     if (Pattern == MachineCombinerPattern::MC_MULADDW_OP1) {
2726       Opc = AArch64::MADDWrrr;
2727       RC = &AArch64::GPR32RegClass;
2728     } else {
2729       Opc = AArch64::MADDXrrr;
2730       RC = &AArch64::GPR64RegClass;
2731     }
2732     MUL = genMadd(MF, MRI, TII, Root, InsInstrs, 1, Opc, RC);
2733     break;
2734   case MachineCombinerPattern::MC_MULADDW_OP2:
2735   case MachineCombinerPattern::MC_MULADDX_OP2:
2736     // MUL I=A,B,0
2737     // ADD R,C,I
2738     // ==> MADD R,A,B,C
2739     // --- Create(MADD);
2740     if (Pattern == MachineCombinerPattern::MC_MULADDW_OP2) {
2741       Opc = AArch64::MADDWrrr;
2742       RC = &AArch64::GPR32RegClass;
2743     } else {
2744       Opc = AArch64::MADDXrrr;
2745       RC = &AArch64::GPR64RegClass;
2746     }
2747     MUL = genMadd(MF, MRI, TII, Root, InsInstrs, 2, Opc, RC);
2748     break;
2749   case MachineCombinerPattern::MC_MULADDWI_OP1:
2750   case MachineCombinerPattern::MC_MULADDXI_OP1: {
2751     // MUL I=A,B,0
2752     // ADD R,I,Imm
2753     // ==> ORR  V, ZR, Imm
2754     // ==> MADD R,A,B,V
2755     // --- Create(MADD);
2756     const TargetRegisterClass *OrrRC;
2757     unsigned BitSize, OrrOpc, ZeroReg;
2758     if (Pattern == MachineCombinerPattern::MC_MULADDWI_OP1) {
2759       OrrOpc = AArch64::ORRWri;
2760       OrrRC = &AArch64::GPR32spRegClass;
2761       BitSize = 32;
2762       ZeroReg = AArch64::WZR;
2763       Opc = AArch64::MADDWrrr;
2764       RC = &AArch64::GPR32RegClass;
2765     } else {
2766       OrrOpc = AArch64::ORRXri;
2767       OrrRC = &AArch64::GPR64spRegClass;
2768       BitSize = 64;
2769       ZeroReg = AArch64::XZR;
2770       Opc = AArch64::MADDXrrr;
2771       RC = &AArch64::GPR64RegClass;
2772     }
2773     unsigned NewVR = MRI.createVirtualRegister(OrrRC);
2774     uint64_t Imm = Root.getOperand(2).getImm();
2775
2776     if (Root.getOperand(3).isImm()) {
2777       unsigned Val = Root.getOperand(3).getImm();
2778       Imm = Imm << Val;
2779     }
2780     uint64_t UImm = Imm << (64 - BitSize) >> (64 - BitSize);
2781     uint64_t Encoding;
2782     if (AArch64_AM::processLogicalImmediate(UImm, BitSize, Encoding)) {
2783       MachineInstrBuilder MIB1 =
2784           BuildMI(MF, Root.getDebugLoc(), TII->get(OrrOpc), NewVR)
2785               .addReg(ZeroReg)
2786               .addImm(Encoding);
2787       InsInstrs.push_back(MIB1);
2788       InstrIdxForVirtReg.insert(std::make_pair(NewVR, 0));
2789       MUL = genMaddR(MF, MRI, TII, Root, InsInstrs, 1, Opc, NewVR, RC);
2790     }
2791     break;
2792   }
2793   case MachineCombinerPattern::MC_MULSUBW_OP1:
2794   case MachineCombinerPattern::MC_MULSUBX_OP1: {
2795     // MUL I=A,B,0
2796     // SUB R,I, C
2797     // ==> SUB  V, 0, C
2798     // ==> MADD R,A,B,V // = -C + A*B
2799     // --- Create(MADD);
2800     const TargetRegisterClass *SubRC;
2801     unsigned SubOpc, ZeroReg;
2802     if (Pattern == MachineCombinerPattern::MC_MULSUBW_OP1) {
2803       SubOpc = AArch64::SUBWrr;
2804       SubRC = &AArch64::GPR32spRegClass;
2805       ZeroReg = AArch64::WZR;
2806       Opc = AArch64::MADDWrrr;
2807       RC = &AArch64::GPR32RegClass;
2808     } else {
2809       SubOpc = AArch64::SUBXrr;
2810       SubRC = &AArch64::GPR64spRegClass;
2811       ZeroReg = AArch64::XZR;
2812       Opc = AArch64::MADDXrrr;
2813       RC = &AArch64::GPR64RegClass;
2814     }
2815     unsigned NewVR = MRI.createVirtualRegister(SubRC);
2816     // SUB NewVR, 0, C
2817     MachineInstrBuilder MIB1 =
2818         BuildMI(MF, Root.getDebugLoc(), TII->get(SubOpc), NewVR)
2819             .addReg(ZeroReg)
2820             .addOperand(Root.getOperand(2));
2821     InsInstrs.push_back(MIB1);
2822     InstrIdxForVirtReg.insert(std::make_pair(NewVR, 0));
2823     MUL = genMaddR(MF, MRI, TII, Root, InsInstrs, 1, Opc, NewVR, RC);
2824     break;
2825   }
2826   case MachineCombinerPattern::MC_MULSUBW_OP2:
2827   case MachineCombinerPattern::MC_MULSUBX_OP2:
2828     // MUL I=A,B,0
2829     // SUB R,C,I
2830     // ==> MSUB R,A,B,C (computes C - A*B)
2831     // --- Create(MSUB);
2832     if (Pattern == MachineCombinerPattern::MC_MULSUBW_OP2) {
2833       Opc = AArch64::MSUBWrrr;
2834       RC = &AArch64::GPR32RegClass;
2835     } else {
2836       Opc = AArch64::MSUBXrrr;
2837       RC = &AArch64::GPR64RegClass;
2838     }
2839     MUL = genMadd(MF, MRI, TII, Root, InsInstrs, 2, Opc, RC);
2840     break;
2841   case MachineCombinerPattern::MC_MULSUBWI_OP1:
2842   case MachineCombinerPattern::MC_MULSUBXI_OP1: {
2843     // MUL I=A,B,0
2844     // SUB R,I, Imm
2845     // ==> ORR  V, ZR, -Imm
2846     // ==> MADD R,A,B,V // = -Imm + A*B
2847     // --- Create(MADD);
2848     const TargetRegisterClass *OrrRC;
2849     unsigned BitSize, OrrOpc, ZeroReg;
2850     if (Pattern == MachineCombinerPattern::MC_MULSUBWI_OP1) {
2851       OrrOpc = AArch64::ORRWri;
2852       OrrRC = &AArch64::GPR32spRegClass;
2853       BitSize = 32;
2854       ZeroReg = AArch64::WZR;
2855       Opc = AArch64::MADDWrrr;
2856       RC = &AArch64::GPR32RegClass;
2857     } else {
2858       OrrOpc = AArch64::ORRXri;
2859       OrrRC = &AArch64::GPR64spRegClass;
2860       BitSize = 64;
2861       ZeroReg = AArch64::XZR;
2862       Opc = AArch64::MADDXrrr;
2863       RC = &AArch64::GPR64RegClass;
2864     }
2865     unsigned NewVR = MRI.createVirtualRegister(OrrRC);
2866     int Imm = Root.getOperand(2).getImm();
2867     if (Root.getOperand(3).isImm()) {
2868       unsigned Val = Root.getOperand(3).getImm();
2869       Imm = Imm << Val;
2870     }
2871     uint64_t UImm = -Imm << (64 - BitSize) >> (64 - BitSize);
2872     uint64_t Encoding;
2873     if (AArch64_AM::processLogicalImmediate(UImm, BitSize, Encoding)) {
2874       MachineInstrBuilder MIB1 =
2875           BuildMI(MF, Root.getDebugLoc(), TII->get(OrrOpc), NewVR)
2876               .addReg(ZeroReg)
2877               .addImm(Encoding);
2878       InsInstrs.push_back(MIB1);
2879       InstrIdxForVirtReg.insert(std::make_pair(NewVR, 0));
2880       MUL = genMaddR(MF, MRI, TII, Root, InsInstrs, 1, Opc, NewVR, RC);
2881     }
2882     break;
2883   }
2884   } // end switch (Pattern)
2885   // Record MUL and ADD/SUB for deletion
2886   DelInstrs.push_back(MUL);
2887   DelInstrs.push_back(&Root);
2888
2889   return;
2890 }
2891
2892 /// \brief Replace csincr-branch sequence by simple conditional branch
2893 ///
2894 /// Examples:
2895 /// 1.
2896 ///   csinc  w9, wzr, wzr, <condition code>
2897 ///   tbnz   w9, #0, 0x44
2898 /// to
2899 ///   b.<inverted condition code>
2900 ///
2901 /// 2.
2902 ///   csinc w9, wzr, wzr, <condition code>
2903 ///   tbz   w9, #0, 0x44
2904 /// to
2905 ///   b.<condition code>
2906 ///
2907 /// \param  MI Conditional Branch
2908 /// \return True when the simple conditional branch is generated
2909 ///
2910 bool AArch64InstrInfo::optimizeCondBranch(MachineInstr *MI) const {
2911   bool IsNegativeBranch = false;
2912   bool IsTestAndBranch = false;
2913   unsigned TargetBBInMI = 0;
2914   switch (MI->getOpcode()) {
2915   default:
2916     llvm_unreachable("Unknown branch instruction?");
2917   case AArch64::Bcc:
2918     return false;
2919   case AArch64::CBZW:
2920   case AArch64::CBZX:
2921     TargetBBInMI = 1;
2922     break;
2923   case AArch64::CBNZW:
2924   case AArch64::CBNZX:
2925     TargetBBInMI = 1;
2926     IsNegativeBranch = true;
2927     break;
2928   case AArch64::TBZW:
2929   case AArch64::TBZX:
2930     TargetBBInMI = 2;
2931     IsTestAndBranch = true;
2932     break;
2933   case AArch64::TBNZW:
2934   case AArch64::TBNZX:
2935     TargetBBInMI = 2;
2936     IsNegativeBranch = true;
2937     IsTestAndBranch = true;
2938     break;
2939   }
2940   // So we increment a zero register and test for bits other
2941   // than bit 0? Conservatively bail out in case the verifier
2942   // missed this case.
2943   if (IsTestAndBranch && MI->getOperand(1).getImm())
2944     return false;
2945
2946   // Find Definition.
2947   assert(MI->getParent() && "Incomplete machine instruciton\n");
2948   MachineBasicBlock *MBB = MI->getParent();
2949   MachineFunction *MF = MBB->getParent();
2950   MachineRegisterInfo *MRI = &MF->getRegInfo();
2951   unsigned VReg = MI->getOperand(0).getReg();
2952   if (!TargetRegisterInfo::isVirtualRegister(VReg))
2953     return false;
2954
2955   MachineInstr *DefMI = MRI->getVRegDef(VReg);
2956
2957   // Look for CSINC
2958   if (!(DefMI->getOpcode() == AArch64::CSINCWr &&
2959         DefMI->getOperand(1).getReg() == AArch64::WZR &&
2960         DefMI->getOperand(2).getReg() == AArch64::WZR) &&
2961       !(DefMI->getOpcode() == AArch64::CSINCXr &&
2962         DefMI->getOperand(1).getReg() == AArch64::XZR &&
2963         DefMI->getOperand(2).getReg() == AArch64::XZR))
2964     return false;
2965
2966   if (DefMI->findRegisterDefOperandIdx(AArch64::NZCV, true) != -1)
2967     return false;
2968
2969   AArch64CC::CondCode CC =
2970       (AArch64CC::CondCode)DefMI->getOperand(3).getImm();
2971   bool CheckOnlyCCWrites = true;
2972   // Convert only when the condition code is not modified between
2973   // the CSINC and the branch. The CC may be used by other
2974   // instructions in between.
2975   if (modifiesConditionCode(DefMI, MI, CheckOnlyCCWrites, &getRegisterInfo()))
2976     return false;
2977   MachineBasicBlock &RefToMBB = *MBB;
2978   MachineBasicBlock *TBB = MI->getOperand(TargetBBInMI).getMBB();
2979   DebugLoc DL = MI->getDebugLoc();
2980   if (IsNegativeBranch)
2981     CC = AArch64CC::getInvertedCondCode(CC);
2982   BuildMI(RefToMBB, MI, DL, get(AArch64::Bcc)).addImm(CC).addMBB(TBB);
2983   MI->eraseFromParent();
2984   return true;
2985 }
2986
2987 std::pair<unsigned, unsigned>
2988 AArch64InstrInfo::decomposeMachineOperandsTargetFlags(unsigned TF) const {
2989   const unsigned Mask = AArch64II::MO_FRAGMENT;
2990   return std::make_pair(TF & Mask, TF & ~Mask);
2991 }
2992
2993 ArrayRef<std::pair<unsigned, const char *>>
2994 AArch64InstrInfo::getSerializableDirectMachineOperandTargetFlags() const {
2995   using namespace AArch64II;
2996   static const std::pair<unsigned, const char *> TargetFlags[] = {
2997       {MO_PAGE, "aarch64-page"},
2998       {MO_PAGEOFF, "aarch64-pageoff"},
2999       {MO_G3, "aarch64-g3"},
3000       {MO_G2, "aarch64-g2"},
3001       {MO_G1, "aarch64-g1"},
3002       {MO_G0, "aarch64-g0"},
3003       {MO_HI12, "aarch64-hi12"}};
3004   return makeArrayRef(TargetFlags);
3005 }
3006
3007 ArrayRef<std::pair<unsigned, const char *>>
3008 AArch64InstrInfo::getSerializableBitmaskMachineOperandTargetFlags() const {
3009   using namespace AArch64II;
3010   static const std::pair<unsigned, const char *> TargetFlags[] = {
3011       {MO_GOT, "aarch64-got"},
3012       {MO_NC, "aarch64-nc"},
3013       {MO_TLS, "aarch64-tls"},
3014       {MO_CONSTPOOL, "aarch64-constant-pool"}};
3015   return makeArrayRef(TargetFlags);
3016 }