lib/Target/AArch64/AArch64AsmPrinter.cpp

   1 //===-- AArch64AsmPrinter.cpp - AArch64 LLVM assembly writer --------------===//
   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 a printer that converts from our internal representation
  11 // of machine-dependent LLVM code to the AArch64 assembly language.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "MCTargetDesc/AArch64AddressingModes.h"
  16 #include "MCTargetDesc/AArch64MCExpr.h"
  17 #include "AArch64.h"
  18 #include "AArch64MCInstLower.h"
  19 #include "AArch64MachineFunctionInfo.h"
  20 #include "AArch64RegisterInfo.h"
  21 #include "AArch64Subtarget.h"
  22 #include "InstPrinter/AArch64InstPrinter.h"
  23 #include "llvm/ADT/SmallString.h"
  24 #include "llvm/ADT/StringSwitch.h"
  25 #include "llvm/ADT/Twine.h"
  26 #include "llvm/CodeGen/AsmPrinter.h"
  27 #include "llvm/CodeGen/MachineInstr.h"
  28 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
  29 #include "llvm/CodeGen/StackMaps.h"
  30 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
  31 #include "llvm/IR/DataLayout.h"
  32 #include "llvm/IR/DebugInfo.h"
  33 #include "llvm/MC/MCAsmInfo.h"
  34 #include "llvm/MC/MCContext.h"
  35 #include "llvm/MC/MCInst.h"
  36 #include "llvm/MC/MCInstBuilder.h"
  37 #include "llvm/MC/MCLinkerOptimizationHint.h"
  38 #include "llvm/MC/MCStreamer.h"
  39 #include "llvm/MC/MCSymbol.h"
  40 #include "llvm/Support/Debug.h"
  41 #include "llvm/Support/TargetRegistry.h"
  42 using namespace llvm;
  43
  44 #define DEBUG_TYPE "asm-printer"
  45
  46 namespace {
  47
  48 class AArch64AsmPrinter : public AsmPrinter {
  49   AArch64MCInstLower MCInstLowering;
  50   StackMaps SM;
  51
  52 public:
  53   AArch64AsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer)
  54       : AsmPrinter(TM, std::move(Streamer)), MCInstLowering(OutContext, *this),
  55         SM(*this), AArch64FI(nullptr), LOHLabelCounter(0) {}
  56
  57   const char *getPassName() const override {
  58     return "AArch64 Assembly Printer";
  59   }
  60
  61   /// \brief Wrapper for MCInstLowering.lowerOperand() for the
  62   /// tblgen'erated pseudo lowering.
  63   bool lowerOperand(const MachineOperand &MO, MCOperand &MCOp) const {
  64     return MCInstLowering.lowerOperand(MO, MCOp);
  65   }
  66
  67   void LowerSTACKMAP(MCStreamer &OutStreamer, StackMaps &SM,
  68                      const MachineInstr &MI);
  69   void LowerPATCHPOINT(MCStreamer &OutStreamer, StackMaps &SM,
  70                        const MachineInstr &MI);
  71   /// \brief tblgen'erated driver function for lowering simple MI->MC
  72   /// pseudo instructions.
  73   bool emitPseudoExpansionLowering(MCStreamer &OutStreamer,
  74                                    const MachineInstr *MI);
  75
  76   void EmitInstruction(const MachineInstr *MI) override;
  77
  78   void getAnalysisUsage(AnalysisUsage &AU) const override {
  79     AsmPrinter::getAnalysisUsage(AU);
  80     AU.setPreservesAll();
  81   }
  82
  83   bool runOnMachineFunction(MachineFunction &F) override {
  84     AArch64FI = F.getInfo<AArch64FunctionInfo>();
  85     return AsmPrinter::runOnMachineFunction(F);
  86   }
  87
  88 private:
  89   MachineLocation getDebugValueLocation(const MachineInstr *MI) const;
  90   void printOperand(const MachineInstr *MI, unsigned OpNum, raw_ostream &O);
  91   bool printAsmMRegister(const MachineOperand &MO, char Mode, raw_ostream &O);
  92   bool printAsmRegInClass(const MachineOperand &MO,
  93                           const TargetRegisterClass *RC, bool isVector,
  94                           raw_ostream &O);
  95
  96   bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNum,
  97                        unsigned AsmVariant, const char *ExtraCode,
  98                        raw_ostream &O) override;
  99   bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNum,
 100                              unsigned AsmVariant, const char *ExtraCode,
 101                              raw_ostream &O) override;
 102
 103   void PrintDebugValueComment(const MachineInstr *MI, raw_ostream &OS);
 104
 105   void EmitFunctionBodyEnd() override;
 106
 107   MCSymbol *GetCPISymbol(unsigned CPID) const override;
 108   void EmitEndOfAsmFile(Module &M) override;
 109   AArch64FunctionInfo *AArch64FI;
 110
 111   /// \brief Emit the LOHs contained in AArch64FI.
 112   void EmitLOHs();
 113
 114   typedef std::map<const MachineInstr *, MCSymbol *> MInstToMCSymbol;
 115   MInstToMCSymbol LOHInstToLabel;
 116   unsigned LOHLabelCounter;
 117 };
 118
 119 } // end of anonymous namespace
 120
 121 //===----------------------------------------------------------------------===//
 122
 123 void AArch64AsmPrinter::EmitEndOfAsmFile(Module &M) {
 124   Triple TT(TM.getTargetTriple());
 125   if (TT.isOSBinFormatMachO()) {
 126     // Funny Darwin hack: This flag tells the linker that no global symbols
 127     // contain code that falls through to other global symbols (e.g. the obvious
 128     // implementation of multiple entry points).  If this doesn't occur, the
 129     // linker can safely perform dead code stripping.  Since LLVM never
 130     // generates code that does this, it is always safe to set.
 131     OutStreamer.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
 132     SM.serializeToStackMapSection();
 133   }
 134
 135   // Emit a .data.rel section containing any stubs that were created.
 136   if (TT.isOSBinFormatELF()) {
 137     const TargetLoweringObjectFileELF &TLOFELF =
 138       static_cast<const TargetLoweringObjectFileELF &>(getObjFileLowering());
 139
 140     MachineModuleInfoELF &MMIELF = MMI->getObjFileInfo<MachineModuleInfoELF>();
 141
 142     // Output stubs for external and common global variables.
 143     MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList();
 144     if (!Stubs.empty()) {
 145       OutStreamer.SwitchSection(TLOFELF.getDataRelSection());
 146       const DataLayout *TD = TM.getDataLayout();
 147
 148       for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 149         OutStreamer.EmitLabel(Stubs[i].first);
 150         OutStreamer.EmitSymbolValue(Stubs[i].second.getPointer(),
 151                                     TD->getPointerSize(0));
 152       }
 153       Stubs.clear();
 154     }
 155   }
 156
 157 }
 158
 159 MachineLocation
 160 AArch64AsmPrinter::getDebugValueLocation(const MachineInstr *MI) const {
 161   MachineLocation Location;
 162   assert(MI->getNumOperands() == 4 && "Invalid no. of machine operands!");
 163   // Frame address.  Currently handles register +- offset only.
 164   if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm())
 165     Location.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
 166   else {
 167     DEBUG(dbgs() << "DBG_VALUE instruction ignored! " << *MI << "\n");
 168   }
 169   return Location;
 170 }
 171
 172 void AArch64AsmPrinter::EmitLOHs() {
 173   SmallVector<MCSymbol *, 3> MCArgs;
 174
 175   for (const auto &D : AArch64FI->getLOHContainer()) {
 176     for (const MachineInstr *MI : D.getArgs()) {
 177       MInstToMCSymbol::iterator LabelIt = LOHInstToLabel.find(MI);
 178       assert(LabelIt != LOHInstToLabel.end() &&
 179              "Label hasn't been inserted for LOH related instruction");
 180       MCArgs.push_back(LabelIt->second);
 181     }
 182     OutStreamer.EmitLOHDirective(D.getKind(), MCArgs);
 183     MCArgs.clear();
 184   }
 185 }
 186
 187 void AArch64AsmPrinter::EmitFunctionBodyEnd() {
 188   if (!AArch64FI->getLOHRelated().empty())
 189     EmitLOHs();
 190 }
 191
 192 /// GetCPISymbol - Return the symbol for the specified constant pool entry.
 193 MCSymbol *AArch64AsmPrinter::GetCPISymbol(unsigned CPID) const {
 194   // Darwin uses a linker-private symbol name for constant-pools (to
 195   // avoid addends on the relocation?), ELF has no such concept and
 196   // uses a normal private symbol.
 197   if (getDataLayout().getLinkerPrivateGlobalPrefix()[0])
 198     return OutContext.GetOrCreateSymbol(
 199         Twine(getDataLayout().getLinkerPrivateGlobalPrefix()) + "CPI" +
 200         Twine(getFunctionNumber()) + "_" + Twine(CPID));
 201
 202   return OutContext.GetOrCreateSymbol(
 203       Twine(getDataLayout().getPrivateGlobalPrefix()) + "CPI" +
 204       Twine(getFunctionNumber()) + "_" + Twine(CPID));
 205 }
 206
 207 void AArch64AsmPrinter::printOperand(const MachineInstr *MI, unsigned OpNum,
 208                                      raw_ostream &O) {
 209   const MachineOperand &MO = MI->getOperand(OpNum);
 210   switch (MO.getType()) {
 211   default:
 212     llvm_unreachable("<unknown operand type>");
 213   case MachineOperand::MO_Register: {
 214     unsigned Reg = MO.getReg();
 215     assert(TargetRegisterInfo::isPhysicalRegister(Reg));
 216     assert(!MO.getSubReg() && "Subregs should be eliminated!");
 217     O << AArch64InstPrinter::getRegisterName(Reg);
 218     break;
 219   }
 220   case MachineOperand::MO_Immediate: {
 221     int64_t Imm = MO.getImm();
 222     O << '#' << Imm;
 223     break;
 224   }
 225   case MachineOperand::MO_GlobalAddress: {
 226     const GlobalValue *GV = MO.getGlobal();
 227     MCSymbol *Sym = getSymbol(GV);
 228
 229     // FIXME: Can we get anything other than a plain symbol here?
 230     assert(!MO.getTargetFlags() && "Unknown operand target flag!");
 231
 232     O << *Sym;
 233     printOffset(MO.getOffset(), O);
 234     break;
 235   }
 236   }
 237 }
 238
 239 bool AArch64AsmPrinter::printAsmMRegister(const MachineOperand &MO, char Mode,
 240                                           raw_ostream &O) {
 241   unsigned Reg = MO.getReg();
 242   switch (Mode) {
 243   default:
 244     return true; // Unknown mode.
 245   case 'w':
 246     Reg = getWRegFromXReg(Reg);
 247     break;
 248   case 'x':
 249     Reg = getXRegFromWReg(Reg);
 250     break;
 251   }
 252
 253   O << AArch64InstPrinter::getRegisterName(Reg);
 254   return false;
 255 }
 256
 257 // Prints the register in MO using class RC using the offset in the
 258 // new register class. This should not be used for cross class
 259 // printing.
 260 bool AArch64AsmPrinter::printAsmRegInClass(const MachineOperand &MO,
 261                                            const TargetRegisterClass *RC,
 262                                            bool isVector, raw_ostream &O) {
 263   assert(MO.isReg() && "Should only get here with a register!");
 264   const AArch64RegisterInfo *RI =
 265       MF->getSubtarget<AArch64Subtarget>().getRegisterInfo();
 266   unsigned Reg = MO.getReg();
 267   unsigned RegToPrint = RC->getRegister(RI->getEncodingValue(Reg));
 268   assert(RI->regsOverlap(RegToPrint, Reg));
 269   O << AArch64InstPrinter::getRegisterName(
 270            RegToPrint, isVector ? AArch64::vreg : AArch64::NoRegAltName);
 271   return false;
 272 }
 273
 274 bool AArch64AsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNum,
 275                                         unsigned AsmVariant,
 276                                         const char *ExtraCode, raw_ostream &O) {
 277   const MachineOperand &MO = MI->getOperand(OpNum);
 278
 279   // First try the generic code, which knows about modifiers like 'c' and 'n'.
 280   if (!AsmPrinter::PrintAsmOperand(MI, OpNum, AsmVariant, ExtraCode, O))
 281     return false;
 282
 283   // Does this asm operand have a single letter operand modifier?
 284   if (ExtraCode && ExtraCode[0]) {
 285     if (ExtraCode[1] != 0)
 286       return true; // Unknown modifier.
 287
 288     switch (ExtraCode[0]) {
 289     default:
 290       return true; // Unknown modifier.
 291     case 'w':      // Print W register
 292     case 'x':      // Print X register
 293       if (MO.isReg())
 294         return printAsmMRegister(MO, ExtraCode[0], O);
 295       if (MO.isImm() && MO.getImm() == 0) {
 296         unsigned Reg = ExtraCode[0] == 'w' ? AArch64::WZR : AArch64::XZR;
 297         O << AArch64InstPrinter::getRegisterName(Reg);
 298         return false;
 299       }
 300       printOperand(MI, OpNum, O);
 301       return false;
 302     case 'b': // Print B register.
 303     case 'h': // Print H register.
 304     case 's': // Print S register.
 305     case 'd': // Print D register.
 306     case 'q': // Print Q register.
 307       if (MO.isReg()) {
 308         const TargetRegisterClass *RC;
 309         switch (ExtraCode[0]) {
 310         case 'b':
 311           RC = &AArch64::FPR8RegClass;
 312           break;
 313         case 'h':
 314           RC = &AArch64::FPR16RegClass;
 315           break;
 316         case 's':
 317           RC = &AArch64::FPR32RegClass;
 318           break;
 319         case 'd':
 320           RC = &AArch64::FPR64RegClass;
 321           break;
 322         case 'q':
 323           RC = &AArch64::FPR128RegClass;
 324           break;
 325         default:
 326           return true;
 327         }
 328         return printAsmRegInClass(MO, RC, false /* vector */, O);
 329       }
 330       printOperand(MI, OpNum, O);
 331       return false;
 332     }
 333   }
 334
 335   // According to ARM, we should emit x and v registers unless we have a
 336   // modifier.
 337   if (MO.isReg()) {
 338     unsigned Reg = MO.getReg();
 339
 340     // If this is a w or x register, print an x register.
 341     if (AArch64::GPR32allRegClass.contains(Reg) ||
 342         AArch64::GPR64allRegClass.contains(Reg))
 343       return printAsmMRegister(MO, 'x', O);
 344
 345     // If this is a b, h, s, d, or q register, print it as a v register.
 346     return printAsmRegInClass(MO, &AArch64::FPR128RegClass, true /* vector */,
 347                               O);
 348   }
 349
 350   printOperand(MI, OpNum, O);
 351   return false;
 352 }
 353
 354 bool AArch64AsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
 355                                               unsigned OpNum,
 356                                               unsigned AsmVariant,
 357                                               const char *ExtraCode,
 358                                               raw_ostream &O) {
 359   if (ExtraCode && ExtraCode[0])
 360     return true; // Unknown modifier.
 361
 362   const MachineOperand &MO = MI->getOperand(OpNum);
 363   assert(MO.isReg() && "unexpected inline asm memory operand");
 364   O << "[" << AArch64InstPrinter::getRegisterName(MO.getReg()) << "]";
 365   return false;
 366 }
 367
 368 void AArch64AsmPrinter::PrintDebugValueComment(const MachineInstr *MI,
 369                                                raw_ostream &OS) {
 370   unsigned NOps = MI->getNumOperands();
 371   assert(NOps == 4);
 372   OS << '\t' << MAI->getCommentString() << "DEBUG_VALUE: ";
 373   // cast away const; DIetc do not take const operands for some reason.
 374   DIVariable V(const_cast<MDNode *>(MI->getOperand(NOps - 1).getMetadata()));
 375   OS << V.getName();
 376   OS << " <- ";
 377   // Frame address.  Currently handles register +- offset only.
 378   assert(MI->getOperand(0).isReg() && MI->getOperand(1).isImm());
 379   OS << '[';
 380   printOperand(MI, 0, OS);
 381   OS << '+';
 382   printOperand(MI, 1, OS);
 383   OS << ']';
 384   OS << "+";
 385   printOperand(MI, NOps - 2, OS);
 386 }
 387
 388 void AArch64AsmPrinter::LowerSTACKMAP(MCStreamer &OutStreamer, StackMaps &SM,
 389                                       const MachineInstr &MI) {
 390   unsigned NumNOPBytes = MI.getOperand(1).getImm();
 391
 392   SM.recordStackMap(MI);
 393   assert(NumNOPBytes % 4 == 0 && "Invalid number of NOP bytes requested!");
 394
 395   // Scan ahead to trim the shadow.
 396   const MachineBasicBlock &MBB = *MI.getParent();
 397   MachineBasicBlock::const_iterator MII(MI);
 398   ++MII;
 399   while (NumNOPBytes > 0) {
 400     if (MII == MBB.end() || MII->isCall() ||
 401         MII->getOpcode() == AArch64::DBG_VALUE ||
 402         MII->getOpcode() == TargetOpcode::PATCHPOINT ||
 403         MII->getOpcode() == TargetOpcode::STACKMAP)
 404       break;
 405     ++MII;
 406     NumNOPBytes -= 4;
 407   }
 408
 409   // Emit nops.
 410   for (unsigned i = 0; i < NumNOPBytes; i += 4)
 411     EmitToStreamer(OutStreamer, MCInstBuilder(AArch64::HINT).addImm(0));
 412 }
 413
 414 // Lower a patchpoint of the form:
 415 // [<def>], <id>, <numBytes>, <target>, <numArgs>
 416 void AArch64AsmPrinter::LowerPATCHPOINT(MCStreamer &OutStreamer, StackMaps &SM,
 417                                         const MachineInstr &MI) {
 418   SM.recordPatchPoint(MI);
 419
 420   PatchPointOpers Opers(&MI);
 421
 422   int64_t CallTarget = Opers.getMetaOper(PatchPointOpers::TargetPos).getImm();
 423   unsigned EncodedBytes = 0;
 424   if (CallTarget) {
 425     assert((CallTarget & 0xFFFFFFFFFFFF) == CallTarget &&
 426            "High 16 bits of call target should be zero.");
 427     unsigned ScratchReg = MI.getOperand(Opers.getNextScratchIdx()).getReg();
 428     EncodedBytes = 16;
 429     // Materialize the jump address:
 430     EmitToStreamer(OutStreamer, MCInstBuilder(AArch64::MOVZWi)
 431                                     .addReg(ScratchReg)
 432                                     .addImm((CallTarget >> 32) & 0xFFFF)
 433                                     .addImm(32));
 434     EmitToStreamer(OutStreamer, MCInstBuilder(AArch64::MOVKWi)
 435                                     .addReg(ScratchReg)
 436                                     .addReg(ScratchReg)
 437                                     .addImm((CallTarget >> 16) & 0xFFFF)
 438                                     .addImm(16));
 439     EmitToStreamer(OutStreamer, MCInstBuilder(AArch64::MOVKWi)
 440                                     .addReg(ScratchReg)
 441                                     .addReg(ScratchReg)
 442                                     .addImm(CallTarget & 0xFFFF)
 443                                     .addImm(0));
 444     EmitToStreamer(OutStreamer, MCInstBuilder(AArch64::BLR).addReg(ScratchReg));
 445   }
 446   // Emit padding.
 447   unsigned NumBytes = Opers.getMetaOper(PatchPointOpers::NBytesPos).getImm();
 448   assert(NumBytes >= EncodedBytes &&
 449          "Patchpoint can't request size less than the length of a call.");
 450   assert((NumBytes - EncodedBytes) % 4 == 0 &&
 451          "Invalid number of NOP bytes requested!");
 452   for (unsigned i = EncodedBytes; i < NumBytes; i += 4)
 453     EmitToStreamer(OutStreamer, MCInstBuilder(AArch64::HINT).addImm(0));
 454 }
 455
 456 // Simple pseudo-instructions have their lowering (with expansion to real
 457 // instructions) auto-generated.
 458 #include "AArch64GenMCPseudoLowering.inc"
 459
 460 void AArch64AsmPrinter::EmitInstruction(const MachineInstr *MI) {
 461   // Do any auto-generated pseudo lowerings.
 462   if (emitPseudoExpansionLowering(OutStreamer, MI))
 463     return;
 464
 465   if (AArch64FI->getLOHRelated().count(MI)) {
 466     // Generate a label for LOH related instruction
 467     MCSymbol *LOHLabel = GetTempSymbol("loh", LOHLabelCounter++);
 468     // Associate the instruction with the label
 469     LOHInstToLabel[MI] = LOHLabel;
 470     OutStreamer.EmitLabel(LOHLabel);
 471   }
 472
 473   // Do any manual lowerings.
 474   switch (MI->getOpcode()) {
 475   default:
 476     break;
 477   case AArch64::DBG_VALUE: {
 478     if (isVerbose() && OutStreamer.hasRawTextSupport()) {
 479       SmallString<128> TmpStr;
 480       raw_svector_ostream OS(TmpStr);
 481       PrintDebugValueComment(MI, OS);
 482       OutStreamer.EmitRawText(StringRef(OS.str()));
 483     }
 484     return;
 485   }
 486
 487   // Tail calls use pseudo instructions so they have the proper code-gen
 488   // attributes (isCall, isReturn, etc.). We lower them to the real
 489   // instruction here.
 490   case AArch64::TCRETURNri: {
 491     MCInst TmpInst;
 492     TmpInst.setOpcode(AArch64::BR);
 493     TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
 494     EmitToStreamer(OutStreamer, TmpInst);
 495     return;
 496   }
 497   case AArch64::TCRETURNdi: {
 498     MCOperand Dest;
 499     MCInstLowering.lowerOperand(MI->getOperand(0), Dest);
 500     MCInst TmpInst;
 501     TmpInst.setOpcode(AArch64::B);
 502     TmpInst.addOperand(Dest);
 503     EmitToStreamer(OutStreamer, TmpInst);
 504     return;
 505   }
 506   case AArch64::TLSDESC_CALLSEQ: {
 507     /// lower this to:
 508     ///    adrp  x0, :tlsdesc:var
 509     ///    ldr   x1, [x0, #:tlsdesc_lo12:var]
 510     ///    add   x0, x0, #:tlsdesc_lo12:var
 511     ///    .tlsdesccall var
 512     ///    blr   x1
 513     ///    (TPIDR_EL0 offset now in x0)
 514     const MachineOperand &MO_Sym = MI->getOperand(0);
 515     MachineOperand MO_TLSDESC_LO12(MO_Sym), MO_TLSDESC(MO_Sym);
 516     MCOperand Sym, SymTLSDescLo12, SymTLSDesc;
 517     MO_TLSDESC_LO12.setTargetFlags(AArch64II::MO_TLS | AArch64II::MO_PAGEOFF |
 518                                    AArch64II::MO_NC);
 519     MO_TLSDESC.setTargetFlags(AArch64II::MO_TLS | AArch64II::MO_PAGE);
 520     MCInstLowering.lowerOperand(MO_Sym, Sym);
 521     MCInstLowering.lowerOperand(MO_TLSDESC_LO12, SymTLSDescLo12);
 522     MCInstLowering.lowerOperand(MO_TLSDESC, SymTLSDesc);
 523
 524     MCInst Adrp;
 525     Adrp.setOpcode(AArch64::ADRP);
 526     Adrp.addOperand(MCOperand::CreateReg(AArch64::X0));
 527     Adrp.addOperand(SymTLSDesc);
 528     EmitToStreamer(OutStreamer, Adrp);
 529
 530     MCInst Ldr;
 531     Ldr.setOpcode(AArch64::LDRXui);
 532     Ldr.addOperand(MCOperand::CreateReg(AArch64::X1));
 533     Ldr.addOperand(MCOperand::CreateReg(AArch64::X0));
 534     Ldr.addOperand(SymTLSDescLo12);
 535     Ldr.addOperand(MCOperand::CreateImm(0));
 536     EmitToStreamer(OutStreamer, Ldr);
 537
 538     MCInst Add;
 539     Add.setOpcode(AArch64::ADDXri);
 540     Add.addOperand(MCOperand::CreateReg(AArch64::X0));
 541     Add.addOperand(MCOperand::CreateReg(AArch64::X0));
 542     Add.addOperand(SymTLSDescLo12);
 543     Add.addOperand(MCOperand::CreateImm(AArch64_AM::getShiftValue(0)));
 544     EmitToStreamer(OutStreamer, Add);
 545
 546     // Emit a relocation-annotation. This expands to no code, but requests
 547     // the following instruction gets an R_AARCH64_TLSDESC_CALL.
 548     MCInst TLSDescCall;
 549     TLSDescCall.setOpcode(AArch64::TLSDESCCALL);
 550     TLSDescCall.addOperand(Sym);
 551     EmitToStreamer(OutStreamer, TLSDescCall);
 552
 553     MCInst Blr;
 554     Blr.setOpcode(AArch64::BLR);
 555     Blr.addOperand(MCOperand::CreateReg(AArch64::X1));
 556     EmitToStreamer(OutStreamer, Blr);
 557
 558     return;
 559   }
 560
 561   case TargetOpcode::STACKMAP:
 562     return LowerSTACKMAP(OutStreamer, SM, *MI);
 563
 564   case TargetOpcode::PATCHPOINT:
 565     return LowerPATCHPOINT(OutStreamer, SM, *MI);
 566   }
 567
 568   // Finally, do the automated lowerings for everything else.
 569   MCInst TmpInst;
 570   MCInstLowering.Lower(MI, TmpInst);
 571   EmitToStreamer(OutStreamer, TmpInst);
 572 }
 573
 574 // Force static initialization.
 575 extern "C" void LLVMInitializeAArch64AsmPrinter() {
 576   RegisterAsmPrinter<AArch64AsmPrinter> X(TheAArch64leTarget);
 577   RegisterAsmPrinter<AArch64AsmPrinter> Y(TheAArch64beTarget);
 578   RegisterAsmPrinter<AArch64AsmPrinter> Z(TheARM64Target);
 579 }