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 "AArch64.h"
  15 #include "AArch64InstrInfo.h"
  16 #include "AArch64MachineFunctionInfo.h"
  17 #include "AArch64TargetMachine.h"
  18 #include "MCTargetDesc/AArch64MCTargetDesc.h"
  19 #include "Utils/AArch64BaseInfo.h"
  20 #include "llvm/CodeGen/MachineConstantPool.h"
  21 #include "llvm/CodeGen/MachineDominators.h"
  22 #include "llvm/CodeGen/MachineFrameInfo.h"
  23 #include "llvm/CodeGen/MachineFunctionPass.h"
  24 #include "llvm/CodeGen/MachineInstrBuilder.h"
  25 #include "llvm/CodeGen/MachineRegisterInfo.h"
  26 #include "llvm/IR/Function.h"
  27 #include "llvm/Support/ErrorHandling.h"
  28 #include "llvm/Support/TargetRegistry.h"
  29 #include <algorithm>
  30
  31 #define GET_INSTRINFO_CTOR_DTOR
  32 #include "AArch64GenInstrInfo.inc"
  33
  34 using namespace llvm;
  35
  36 AArch64InstrInfo::AArch64InstrInfo(const AArch64Subtarget &STI)
  37   : AArch64GenInstrInfo(AArch64::ADJCALLSTACKDOWN, AArch64::ADJCALLSTACKUP),
  38     Subtarget(STI) {}
  39
  40 void AArch64InstrInfo::copyPhysReg(MachineBasicBlock &MBB,
  41                                    MachineBasicBlock::iterator I, DebugLoc DL,
  42                                    unsigned DestReg, unsigned SrcReg,
  43                                    bool KillSrc) const {
  44   unsigned Opc = 0;
  45   unsigned ZeroReg = 0;
  46   if (DestReg == AArch64::XSP || SrcReg == AArch64::XSP) {
  47     // E.g. ADD xDst, xsp, #0 (, lsl #0)
  48     BuildMI(MBB, I, DL, get(AArch64::ADDxxi_lsl0_s), DestReg)
  49       .addReg(SrcReg)
  50       .addImm(0);
  51     return;
  52   } else if (DestReg == AArch64::WSP || SrcReg == AArch64::WSP) {
  53     // E.g. ADD wDST, wsp, #0 (, lsl #0)
  54     BuildMI(MBB, I, DL, get(AArch64::ADDwwi_lsl0_s), DestReg)
  55       .addReg(SrcReg)
  56       .addImm(0);
  57     return;
  58   } else if (DestReg == AArch64::NZCV) {
  59     assert(AArch64::GPR64RegClass.contains(SrcReg));
  60     // E.g. MSR NZCV, xDST
  61     BuildMI(MBB, I, DL, get(AArch64::MSRix))
  62       .addImm(A64SysReg::NZCV)
  63       .addReg(SrcReg);
  64   } else if (SrcReg == AArch64::NZCV) {
  65     assert(AArch64::GPR64RegClass.contains(DestReg));
  66     // E.g. MRS xDST, NZCV
  67     BuildMI(MBB, I, DL, get(AArch64::MRSxi), DestReg)
  68       .addImm(A64SysReg::NZCV);
  69   } else if (AArch64::GPR64RegClass.contains(DestReg)) {
  70     if(AArch64::GPR64RegClass.contains(SrcReg)){
  71       Opc = AArch64::ORRxxx_lsl;
  72       ZeroReg = AArch64::XZR;
  73     } else{
  74       assert(AArch64::FPR64RegClass.contains(SrcReg));
  75       BuildMI(MBB, I, DL, get(AArch64::FMOVxd), DestReg)
  76         .addReg(SrcReg);
  77       return;
  78     }
  79   } else if (AArch64::GPR32RegClass.contains(DestReg)) {
  80     if(AArch64::GPR32RegClass.contains(SrcReg)){
  81       Opc = AArch64::ORRwww_lsl;
  82       ZeroReg = AArch64::WZR;
  83     } else{
  84       assert(AArch64::FPR32RegClass.contains(SrcReg));
  85       BuildMI(MBB, I, DL, get(AArch64::FMOVws), DestReg)
  86         .addReg(SrcReg);
  87       return;
  88     }
  89   } else if (AArch64::FPR32RegClass.contains(DestReg)) {
  90     if(AArch64::FPR32RegClass.contains(SrcReg)){
  91       BuildMI(MBB, I, DL, get(AArch64::FMOVss), DestReg)
  92         .addReg(SrcReg);
  93       return;
  94     }
  95     else {
  96       assert(AArch64::GPR32RegClass.contains(SrcReg));
  97       BuildMI(MBB, I, DL, get(AArch64::FMOVsw), DestReg)
  98         .addReg(SrcReg);
  99       return;
 100     }
 101   } else if (AArch64::FPR64RegClass.contains(DestReg)) {
 102     if(AArch64::FPR64RegClass.contains(SrcReg)){
 103       BuildMI(MBB, I, DL, get(AArch64::FMOVdd), DestReg)
 104         .addReg(SrcReg);
 105       return;
 106     }
 107     else {
 108       assert(AArch64::GPR64RegClass.contains(SrcReg));
 109       BuildMI(MBB, I, DL, get(AArch64::FMOVdx), DestReg)
 110         .addReg(SrcReg);
 111       return;
 112     }
 113   } else if (AArch64::FPR128RegClass.contains(DestReg)) {
 114     assert(AArch64::FPR128RegClass.contains(SrcReg));
 115
 116     // If NEON is enable, we use ORR to implement this copy.
 117     // If NEON isn't available, emit STR and LDR to handle this.
 118     if(getSubTarget().hasNEON()) {
 119       BuildMI(MBB, I, DL, get(AArch64::ORRvvv_16B), DestReg)
 120         .addReg(SrcReg)
 121         .addReg(SrcReg);
 122       return;
 123     } else {
 124       BuildMI(MBB, I, DL, get(AArch64::LSFP128_PreInd_STR), AArch64::XSP)
 125         .addReg(SrcReg)
 126         .addReg(AArch64::XSP)
 127         .addImm(0x1ff & -16);
 128
 129       BuildMI(MBB, I, DL, get(AArch64::LSFP128_PostInd_LDR), DestReg)
 130         .addReg(AArch64::XSP, RegState::Define)
 131         .addReg(AArch64::XSP)
 132         .addImm(16);
 133       return;
 134     }
 135   } else if (AArch64::FPR8RegClass.contains(DestReg, SrcReg)) {
 136     // The copy of two FPR8 registers is implemented by the copy of two FPR32
 137     const TargetRegisterInfo *TRI = &getRegisterInfo();
 138     unsigned Dst = TRI->getMatchingSuperReg(DestReg, AArch64::sub_8,
 139                                             &AArch64::FPR32RegClass);
 140     unsigned Src = TRI->getMatchingSuperReg(SrcReg, AArch64::sub_8,
 141                                             &AArch64::FPR32RegClass);
 142     BuildMI(MBB, I, DL, get(AArch64::FMOVss), Dst)
 143       .addReg(Src);
 144     return;
 145   } else if (AArch64::FPR16RegClass.contains(DestReg, SrcReg)) {
 146     // The copy of two FPR16 registers is implemented by the copy of two FPR32
 147     const TargetRegisterInfo *TRI = &getRegisterInfo();
 148     unsigned Dst = TRI->getMatchingSuperReg(DestReg, AArch64::sub_16,
 149                                             &AArch64::FPR32RegClass);
 150     unsigned Src = TRI->getMatchingSuperReg(SrcReg, AArch64::sub_16,
 151                                             &AArch64::FPR32RegClass);
 152     BuildMI(MBB, I, DL, get(AArch64::FMOVss), Dst)
 153       .addReg(Src);
 154     return;
 155   } else {
 156     CopyPhysRegTuple(MBB, I, DL, DestReg, SrcReg);
 157     return;
 158   }
 159
 160   // E.g. ORR xDst, xzr, xSrc, lsl #0
 161   BuildMI(MBB, I, DL, get(Opc), DestReg)
 162     .addReg(ZeroReg)
 163     .addReg(SrcReg)
 164     .addImm(0);
 165 }
 166
 167 void AArch64InstrInfo::CopyPhysRegTuple(MachineBasicBlock &MBB,
 168                                         MachineBasicBlock::iterator I,
 169                                         DebugLoc DL, unsigned DestReg,
 170                                         unsigned SrcReg) const {
 171   unsigned SubRegs;
 172   bool IsQRegs;
 173   if (AArch64::DPairRegClass.contains(DestReg, SrcReg)) {
 174     SubRegs = 2;
 175     IsQRegs = false;
 176   } else if (AArch64::DTripleRegClass.contains(DestReg, SrcReg)) {
 177     SubRegs = 3;
 178     IsQRegs = false;
 179   } else if (AArch64::DQuadRegClass.contains(DestReg, SrcReg)) {
 180     SubRegs = 4;
 181     IsQRegs = false;
 182   } else if (AArch64::QPairRegClass.contains(DestReg, SrcReg)) {
 183     SubRegs = 2;
 184     IsQRegs = true;
 185   } else if (AArch64::QTripleRegClass.contains(DestReg, SrcReg)) {
 186     SubRegs = 3;
 187     IsQRegs = true;
 188   } else if (AArch64::QQuadRegClass.contains(DestReg, SrcReg)) {
 189     SubRegs = 4;
 190     IsQRegs = true;
 191   } else
 192     llvm_unreachable("Unknown register class");
 193
 194   unsigned BeginIdx = IsQRegs ? AArch64::qsub_0 : AArch64::dsub_0;
 195   int Spacing = 1;
 196   const TargetRegisterInfo *TRI = &getRegisterInfo();
 197   // Copy register tuples backward when the first Dest reg overlaps
 198   // with SrcReg.
 199   if (TRI->regsOverlap(SrcReg, TRI->getSubReg(DestReg, BeginIdx))) {
 200     BeginIdx = BeginIdx + (SubRegs - 1);
 201     Spacing = -1;
 202   }
 203
 204   unsigned Opc = IsQRegs ? AArch64::ORRvvv_16B : AArch64::ORRvvv_8B;
 205   for (unsigned i = 0; i != SubRegs; ++i) {
 206     unsigned Dst = TRI->getSubReg(DestReg, BeginIdx + i * Spacing);
 207     unsigned Src = TRI->getSubReg(SrcReg, BeginIdx + i * Spacing);
 208     assert(Dst && Src && "Bad sub-register");
 209     BuildMI(MBB, I, I->getDebugLoc(), get(Opc), Dst)
 210         .addReg(Src)
 211         .addReg(Src);
 212   }
 213   return;
 214 }
 215
 216 /// Does the Opcode represent a conditional branch that we can remove and re-add
 217 /// at the end of a basic block?
 218 static bool isCondBranch(unsigned Opc) {
 219   return Opc == AArch64::Bcc || Opc == AArch64::CBZw || Opc == AArch64::CBZx ||
 220          Opc == AArch64::CBNZw || Opc == AArch64::CBNZx ||
 221          Opc == AArch64::TBZwii || Opc == AArch64::TBZxii ||
 222          Opc == AArch64::TBNZwii || Opc == AArch64::TBNZxii;
 223 }
 224
 225 /// Takes apart a given conditional branch MachineInstr (see isCondBranch),
 226 /// setting TBB to the destination basic block and populating the Cond vector
 227 /// with data necessary to recreate the conditional branch at a later
 228 /// date. First element will be the opcode, and subsequent ones define the
 229 /// conditions being branched on in an instruction-specific manner.
 230 static void classifyCondBranch(MachineInstr *I, MachineBasicBlock *&TBB,
 231                                SmallVectorImpl<MachineOperand> &Cond) {
 232   switch(I->getOpcode()) {
 233   case AArch64::Bcc:
 234   case AArch64::CBZw:
 235   case AArch64::CBZx:
 236   case AArch64::CBNZw:
 237   case AArch64::CBNZx:
 238     // These instructions just have one predicate operand in position 0 (either
 239     // a condition code or a register being compared).
 240     Cond.push_back(MachineOperand::CreateImm(I->getOpcode()));
 241     Cond.push_back(I->getOperand(0));
 242     TBB = I->getOperand(1).getMBB();
 243     return;
 244   case AArch64::TBZwii:
 245   case AArch64::TBZxii:
 246   case AArch64::TBNZwii:
 247   case AArch64::TBNZxii:
 248     // These have two predicate operands: a register and a bit position.
 249     Cond.push_back(MachineOperand::CreateImm(I->getOpcode()));
 250     Cond.push_back(I->getOperand(0));
 251     Cond.push_back(I->getOperand(1));
 252     TBB = I->getOperand(2).getMBB();
 253     return;
 254   default:
 255     llvm_unreachable("Unknown conditional branch to classify");
 256   }
 257 }
 258
 259
 260 bool
 261 AArch64InstrInfo::AnalyzeBranch(MachineBasicBlock &MBB,MachineBasicBlock *&TBB,
 262                                 MachineBasicBlock *&FBB,
 263                                 SmallVectorImpl<MachineOperand> &Cond,
 264                                 bool AllowModify) const {
 265   // If the block has no terminators, it just falls into the block after it.
 266   MachineBasicBlock::iterator I = MBB.end();
 267   if (I == MBB.begin())
 268     return false;
 269   --I;
 270   while (I->isDebugValue()) {
 271     if (I == MBB.begin())
 272       return false;
 273     --I;
 274   }
 275   if (!isUnpredicatedTerminator(I))
 276     return false;
 277
 278   // Get the last instruction in the block.
 279   MachineInstr *LastInst = I;
 280
 281   // If there is only one terminator instruction, process it.
 282   unsigned LastOpc = LastInst->getOpcode();
 283   if (I == MBB.begin() || !isUnpredicatedTerminator(--I)) {
 284     if (LastOpc == AArch64::Bimm) {
 285       TBB = LastInst->getOperand(0).getMBB();
 286       return false;
 287     }
 288     if (isCondBranch(LastOpc)) {
 289       classifyCondBranch(LastInst, TBB, Cond);
 290       return false;
 291     }
 292     return true;  // Can't handle indirect branch.
 293   }
 294
 295   // Get the instruction before it if it is a terminator.
 296   MachineInstr *SecondLastInst = I;
 297   unsigned SecondLastOpc = SecondLastInst->getOpcode();
 298
 299   // If AllowModify is true and the block ends with two or more unconditional
 300   // branches, delete all but the first unconditional branch.
 301   if (AllowModify && LastOpc == AArch64::Bimm) {
 302     while (SecondLastOpc == AArch64::Bimm) {
 303       LastInst->eraseFromParent();
 304       LastInst = SecondLastInst;
 305       LastOpc = LastInst->getOpcode();
 306       if (I == MBB.begin() || !isUnpredicatedTerminator(--I)) {
 307         // Return now the only terminator is an unconditional branch.
 308         TBB = LastInst->getOperand(0).getMBB();
 309         return false;
 310       } else {
 311         SecondLastInst = I;
 312         SecondLastOpc = SecondLastInst->getOpcode();
 313       }
 314     }
 315   }
 316
 317   // If there are three terminators, we don't know what sort of block this is.
 318   if (SecondLastInst && I != MBB.begin() && isUnpredicatedTerminator(--I))
 319     return true;
 320
 321   // If the block ends with a B and a Bcc, handle it.
 322   if (LastOpc == AArch64::Bimm) {
 323     if (SecondLastOpc == AArch64::Bcc) {
 324       TBB =  SecondLastInst->getOperand(1).getMBB();
 325       Cond.push_back(MachineOperand::CreateImm(AArch64::Bcc));
 326       Cond.push_back(SecondLastInst->getOperand(0));
 327       FBB = LastInst->getOperand(0).getMBB();
 328       return false;
 329     } else if (isCondBranch(SecondLastOpc)) {
 330       classifyCondBranch(SecondLastInst, TBB, Cond);
 331       FBB = LastInst->getOperand(0).getMBB();
 332       return false;
 333     }
 334   }
 335
 336   // If the block ends with two unconditional branches, handle it.  The second
 337   // one is not executed, so remove it.
 338   if (SecondLastOpc == AArch64::Bimm && LastOpc == AArch64::Bimm) {
 339     TBB = SecondLastInst->getOperand(0).getMBB();
 340     I = LastInst;
 341     if (AllowModify)
 342       I->eraseFromParent();
 343     return false;
 344   }
 345
 346   // Otherwise, can't handle this.
 347   return true;
 348 }
 349
 350 bool AArch64InstrInfo::ReverseBranchCondition(
 351                                   SmallVectorImpl<MachineOperand> &Cond) const {
 352   switch (Cond[0].getImm()) {
 353   case AArch64::Bcc: {
 354     A64CC::CondCodes CC = static_cast<A64CC::CondCodes>(Cond[1].getImm());
 355     CC = A64InvertCondCode(CC);
 356     Cond[1].setImm(CC);
 357     return false;
 358   }
 359   case AArch64::CBZw:
 360     Cond[0].setImm(AArch64::CBNZw);
 361     return false;
 362   case AArch64::CBZx:
 363     Cond[0].setImm(AArch64::CBNZx);
 364     return false;
 365   case AArch64::CBNZw:
 366     Cond[0].setImm(AArch64::CBZw);
 367     return false;
 368   case AArch64::CBNZx:
 369     Cond[0].setImm(AArch64::CBZx);
 370     return false;
 371   case AArch64::TBZwii:
 372     Cond[0].setImm(AArch64::TBNZwii);
 373     return false;
 374   case AArch64::TBZxii:
 375     Cond[0].setImm(AArch64::TBNZxii);
 376     return false;
 377   case AArch64::TBNZwii:
 378     Cond[0].setImm(AArch64::TBZwii);
 379     return false;
 380   case AArch64::TBNZxii:
 381     Cond[0].setImm(AArch64::TBZxii);
 382     return false;
 383   default:
 384     llvm_unreachable("Unknown branch type");
 385   }
 386 }
 387
 388
 389 unsigned
 390 AArch64InstrInfo::InsertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
 391                                MachineBasicBlock *FBB,
 392                                const SmallVectorImpl<MachineOperand> &Cond,
 393                                DebugLoc DL) const {
 394   if (FBB == 0 && Cond.empty()) {
 395     BuildMI(&MBB, DL, get(AArch64::Bimm)).addMBB(TBB);
 396     return 1;
 397   } else if (FBB == 0) {
 398     MachineInstrBuilder MIB = BuildMI(&MBB, DL, get(Cond[0].getImm()));
 399     for (int i = 1, e = Cond.size(); i != e; ++i)
 400       MIB.addOperand(Cond[i]);
 401     MIB.addMBB(TBB);
 402     return 1;
 403   }
 404
 405   MachineInstrBuilder MIB = BuildMI(&MBB, DL, get(Cond[0].getImm()));
 406   for (int i = 1, e = Cond.size(); i != e; ++i)
 407     MIB.addOperand(Cond[i]);
 408   MIB.addMBB(TBB);
 409
 410   BuildMI(&MBB, DL, get(AArch64::Bimm)).addMBB(FBB);
 411   return 2;
 412 }
 413
 414 unsigned AArch64InstrInfo::RemoveBranch(MachineBasicBlock &MBB) const {
 415   MachineBasicBlock::iterator I = MBB.end();
 416   if (I == MBB.begin()) return 0;
 417   --I;
 418   while (I->isDebugValue()) {
 419     if (I == MBB.begin())
 420       return 0;
 421     --I;
 422   }
 423   if (I->getOpcode() != AArch64::Bimm && !isCondBranch(I->getOpcode()))
 424     return 0;
 425
 426   // Remove the branch.
 427   I->eraseFromParent();
 428
 429   I = MBB.end();
 430
 431   if (I == MBB.begin()) return 1;
 432   --I;
 433   if (!isCondBranch(I->getOpcode()))
 434     return 1;
 435
 436   // Remove the branch.
 437   I->eraseFromParent();
 438   return 2;
 439 }
 440
 441 bool
 442 AArch64InstrInfo::expandPostRAPseudo(MachineBasicBlock::iterator MBBI) const {
 443   MachineInstr &MI = *MBBI;
 444   MachineBasicBlock &MBB = *MI.getParent();
 445
 446   unsigned Opcode = MI.getOpcode();
 447   switch (Opcode) {
 448   case AArch64::TLSDESC_BLRx: {
 449     MachineInstr *NewMI =
 450       BuildMI(MBB, MBBI, MI.getDebugLoc(), get(AArch64::TLSDESCCALL))
 451         .addOperand(MI.getOperand(1));
 452     MI.setDesc(get(AArch64::BLRx));
 453
 454     llvm::finalizeBundle(MBB, NewMI, *++MBBI);
 455     return true;
 456     }
 457   default:
 458     return false;
 459   }
 460
 461   return false;
 462 }
 463
 464 void
 465 AArch64InstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
 466                                       MachineBasicBlock::iterator MBBI,
 467                                       unsigned SrcReg, bool isKill,
 468                                       int FrameIdx,
 469                                       const TargetRegisterClass *RC,
 470                                       const TargetRegisterInfo *TRI) const {
 471   DebugLoc DL = MBB.findDebugLoc(MBBI);
 472   MachineFunction &MF = *MBB.getParent();
 473   MachineFrameInfo &MFI = *MF.getFrameInfo();
 474   unsigned Align = MFI.getObjectAlignment(FrameIdx);
 475
 476   MachineMemOperand *MMO
 477     = MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(FrameIdx),
 478                               MachineMemOperand::MOStore,
 479                               MFI.getObjectSize(FrameIdx),
 480                               Align);
 481
 482   unsigned StoreOp = 0;
 483   if (RC->hasType(MVT::i64) || RC->hasType(MVT::i32)) {
 484     switch(RC->getSize()) {
 485     case 4: StoreOp = AArch64::LS32_STR; break;
 486     case 8: StoreOp = AArch64::LS64_STR; break;
 487     default:
 488       llvm_unreachable("Unknown size for regclass");
 489     }
 490   } else if (AArch64::FPR8RegClass.hasSubClassEq(RC)) {
 491     StoreOp = AArch64::LSFP8_STR;
 492   } else if (AArch64::FPR16RegClass.hasSubClassEq(RC)) {
 493     StoreOp = AArch64::LSFP16_STR;
 494   } else if (RC->hasType(MVT::f32) || RC->hasType(MVT::f64) ||
 495              RC->hasType(MVT::f128)) {
 496     switch (RC->getSize()) {
 497     case 4: StoreOp = AArch64::LSFP32_STR; break;
 498     case 8: StoreOp = AArch64::LSFP64_STR; break;
 499     case 16: StoreOp = AArch64::LSFP128_STR; break;
 500     default:
 501       llvm_unreachable("Unknown size for regclass");
 502     }
 503   } else { // For a super register class has more than one sub registers
 504     if (AArch64::DPairRegClass.hasSubClassEq(RC))
 505       StoreOp = AArch64::ST1x2_8B;
 506     else if (AArch64::DTripleRegClass.hasSubClassEq(RC))
 507       StoreOp = AArch64::ST1x3_8B;
 508     else if (AArch64::DQuadRegClass.hasSubClassEq(RC))
 509       StoreOp = AArch64::ST1x4_8B;
 510     else if (AArch64::QPairRegClass.hasSubClassEq(RC))
 511       StoreOp = AArch64::ST1x2_16B;
 512     else if (AArch64::QTripleRegClass.hasSubClassEq(RC))
 513       StoreOp = AArch64::ST1x3_16B;
 514     else if (AArch64::QQuadRegClass.hasSubClassEq(RC))
 515       StoreOp = AArch64::ST1x4_16B;
 516     else
 517       llvm_unreachable("Unknown reg class");
 518
 519     MachineInstrBuilder NewMI = BuildMI(MBB, MBBI, DL, get(StoreOp));
 520     // Vector store has different operands from other store instructions.
 521     NewMI.addFrameIndex(FrameIdx)
 522          .addReg(SrcReg, getKillRegState(isKill))
 523          .addMemOperand(MMO);
 524     return;
 525   }
 526
 527   MachineInstrBuilder NewMI = BuildMI(MBB, MBBI, DL, get(StoreOp));
 528   NewMI.addReg(SrcReg, getKillRegState(isKill))
 529     .addFrameIndex(FrameIdx)
 530     .addImm(0)
 531     .addMemOperand(MMO);
 532
 533 }
 534
 535 void
 536 AArch64InstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
 537                                        MachineBasicBlock::iterator MBBI,
 538                                        unsigned DestReg, int FrameIdx,
 539                                        const TargetRegisterClass *RC,
 540                                        const TargetRegisterInfo *TRI) const {
 541   DebugLoc DL = MBB.findDebugLoc(MBBI);
 542   MachineFunction &MF = *MBB.getParent();
 543   MachineFrameInfo &MFI = *MF.getFrameInfo();
 544   unsigned Align = MFI.getObjectAlignment(FrameIdx);
 545
 546   MachineMemOperand *MMO
 547     = MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(FrameIdx),
 548                               MachineMemOperand::MOLoad,
 549                               MFI.getObjectSize(FrameIdx),
 550                               Align);
 551
 552   unsigned LoadOp = 0;
 553   if (RC->hasType(MVT::i64) || RC->hasType(MVT::i32)) {
 554     switch(RC->getSize()) {
 555     case 4: LoadOp = AArch64::LS32_LDR; break;
 556     case 8: LoadOp = AArch64::LS64_LDR; break;
 557     default:
 558       llvm_unreachable("Unknown size for regclass");
 559     }
 560   } else if (AArch64::FPR8RegClass.hasSubClassEq(RC)) {
 561     LoadOp = AArch64::LSFP8_LDR;
 562   } else if (AArch64::FPR16RegClass.hasSubClassEq(RC)) {
 563     LoadOp = AArch64::LSFP16_LDR;
 564   } else if (RC->hasType(MVT::f32) || RC->hasType(MVT::f64) ||
 565              RC->hasType(MVT::f128)) {
 566     switch (RC->getSize()) {
 567     case 4: LoadOp = AArch64::LSFP32_LDR; break;
 568     case 8: LoadOp = AArch64::LSFP64_LDR; break;
 569     case 16: LoadOp = AArch64::LSFP128_LDR; break;
 570     default:
 571       llvm_unreachable("Unknown size for regclass");
 572     }
 573   } else { // For a super register class has more than one sub registers
 574     if (AArch64::DPairRegClass.hasSubClassEq(RC))
 575       LoadOp = AArch64::LD1x2_8B;
 576     else if (AArch64::DTripleRegClass.hasSubClassEq(RC))
 577       LoadOp = AArch64::LD1x3_8B;
 578     else if (AArch64::DQuadRegClass.hasSubClassEq(RC))
 579       LoadOp = AArch64::LD1x4_8B;
 580     else if (AArch64::QPairRegClass.hasSubClassEq(RC))
 581       LoadOp = AArch64::LD1x2_16B;
 582     else if (AArch64::QTripleRegClass.hasSubClassEq(RC))
 583       LoadOp = AArch64::LD1x3_16B;
 584     else if (AArch64::QQuadRegClass.hasSubClassEq(RC))
 585       LoadOp = AArch64::LD1x4_16B;
 586     else
 587       llvm_unreachable("Unknown reg class");
 588
 589     MachineInstrBuilder NewMI = BuildMI(MBB, MBBI, DL, get(LoadOp), DestReg);
 590     // Vector load has different operands from other load instructions.
 591     NewMI.addFrameIndex(FrameIdx)
 592          .addMemOperand(MMO);
 593     return;
 594   }
 595
 596   MachineInstrBuilder NewMI = BuildMI(MBB, MBBI, DL, get(LoadOp), DestReg);
 597   NewMI.addFrameIndex(FrameIdx)
 598        .addImm(0)
 599        .addMemOperand(MMO);
 600 }
 601
 602 unsigned AArch64InstrInfo::estimateRSStackLimit(MachineFunction &MF) const {
 603   unsigned Limit = (1 << 16) - 1;
 604   for (MachineFunction::iterator BB = MF.begin(),E = MF.end(); BB != E; ++BB) {
 605     for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end();
 606          I != E; ++I) {
 607       for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
 608         if (!I->getOperand(i).isFI()) continue;
 609
 610         // When using ADDxxi_lsl0_s to get the address of a stack object, 0xfff
 611         // is the largest offset guaranteed to fit in the immediate offset.
 612         if (I->getOpcode() == AArch64::ADDxxi_lsl0_s) {
 613           Limit = std::min(Limit, 0xfffu);
 614           break;
 615         }
 616
 617         int AccessScale, MinOffset, MaxOffset;
 618         getAddressConstraints(*I, AccessScale, MinOffset, MaxOffset);
 619         Limit = std::min(Limit, static_cast<unsigned>(MaxOffset));
 620
 621         break; // At most one FI per instruction
 622       }
 623     }
 624   }
 625
 626   return Limit;
 627 }
 628 void AArch64InstrInfo::getAddressConstraints(const MachineInstr &MI,
 629                                              int &AccessScale, int &MinOffset,
 630                                              int &MaxOffset) const {
 631   switch (MI.getOpcode()) {
 632   default:
 633     llvm_unreachable("Unknown load/store kind");
 634   case TargetOpcode::DBG_VALUE:
 635     AccessScale = 1;
 636     MinOffset = INT_MIN;
 637     MaxOffset = INT_MAX;
 638     return;
 639   case AArch64::LS8_LDR: case AArch64::LS8_STR:
 640   case AArch64::LSFP8_LDR: case AArch64::LSFP8_STR:
 641   case AArch64::LDRSBw:
 642   case AArch64::LDRSBx:
 643     AccessScale = 1;
 644     MinOffset = 0;
 645     MaxOffset = 0xfff;
 646     return;
 647   case AArch64::LS16_LDR: case AArch64::LS16_STR:
 648   case AArch64::LSFP16_LDR: case AArch64::LSFP16_STR:
 649   case AArch64::LDRSHw:
 650   case AArch64::LDRSHx:
 651     AccessScale = 2;
 652     MinOffset = 0;
 653     MaxOffset = 0xfff * AccessScale;
 654     return;
 655   case AArch64::LS32_LDR:  case AArch64::LS32_STR:
 656   case AArch64::LSFP32_LDR: case AArch64::LSFP32_STR:
 657   case AArch64::LDRSWx:
 658   case AArch64::LDPSWx:
 659     AccessScale = 4;
 660     MinOffset = 0;
 661     MaxOffset = 0xfff * AccessScale;
 662     return;
 663   case AArch64::LS64_LDR: case AArch64::LS64_STR:
 664   case AArch64::LSFP64_LDR: case AArch64::LSFP64_STR:
 665   case AArch64::PRFM:
 666     AccessScale = 8;
 667     MinOffset = 0;
 668     MaxOffset = 0xfff * AccessScale;
 669     return;
 670   case AArch64::LSFP128_LDR: case AArch64::LSFP128_STR:
 671     AccessScale = 16;
 672     MinOffset = 0;
 673     MaxOffset = 0xfff * AccessScale;
 674     return;
 675   case AArch64::LSPair32_LDR: case AArch64::LSPair32_STR:
 676   case AArch64::LSFPPair32_LDR: case AArch64::LSFPPair32_STR:
 677     AccessScale = 4;
 678     MinOffset = -0x40 * AccessScale;
 679     MaxOffset = 0x3f * AccessScale;
 680     return;
 681   case AArch64::LSPair64_LDR: case AArch64::LSPair64_STR:
 682   case AArch64::LSFPPair64_LDR: case AArch64::LSFPPair64_STR:
 683     AccessScale = 8;
 684     MinOffset = -0x40 * AccessScale;
 685     MaxOffset = 0x3f * AccessScale;
 686     return;
 687   case AArch64::LSFPPair128_LDR: case AArch64::LSFPPair128_STR:
 688     AccessScale = 16;
 689     MinOffset = -0x40 * AccessScale;
 690     MaxOffset = 0x3f * AccessScale;
 691     return;
 692   case AArch64::LD1x2_8B: case AArch64::ST1x2_8B:
 693     AccessScale = 16;
 694     MinOffset = 0;
 695     MaxOffset = 0xfff * AccessScale;
 696     return;
 697   case AArch64::LD1x3_8B: case AArch64::ST1x3_8B:
 698     AccessScale = 24;
 699     MinOffset = 0;
 700     MaxOffset = 0xfff * AccessScale;
 701     return;
 702   case AArch64::LD1x4_8B: case AArch64::ST1x4_8B:
 703   case AArch64::LD1x2_16B: case AArch64::ST1x2_16B:
 704     AccessScale = 32;
 705     MinOffset = 0;
 706     MaxOffset = 0xfff * AccessScale;
 707     return;
 708   case AArch64::LD1x3_16B: case AArch64::ST1x3_16B:
 709     AccessScale = 48;
 710     MinOffset = 0;
 711     MaxOffset = 0xfff * AccessScale;
 712     return;
 713   case AArch64::LD1x4_16B: case AArch64::ST1x4_16B:
 714     AccessScale = 64;
 715     MinOffset = 0;
 716     MaxOffset = 0xfff * AccessScale;
 717     return;
 718   }
 719 }
 720
 721 unsigned AArch64InstrInfo::getInstSizeInBytes(const MachineInstr &MI) const {
 722   const MCInstrDesc &MCID = MI.getDesc();
 723   const MachineBasicBlock &MBB = *MI.getParent();
 724   const MachineFunction &MF = *MBB.getParent();
 725   const MCAsmInfo &MAI = *MF.getTarget().getMCAsmInfo();
 726
 727   if (MCID.getSize())
 728     return MCID.getSize();
 729
 730   if (MI.getOpcode() == AArch64::INLINEASM)
 731     return getInlineAsmLength(MI.getOperand(0).getSymbolName(), MAI);
 732
 733   if (MI.isLabel())
 734     return 0;
 735
 736   switch (MI.getOpcode()) {
 737   case TargetOpcode::BUNDLE:
 738     return getInstBundleLength(MI);
 739   case TargetOpcode::IMPLICIT_DEF:
 740   case TargetOpcode::KILL:
 741   case TargetOpcode::PROLOG_LABEL:
 742   case TargetOpcode::EH_LABEL:
 743   case TargetOpcode::DBG_VALUE:
 744     return 0;
 745   case AArch64::TLSDESCCALL:
 746     return 0;
 747   default:
 748     llvm_unreachable("Unknown instruction class");
 749   }
 750 }
 751
 752 unsigned AArch64InstrInfo::getInstBundleLength(const MachineInstr &MI) const {
 753   unsigned Size = 0;
 754   MachineBasicBlock::const_instr_iterator I = MI;
 755   MachineBasicBlock::const_instr_iterator E = MI.getParent()->instr_end();
 756   while (++I != E && I->isInsideBundle()) {
 757     assert(!I->isBundle() && "No nested bundle!");
 758     Size += getInstSizeInBytes(*I);
 759   }
 760   return Size;
 761 }
 762
 763 bool llvm::rewriteA64FrameIndex(MachineInstr &MI, unsigned FrameRegIdx,
 764                                 unsigned FrameReg, int &Offset,
 765                                 const AArch64InstrInfo &TII) {
 766   MachineBasicBlock &MBB = *MI.getParent();
 767   MachineFunction &MF = *MBB.getParent();
 768   MachineFrameInfo &MFI = *MF.getFrameInfo();
 769
 770   MFI.getObjectOffset(FrameRegIdx);
 771   llvm_unreachable("Unimplemented rewriteFrameIndex");
 772 }
 773
 774 void llvm::emitRegUpdate(MachineBasicBlock &MBB,
 775                          MachineBasicBlock::iterator MBBI,
 776                          DebugLoc dl, const TargetInstrInfo &TII,
 777                          unsigned DstReg, unsigned SrcReg, unsigned ScratchReg,
 778                          int64_t NumBytes, MachineInstr::MIFlag MIFlags) {
 779   if (NumBytes == 0 && DstReg == SrcReg)
 780     return;
 781   else if (abs64(NumBytes) & ~0xffffff) {
 782     // Generically, we have to materialize the offset into a temporary register
 783     // and subtract it. There are a couple of ways this could be done, for now
 784     // we'll use a movz/movk or movn/movk sequence.
 785     uint64_t Bits = static_cast<uint64_t>(abs64(NumBytes));
 786     BuildMI(MBB, MBBI, dl, TII.get(AArch64::MOVZxii), ScratchReg)
 787       .addImm(0xffff & Bits).addImm(0)
 788       .setMIFlags(MIFlags);
 789
 790     Bits >>= 16;
 791     if (Bits & 0xffff) {
 792       BuildMI(MBB, MBBI, dl, TII.get(AArch64::MOVKxii), ScratchReg)
 793         .addReg(ScratchReg)
 794         .addImm(0xffff & Bits).addImm(1)
 795         .setMIFlags(MIFlags);
 796     }
 797
 798     Bits >>= 16;
 799     if (Bits & 0xffff) {
 800       BuildMI(MBB, MBBI, dl, TII.get(AArch64::MOVKxii), ScratchReg)
 801         .addReg(ScratchReg)
 802         .addImm(0xffff & Bits).addImm(2)
 803         .setMIFlags(MIFlags);
 804     }
 805
 806     Bits >>= 16;
 807     if (Bits & 0xffff) {
 808       BuildMI(MBB, MBBI, dl, TII.get(AArch64::MOVKxii), ScratchReg)
 809         .addReg(ScratchReg)
 810         .addImm(0xffff & Bits).addImm(3)
 811         .setMIFlags(MIFlags);
 812     }
 813
 814     // ADD DST, SRC, xTMP (, lsl #0)
 815     unsigned AddOp = NumBytes > 0 ? AArch64::ADDxxx_uxtx : AArch64::SUBxxx_uxtx;
 816     BuildMI(MBB, MBBI, dl, TII.get(AddOp), DstReg)
 817       .addReg(SrcReg, RegState::Kill)
 818       .addReg(ScratchReg, RegState::Kill)
 819       .addImm(0)
 820       .setMIFlag(MIFlags);
 821     return;
 822   }
 823
 824   // Now we know that the adjustment can be done in at most two add/sub
 825   // (immediate) instructions, which is always more efficient than a
 826   // literal-pool load, or even a hypothetical movz/movk/add sequence
 827
 828   // Decide whether we're doing addition or subtraction
 829   unsigned LowOp, HighOp;
 830   if (NumBytes >= 0) {
 831     LowOp = AArch64::ADDxxi_lsl0_s;
 832     HighOp = AArch64::ADDxxi_lsl12_s;
 833   } else {
 834     LowOp = AArch64::SUBxxi_lsl0_s;
 835     HighOp = AArch64::SUBxxi_lsl12_s;
 836     NumBytes = abs64(NumBytes);
 837   }
 838
 839   // If we're here, at the very least a move needs to be produced, which just
 840   // happens to be materializable by an ADD.
 841   if ((NumBytes & 0xfff) || NumBytes == 0) {
 842     BuildMI(MBB, MBBI, dl, TII.get(LowOp), DstReg)
 843       .addReg(SrcReg, RegState::Kill)
 844       .addImm(NumBytes & 0xfff)
 845       .setMIFlag(MIFlags);
 846
 847     // Next update should use the register we've just defined.
 848     SrcReg = DstReg;
 849   }
 850
 851   if (NumBytes & 0xfff000) {
 852     BuildMI(MBB, MBBI, dl, TII.get(HighOp), DstReg)
 853       .addReg(SrcReg, RegState::Kill)
 854       .addImm(NumBytes >> 12)
 855       .setMIFlag(MIFlags);
 856   }
 857 }
 858
 859 void llvm::emitSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
 860                         DebugLoc dl, const TargetInstrInfo &TII,
 861                         unsigned ScratchReg, int64_t NumBytes,
 862                         MachineInstr::MIFlag MIFlags) {
 863   emitRegUpdate(MBB, MI, dl, TII, AArch64::XSP, AArch64::XSP, AArch64::X16,
 864                 NumBytes, MIFlags);
 865 }
 866
 867
 868 namespace {
 869   struct LDTLSCleanup : public MachineFunctionPass {
 870     static char ID;
 871     LDTLSCleanup() : MachineFunctionPass(ID) {}
 872
 873     virtual bool runOnMachineFunction(MachineFunction &MF) {
 874       AArch64MachineFunctionInfo* MFI
 875         = MF.getInfo<AArch64MachineFunctionInfo>();
 876       if (MFI->getNumLocalDynamicTLSAccesses() < 2) {
 877         // No point folding accesses if there isn't at least two.
 878         return false;
 879       }
 880
 881       MachineDominatorTree *DT = &getAnalysis<MachineDominatorTree>();
 882       return VisitNode(DT->getRootNode(), 0);
 883     }
 884
 885     // Visit the dominator subtree rooted at Node in pre-order.
 886     // If TLSBaseAddrReg is non-null, then use that to replace any
 887     // TLS_base_addr instructions. Otherwise, create the register
 888     // when the first such instruction is seen, and then use it
 889     // as we encounter more instructions.
 890     bool VisitNode(MachineDomTreeNode *Node, unsigned TLSBaseAddrReg) {
 891       MachineBasicBlock *BB = Node->getBlock();
 892       bool Changed = false;
 893
 894       // Traverse the current block.
 895       for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;
 896            ++I) {
 897         switch (I->getOpcode()) {
 898         case AArch64::TLSDESC_BLRx:
 899           // Make sure it's a local dynamic access.
 900           if (!I->getOperand(1).isSymbol() ||
 901               strcmp(I->getOperand(1).getSymbolName(), "_TLS_MODULE_BASE_"))
 902             break;
 903
 904           if (TLSBaseAddrReg)
 905             I = ReplaceTLSBaseAddrCall(I, TLSBaseAddrReg);
 906           else
 907             I = SetRegister(I, &TLSBaseAddrReg);
 908           Changed = true;
 909           break;
 910         default:
 911           break;
 912         }
 913       }
 914
 915       // Visit the children of this block in the dominator tree.
 916       for (MachineDomTreeNode::iterator I = Node->begin(), E = Node->end();
 917            I != E; ++I) {
 918         Changed |= VisitNode(*I, TLSBaseAddrReg);
 919       }
 920
 921       return Changed;
 922     }
 923
 924     // Replace the TLS_base_addr instruction I with a copy from
 925     // TLSBaseAddrReg, returning the new instruction.
 926     MachineInstr *ReplaceTLSBaseAddrCall(MachineInstr *I,
 927                                          unsigned TLSBaseAddrReg) {
 928       MachineFunction *MF = I->getParent()->getParent();
 929       const AArch64TargetMachine *TM =
 930           static_cast<const AArch64TargetMachine *>(&MF->getTarget());
 931       const AArch64InstrInfo *TII = TM->getInstrInfo();
 932
 933       // Insert a Copy from TLSBaseAddrReg to x0, which is where the rest of the
 934       // code sequence assumes the address will be.
 935       MachineInstr *Copy = BuildMI(*I->getParent(), I, I->getDebugLoc(),
 936                                    TII->get(TargetOpcode::COPY),
 937                                    AArch64::X0)
 938         .addReg(TLSBaseAddrReg);
 939
 940       // Erase the TLS_base_addr instruction.
 941       I->eraseFromParent();
 942
 943       return Copy;
 944     }
 945
 946     // Create a virtal register in *TLSBaseAddrReg, and populate it by
 947     // inserting a copy instruction after I. Returns the new instruction.
 948     MachineInstr *SetRegister(MachineInstr *I, unsigned *TLSBaseAddrReg) {
 949       MachineFunction *MF = I->getParent()->getParent();
 950       const AArch64TargetMachine *TM =
 951           static_cast<const AArch64TargetMachine *>(&MF->getTarget());
 952       const AArch64InstrInfo *TII = TM->getInstrInfo();
 953
 954       // Create a virtual register for the TLS base address.
 955       MachineRegisterInfo &RegInfo = MF->getRegInfo();
 956       *TLSBaseAddrReg = RegInfo.createVirtualRegister(&AArch64::GPR64RegClass);
 957
 958       // Insert a copy from X0 to TLSBaseAddrReg for later.
 959       MachineInstr *Next = I->getNextNode();
 960       MachineInstr *Copy = BuildMI(*I->getParent(), Next, I->getDebugLoc(),
 961                                    TII->get(TargetOpcode::COPY),
 962                                    *TLSBaseAddrReg)
 963         .addReg(AArch64::X0);
 964
 965       return Copy;
 966     }
 967
 968     virtual const char *getPassName() const {
 969       return "Local Dynamic TLS Access Clean-up";
 970     }
 971
 972     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
 973       AU.setPreservesCFG();
 974       AU.addRequired<MachineDominatorTree>();
 975       MachineFunctionPass::getAnalysisUsage(AU);
 976     }
 977   };
 978 }
 979
 980 char LDTLSCleanup::ID = 0;
 981 FunctionPass*
 982 llvm::createAArch64CleanupLocalDynamicTLSPass() { return new LDTLSCleanup(); }