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