lib/Target/ARM64/ARM64AsmPrinter.cpp

   1 //===-- ARM64AsmPrinter.cpp - ARM64 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 ARM64 assembly language.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "ARM64.h"
  16 #include "ARM64MachineFunctionInfo.h"
  17 #include "ARM64MCInstLower.h"
  18 #include "ARM64RegisterInfo.h"
  19 #include "ARM64Subtarget.h"
  20 #include "InstPrinter/ARM64InstPrinter.h"
  21 #include "llvm/ADT/SmallString.h"
  22 #include "llvm/ADT/StringSwitch.h"
  23 #include "llvm/ADT/Twine.h"
  24 #include "llvm/CodeGen/AsmPrinter.h"
  25 #include "llvm/CodeGen/MachineInstr.h"
  26 #include "llvm/CodeGen/StackMaps.h"
  27 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
  28 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
  29 #include "llvm/IR/DataLayout.h"
  30 #include "llvm/IR/DebugInfo.h"
  31 #include "llvm/MC/MCAsmInfo.h"
  32 #include "llvm/MC/MCContext.h"
  33 #include "llvm/MC/MCInst.h"
  34 #include "llvm/MC/MCInstBuilder.h"
  35 #include "llvm/MC/MCLinkerOptimizationHint.h"
  36 #include "llvm/MC/MCStreamer.h"
  37 #include "llvm/Support/Debug.h"
  38 #include "llvm/Support/TargetRegistry.h"
  39 using namespace llvm;
  40
  41 #define DEBUG_TYPE "asm-printer"
  42
  43 namespace {
  44
  45 class ARM64AsmPrinter : public AsmPrinter {
  46   /// Subtarget - Keep a pointer to the ARM64Subtarget around so that we can
  47   /// make the right decision when printing asm code for different targets.
  48   const ARM64Subtarget *Subtarget;
  49
  50   ARM64MCInstLower MCInstLowering;
  51   StackMaps SM;
  52
  53 public:
  54   ARM64AsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
  55       : AsmPrinter(TM, Streamer), Subtarget(&TM.getSubtarget<ARM64Subtarget>()),
  56         MCInstLowering(OutContext, *Mang, *this), SM(*this), ARM64FI(nullptr),
  57         LOHLabelCounter(0) {}
  58
  59   const char *getPassName() const override { return "ARM64 Assembly Printer"; }
  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     ARM64FI = F.getInfo<ARM64FunctionInfo>();
  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   ARM64FunctionInfo *ARM64FI;
 110
 111   /// \brief Emit the LOHs contained in ARM64FI.
 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 ARM64AsmPrinter::EmitEndOfAsmFile(Module &M) {
 124   if (Subtarget->isTargetMachO()) {
 125     // Funny Darwin hack: This flag tells the linker that no global symbols
 126     // contain code that falls through to other global symbols (e.g. the obvious
 127     // implementation of multiple entry points).  If this doesn't occur, the
 128     // linker can safely perform dead code stripping.  Since LLVM never
 129     // generates code that does this, it is always safe to set.
 130     OutStreamer.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
 131     SM.serializeToStackMapSection();
 132   }
 133
 134   // Emit a .data.rel section containing any stubs that were created.
 135   if (Subtarget->isTargetELF()) {
 136     const TargetLoweringObjectFileELF &TLOFELF =
 137       static_cast<const TargetLoweringObjectFileELF &>(getObjFileLowering());
 138
 139     MachineModuleInfoELF &MMIELF = MMI->getObjFileInfo<MachineModuleInfoELF>();
 140
 141     // Output stubs for external and common global variables.
 142     MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList();
 143     if (!Stubs.empty()) {
 144       OutStreamer.SwitchSection(TLOFELF.getDataRelSection());
 145       const DataLayout *TD = TM.getDataLayout();
 146
 147       for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 148         OutStreamer.EmitLabel(Stubs[i].first);
 149         OutStreamer.EmitSymbolValue(Stubs[i].second.getPointer(),
 150                                     TD->getPointerSize(0));
 151       }
 152       Stubs.clear();
 153     }
 154   }
 155
 156 }
 157
 158 MachineLocation
 159 ARM64AsmPrinter::getDebugValueLocation(const MachineInstr *MI) const {
 160   MachineLocation Location;
 161   assert(MI->getNumOperands() == 4 && "Invalid no. of machine operands!");
 162   // Frame address.  Currently handles register +- offset only.
 163   if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm())
 164     Location.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
 165   else {
 166     DEBUG(dbgs() << "DBG_VALUE instruction ignored! " << *MI << "\n");
 167   }
 168   return Location;
 169 }
 170
 171 void ARM64AsmPrinter::EmitLOHs() {
 172   SmallVector<MCSymbol *, 3> MCArgs;
 173
 174   for (const auto &D : ARM64FI->getLOHContainer()) {
 175     for (const MachineInstr *MI : D.getArgs()) {
 176       MInstToMCSymbol::iterator LabelIt = LOHInstToLabel.find(MI);
 177       assert(LabelIt != LOHInstToLabel.end() &&
 178              "Label hasn't been inserted for LOH related instruction");
 179       MCArgs.push_back(LabelIt->second);
 180     }
 181     OutStreamer.EmitLOHDirective(D.getKind(), MCArgs);
 182     MCArgs.clear();
 183   }
 184 }
 185
 186 void ARM64AsmPrinter::EmitFunctionBodyEnd() {
 187   if (!ARM64FI->getLOHRelated().empty())
 188     EmitLOHs();
 189 }
 190
 191 /// GetCPISymbol - Return the symbol for the specified constant pool entry.
 192 MCSymbol *ARM64AsmPrinter::GetCPISymbol(unsigned CPID) const {
 193   // Darwin uses a linker-private symbol name for constant-pools (to
 194   // avoid addends on the relocation?), ELF has no such concept and
 195   // uses a normal private symbol.
 196   if (getDataLayout().getLinkerPrivateGlobalPrefix()[0])
 197     return OutContext.GetOrCreateSymbol(
 198         Twine(getDataLayout().getLinkerPrivateGlobalPrefix()) + "CPI" +
 199         Twine(getFunctionNumber()) + "_" + Twine(CPID));
 200
 201   return OutContext.GetOrCreateSymbol(
 202       Twine(getDataLayout().getPrivateGlobalPrefix()) + "CPI" +
 203       Twine(getFunctionNumber()) + "_" + Twine(CPID));
 204 }
 205
 206 void ARM64AsmPrinter::printOperand(const MachineInstr *MI, unsigned OpNum,
 207                                    raw_ostream &O) {
 208   const MachineOperand &MO = MI->getOperand(OpNum);
 209   switch (MO.getType()) {
 210   default:
 211     assert(0 && "<unknown operand type>");
 212   case MachineOperand::MO_Register: {
 213     unsigned Reg = MO.getReg();
 214     assert(TargetRegisterInfo::isPhysicalRegister(Reg));
 215     assert(!MO.getSubReg() && "Subregs should be eliminated!");
 216     O << ARM64InstPrinter::getRegisterName(Reg);
 217     break;
 218   }
 219   case MachineOperand::MO_Immediate: {
 220     int64_t Imm = MO.getImm();
 221     O << '#' << Imm;
 222     break;
 223   }
 224   }
 225 }
 226
 227 bool ARM64AsmPrinter::printAsmMRegister(const MachineOperand &MO, char Mode,
 228                                         raw_ostream &O) {
 229   unsigned Reg = MO.getReg();
 230   switch (Mode) {
 231   default:
 232     return true; // Unknown mode.
 233   case 'w':
 234     Reg = getWRegFromXReg(Reg);
 235     break;
 236   case 'x':
 237     Reg = getXRegFromWReg(Reg);
 238     break;
 239   }
 240
 241   O << ARM64InstPrinter::getRegisterName(Reg);
 242   return false;
 243 }
 244
 245 // Prints the register in MO using class RC using the offset in the
 246 // new register class. This should not be used for cross class
 247 // printing.
 248 bool ARM64AsmPrinter::printAsmRegInClass(const MachineOperand &MO,
 249                                          const TargetRegisterClass *RC,
 250                                          bool isVector, raw_ostream &O) {
 251   assert(MO.isReg() && "Should only get here with a register!");
 252   const ARM64RegisterInfo *RI =
 253       static_cast<const ARM64RegisterInfo *>(TM.getRegisterInfo());
 254   unsigned Reg = MO.getReg();
 255   unsigned RegToPrint = RC->getRegister(RI->getEncodingValue(Reg));
 256   assert(RI->regsOverlap(RegToPrint, Reg));
 257   O << ARM64InstPrinter::getRegisterName(
 258            RegToPrint, isVector ? ARM64::vreg : ARM64::NoRegAltName);
 259   return false;
 260 }
 261
 262 bool ARM64AsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNum,
 263                                       unsigned AsmVariant,
 264                                       const char *ExtraCode, raw_ostream &O) {
 265   const MachineOperand &MO = MI->getOperand(OpNum);
 266   // Does this asm operand have a single letter operand modifier?
 267   if (ExtraCode && ExtraCode[0]) {
 268     if (ExtraCode[1] != 0)
 269       return true; // Unknown modifier.
 270
 271     switch (ExtraCode[0]) {
 272     default:
 273       return true; // Unknown modifier.
 274     case 'w':      // Print W register
 275     case 'x':      // Print X register
 276       if (MO.isReg())
 277         return printAsmMRegister(MO, ExtraCode[0], O);
 278       if (MO.isImm() && MO.getImm() == 0) {
 279         unsigned Reg = ExtraCode[0] == 'w' ? ARM64::WZR : ARM64::XZR;
 280         O << ARM64InstPrinter::getRegisterName(Reg);
 281         return false;
 282       }
 283       printOperand(MI, OpNum, O);
 284       return false;
 285     case 'b': // Print B register.
 286     case 'h': // Print H register.
 287     case 's': // Print S register.
 288     case 'd': // Print D register.
 289     case 'q': // Print Q register.
 290       if (MO.isReg()) {
 291         const TargetRegisterClass *RC;
 292         switch (ExtraCode[0]) {
 293         case 'b':
 294           RC = &ARM64::FPR8RegClass;
 295           break;
 296         case 'h':
 297           RC = &ARM64::FPR16RegClass;
 298           break;
 299         case 's':
 300           RC = &ARM64::FPR32RegClass;
 301           break;
 302         case 'd':
 303           RC = &ARM64::FPR64RegClass;
 304           break;
 305         case 'q':
 306           RC = &ARM64::FPR128RegClass;
 307           break;
 308         default:
 309           return true;
 310         }
 311         return printAsmRegInClass(MO, RC, false /* vector */, O);
 312       }
 313       printOperand(MI, OpNum, O);
 314       return false;
 315     }
 316   }
 317
 318   // According to ARM, we should emit x and v registers unless we have a
 319   // modifier.
 320   if (MO.isReg()) {
 321     unsigned Reg = MO.getReg();
 322
 323     // If this is a w or x register, print an x register.
 324     if (ARM64::GPR32allRegClass.contains(Reg) ||
 325         ARM64::GPR64allRegClass.contains(Reg))
 326       return printAsmMRegister(MO, 'x', O);
 327
 328     // If this is a b, h, s, d, or q register, print it as a v register.
 329     return printAsmRegInClass(MO, &ARM64::FPR128RegClass, true /* vector */, O);
 330   }
 331
 332   printOperand(MI, OpNum, O);
 333   return false;
 334 }
 335
 336 bool ARM64AsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
 337                                             unsigned OpNum, unsigned AsmVariant,
 338                                             const char *ExtraCode,
 339                                             raw_ostream &O) {
 340   if (ExtraCode && ExtraCode[0])
 341     return true; // Unknown modifier.
 342
 343   const MachineOperand &MO = MI->getOperand(OpNum);
 344   assert(MO.isReg() && "unexpected inline asm memory operand");
 345   O << "[" << ARM64InstPrinter::getRegisterName(MO.getReg()) << "]";
 346   return false;
 347 }
 348
 349 void ARM64AsmPrinter::PrintDebugValueComment(const MachineInstr *MI,
 350                                              raw_ostream &OS) {
 351   unsigned NOps = MI->getNumOperands();
 352   assert(NOps == 4);
 353   OS << '\t' << MAI->getCommentString() << "DEBUG_VALUE: ";
 354   // cast away const; DIetc do not take const operands for some reason.
 355   DIVariable V(const_cast<MDNode *>(MI->getOperand(NOps - 1).getMetadata()));
 356   OS << V.getName();
 357   OS << " <- ";
 358   // Frame address.  Currently handles register +- offset only.
 359   assert(MI->getOperand(0).isReg() && MI->getOperand(1).isImm());
 360   OS << '[';
 361   printOperand(MI, 0, OS);
 362   OS << '+';
 363   printOperand(MI, 1, OS);
 364   OS << ']';
 365   OS << "+";
 366   printOperand(MI, NOps - 2, OS);
 367 }
 368
 369 void ARM64AsmPrinter::LowerSTACKMAP(MCStreamer &OutStreamer, StackMaps &SM,
 370                                     const MachineInstr &MI) {
 371   unsigned NumNOPBytes = MI.getOperand(1).getImm();
 372
 373   SM.recordStackMap(MI);
 374   // Emit padding.
 375   assert(NumNOPBytes % 4 == 0 && "Invalid number of NOP bytes requested!");
 376   for (unsigned i = 0; i < NumNOPBytes; i += 4)
 377     EmitToStreamer(OutStreamer, MCInstBuilder(ARM64::HINT).addImm(0));
 378 }
 379
 380 // Lower a patchpoint of the form:
 381 // [<def>], <id>, <numBytes>, <target>, <numArgs>
 382 void ARM64AsmPrinter::LowerPATCHPOINT(MCStreamer &OutStreamer, StackMaps &SM,
 383                                       const MachineInstr &MI) {
 384   SM.recordPatchPoint(MI);
 385
 386   PatchPointOpers Opers(&MI);
 387
 388   int64_t CallTarget = Opers.getMetaOper(PatchPointOpers::TargetPos).getImm();
 389   unsigned EncodedBytes = 0;
 390   if (CallTarget) {
 391     assert((CallTarget & 0xFFFFFFFFFFFF) == CallTarget &&
 392            "High 16 bits of call target should be zero.");
 393     unsigned ScratchReg = MI.getOperand(Opers.getNextScratchIdx()).getReg();
 394     EncodedBytes = 16;
 395     // Materialize the jump address:
 396     EmitToStreamer(OutStreamer, MCInstBuilder(ARM64::MOVZWi)
 397                                     .addReg(ScratchReg)
 398                                     .addImm((CallTarget >> 32) & 0xFFFF)
 399                                     .addImm(32));
 400     EmitToStreamer(OutStreamer, MCInstBuilder(ARM64::MOVKWi)
 401                                     .addReg(ScratchReg)
 402                                     .addReg(ScratchReg)
 403                                     .addImm((CallTarget >> 16) & 0xFFFF)
 404                                     .addImm(16));
 405     EmitToStreamer(OutStreamer, MCInstBuilder(ARM64::MOVKWi)
 406                                     .addReg(ScratchReg)
 407                                     .addReg(ScratchReg)
 408                                     .addImm(CallTarget & 0xFFFF)
 409                                     .addImm(0));
 410     EmitToStreamer(OutStreamer, MCInstBuilder(ARM64::BLR).addReg(ScratchReg));
 411   }
 412   // Emit padding.
 413   unsigned NumBytes = Opers.getMetaOper(PatchPointOpers::NBytesPos).getImm();
 414   assert(NumBytes >= EncodedBytes &&
 415          "Patchpoint can't request size less than the length of a call.");
 416   assert((NumBytes - EncodedBytes) % 4 == 0 &&
 417          "Invalid number of NOP bytes requested!");
 418   for (unsigned i = EncodedBytes; i < NumBytes; i += 4)
 419     EmitToStreamer(OutStreamer, MCInstBuilder(ARM64::HINT).addImm(0));
 420 }
 421
 422 // Simple pseudo-instructions have their lowering (with expansion to real
 423 // instructions) auto-generated.
 424 #include "ARM64GenMCPseudoLowering.inc"
 425
 426 void ARM64AsmPrinter::EmitInstruction(const MachineInstr *MI) {
 427   // Do any auto-generated pseudo lowerings.
 428   if (emitPseudoExpansionLowering(OutStreamer, MI))
 429     return;
 430
 431   if (ARM64FI->getLOHRelated().count(MI)) {
 432     // Generate a label for LOH related instruction
 433     MCSymbol *LOHLabel = GetTempSymbol("loh", LOHLabelCounter++);
 434     // Associate the instruction with the label
 435     LOHInstToLabel[MI] = LOHLabel;
 436     OutStreamer.EmitLabel(LOHLabel);
 437   }
 438
 439   // Do any manual lowerings.
 440   switch (MI->getOpcode()) {
 441   default:
 442     break;
 443   case ARM64::DBG_VALUE: {
 444     if (isVerbose() && OutStreamer.hasRawTextSupport()) {
 445       SmallString<128> TmpStr;
 446       raw_svector_ostream OS(TmpStr);
 447       PrintDebugValueComment(MI, OS);
 448       OutStreamer.EmitRawText(StringRef(OS.str()));
 449     }
 450     return;
 451   }
 452
 453   // Tail calls use pseudo instructions so they have the proper code-gen
 454   // attributes (isCall, isReturn, etc.). We lower them to the real
 455   // instruction here.
 456   case ARM64::TCRETURNri: {
 457     MCInst TmpInst;
 458     TmpInst.setOpcode(ARM64::BR);
 459     TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
 460     EmitToStreamer(OutStreamer, TmpInst);
 461     return;
 462   }
 463   case ARM64::TCRETURNdi: {
 464     MCOperand Dest;
 465     MCInstLowering.lowerOperand(MI->getOperand(0), Dest);
 466     MCInst TmpInst;
 467     TmpInst.setOpcode(ARM64::B);
 468     TmpInst.addOperand(Dest);
 469     EmitToStreamer(OutStreamer, TmpInst);
 470     return;
 471   }
 472   case ARM64::TLSDESC_BLR: {
 473     MCOperand Callee, Sym;
 474     MCInstLowering.lowerOperand(MI->getOperand(0), Callee);
 475     MCInstLowering.lowerOperand(MI->getOperand(1), Sym);
 476
 477     // First emit a relocation-annotation. This expands to no code, but requests
 478     // the following instruction gets an R_AARCH64_TLSDESC_CALL.
 479     MCInst TLSDescCall;
 480     TLSDescCall.setOpcode(ARM64::TLSDESCCALL);
 481     TLSDescCall.addOperand(Sym);
 482     EmitToStreamer(OutStreamer, TLSDescCall);
 483
 484     // Other than that it's just a normal indirect call to the function loaded
 485     // from the descriptor.
 486     MCInst BLR;
 487     BLR.setOpcode(ARM64::BLR);
 488     BLR.addOperand(Callee);
 489     EmitToStreamer(OutStreamer, BLR);
 490
 491     return;
 492   }
 493
 494   case TargetOpcode::STACKMAP:
 495     return LowerSTACKMAP(OutStreamer, SM, *MI);
 496
 497   case TargetOpcode::PATCHPOINT:
 498     return LowerPATCHPOINT(OutStreamer, SM, *MI);
 499   }
 500
 501   // Finally, do the automated lowerings for everything else.
 502   MCInst TmpInst;
 503   MCInstLowering.Lower(MI, TmpInst);
 504   EmitToStreamer(OutStreamer, TmpInst);
 505 }
 506
 507 // Force static initialization.
 508 extern "C" void LLVMInitializeARM64AsmPrinter() {
 509   RegisterAsmPrinter<ARM64AsmPrinter> X(TheARM64leTarget);
 510   RegisterAsmPrinter<ARM64AsmPrinter> Y(TheARM64beTarget);
 511
 512   RegisterAsmPrinter<ARM64AsmPrinter> Z(TheAArch64leTarget);
 513   RegisterAsmPrinter<ARM64AsmPrinter> W(TheAArch64beTarget);
 514 }