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