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 { // For a super register class has more than one sub registers
 481     if (AArch64::DPairRegClass.hasSubClassEq(RC))
 482       StoreOp = AArch64::ST1x2_8B;
 483     else if (AArch64::DTripleRegClass.hasSubClassEq(RC))
 484       StoreOp = AArch64::ST1x3_8B;
 485     else if (AArch64::DQuadRegClass.hasSubClassEq(RC))
 486       StoreOp = AArch64::ST1x4_8B;
 487     else if (AArch64::QPairRegClass.hasSubClassEq(RC))
 488       StoreOp = AArch64::ST1x2_16B;
 489     else if (AArch64::QTripleRegClass.hasSubClassEq(RC))
 490       StoreOp = AArch64::ST1x3_16B;
 491     else if (AArch64::QQuadRegClass.hasSubClassEq(RC))
 492       StoreOp = AArch64::ST1x4_16B;
 493     else
 494       llvm_unreachable("Unknown reg class");
 495
 496     MachineInstrBuilder NewMI = BuildMI(MBB, MBBI, DL, get(StoreOp));
 497     // Vector store has different operands from other store instructions.
 498     NewMI.addFrameIndex(FrameIdx)
 499          .addReg(SrcReg, getKillRegState(isKill))
 500          .addMemOperand(MMO);
 501     return;
 502   }
 503
 504   MachineInstrBuilder NewMI = BuildMI(MBB, MBBI, DL, get(StoreOp));
 505   NewMI.addReg(SrcReg, getKillRegState(isKill))
 506     .addFrameIndex(FrameIdx)
 507     .addImm(0)
 508     .addMemOperand(MMO);
 509
 510 }
 511
 512 void
 513 AArch64InstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
 514                                        MachineBasicBlock::iterator MBBI,
 515                                        unsigned DestReg, int FrameIdx,
 516                                        const TargetRegisterClass *RC,
 517                                        const TargetRegisterInfo *TRI) const {
 518   DebugLoc DL = MBB.findDebugLoc(MBBI);
 519   MachineFunction &MF = *MBB.getParent();
 520   MachineFrameInfo &MFI = *MF.getFrameInfo();
 521   unsigned Align = MFI.getObjectAlignment(FrameIdx);
 522
 523   MachineMemOperand *MMO
 524     = MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(FrameIdx),
 525                               MachineMemOperand::MOLoad,
 526                               MFI.getObjectSize(FrameIdx),
 527                               Align);
 528
 529   unsigned LoadOp = 0;
 530   if (RC->hasType(MVT::i64) || RC->hasType(MVT::i32)) {
 531     switch(RC->getSize()) {
 532     case 4: LoadOp = AArch64::LS32_LDR; break;
 533     case 8: LoadOp = AArch64::LS64_LDR; break;
 534     default:
 535       llvm_unreachable("Unknown size for regclass");
 536     }
 537   } else if (RC->hasType(MVT::f32) || RC->hasType(MVT::f64) ||
 538              RC->hasType(MVT::f128)) {
 539     switch (RC->getSize()) {
 540     case 4: LoadOp = AArch64::LSFP32_LDR; break;
 541     case 8: LoadOp = AArch64::LSFP64_LDR; break;
 542     case 16: LoadOp = AArch64::LSFP128_LDR; break;
 543     default:
 544       llvm_unreachable("Unknown size for regclass");
 545     }
 546   } else { // For a super register class has more than one sub registers
 547     if (AArch64::DPairRegClass.hasSubClassEq(RC))
 548       LoadOp = AArch64::LD1x2_8B;
 549     else if (AArch64::DTripleRegClass.hasSubClassEq(RC))
 550       LoadOp = AArch64::LD1x3_8B;
 551     else if (AArch64::DQuadRegClass.hasSubClassEq(RC))
 552       LoadOp = AArch64::LD1x4_8B;
 553     else if (AArch64::QPairRegClass.hasSubClassEq(RC))
 554       LoadOp = AArch64::LD1x2_16B;
 555     else if (AArch64::QTripleRegClass.hasSubClassEq(RC))
 556       LoadOp = AArch64::LD1x3_16B;
 557     else if (AArch64::QQuadRegClass.hasSubClassEq(RC))
 558       LoadOp = AArch64::LD1x4_16B;
 559     else
 560       llvm_unreachable("Unknown reg class");
 561
 562     MachineInstrBuilder NewMI = BuildMI(MBB, MBBI, DL, get(LoadOp), DestReg);
 563     // Vector load has different operands from other load instructions.
 564     NewMI.addFrameIndex(FrameIdx)
 565          .addMemOperand(MMO);
 566     return;
 567   }
 568
 569   MachineInstrBuilder NewMI = BuildMI(MBB, MBBI, DL, get(LoadOp), DestReg);
 570   NewMI.addFrameIndex(FrameIdx)
 571        .addImm(0)
 572        .addMemOperand(MMO);
 573 }
 574
 575 unsigned AArch64InstrInfo::estimateRSStackLimit(MachineFunction &MF) const {
 576   unsigned Limit = (1 << 16) - 1;
 577   for (MachineFunction::iterator BB = MF.begin(),E = MF.end(); BB != E; ++BB) {
 578     for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end();
 579          I != E; ++I) {
 580       for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
 581         if (!I->getOperand(i).isFI()) continue;
 582
 583         // When using ADDxxi_lsl0_s to get the address of a stack object, 0xfff
 584         // is the largest offset guaranteed to fit in the immediate offset.
 585         if (I->getOpcode() == AArch64::ADDxxi_lsl0_s) {
 586           Limit = std::min(Limit, 0xfffu);
 587           break;
 588         }
 589
 590         int AccessScale, MinOffset, MaxOffset;
 591         getAddressConstraints(*I, AccessScale, MinOffset, MaxOffset);
 592         Limit = std::min(Limit, static_cast<unsigned>(MaxOffset));
 593
 594         break; // At most one FI per instruction
 595       }
 596     }
 597   }
 598
 599   return Limit;
 600 }
 601 void AArch64InstrInfo::getAddressConstraints(const MachineInstr &MI,
 602                                              int &AccessScale, int &MinOffset,
 603                                              int &MaxOffset) const {
 604   switch (MI.getOpcode()) {
 605   default: llvm_unreachable("Unkown load/store kind");
 606   case TargetOpcode::DBG_VALUE:
 607     AccessScale = 1;
 608     MinOffset = INT_MIN;
 609     MaxOffset = INT_MAX;
 610     return;
 611   case AArch64::LS8_LDR: case AArch64::LS8_STR:
 612   case AArch64::LSFP8_LDR: case AArch64::LSFP8_STR:
 613   case AArch64::LDRSBw:
 614   case AArch64::LDRSBx:
 615     AccessScale = 1;
 616     MinOffset = 0;
 617     MaxOffset = 0xfff;
 618     return;
 619   case AArch64::LS16_LDR: case AArch64::LS16_STR:
 620   case AArch64::LSFP16_LDR: case AArch64::LSFP16_STR:
 621   case AArch64::LDRSHw:
 622   case AArch64::LDRSHx:
 623     AccessScale = 2;
 624     MinOffset = 0;
 625     MaxOffset = 0xfff * AccessScale;
 626     return;
 627   case AArch64::LS32_LDR:  case AArch64::LS32_STR:
 628   case AArch64::LSFP32_LDR: case AArch64::LSFP32_STR:
 629   case AArch64::LDRSWx:
 630   case AArch64::LDPSWx:
 631     AccessScale = 4;
 632     MinOffset = 0;
 633     MaxOffset = 0xfff * AccessScale;
 634     return;
 635   case AArch64::LS64_LDR: case AArch64::LS64_STR:
 636   case AArch64::LSFP64_LDR: case AArch64::LSFP64_STR:
 637   case AArch64::PRFM:
 638     AccessScale = 8;
 639     MinOffset = 0;
 640     MaxOffset = 0xfff * AccessScale;
 641     return;
 642   case AArch64::LSFP128_LDR: case AArch64::LSFP128_STR:
 643     AccessScale = 16;
 644     MinOffset = 0;
 645     MaxOffset = 0xfff * AccessScale;
 646     return;
 647   case AArch64::LSPair32_LDR: case AArch64::LSPair32_STR:
 648   case AArch64::LSFPPair32_LDR: case AArch64::LSFPPair32_STR:
 649     AccessScale = 4;
 650     MinOffset = -0x40 * AccessScale;
 651     MaxOffset = 0x3f * AccessScale;
 652     return;
 653   case AArch64::LSPair64_LDR: case AArch64::LSPair64_STR:
 654   case AArch64::LSFPPair64_LDR: case AArch64::LSFPPair64_STR:
 655     AccessScale = 8;
 656     MinOffset = -0x40 * AccessScale;
 657     MaxOffset = 0x3f * AccessScale;
 658     return;
 659   case AArch64::LSFPPair128_LDR: case AArch64::LSFPPair128_STR:
 660     AccessScale = 16;
 661     MinOffset = -0x40 * AccessScale;
 662     MaxOffset = 0x3f * AccessScale;
 663     return;
 664   case AArch64::LD1x2_8B: case AArch64::ST1x2_8B:
 665     AccessScale = 16;
 666     MinOffset = 0;
 667     MaxOffset = 0xfff * AccessScale;
 668     return;
 669   case AArch64::LD1x3_8B: case AArch64::ST1x3_8B:
 670     AccessScale = 24;
 671     MinOffset = 0;
 672     MaxOffset = 0xfff * AccessScale;
 673     return;
 674   case AArch64::LD1x4_8B: case AArch64::ST1x4_8B:
 675   case AArch64::LD1x2_16B: case AArch64::ST1x2_16B:
 676     AccessScale = 32;
 677     MinOffset = 0;
 678     MaxOffset = 0xfff * AccessScale;
 679     return;
 680   case AArch64::LD1x3_16B: case AArch64::ST1x3_16B:
 681     AccessScale = 48;
 682     MinOffset = 0;
 683     MaxOffset = 0xfff * AccessScale;
 684     return;
 685   case AArch64::LD1x4_16B: case AArch64::ST1x4_16B:
 686     AccessScale = 64;
 687     MinOffset = 0;
 688     MaxOffset = 0xfff * AccessScale;
 689     return;
 690   }
 691 }
 692
 693 unsigned AArch64InstrInfo::getInstSizeInBytes(const MachineInstr &MI) const {
 694   const MCInstrDesc &MCID = MI.getDesc();
 695   const MachineBasicBlock &MBB = *MI.getParent();
 696   const MachineFunction &MF = *MBB.getParent();
 697   const MCAsmInfo &MAI = *MF.getTarget().getMCAsmInfo();
 698
 699   if (MCID.getSize())
 700     return MCID.getSize();
 701
 702   if (MI.getOpcode() == AArch64::INLINEASM)
 703     return getInlineAsmLength(MI.getOperand(0).getSymbolName(), MAI);
 704
 705   if (MI.isLabel())
 706     return 0;
 707
 708   switch (MI.getOpcode()) {
 709   case TargetOpcode::BUNDLE:
 710     return getInstBundleLength(MI);
 711   case TargetOpcode::IMPLICIT_DEF:
 712   case TargetOpcode::KILL:
 713   case TargetOpcode::PROLOG_LABEL:
 714   case TargetOpcode::EH_LABEL:
 715   case TargetOpcode::DBG_VALUE:
 716     return 0;
 717   case AArch64::TLSDESCCALL:
 718     return 0;
 719   default:
 720     llvm_unreachable("Unknown instruction class");
 721   }
 722 }
 723
 724 unsigned AArch64InstrInfo::getInstBundleLength(const MachineInstr &MI) const {
 725   unsigned Size = 0;
 726   MachineBasicBlock::const_instr_iterator I = MI;
 727   MachineBasicBlock::const_instr_iterator E = MI.getParent()->instr_end();
 728   while (++I != E && I->isInsideBundle()) {
 729     assert(!I->isBundle() && "No nested bundle!");
 730     Size += getInstSizeInBytes(*I);
 731   }
 732   return Size;
 733 }
 734
 735 bool llvm::rewriteA64FrameIndex(MachineInstr &MI, unsigned FrameRegIdx,
 736                                 unsigned FrameReg, int &Offset,
 737                                 const AArch64InstrInfo &TII) {
 738   MachineBasicBlock &MBB = *MI.getParent();
 739   MachineFunction &MF = *MBB.getParent();
 740   MachineFrameInfo &MFI = *MF.getFrameInfo();
 741
 742   MFI.getObjectOffset(FrameRegIdx);
 743   llvm_unreachable("Unimplemented rewriteFrameIndex");
 744 }
 745
 746 void llvm::emitRegUpdate(MachineBasicBlock &MBB,
 747                          MachineBasicBlock::iterator MBBI,
 748                          DebugLoc dl, const TargetInstrInfo &TII,
 749                          unsigned DstReg, unsigned SrcReg, unsigned ScratchReg,
 750                          int64_t NumBytes, MachineInstr::MIFlag MIFlags) {
 751   if (NumBytes == 0 && DstReg == SrcReg)
 752     return;
 753   else if (abs64(NumBytes) & ~0xffffff) {
 754     // Generically, we have to materialize the offset into a temporary register
 755     // and subtract it. There are a couple of ways this could be done, for now
 756     // we'll use a movz/movk or movn/movk sequence.
 757     uint64_t Bits = static_cast<uint64_t>(abs64(NumBytes));
 758     BuildMI(MBB, MBBI, dl, TII.get(AArch64::MOVZxii), ScratchReg)
 759       .addImm(0xffff & Bits).addImm(0)
 760       .setMIFlags(MIFlags);
 761
 762     Bits >>= 16;
 763     if (Bits & 0xffff) {
 764       BuildMI(MBB, MBBI, dl, TII.get(AArch64::MOVKxii), ScratchReg)
 765         .addReg(ScratchReg)
 766         .addImm(0xffff & Bits).addImm(1)
 767         .setMIFlags(MIFlags);
 768     }
 769
 770     Bits >>= 16;
 771     if (Bits & 0xffff) {
 772       BuildMI(MBB, MBBI, dl, TII.get(AArch64::MOVKxii), ScratchReg)
 773         .addReg(ScratchReg)
 774         .addImm(0xffff & Bits).addImm(2)
 775         .setMIFlags(MIFlags);
 776     }
 777
 778     Bits >>= 16;
 779     if (Bits & 0xffff) {
 780       BuildMI(MBB, MBBI, dl, TII.get(AArch64::MOVKxii), ScratchReg)
 781         .addReg(ScratchReg)
 782         .addImm(0xffff & Bits).addImm(3)
 783         .setMIFlags(MIFlags);
 784     }
 785
 786     // ADD DST, SRC, xTMP (, lsl #0)
 787     unsigned AddOp = NumBytes > 0 ? AArch64::ADDxxx_uxtx : AArch64::SUBxxx_uxtx;
 788     BuildMI(MBB, MBBI, dl, TII.get(AddOp), DstReg)
 789       .addReg(SrcReg, RegState::Kill)
 790       .addReg(ScratchReg, RegState::Kill)
 791       .addImm(0)
 792       .setMIFlag(MIFlags);
 793     return;
 794   }
 795
 796   // Now we know that the adjustment can be done in at most two add/sub
 797   // (immediate) instructions, which is always more efficient than a
 798   // literal-pool load, or even a hypothetical movz/movk/add sequence
 799
 800   // Decide whether we're doing addition or subtraction
 801   unsigned LowOp, HighOp;
 802   if (NumBytes >= 0) {
 803     LowOp = AArch64::ADDxxi_lsl0_s;
 804     HighOp = AArch64::ADDxxi_lsl12_s;
 805   } else {
 806     LowOp = AArch64::SUBxxi_lsl0_s;
 807     HighOp = AArch64::SUBxxi_lsl12_s;
 808     NumBytes = abs64(NumBytes);
 809   }
 810
 811   // If we're here, at the very least a move needs to be produced, which just
 812   // happens to be materializable by an ADD.
 813   if ((NumBytes & 0xfff) || NumBytes == 0) {
 814     BuildMI(MBB, MBBI, dl, TII.get(LowOp), DstReg)
 815       .addReg(SrcReg, RegState::Kill)
 816       .addImm(NumBytes & 0xfff)
 817       .setMIFlag(MIFlags);
 818
 819     // Next update should use the register we've just defined.
 820     SrcReg = DstReg;
 821   }
 822
 823   if (NumBytes & 0xfff000) {
 824     BuildMI(MBB, MBBI, dl, TII.get(HighOp), DstReg)
 825       .addReg(SrcReg, RegState::Kill)
 826       .addImm(NumBytes >> 12)
 827       .setMIFlag(MIFlags);
 828   }
 829 }
 830
 831 void llvm::emitSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI,
 832                         DebugLoc dl, const TargetInstrInfo &TII,
 833                         unsigned ScratchReg, int64_t NumBytes,
 834                         MachineInstr::MIFlag MIFlags) {
 835   emitRegUpdate(MBB, MI, dl, TII, AArch64::XSP, AArch64::XSP, AArch64::X16,
 836                 NumBytes, MIFlags);
 837 }
 838
 839
 840 namespace {
 841   struct LDTLSCleanup : public MachineFunctionPass {
 842     static char ID;
 843     LDTLSCleanup() : MachineFunctionPass(ID) {}
 844
 845     virtual bool runOnMachineFunction(MachineFunction &MF) {
 846       AArch64MachineFunctionInfo* MFI
 847         = MF.getInfo<AArch64MachineFunctionInfo>();
 848       if (MFI->getNumLocalDynamicTLSAccesses() < 2) {
 849         // No point folding accesses if there isn't at least two.
 850         return false;
 851       }
 852
 853       MachineDominatorTree *DT = &getAnalysis<MachineDominatorTree>();
 854       return VisitNode(DT->getRootNode(), 0);
 855     }
 856
 857     // Visit the dominator subtree rooted at Node in pre-order.
 858     // If TLSBaseAddrReg is non-null, then use that to replace any
 859     // TLS_base_addr instructions. Otherwise, create the register
 860     // when the first such instruction is seen, and then use it
 861     // as we encounter more instructions.
 862     bool VisitNode(MachineDomTreeNode *Node, unsigned TLSBaseAddrReg) {
 863       MachineBasicBlock *BB = Node->getBlock();
 864       bool Changed = false;
 865
 866       // Traverse the current block.
 867       for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;
 868            ++I) {
 869         switch (I->getOpcode()) {
 870         case AArch64::TLSDESC_BLRx:
 871           // Make sure it's a local dynamic access.
 872           if (!I->getOperand(1).isSymbol() ||
 873               strcmp(I->getOperand(1).getSymbolName(), "_TLS_MODULE_BASE_"))
 874             break;
 875
 876           if (TLSBaseAddrReg)
 877             I = ReplaceTLSBaseAddrCall(I, TLSBaseAddrReg);
 878           else
 879             I = SetRegister(I, &TLSBaseAddrReg);
 880           Changed = true;
 881           break;
 882         default:
 883           break;
 884         }
 885       }
 886
 887       // Visit the children of this block in the dominator tree.
 888       for (MachineDomTreeNode::iterator I = Node->begin(), E = Node->end();
 889            I != E; ++I) {
 890         Changed |= VisitNode(*I, TLSBaseAddrReg);
 891       }
 892
 893       return Changed;
 894     }
 895
 896     // Replace the TLS_base_addr instruction I with a copy from
 897     // TLSBaseAddrReg, returning the new instruction.
 898     MachineInstr *ReplaceTLSBaseAddrCall(MachineInstr *I,
 899                                          unsigned TLSBaseAddrReg) {
 900       MachineFunction *MF = I->getParent()->getParent();
 901       const AArch64TargetMachine *TM =
 902           static_cast<const AArch64TargetMachine *>(&MF->getTarget());
 903       const AArch64InstrInfo *TII = TM->getInstrInfo();
 904
 905       // Insert a Copy from TLSBaseAddrReg to x0, which is where the rest of the
 906       // code sequence assumes the address will be.
 907       MachineInstr *Copy = BuildMI(*I->getParent(), I, I->getDebugLoc(),
 908                                    TII->get(TargetOpcode::COPY),
 909                                    AArch64::X0)
 910         .addReg(TLSBaseAddrReg);
 911
 912       // Erase the TLS_base_addr instruction.
 913       I->eraseFromParent();
 914
 915       return Copy;
 916     }
 917
 918     // Create a virtal register in *TLSBaseAddrReg, and populate it by
 919     // inserting a copy instruction after I. Returns the new instruction.
 920     MachineInstr *SetRegister(MachineInstr *I, unsigned *TLSBaseAddrReg) {
 921       MachineFunction *MF = I->getParent()->getParent();
 922       const AArch64TargetMachine *TM =
 923           static_cast<const AArch64TargetMachine *>(&MF->getTarget());
 924       const AArch64InstrInfo *TII = TM->getInstrInfo();
 925
 926       // Create a virtual register for the TLS base address.
 927       MachineRegisterInfo &RegInfo = MF->getRegInfo();
 928       *TLSBaseAddrReg = RegInfo.createVirtualRegister(&AArch64::GPR64RegClass);
 929
 930       // Insert a copy from X0 to TLSBaseAddrReg for later.
 931       MachineInstr *Next = I->getNextNode();
 932       MachineInstr *Copy = BuildMI(*I->getParent(), Next, I->getDebugLoc(),
 933                                    TII->get(TargetOpcode::COPY),
 934                                    *TLSBaseAddrReg)
 935         .addReg(AArch64::X0);
 936
 937       return Copy;
 938     }
 939
 940     virtual const char *getPassName() const {
 941       return "Local Dynamic TLS Access Clean-up";
 942     }
 943
 944     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
 945       AU.setPreservesCFG();
 946       AU.addRequired<MachineDominatorTree>();
 947       MachineFunctionPass::getAnalysisUsage(AU);
 948     }
 949   };
 950 }
 951
 952 char LDTLSCleanup::ID = 0;
 953 FunctionPass*
 954 llvm::createAArch64CleanupLocalDynamicTLSPass() { return new LDTLSCleanup(); }