LLVM  9.0.0svn
X86AsmPrinter.cpp
Go to the documentation of this file.
1 //===-- X86AsmPrinter.cpp - Convert X86 LLVM code to AT&T assembly --------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains a printer that converts from our internal representation
10 // of machine-dependent LLVM code to X86 machine code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "X86AsmPrinter.h"
19 #include "X86InstrInfo.h"
20 #include "X86MachineFunctionInfo.h"
21 #include "llvm/BinaryFormat/COFF.h"
22 #include "llvm/BinaryFormat/ELF.h"
26 #include "llvm/IR/DerivedTypes.h"
27 #include "llvm/IR/InlineAsm.h"
28 #include "llvm/IR/Mangler.h"
29 #include "llvm/IR/Module.h"
30 #include "llvm/IR/Type.h"
31 #include "llvm/MC/MCCodeEmitter.h"
32 #include "llvm/MC/MCContext.h"
33 #include "llvm/MC/MCExpr.h"
34 #include "llvm/MC/MCSectionCOFF.h"
35 #include "llvm/MC/MCSectionELF.h"
36 #include "llvm/MC/MCSectionMachO.h"
37 #include "llvm/MC/MCStreamer.h"
38 #include "llvm/MC/MCSymbol.h"
39 #include "llvm/Support/Debug.h"
43 using namespace llvm;
44 
46  std::unique_ptr<MCStreamer> Streamer)
47  : AsmPrinter(TM, std::move(Streamer)), SM(*this), FM(*this) {}
48 
49 //===----------------------------------------------------------------------===//
50 // Primitive Helper Functions.
51 //===----------------------------------------------------------------------===//
52 
53 /// runOnMachineFunction - Emit the function body.
54 ///
56  Subtarget = &MF.getSubtarget<X86Subtarget>();
57 
58  SMShadowTracker.startFunction(MF);
59  CodeEmitter.reset(TM.getTarget().createMCCodeEmitter(
60  *Subtarget->getInstrInfo(), *Subtarget->getRegisterInfo(),
61  MF.getContext()));
62 
63  EmitFPOData =
64  Subtarget->isTargetWin32() && MF.getMMI().getModule()->getCodeViewFlag();
65 
67 
68  if (Subtarget->isTargetCOFF()) {
69  bool Local = MF.getFunction().hasLocalLinkage();
70  OutStreamer->BeginCOFFSymbolDef(CurrentFnSym);
71  OutStreamer->EmitCOFFSymbolStorageClass(
75  OutStreamer->EndCOFFSymbolDef();
76  }
77 
78  // Emit the rest of the function body.
80 
81  // Emit the XRay table for this function.
82  emitXRayTable();
83 
84  EmitFPOData = false;
85 
86  // We didn't modify anything.
87  return false;
88 }
89 
91  if (EmitFPOData) {
92  if (auto *XTS =
93  static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer()))
94  XTS->emitFPOProc(
97  }
98 }
99 
101  if (EmitFPOData) {
102  if (auto *XTS =
103  static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer()))
104  XTS->emitFPOEndProc();
105  }
106 }
107 
108 /// PrintSymbolOperand - Print a raw symbol reference operand. This handles
109 /// jump tables, constant pools, global address and external symbols, all of
110 /// which print to a label with various suffixes for relocation types etc.
111 void X86AsmPrinter::PrintSymbolOperand(const MachineOperand &MO,
112  raw_ostream &O) {
113  switch (MO.getType()) {
114  default: llvm_unreachable("unknown symbol type!");
116  GetCPISymbol(MO.getIndex())->print(O, MAI);
117  printOffset(MO.getOffset(), O);
118  break;
120  const GlobalValue *GV = MO.getGlobal();
121 
122  MCSymbol *GVSym;
125  GVSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
126  else
127  GVSym = getSymbol(GV);
128 
129  // Handle dllimport linkage.
131  GVSym = OutContext.getOrCreateSymbol(Twine("__imp_") + GVSym->getName());
132  else if (MO.getTargetFlags() == X86II::MO_COFFSTUB)
133  GVSym =
134  OutContext.getOrCreateSymbol(Twine(".refptr.") + GVSym->getName());
135 
138  MCSymbol *Sym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
140  MMI->getObjFileInfo<MachineModuleInfoMachO>().getGVStubEntry(Sym);
141  if (!StubSym.getPointer())
143  !GV->hasInternalLinkage());
144  }
145 
146  // If the name begins with a dollar-sign, enclose it in parens. We do this
147  // to avoid having it look like an integer immediate to the assembler.
148  if (GVSym->getName()[0] != '$')
149  GVSym->print(O, MAI);
150  else {
151  O << '(';
152  GVSym->print(O, MAI);
153  O << ')';
154  }
155  printOffset(MO.getOffset(), O);
156  break;
157  }
158  }
159 
160  switch (MO.getTargetFlags()) {
161  default:
162  llvm_unreachable("Unknown target flag on GV operand");
163  case X86II::MO_NO_FLAG: // No flag.
164  break;
166  case X86II::MO_DLLIMPORT:
167  case X86II::MO_COFFSTUB:
168  // These affect the name of the symbol, not any suffix.
169  break;
171  O << " + [.-";
172  MF->getPICBaseSymbol()->print(O, MAI);
173  O << ']';
174  break;
177  O << '-';
178  MF->getPICBaseSymbol()->print(O, MAI);
179  break;
180  case X86II::MO_TLSGD: O << "@TLSGD"; break;
181  case X86II::MO_TLSLD: O << "@TLSLD"; break;
182  case X86II::MO_TLSLDM: O << "@TLSLDM"; break;
183  case X86II::MO_GOTTPOFF: O << "@GOTTPOFF"; break;
184  case X86II::MO_INDNTPOFF: O << "@INDNTPOFF"; break;
185  case X86II::MO_TPOFF: O << "@TPOFF"; break;
186  case X86II::MO_DTPOFF: O << "@DTPOFF"; break;
187  case X86II::MO_NTPOFF: O << "@NTPOFF"; break;
188  case X86II::MO_GOTNTPOFF: O << "@GOTNTPOFF"; break;
189  case X86II::MO_GOTPCREL: O << "@GOTPCREL"; break;
190  case X86II::MO_GOT: O << "@GOT"; break;
191  case X86II::MO_GOTOFF: O << "@GOTOFF"; break;
192  case X86II::MO_PLT: O << "@PLT"; break;
193  case X86II::MO_TLVP: O << "@TLVP"; break;
195  O << "@TLVP" << '-';
196  MF->getPICBaseSymbol()->print(O, MAI);
197  break;
198  case X86II::MO_SECREL: O << "@SECREL32"; break;
199  }
200 }
201 
202 void X86AsmPrinter::PrintOperand(const MachineInstr *MI, unsigned OpNo,
203  raw_ostream &O) {
204  const MachineOperand &MO = MI->getOperand(OpNo);
205  const bool IsATT = MI->getInlineAsmDialect() == InlineAsm::AD_ATT;
206  switch (MO.getType()) {
207  default: llvm_unreachable("unknown operand type!");
209  if (IsATT)
210  O << '%';
212  return;
213  }
214 
216  if (IsATT)
217  O << '$';
218  O << MO.getImm();
219  return;
220 
222  if (IsATT)
223  O << '$';
224  PrintSymbolOperand(MO, O);
225  break;
226  }
229  Sym->print(O, MAI);
230  break;
231  }
232  }
233 }
234 
235 /// PrintModifiedOperand - Print subregisters based on supplied modifier,
236 /// deferring to PrintOperand() if no modifier was supplied or if operand is not
237 /// a register.
238 void X86AsmPrinter::PrintModifiedOperand(const MachineInstr *MI, unsigned OpNo,
239  raw_ostream &O, const char *Modifier) {
240  const MachineOperand &MO = MI->getOperand(OpNo);
241  if (!Modifier || MO.getType() != MachineOperand::MO_Register)
242  return PrintOperand(MI, OpNo, O);
244  O << '%';
245  unsigned Reg = MO.getReg();
246  if (strncmp(Modifier, "subreg", strlen("subreg")) == 0) {
247  unsigned Size = (strcmp(Modifier+6,"64") == 0) ? 64 :
248  (strcmp(Modifier+6,"32") == 0) ? 32 :
249  (strcmp(Modifier+6,"16") == 0) ? 16 : 8;
250  Reg = getX86SubSuperRegister(Reg, Size);
251  }
253 }
254 
255 /// PrintPCRelImm - This is used to print an immediate value that ends up
256 /// being encoded as a pc-relative value. These print slightly differently, for
257 /// example, a $ is not emitted.
258 void X86AsmPrinter::PrintPCRelImm(const MachineInstr *MI, unsigned OpNo,
259  raw_ostream &O) {
260  const MachineOperand &MO = MI->getOperand(OpNo);
261  switch (MO.getType()) {
262  default: llvm_unreachable("Unknown pcrel immediate operand");
264  // pc-relativeness was handled when computing the value in the reg.
265  PrintOperand(MI, OpNo, O);
266  return;
268  O << MO.getImm();
269  return;
271  PrintSymbolOperand(MO, O);
272  return;
273  }
274 }
275 
276 void X86AsmPrinter::PrintLeaMemReference(const MachineInstr *MI, unsigned OpNo,
277  raw_ostream &O, const char *Modifier) {
278  const MachineOperand &BaseReg = MI->getOperand(OpNo + X86::AddrBaseReg);
279  const MachineOperand &IndexReg = MI->getOperand(OpNo + X86::AddrIndexReg);
280  const MachineOperand &DispSpec = MI->getOperand(OpNo + X86::AddrDisp);
281 
282  // If we really don't want to print out (rip), don't.
283  bool HasBaseReg = BaseReg.getReg() != 0;
284  if (HasBaseReg && Modifier && !strcmp(Modifier, "no-rip") &&
285  BaseReg.getReg() == X86::RIP)
286  HasBaseReg = false;
287 
288  // HasParenPart - True if we will print out the () part of the mem ref.
289  bool HasParenPart = IndexReg.getReg() || HasBaseReg;
290 
291  switch (DispSpec.getType()) {
292  default:
293  llvm_unreachable("unknown operand type!");
295  int DispVal = DispSpec.getImm();
296  if (DispVal || !HasParenPart)
297  O << DispVal;
298  break;
299  }
302  PrintSymbolOperand(DispSpec, O);
303  break;
304  }
305 
306  if (Modifier && strcmp(Modifier, "H") == 0)
307  O << "+8";
308 
309  if (HasParenPart) {
310  assert(IndexReg.getReg() != X86::ESP &&
311  "X86 doesn't allow scaling by ESP");
312 
313  O << '(';
314  if (HasBaseReg)
315  PrintModifiedOperand(MI, OpNo + X86::AddrBaseReg, O, Modifier);
316 
317  if (IndexReg.getReg()) {
318  O << ',';
319  PrintModifiedOperand(MI, OpNo + X86::AddrIndexReg, O, Modifier);
320  unsigned ScaleVal = MI->getOperand(OpNo + X86::AddrScaleAmt).getImm();
321  if (ScaleVal != 1)
322  O << ',' << ScaleVal;
323  }
324  O << ')';
325  }
326 }
327 
328 void X86AsmPrinter::PrintMemReference(const MachineInstr *MI, unsigned OpNo,
329  raw_ostream &O, const char *Modifier) {
330  assert(isMem(*MI, OpNo) && "Invalid memory reference!");
331  const MachineOperand &Segment = MI->getOperand(OpNo + X86::AddrSegmentReg);
332  if (Segment.getReg()) {
333  PrintModifiedOperand(MI, OpNo + X86::AddrSegmentReg, O, Modifier);
334  O << ':';
335  }
336  PrintLeaMemReference(MI, OpNo, O, Modifier);
337 }
338 
339 void X86AsmPrinter::PrintIntelMemReference(const MachineInstr *MI,
340  unsigned OpNo, raw_ostream &O) {
341  const MachineOperand &BaseReg = MI->getOperand(OpNo + X86::AddrBaseReg);
342  unsigned ScaleVal = MI->getOperand(OpNo + X86::AddrScaleAmt).getImm();
343  const MachineOperand &IndexReg = MI->getOperand(OpNo + X86::AddrIndexReg);
344  const MachineOperand &DispSpec = MI->getOperand(OpNo + X86::AddrDisp);
345  const MachineOperand &SegReg = MI->getOperand(OpNo + X86::AddrSegmentReg);
346 
347  // If this has a segment register, print it.
348  if (SegReg.getReg()) {
349  PrintOperand(MI, OpNo + X86::AddrSegmentReg, O);
350  O << ':';
351  }
352 
353  O << '[';
354 
355  bool NeedPlus = false;
356  if (BaseReg.getReg()) {
357  PrintOperand(MI, OpNo + X86::AddrBaseReg, O);
358  NeedPlus = true;
359  }
360 
361  if (IndexReg.getReg()) {
362  if (NeedPlus) O << " + ";
363  if (ScaleVal != 1)
364  O << ScaleVal << '*';
365  PrintOperand(MI, OpNo + X86::AddrIndexReg, O);
366  NeedPlus = true;
367  }
368 
369  if (!DispSpec.isImm()) {
370  if (NeedPlus) O << " + ";
371  PrintOperand(MI, OpNo + X86::AddrDisp, O);
372  } else {
373  int64_t DispVal = DispSpec.getImm();
374  if (DispVal || (!IndexReg.getReg() && !BaseReg.getReg())) {
375  if (NeedPlus) {
376  if (DispVal > 0)
377  O << " + ";
378  else {
379  O << " - ";
380  DispVal = -DispVal;
381  }
382  }
383  O << DispVal;
384  }
385  }
386  O << ']';
387 }
388 
390  char Mode, raw_ostream &O) {
391  unsigned Reg = MO.getReg();
392  bool EmitPercent = true;
393 
394  if (!X86::GR8RegClass.contains(Reg) &&
395  !X86::GR16RegClass.contains(Reg) &&
396  !X86::GR32RegClass.contains(Reg) &&
397  !X86::GR64RegClass.contains(Reg))
398  return true;
399 
400  switch (Mode) {
401  default: return true; // Unknown mode.
402  case 'b': // Print QImode register
403  Reg = getX86SubSuperRegister(Reg, 8);
404  break;
405  case 'h': // Print QImode high register
406  Reg = getX86SubSuperRegister(Reg, 8, true);
407  break;
408  case 'w': // Print HImode register
409  Reg = getX86SubSuperRegister(Reg, 16);
410  break;
411  case 'k': // Print SImode register
412  Reg = getX86SubSuperRegister(Reg, 32);
413  break;
414  case 'V':
415  EmitPercent = false;
417  case 'q':
418  // Print 64-bit register names if 64-bit integer registers are available.
419  // Otherwise, print 32-bit register names.
420  Reg = getX86SubSuperRegister(Reg, P.getSubtarget().is64Bit() ? 64 : 32);
421  break;
422  }
423 
424  if (EmitPercent)
425  O << '%';
426 
428  return false;
429 }
430 
431 /// PrintAsmOperand - Print out an operand for an inline asm expression.
432 ///
433 bool X86AsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
434  const char *ExtraCode, raw_ostream &O) {
435  // Does this asm operand have a single letter operand modifier?
436  if (ExtraCode && ExtraCode[0]) {
437  if (ExtraCode[1] != 0) return true; // Unknown modifier.
438 
439  const MachineOperand &MO = MI->getOperand(OpNo);
440 
441  switch (ExtraCode[0]) {
442  default:
443  // See if this is a generic print operand
444  return AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, O);
445  case 'a': // This is an address. Currently only 'i' and 'r' are expected.
446  switch (MO.getType()) {
447  default:
448  return true;
450  O << MO.getImm();
451  return false;
455  llvm_unreachable("unexpected operand type!");
457  PrintSymbolOperand(MO, O);
458  if (Subtarget->isPICStyleRIPRel())
459  O << "(%rip)";
460  return false;
462  O << '(';
463  PrintOperand(MI, OpNo, O);
464  O << ')';
465  return false;
466  }
467 
468  case 'c': // Don't print "$" before a global var name or constant.
469  switch (MO.getType()) {
470  default:
471  PrintOperand(MI, OpNo, O);
472  break;
474  O << MO.getImm();
475  break;
479  llvm_unreachable("unexpected operand type!");
481  PrintSymbolOperand(MO, O);
482  break;
483  }
484  return false;
485 
486  case 'A': // Print '*' before a register (it must be a register)
487  if (MO.isReg()) {
488  O << '*';
489  PrintOperand(MI, OpNo, O);
490  return false;
491  }
492  return true;
493 
494  case 'b': // Print QImode register
495  case 'h': // Print QImode high register
496  case 'w': // Print HImode register
497  case 'k': // Print SImode register
498  case 'q': // Print DImode register
499  case 'V': // Print native register without '%'
500  if (MO.isReg())
501  return printAsmMRegister(*this, MO, ExtraCode[0], O);
502  PrintOperand(MI, OpNo, O);
503  return false;
504 
505  case 'P': // This is the operand of a call, treat specially.
506  PrintPCRelImm(MI, OpNo, O);
507  return false;
508 
509  case 'n': // Negate the immediate or print a '-' before the operand.
510  // Note: this is a temporary solution. It should be handled target
511  // independently as part of the 'MC' work.
512  if (MO.isImm()) {
513  O << -MO.getImm();
514  return false;
515  }
516  O << '-';
517  }
518  }
519 
520  PrintOperand(MI, OpNo, O);
521  return false;
522 }
523 
525  const char *ExtraCode,
526  raw_ostream &O) {
528  PrintIntelMemReference(MI, OpNo, O);
529  return false;
530  }
531 
532  if (ExtraCode && ExtraCode[0]) {
533  if (ExtraCode[1] != 0) return true; // Unknown modifier.
534 
535  switch (ExtraCode[0]) {
536  default: return true; // Unknown modifier.
537  case 'b': // Print QImode register
538  case 'h': // Print QImode high register
539  case 'w': // Print HImode register
540  case 'k': // Print SImode register
541  case 'q': // Print SImode register
542  // These only apply to registers, ignore on mem.
543  break;
544  case 'H':
545  PrintMemReference(MI, OpNo, O, "H");
546  return false;
547  case 'P': // Don't print @PLT, but do print as memory.
548  PrintMemReference(MI, OpNo, O, "no-rip");
549  return false;
550  }
551  }
552  PrintMemReference(MI, OpNo, O, nullptr);
553  return false;
554 }
555 
557  const Triple &TT = TM.getTargetTriple();
558 
559  if (TT.isOSBinFormatELF()) {
560  // Assemble feature flags that may require creation of a note section.
561  unsigned FeatureFlagsAnd = 0;
562  if (M.getModuleFlag("cf-protection-branch"))
563  FeatureFlagsAnd |= ELF::GNU_PROPERTY_X86_FEATURE_1_IBT;
564  if (M.getModuleFlag("cf-protection-return"))
565  FeatureFlagsAnd |= ELF::GNU_PROPERTY_X86_FEATURE_1_SHSTK;
566 
567  if (FeatureFlagsAnd) {
568  // Emit a .note.gnu.property section with the flags.
569  if (!TT.isArch32Bit() && !TT.isArch64Bit())
570  llvm_unreachable("CFProtection used on invalid architecture!");
571  MCSection *Cur = OutStreamer->getCurrentSectionOnly();
573  ".note.gnu.property", ELF::SHT_NOTE, ELF::SHF_ALLOC);
574  OutStreamer->SwitchSection(Nt);
575 
576  // Emitting note header.
577  int WordSize = TT.isArch64Bit() ? 8 : 4;
578  EmitAlignment(WordSize == 4 ? 2 : 3);
579  OutStreamer->EmitIntValue(4, 4 /*size*/); // data size for "GNU\0"
580  OutStreamer->EmitIntValue(8 + WordSize, 4 /*size*/); // Elf_Prop size
581  OutStreamer->EmitIntValue(ELF::NT_GNU_PROPERTY_TYPE_0, 4 /*size*/);
582  OutStreamer->EmitBytes(StringRef("GNU", 4)); // note name
583 
584  // Emitting an Elf_Prop for the CET properties.
586  OutStreamer->EmitIntValue(4, 4); // data size
587  OutStreamer->EmitIntValue(FeatureFlagsAnd, 4); // data
588  EmitAlignment(WordSize == 4 ? 2 : 3); // padding
589 
590  OutStreamer->endSection(Nt);
591  OutStreamer->SwitchSection(Cur);
592  }
593  }
594 
595  if (TT.isOSBinFormatMachO())
596  OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
597 
598  if (TT.isOSBinFormatCOFF()) {
599  // Emit an absolute @feat.00 symbol. This appears to be some kind of
600  // compiler features bitfield read by link.exe.
601  MCSymbol *S = MMI->getContext().getOrCreateSymbol(StringRef("@feat.00"));
602  OutStreamer->BeginCOFFSymbolDef(S);
603  OutStreamer->EmitCOFFSymbolStorageClass(COFF::IMAGE_SYM_CLASS_STATIC);
604  OutStreamer->EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_NULL);
605  OutStreamer->EndCOFFSymbolDef();
606  int64_t Feat00Flags = 0;
607 
608  if (TT.getArch() == Triple::x86) {
609  // According to the PE-COFF spec, the LSB of this value marks the object
610  // for "registered SEH". This means that all SEH handler entry points
611  // must be registered in .sxdata. Use of any unregistered handlers will
612  // cause the process to terminate immediately. LLVM does not know how to
613  // register any SEH handlers, so its object files should be safe.
614  Feat00Flags |= 1;
615  }
616 
617  if (M.getModuleFlag("cfguardtable"))
618  Feat00Flags |= 0x800; // Object is CFG-aware.
619 
620  OutStreamer->EmitSymbolAttribute(S, MCSA_Global);
621  OutStreamer->EmitAssignment(
622  S, MCConstantExpr::create(Feat00Flags, MMI->getContext()));
623  }
624  OutStreamer->EmitSyntaxDirective();
625 
626  // If this is not inline asm and we're in 16-bit
627  // mode prefix assembly with .code16.
628  bool is16 = TT.getEnvironment() == Triple::CODE16;
629  if (M.getModuleInlineAsm().empty() && is16)
630  OutStreamer->EmitAssemblerFlag(MCAF_Code16);
631 }
632 
633 static void
636  // L_foo$stub:
637  OutStreamer.EmitLabel(StubLabel);
638  // .indirect_symbol _foo
639  OutStreamer.EmitSymbolAttribute(MCSym.getPointer(), MCSA_IndirectSymbol);
640 
641  if (MCSym.getInt())
642  // External to current translation unit.
643  OutStreamer.EmitIntValue(0, 4/*size*/);
644  else
645  // Internal to current translation unit.
646  //
647  // When we place the LSDA into the TEXT section, the type info
648  // pointers need to be indirect and pc-rel. We accomplish this by
649  // using NLPs; however, sometimes the types are local to the file.
650  // We need to fill in the value for the NLP in those cases.
651  OutStreamer.EmitValue(
652  MCSymbolRefExpr::create(MCSym.getPointer(), OutStreamer.getContext()),
653  4 /*size*/);
654 }
655 
657 
658  MachineModuleInfoMachO &MMIMacho =
660 
661  // Output stubs for dynamically-linked functions.
663 
664  // Output stubs for external and common global variables.
665  Stubs = MMIMacho.GetGVStubList();
666  if (!Stubs.empty()) {
667  OutStreamer.SwitchSection(MMI->getContext().getMachOSection(
668  "__IMPORT", "__pointers", MachO::S_NON_LAZY_SYMBOL_POINTERS,
670 
671  for (auto &Stub : Stubs)
672  emitNonLazySymbolPointer(OutStreamer, Stub.first, Stub.second);
673 
674  Stubs.clear();
675  OutStreamer.AddBlankLine();
676  }
677 }
678 
680  const Triple &TT = TM.getTargetTriple();
681 
682  if (TT.isOSBinFormatMachO()) {
683  // Mach-O uses non-lazy symbol stubs to encode per-TU information into
684  // global table for symbol lookup.
686 
687  // Emit stack and fault map information.
688  emitStackMaps(SM);
690 
691  // This flag tells the linker that no global symbols contain code that fall
692  // through to other global symbols (e.g. an implementation of multiple entry
693  // points). If this doesn't occur, the linker can safely perform dead code
694  // stripping. Since LLVM never generates code that does this, it is always
695  // safe to set.
696  OutStreamer->EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
697  } else if (TT.isOSBinFormatCOFF()) {
698  if (MMI->usesMSVCFloatingPoint()) {
699  // In Windows' libcmt.lib, there is a file which is linked in only if the
700  // symbol _fltused is referenced. Linking this in causes some
701  // side-effects:
702  //
703  // 1. For x86-32, it will set the x87 rounding mode to 53-bit instead of
704  // 64-bit mantissas at program start.
705  //
706  // 2. It links in support routines for floating-point in scanf and printf.
707  //
708  // MSVC emits an undefined reference to _fltused when there are any
709  // floating point operations in the program (including calls). A program
710  // that only has: `scanf("%f", &global_float);` may fail to trigger this,
711  // but oh well...that's a documented issue.
713  (TT.getArch() == Triple::x86) ? "__fltused" : "_fltused";
714  MCSymbol *S = MMI->getContext().getOrCreateSymbol(SymbolName);
715  OutStreamer->EmitSymbolAttribute(S, MCSA_Global);
716  return;
717  }
718  emitStackMaps(SM);
719  } else if (TT.isOSBinFormatELF()) {
720  emitStackMaps(SM);
722  }
723 }
724 
725 //===----------------------------------------------------------------------===//
726 // Target Registry Stuff
727 //===----------------------------------------------------------------------===//
728 
729 // Force static initialization.
730 extern "C" void LLVMInitializeX86AsmPrinter() {
733 }
unsigned getTargetFlags() const
MO_SECREL - On a symbol operand this indicates that the immediate is the offset from beginning of sec...
Definition: X86BaseInfo.h:265
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:212
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:38
bool is64Bit() const
Is this x86_64? (disregarding specific ABI / programming model)
Definition: X86Subtarget.h:536
SymbolListTy GetGVStubList()
Accessor methods to return the set of stubs in sorted order.
S_NON_LAZY_SYMBOL_POINTERS - Section with non-lazy symbol pointers.
Definition: MachO.h:131
static bool printAsmMRegister(X86AsmPrinter &P, const MachineOperand &MO, char Mode, raw_ostream &O)
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
void LLVMInitializeX86AsmPrinter()
bool hasLocalLinkage() const
Definition: GlobalValue.h:435
static const char * getRegisterName(unsigned RegNo)
MO_COFFSTUB - On a symbol operand "FOO", this indicates that the reference is actually to the "...
Definition: X86BaseInfo.h:275
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:93
SI Whole Quad Mode
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:321
This class represents lattice values for constants.
Definition: AllocatorList.h:23
PointerTy getPointer() const
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
MO_TLSLD - On a symbol operand this indicates that the immediate is the offset of the GOT entry with ...
Definition: X86BaseInfo.h:173
virtual void AddBlankLine()
AddBlankLine - Emit a blank line to a .s file to pretty it up.
Definition: MCStreamer.h:330
MO_TLVP_PIC_BASE - On a symbol operand this indicates that the immediate is some TLS offset from the ...
Definition: X86BaseInfo.h:259
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
Definition: Triple.h:615
MCContext & OutContext
This is the context for the output file that we are streaming.
Definition: AsmPrinter.h:88
const X86InstrInfo * getInstrInfo() const override
Definition: X86Subtarget.h:495
unsigned getReg() const
getReg - Returns the register number.
bool runOnMachineFunction(MachineFunction &F) override
runOnMachineFunction - Emit the function body.
Address of indexed Jump Table for switch.
unsigned Reg
bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS) override
PrintAsmOperand - Print out an operand for an inline asm expression.
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:96
MachineModuleInfo & getMMI() const
MO_GOTPCREL - On a symbol operand this indicates that the immediate is offset to the GOT entry for th...
Definition: X86BaseInfo.h:147
MO_DTPOFF - On a symbol operand this indicates that the immediate is the offset of the GOT entry with...
Definition: X86BaseInfo.h:216
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
No complex type; simple scalar variable.
Definition: COFF.h:259
return AArch64::GPR64RegClass contains(Reg)
X86MachineFunctionInfo - This class is derived from MachineFunction and contains private X86 target-s...
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
MCContext & getContext() const
Definition: MCStreamer.h:250
MO_DARWIN_NONLAZY_PIC_BASE - On a symbol operand "FOO", this indicates that the reference is actually...
Definition: X86BaseInfo.h:247
Definition: BitVector.h:937
constexpr char SymbolName[]
Key for Kernel::Metadata::mSymbolName.
This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...
bool isPICStyleRIPRel() const
Definition: X86Subtarget.h:795
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
Name of external global symbol.
static bool isMem(const MachineInstr &MI, unsigned Op)
Definition: X86InstrInfo.h:122
void emitXRayTable()
Emit a table with all XRay instrumentation points.
void EmitFunctionBody()
This method emits the body and trailer for a function.
.code16 (X86) / .code 16 (ARM)
Definition: MCDirectives.h:51
MCSectionMachO * getMachOSection(StringRef Segment, StringRef Section, unsigned TypeAndAttributes, unsigned Reserved2, SectionKind K, const char *BeginSymName=nullptr)
Return the MCSection for the specified mach-o section.
Definition: MCContext.cpp:276
MO_GOT - On a symbol operand this indicates that the immediate is the offset to the GOT entry for the...
Definition: X86BaseInfo.h:132
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:292
IntType getInt() const
const MCContext & getContext() const
bool isArch32Bit() const
Test whether the architecture is 32-bit.
Definition: Triple.cpp:1288
MO_GOTTPOFF - On a symbol operand this indicates that the immediate is the offset of the GOT entry wi...
Definition: X86BaseInfo.h:191
RegisterAsmPrinter - Helper template for registering a target specific assembly printer, for use in the target machine initialization function.
static void emitNonLazySymbolPointer(MCStreamer &OutStreamer, MCSymbol *StubLabel, MachineModuleInfoImpl::StubValueTy &MCSym)
Type is formed as (base + (derived << SCT_COMPLEX_TYPE_SHIFT))
Definition: COFF.h:265
void printOffset(int64_t Offset, raw_ostream &OS) const
This is just convenient handler for printing offsets.
MCCodeEmitter * createMCCodeEmitter(const MCInstrInfo &II, const MCRegisterInfo &MRI, MCContext &Ctx) const
createMCCodeEmitter - Create a target specific code emitter.
virtual void EmitIntValue(uint64_t Value, unsigned Size)
Special case of EmitValue that avoids the client having to pass in a MCExpr for constant integers...
Definition: MCStreamer.cpp:128
MO_DARWIN_NONLAZY - On a symbol operand "FOO", this indicates that the reference is actually to the "...
Definition: X86BaseInfo.h:242
void EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:159
MachineModuleInfo * MMI
This is a pointer to the current MachineModuleInfo.
Definition: AsmPrinter.h:99
unsigned getCodeViewFlag() const
Returns the CodeView Version by checking module flags.
Definition: Module.cpp:468
MCContext & getContext() const
static void emitNonLazyStubs(MachineModuleInfo *MMI, MCStreamer &OutStreamer)
#define P(N)
Address of a global value.
Streaming machine code generation interface.
Definition: MCStreamer.h:188
MCSymbol * CurrentFnSym
The symbol for the current function.
Definition: AsmPrinter.h:112
MO_GOT_ABSOLUTE_ADDRESS - On a symbol operand, this represents a relocation of: SYMBOL_LABEL + [...
Definition: X86BaseInfo.h:120
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:84
PointerIntPair - This class implements a pair of a pointer and small integer.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
bool isOSBinFormatCOFF() const
Tests whether the OS uses the COFF binary format.
Definition: Triple.h:620
Metadata * getModuleFlag(StringRef Key) const
Return the corresponding value if Key appears in module flags, otherwise return null.
Definition: Module.cpp:310
MO_GOTNTPOFF - On a symbol operand this indicates that the immediate is the offset of the GOT entry w...
Definition: X86BaseInfo.h:232
MO_TLVP - On a symbol operand this indicates that the immediate is some TLS offset.
Definition: X86BaseInfo.h:253
virtual void SwitchSection(MCSection *Section, const MCExpr *Subsection=nullptr)
Set the current section where code is being emitted to Section.
const GlobalValue * getGlobal() const
MO_TLSLDM - On a symbol operand this indicates that the immediate is the offset of the GOT entry with...
Definition: X86BaseInfo.h:183
void EmitAlignment(unsigned NumBits, const GlobalObject *GV=nullptr) const
Emit an alignment directive to the specified power of two boundary.
void EmitFunctionBodyEnd() override
Targets can override this to emit stuff after the last basic block in the function.
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:81
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:78
virtual bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute)=0
Add the given Attribute to Symbol.
bool hasInternalLinkage() const
Definition: GlobalValue.h:433
Address of a basic block.
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
.subsections_via_symbols (MachO)
Definition: MCDirectives.h:50
const Triple & getTargetTriple() const
MO_NTPOFF - On a symbol operand this indicates that the immediate is the negative thread-pointer offs...
Definition: X86BaseInfo.h:224
Ty & getObjFileInfo()
Keep track of various per-function pieces of information for backends that would like to do so...
bool isOSBinFormatMachO() const
Tests whether the environment is MachO.
Definition: Triple.h:625
const Target & getTarget() const
void emitStackMaps(StackMaps &SM)
Emit the stack maps.
virtual MCSymbol * GetCPISymbol(unsigned CPID) const
Return the symbol for the specified constant pool entry.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:43
MO_TLSGD - On a symbol operand this indicates that the immediate is the offset of the GOT entry with ...
Definition: X86BaseInfo.h:163
const X86RegisterInfo * getRegisterInfo() const override
Definition: X86Subtarget.h:505
MO_TPOFF - On a symbol operand this indicates that the immediate is the thread-pointer offset for the...
Definition: X86BaseInfo.h:208
void EmitFunctionBodyStart() override
Targets can override this to emit stuff before the first basic block in the function.
MCSymbol * GetBlockAddressSymbol(const BlockAddress *BA) const
Return the MCSymbol used to satisfy BlockAddress uses of the specified basic block.
InlineAsm::AsmDialect getInlineAsmDialect() const
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:441
void serializeToFaultMapSection()
Definition: FaultMaps.cpp:49
MachineOperand class - Representation of each machine instruction operand.
Module.h This file contains the declarations for the Module class.
void EmitStartOfAsmFile(Module &M) override
This virtual method can be overridden by targets that want to emit something at the start of their fi...
.indirect_symbol (MachO)
Definition: MCDirectives.h:32
static SectionKind getMetadata()
Definition: SectionKind.h:178
EnvironmentType getEnvironment() const
getEnvironment - Get the parsed environment type of this triple.
Definition: Triple.h:310
virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS)
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant...
bool isTargetWin32() const
Definition: X86Subtarget.h:792
int64_t getImm() const
const Function & getFunction() const
Return the LLVM function that this machine code represents.
unsigned getX86SubSuperRegister(unsigned, unsigned, bool High=false)
Returns the sub or super register of a specific X86 register.
bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS) override
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant as...
Representation of each machine instruction.
Definition: MachineInstr.h:63
MO_GOTOFF - On a symbol operand this indicates that the immediate is the offset to the location of th...
Definition: X86BaseInfo.h:139
void SetupMachineFunction(MachineFunction &MF)
This should be called when a new MachineFunction is being processed from runOnMachineFunction.
MO_INDNTPOFF - On a symbol operand this indicates that the immediate is the absolute address of the G...
Definition: X86BaseInfo.h:200
.type _foo,
Definition: MCDirectives.h:30
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:123
bool isArch64Bit() const
Test whether the architecture is 64-bit.
Definition: Triple.cpp:1284
int64_t getOffset() const
Return the offset from the symbol in this operand.
const BlockAddress * getBlockAddress() const
AddrSegmentReg - The operand # of the segment in the memory operand.
Definition: X86BaseInfo.h:38
void EmitEndOfAsmFile(Module &M) override
This virtual method can be overridden by targets that want to emit something at the end of their file...
bool usesMSVCFloatingPoint() const
virtual void print(raw_ostream &OS, const Module *M) const
print - Print out the internal state of the pass.
Definition: Pass.cpp:128
bool isTargetCOFF() const
Definition: X86Subtarget.h:749
Target & getTheX86_32Target()
uint32_t Size
Definition: Profile.cpp:46
const Module * getModule() const
MachineModuleInfoMachO - This is a MachineModuleInfoImpl implementation for MachO targets...
bool isReg() const
isReg - Tests if this is a MO_Register operand.
std::vector< std::pair< MCSymbol *, StubValueTy > > SymbolListTy
MO_PLT - On a symbol operand this indicates that the immediate is offset to the PLT entry of symbol n...
Definition: X86BaseInfo.h:154
const std::string & getModuleInlineAsm() const
Get any module-scope inline assembly blocks.
Definition: Module.h:248
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:202
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:388
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:250
MCSymbol * getPICBaseSymbol() const
getPICBaseSymbol - Return a function-local symbol to represent the PIC base.
virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc())
Emit a label for Symbol into the current section.
Definition: MCStreamer.cpp:351
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:65
MO_PIC_BASE_OFFSET - On a symbol operand this indicates that the immediate should get the value of th...
Definition: X86BaseInfo.h:125
IRTranslator LLVM IR MI
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
Address of indexed Constant in Constant Pool.
X86AsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > Streamer)
MCSymbol * getSymbolWithGlobalValueBase(const GlobalValue *GV, StringRef Suffix) const
Return the MCSymbol for a private symbol with global value name as its base, with the specified suffi...
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:413
Target & getTheX86_64Target()
MachineOperandType getType() const
getType - Returns the MachineOperandType for this operand.
const X86Subtarget & getSubtarget() const
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx)
Definition: MCExpr.cpp:163
MO_DLLIMPORT - On a symbol operand "FOO", this indicates that the reference is actually to the "__imp...
Definition: X86BaseInfo.h:237
This class contains meta information specific to a module.
void print(raw_ostream &OS, const MCAsmInfo *MAI) const
print - Print the value to the stream OS.
Definition: MCSymbol.cpp:59
A function that returns a base type.
Definition: COFF.h:261