LLVM  14.0.0git
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 "X86Subtarget.h"
22 #include "llvm/BinaryFormat/COFF.h"
23 #include "llvm/BinaryFormat/ELF.h"
27 #include "llvm/IR/DerivedTypes.h"
28 #include "llvm/IR/InlineAsm.h"
29 #include "llvm/IR/Mangler.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/IR/Type.h"
32 #include "llvm/MC/MCCodeEmitter.h"
33 #include "llvm/MC/MCContext.h"
34 #include "llvm/MC/MCExpr.h"
35 #include "llvm/MC/MCSectionCOFF.h"
36 #include "llvm/MC/MCSectionELF.h"
37 #include "llvm/MC/MCSectionMachO.h"
38 #include "llvm/MC/MCStreamer.h"
39 #include "llvm/MC/MCSymbol.h"
40 #include "llvm/Support/Debug.h"
45 
46 using namespace llvm;
47 
49  std::unique_ptr<MCStreamer> Streamer)
50  : AsmPrinter(TM, std::move(Streamer)), SM(*this), FM(*this) {}
51 
52 //===----------------------------------------------------------------------===//
53 // Primitive Helper Functions.
54 //===----------------------------------------------------------------------===//
55 
56 /// runOnMachineFunction - Emit the function body.
57 ///
59  Subtarget = &MF.getSubtarget<X86Subtarget>();
60 
61  SMShadowTracker.startFunction(MF);
62  CodeEmitter.reset(TM.getTarget().createMCCodeEmitter(
63  *Subtarget->getInstrInfo(), *Subtarget->getRegisterInfo(),
64  MF.getContext()));
65 
66  EmitFPOData =
67  Subtarget->isTargetWin32() && MF.getMMI().getModule()->getCodeViewFlag();
68 
70 
71  if (Subtarget->isTargetCOFF()) {
72  bool Local = MF.getFunction().hasLocalLinkage();
73  OutStreamer->BeginCOFFSymbolDef(CurrentFnSym);
74  OutStreamer->EmitCOFFSymbolStorageClass(
78  OutStreamer->EndCOFFSymbolDef();
79  }
80 
81  // Emit the rest of the function body.
83 
84  // Emit the XRay table for this function.
85  emitXRayTable();
86 
87  EmitFPOData = false;
88 
89  // We didn't modify anything.
90  return false;
91 }
92 
94  if (EmitFPOData) {
95  if (auto *XTS =
96  static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer()))
97  XTS->emitFPOProc(
100  }
101 }
102 
104  if (EmitFPOData) {
105  if (auto *XTS =
106  static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer()))
107  XTS->emitFPOEndProc();
108  }
109 }
110 
111 /// PrintSymbolOperand - Print a raw symbol reference operand. This handles
112 /// jump tables, constant pools, global address and external symbols, all of
113 /// which print to a label with various suffixes for relocation types etc.
114 void X86AsmPrinter::PrintSymbolOperand(const MachineOperand &MO,
115  raw_ostream &O) {
116  switch (MO.getType()) {
117  default: llvm_unreachable("unknown symbol type!");
119  GetCPISymbol(MO.getIndex())->print(O, MAI);
120  printOffset(MO.getOffset(), O);
121  break;
123  const GlobalValue *GV = MO.getGlobal();
124 
125  MCSymbol *GVSym;
128  GVSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
129  else
130  GVSym = getSymbolPreferLocal(*GV);
131 
132  // Handle dllimport linkage.
134  GVSym = OutContext.getOrCreateSymbol(Twine("__imp_") + GVSym->getName());
135  else if (MO.getTargetFlags() == X86II::MO_COFFSTUB)
136  GVSym =
137  OutContext.getOrCreateSymbol(Twine(".refptr.") + GVSym->getName());
138 
141  MCSymbol *Sym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
143  MMI->getObjFileInfo<MachineModuleInfoMachO>().getGVStubEntry(Sym);
144  if (!StubSym.getPointer())
146  !GV->hasInternalLinkage());
147  }
148 
149  // If the name begins with a dollar-sign, enclose it in parens. We do this
150  // to avoid having it look like an integer immediate to the assembler.
151  if (GVSym->getName()[0] != '$')
152  GVSym->print(O, MAI);
153  else {
154  O << '(';
155  GVSym->print(O, MAI);
156  O << ')';
157  }
158  printOffset(MO.getOffset(), O);
159  break;
160  }
161  }
162 
163  switch (MO.getTargetFlags()) {
164  default:
165  llvm_unreachable("Unknown target flag on GV operand");
166  case X86II::MO_NO_FLAG: // No flag.
167  break;
169  case X86II::MO_DLLIMPORT:
170  case X86II::MO_COFFSTUB:
171  // These affect the name of the symbol, not any suffix.
172  break;
174  O << " + [.-";
175  MF->getPICBaseSymbol()->print(O, MAI);
176  O << ']';
177  break;
180  O << '-';
181  MF->getPICBaseSymbol()->print(O, MAI);
182  break;
183  case X86II::MO_TLSGD: O << "@TLSGD"; break;
184  case X86II::MO_TLSLD: O << "@TLSLD"; break;
185  case X86II::MO_TLSLDM: O << "@TLSLDM"; break;
186  case X86II::MO_GOTTPOFF: O << "@GOTTPOFF"; break;
187  case X86II::MO_INDNTPOFF: O << "@INDNTPOFF"; break;
188  case X86II::MO_TPOFF: O << "@TPOFF"; break;
189  case X86II::MO_DTPOFF: O << "@DTPOFF"; break;
190  case X86II::MO_NTPOFF: O << "@NTPOFF"; break;
191  case X86II::MO_GOTNTPOFF: O << "@GOTNTPOFF"; break;
192  case X86II::MO_GOTPCREL: O << "@GOTPCREL"; break;
193  case X86II::MO_GOT: O << "@GOT"; break;
194  case X86II::MO_GOTOFF: O << "@GOTOFF"; break;
195  case X86II::MO_PLT: O << "@PLT"; break;
196  case X86II::MO_TLVP: O << "@TLVP"; break;
198  O << "@TLVP" << '-';
199  MF->getPICBaseSymbol()->print(O, MAI);
200  break;
201  case X86II::MO_SECREL: O << "@SECREL32"; break;
202  }
203 }
204 
205 void X86AsmPrinter::PrintOperand(const MachineInstr *MI, unsigned OpNo,
206  raw_ostream &O) {
207  const MachineOperand &MO = MI->getOperand(OpNo);
208  const bool IsATT = MI->getInlineAsmDialect() == InlineAsm::AD_ATT;
209  switch (MO.getType()) {
210  default: llvm_unreachable("unknown operand type!");
212  if (IsATT)
213  O << '%';
215  return;
216  }
217 
219  if (IsATT)
220  O << '$';
221  O << MO.getImm();
222  return;
223 
226  switch (MI->getInlineAsmDialect()) {
227  case InlineAsm::AD_ATT:
228  O << '$';
229  break;
230  case InlineAsm::AD_Intel:
231  O << "offset ";
232  break;
233  }
234  PrintSymbolOperand(MO, O);
235  break;
236  }
239  Sym->print(O, MAI);
240  break;
241  }
242  }
243 }
244 
245 /// PrintModifiedOperand - Print subregisters based on supplied modifier,
246 /// deferring to PrintOperand() if no modifier was supplied or if operand is not
247 /// a register.
248 void X86AsmPrinter::PrintModifiedOperand(const MachineInstr *MI, unsigned OpNo,
249  raw_ostream &O, const char *Modifier) {
250  const MachineOperand &MO = MI->getOperand(OpNo);
251  if (!Modifier || MO.getType() != MachineOperand::MO_Register)
252  return PrintOperand(MI, OpNo, O);
253  if (MI->getInlineAsmDialect() == InlineAsm::AD_ATT)
254  O << '%';
255  Register Reg = MO.getReg();
256  if (strncmp(Modifier, "subreg", strlen("subreg")) == 0) {
257  unsigned Size = (strcmp(Modifier+6,"64") == 0) ? 64 :
258  (strcmp(Modifier+6,"32") == 0) ? 32 :
259  (strcmp(Modifier+6,"16") == 0) ? 16 : 8;
261  }
263 }
264 
265 /// PrintPCRelImm - This is used to print an immediate value that ends up
266 /// being encoded as a pc-relative value. These print slightly differently, for
267 /// example, a $ is not emitted.
268 void X86AsmPrinter::PrintPCRelImm(const MachineInstr *MI, unsigned OpNo,
269  raw_ostream &O) {
270  const MachineOperand &MO = MI->getOperand(OpNo);
271  switch (MO.getType()) {
272  default: llvm_unreachable("Unknown pcrel immediate operand");
274  // pc-relativeness was handled when computing the value in the reg.
275  PrintOperand(MI, OpNo, O);
276  return;
278  O << MO.getImm();
279  return;
281  PrintSymbolOperand(MO, O);
282  return;
283  }
284 }
285 
286 void X86AsmPrinter::PrintLeaMemReference(const MachineInstr *MI, unsigned OpNo,
287  raw_ostream &O, const char *Modifier) {
288  const MachineOperand &BaseReg = MI->getOperand(OpNo + X86::AddrBaseReg);
289  const MachineOperand &IndexReg = MI->getOperand(OpNo + X86::AddrIndexReg);
290  const MachineOperand &DispSpec = MI->getOperand(OpNo + X86::AddrDisp);
291 
292  // If we really don't want to print out (rip), don't.
293  bool HasBaseReg = BaseReg.getReg() != 0;
294  if (HasBaseReg && Modifier && !strcmp(Modifier, "no-rip") &&
295  BaseReg.getReg() == X86::RIP)
296  HasBaseReg = false;
297 
298  // HasParenPart - True if we will print out the () part of the mem ref.
299  bool HasParenPart = IndexReg.getReg() || HasBaseReg;
300 
301  switch (DispSpec.getType()) {
302  default:
303  llvm_unreachable("unknown operand type!");
305  int DispVal = DispSpec.getImm();
306  if (DispVal || !HasParenPart)
307  O << DispVal;
308  break;
309  }
312  PrintSymbolOperand(DispSpec, O);
313  break;
314  }
315 
316  if (Modifier && strcmp(Modifier, "H") == 0)
317  O << "+8";
318 
319  if (HasParenPart) {
320  assert(IndexReg.getReg() != X86::ESP &&
321  "X86 doesn't allow scaling by ESP");
322 
323  O << '(';
324  if (HasBaseReg)
325  PrintModifiedOperand(MI, OpNo + X86::AddrBaseReg, O, Modifier);
326 
327  if (IndexReg.getReg()) {
328  O << ',';
329  PrintModifiedOperand(MI, OpNo + X86::AddrIndexReg, O, Modifier);
330  unsigned ScaleVal = MI->getOperand(OpNo + X86::AddrScaleAmt).getImm();
331  if (ScaleVal != 1)
332  O << ',' << ScaleVal;
333  }
334  O << ')';
335  }
336 }
337 
338 void X86AsmPrinter::PrintMemReference(const MachineInstr *MI, unsigned OpNo,
339  raw_ostream &O, const char *Modifier) {
340  assert(isMem(*MI, OpNo) && "Invalid memory reference!");
341  const MachineOperand &Segment = MI->getOperand(OpNo + X86::AddrSegmentReg);
342  if (Segment.getReg()) {
343  PrintModifiedOperand(MI, OpNo + X86::AddrSegmentReg, O, Modifier);
344  O << ':';
345  }
346  PrintLeaMemReference(MI, OpNo, O, Modifier);
347 }
348 
349 
350 void X86AsmPrinter::PrintIntelMemReference(const MachineInstr *MI,
351  unsigned OpNo, raw_ostream &O,
352  const char *Modifier) {
353  const MachineOperand &BaseReg = MI->getOperand(OpNo + X86::AddrBaseReg);
354  unsigned ScaleVal = MI->getOperand(OpNo + X86::AddrScaleAmt).getImm();
355  const MachineOperand &IndexReg = MI->getOperand(OpNo + X86::AddrIndexReg);
356  const MachineOperand &DispSpec = MI->getOperand(OpNo + X86::AddrDisp);
357  const MachineOperand &SegReg = MI->getOperand(OpNo + X86::AddrSegmentReg);
358 
359  // If we really don't want to print out (rip), don't.
360  bool HasBaseReg = BaseReg.getReg() != 0;
361  if (HasBaseReg && Modifier && !strcmp(Modifier, "no-rip") &&
362  BaseReg.getReg() == X86::RIP)
363  HasBaseReg = false;
364 
365  // If this has a segment register, print it.
366  if (SegReg.getReg()) {
367  PrintOperand(MI, OpNo + X86::AddrSegmentReg, O);
368  O << ':';
369  }
370 
371  O << '[';
372 
373  bool NeedPlus = false;
374  if (HasBaseReg) {
375  PrintOperand(MI, OpNo + X86::AddrBaseReg, O);
376  NeedPlus = true;
377  }
378 
379  if (IndexReg.getReg()) {
380  if (NeedPlus) O << " + ";
381  if (ScaleVal != 1)
382  O << ScaleVal << '*';
383  PrintOperand(MI, OpNo + X86::AddrIndexReg, O);
384  NeedPlus = true;
385  }
386 
387  if (!DispSpec.isImm()) {
388  if (NeedPlus) O << " + ";
389  PrintOperand(MI, OpNo + X86::AddrDisp, O);
390  } else {
391  int64_t DispVal = DispSpec.getImm();
392  if (DispVal || (!IndexReg.getReg() && !HasBaseReg)) {
393  if (NeedPlus) {
394  if (DispVal > 0)
395  O << " + ";
396  else {
397  O << " - ";
398  DispVal = -DispVal;
399  }
400  }
401  O << DispVal;
402  }
403  }
404  O << ']';
405 }
406 
407 static bool printAsmMRegister(const X86AsmPrinter &P, const MachineOperand &MO,
408  char Mode, raw_ostream &O) {
409  Register Reg = MO.getReg();
410  bool EmitPercent = MO.getParent()->getInlineAsmDialect() == InlineAsm::AD_ATT;
411 
412  if (!X86::GR8RegClass.contains(Reg) &&
413  !X86::GR16RegClass.contains(Reg) &&
414  !X86::GR32RegClass.contains(Reg) &&
415  !X86::GR64RegClass.contains(Reg))
416  return true;
417 
418  switch (Mode) {
419  default: return true; // Unknown mode.
420  case 'b': // Print QImode register
422  break;
423  case 'h': // Print QImode high register
424  Reg = getX86SubSuperRegister(Reg, 8, true);
425  break;
426  case 'w': // Print HImode register
428  break;
429  case 'k': // Print SImode register
431  break;
432  case 'V':
433  EmitPercent = false;
435  case 'q':
436  // Print 64-bit register names if 64-bit integer registers are available.
437  // Otherwise, print 32-bit register names.
438  Reg = getX86SubSuperRegister(Reg, P.getSubtarget().is64Bit() ? 64 : 32);
439  break;
440  }
441 
442  if (EmitPercent)
443  O << '%';
444 
446  return false;
447 }
448 
449 static bool printAsmVRegister(const MachineOperand &MO, char Mode,
450  raw_ostream &O) {
451  Register Reg = MO.getReg();
452  bool EmitPercent = MO.getParent()->getInlineAsmDialect() == InlineAsm::AD_ATT;
453 
454  unsigned Index;
455  if (X86::VR128XRegClass.contains(Reg))
456  Index = Reg - X86::XMM0;
457  else if (X86::VR256XRegClass.contains(Reg))
458  Index = Reg - X86::YMM0;
459  else if (X86::VR512RegClass.contains(Reg))
460  Index = Reg - X86::ZMM0;
461  else
462  return true;
463 
464  switch (Mode) {
465  default: // Unknown mode.
466  return true;
467  case 'x': // Print V4SFmode register
468  Reg = X86::XMM0 + Index;
469  break;
470  case 't': // Print V8SFmode register
471  Reg = X86::YMM0 + Index;
472  break;
473  case 'g': // Print V16SFmode register
474  Reg = X86::ZMM0 + Index;
475  break;
476  }
477 
478  if (EmitPercent)
479  O << '%';
480 
482  return false;
483 }
484 
485 /// PrintAsmOperand - Print out an operand for an inline asm expression.
486 ///
487 bool X86AsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
488  const char *ExtraCode, raw_ostream &O) {
489  // Does this asm operand have a single letter operand modifier?
490  if (ExtraCode && ExtraCode[0]) {
491  if (ExtraCode[1] != 0) return true; // Unknown modifier.
492 
493  const MachineOperand &MO = MI->getOperand(OpNo);
494 
495  switch (ExtraCode[0]) {
496  default:
497  // See if this is a generic print operand
498  return AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, O);
499  case 'a': // This is an address. Currently only 'i' and 'r' are expected.
500  switch (MO.getType()) {
501  default:
502  return true;
504  O << MO.getImm();
505  return false;
509  llvm_unreachable("unexpected operand type!");
511  PrintSymbolOperand(MO, O);
512  if (Subtarget->isPICStyleRIPRel())
513  O << "(%rip)";
514  return false;
516  O << '(';
517  PrintOperand(MI, OpNo, O);
518  O << ')';
519  return false;
520  }
521 
522  case 'c': // Don't print "$" before a global var name or constant.
523  switch (MO.getType()) {
524  default:
525  PrintOperand(MI, OpNo, O);
526  break;
528  O << MO.getImm();
529  break;
533  llvm_unreachable("unexpected operand type!");
535  PrintSymbolOperand(MO, O);
536  break;
537  }
538  return false;
539 
540  case 'A': // Print '*' before a register (it must be a register)
541  if (MO.isReg()) {
542  O << '*';
543  PrintOperand(MI, OpNo, O);
544  return false;
545  }
546  return true;
547 
548  case 'b': // Print QImode register
549  case 'h': // Print QImode high register
550  case 'w': // Print HImode register
551  case 'k': // Print SImode register
552  case 'q': // Print DImode register
553  case 'V': // Print native register without '%'
554  if (MO.isReg())
555  return printAsmMRegister(*this, MO, ExtraCode[0], O);
556  PrintOperand(MI, OpNo, O);
557  return false;
558 
559  case 'x': // Print V4SFmode register
560  case 't': // Print V8SFmode register
561  case 'g': // Print V16SFmode register
562  if (MO.isReg())
563  return printAsmVRegister(MO, ExtraCode[0], O);
564  PrintOperand(MI, OpNo, O);
565  return false;
566 
567  case 'P': // This is the operand of a call, treat specially.
568  PrintPCRelImm(MI, OpNo, O);
569  return false;
570 
571  case 'n': // Negate the immediate or print a '-' before the operand.
572  // Note: this is a temporary solution. It should be handled target
573  // independently as part of the 'MC' work.
574  if (MO.isImm()) {
575  O << -MO.getImm();
576  return false;
577  }
578  O << '-';
579  }
580  }
581 
582  PrintOperand(MI, OpNo, O);
583  return false;
584 }
585 
587  const char *ExtraCode,
588  raw_ostream &O) {
589  if (ExtraCode && ExtraCode[0]) {
590  if (ExtraCode[1] != 0) return true; // Unknown modifier.
591 
592  switch (ExtraCode[0]) {
593  default: return true; // Unknown modifier.
594  case 'b': // Print QImode register
595  case 'h': // Print QImode high register
596  case 'w': // Print HImode register
597  case 'k': // Print SImode register
598  case 'q': // Print SImode register
599  // These only apply to registers, ignore on mem.
600  break;
601  case 'H':
602  if (MI->getInlineAsmDialect() == InlineAsm::AD_Intel) {
603  return true; // Unsupported modifier in Intel inline assembly.
604  } else {
605  PrintMemReference(MI, OpNo, O, "H");
606  }
607  return false;
608  case 'P': // Don't print @PLT, but do print as memory.
609  if (MI->getInlineAsmDialect() == InlineAsm::AD_Intel) {
610  PrintIntelMemReference(MI, OpNo, O, "no-rip");
611  } else {
612  PrintMemReference(MI, OpNo, O, "no-rip");
613  }
614  return false;
615  }
616  }
617  if (MI->getInlineAsmDialect() == InlineAsm::AD_Intel) {
618  PrintIntelMemReference(MI, OpNo, O, nullptr);
619  } else {
620  PrintMemReference(MI, OpNo, O, nullptr);
621  }
622  return false;
623 }
624 
626  const Triple &TT = TM.getTargetTriple();
627 
628  if (TT.isOSBinFormatELF()) {
629  // Assemble feature flags that may require creation of a note section.
630  unsigned FeatureFlagsAnd = 0;
631  if (M.getModuleFlag("cf-protection-branch"))
632  FeatureFlagsAnd |= ELF::GNU_PROPERTY_X86_FEATURE_1_IBT;
633  if (M.getModuleFlag("cf-protection-return"))
634  FeatureFlagsAnd |= ELF::GNU_PROPERTY_X86_FEATURE_1_SHSTK;
635 
636  if (FeatureFlagsAnd) {
637  // Emit a .note.gnu.property section with the flags.
638  if (!TT.isArch32Bit() && !TT.isArch64Bit())
639  llvm_unreachable("CFProtection used on invalid architecture!");
640  MCSection *Cur = OutStreamer->getCurrentSectionOnly();
642  ".note.gnu.property", ELF::SHT_NOTE, ELF::SHF_ALLOC);
643  OutStreamer->SwitchSection(Nt);
644 
645  // Emitting note header.
646  const int WordSize = TT.isArch64Bit() && !TT.isX32() ? 8 : 4;
647  emitAlignment(WordSize == 4 ? Align(4) : Align(8));
648  OutStreamer->emitIntValue(4, 4 /*size*/); // data size for "GNU\0"
649  OutStreamer->emitIntValue(8 + WordSize, 4 /*size*/); // Elf_Prop size
650  OutStreamer->emitIntValue(ELF::NT_GNU_PROPERTY_TYPE_0, 4 /*size*/);
651  OutStreamer->emitBytes(StringRef("GNU", 4)); // note name
652 
653  // Emitting an Elf_Prop for the CET properties.
655  OutStreamer->emitInt32(4); // data size
656  OutStreamer->emitInt32(FeatureFlagsAnd); // data
657  emitAlignment(WordSize == 4 ? Align(4) : Align(8)); // padding
658 
659  OutStreamer->endSection(Nt);
660  OutStreamer->SwitchSection(Cur);
661  }
662  }
663 
664  if (TT.isOSBinFormatMachO())
665  OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
666 
667  if (TT.isOSBinFormatCOFF()) {
668  // Emit an absolute @feat.00 symbol. This appears to be some kind of
669  // compiler features bitfield read by link.exe.
670  MCSymbol *S = MMI->getContext().getOrCreateSymbol(StringRef("@feat.00"));
671  OutStreamer->BeginCOFFSymbolDef(S);
672  OutStreamer->EmitCOFFSymbolStorageClass(COFF::IMAGE_SYM_CLASS_STATIC);
673  OutStreamer->EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_NULL);
674  OutStreamer->EndCOFFSymbolDef();
675  int64_t Feat00Flags = 0;
676 
677  if (TT.getArch() == Triple::x86) {
678  // According to the PE-COFF spec, the LSB of this value marks the object
679  // for "registered SEH". This means that all SEH handler entry points
680  // must be registered in .sxdata. Use of any unregistered handlers will
681  // cause the process to terminate immediately. LLVM does not know how to
682  // register any SEH handlers, so its object files should be safe.
683  Feat00Flags |= 1;
684  }
685 
686  if (M.getModuleFlag("cfguard")) {
687  Feat00Flags |= 0x800; // Object is CFG-aware.
688  }
689 
690  if (M.getModuleFlag("ehcontguard")) {
691  Feat00Flags |= 0x4000; // Object also has EHCont.
692  }
693 
694  OutStreamer->emitSymbolAttribute(S, MCSA_Global);
695  OutStreamer->emitAssignment(
696  S, MCConstantExpr::create(Feat00Flags, MMI->getContext()));
697  }
698  OutStreamer->emitSyntaxDirective();
699 
700  // If this is not inline asm and we're in 16-bit
701  // mode prefix assembly with .code16.
702  bool is16 = TT.getEnvironment() == Triple::CODE16;
703  if (M.getModuleInlineAsm().empty() && is16)
704  OutStreamer->emitAssemblerFlag(MCAF_Code16);
705 }
706 
707 static void
710  // L_foo$stub:
711  OutStreamer.emitLabel(StubLabel);
712  // .indirect_symbol _foo
713  OutStreamer.emitSymbolAttribute(MCSym.getPointer(), MCSA_IndirectSymbol);
714 
715  if (MCSym.getInt())
716  // External to current translation unit.
717  OutStreamer.emitIntValue(0, 4/*size*/);
718  else
719  // Internal to current translation unit.
720  //
721  // When we place the LSDA into the TEXT section, the type info
722  // pointers need to be indirect and pc-rel. We accomplish this by
723  // using NLPs; however, sometimes the types are local to the file.
724  // We need to fill in the value for the NLP in those cases.
725  OutStreamer.emitValue(
726  MCSymbolRefExpr::create(MCSym.getPointer(), OutStreamer.getContext()),
727  4 /*size*/);
728 }
729 
730 static void emitNonLazyStubs(MachineModuleInfo *MMI, MCStreamer &OutStreamer) {
731 
732  MachineModuleInfoMachO &MMIMacho =
734 
735  // Output stubs for dynamically-linked functions.
737 
738  // Output stubs for external and common global variables.
739  Stubs = MMIMacho.GetGVStubList();
740  if (!Stubs.empty()) {
741  OutStreamer.SwitchSection(MMI->getContext().getMachOSection(
742  "__IMPORT", "__pointers", MachO::S_NON_LAZY_SYMBOL_POINTERS,
744 
745  for (auto &Stub : Stubs)
746  emitNonLazySymbolPointer(OutStreamer, Stub.first, Stub.second);
747 
748  Stubs.clear();
749  OutStreamer.AddBlankLine();
750  }
751 }
752 
754  const Triple &TT = TM.getTargetTriple();
755 
756  emitAsanMemaccessSymbols(M);
757 
758  if (TT.isOSBinFormatMachO()) {
759  // Mach-O uses non-lazy symbol stubs to encode per-TU information into
760  // global table for symbol lookup.
762 
763  // Emit stack and fault map information.
764  emitStackMaps(SM);
766 
767  // This flag tells the linker that no global symbols contain code that fall
768  // through to other global symbols (e.g. an implementation of multiple entry
769  // points). If this doesn't occur, the linker can safely perform dead code
770  // stripping. Since LLVM never generates code that does this, it is always
771  // safe to set.
772  OutStreamer->emitAssemblerFlag(MCAF_SubsectionsViaSymbols);
773  } else if (TT.isOSBinFormatCOFF()) {
774  if (MMI->usesMSVCFloatingPoint()) {
775  // In Windows' libcmt.lib, there is a file which is linked in only if the
776  // symbol _fltused is referenced. Linking this in causes some
777  // side-effects:
778  //
779  // 1. For x86-32, it will set the x87 rounding mode to 53-bit instead of
780  // 64-bit mantissas at program start.
781  //
782  // 2. It links in support routines for floating-point in scanf and printf.
783  //
784  // MSVC emits an undefined reference to _fltused when there are any
785  // floating point operations in the program (including calls). A program
786  // that only has: `scanf("%f", &global_float);` may fail to trigger this,
787  // but oh well...that's a documented issue.
789  (TT.getArch() == Triple::x86) ? "__fltused" : "_fltused";
791  OutStreamer->emitSymbolAttribute(S, MCSA_Global);
792  return;
793  }
794  emitStackMaps(SM);
795  } else if (TT.isOSBinFormatELF()) {
796  emitStackMaps(SM);
798  }
799 }
800 
801 //===----------------------------------------------------------------------===//
802 // Target Registry Stuff
803 //===----------------------------------------------------------------------===//
804 
805 // Force static initialization.
809 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::X86II::MO_TLVP
@ MO_TLVP
MO_TLVP - On a symbol operand this indicates that the immediate is some TLS offset.
Definition: X86BaseInfo.h:548
llvm::X86II::MO_DARWIN_NONLAZY
@ MO_DARWIN_NONLAZY
MO_DARWIN_NONLAZY - On a symbol operand "FOO", this indicates that the reference is actually to the "...
Definition: X86BaseInfo.h:537
llvm::X86II::MO_GOTTPOFF
@ MO_GOTTPOFF
MO_GOTTPOFF - On a symbol operand this indicates that the immediate is the offset of the GOT entry wi...
Definition: X86BaseInfo.h:486
llvm::ELF::GNU_PROPERTY_X86_FEATURE_1_AND
@ GNU_PROPERTY_X86_FEATURE_1_AND
Definition: ELF.h:1528
llvm::X86AsmPrinter::emitFunctionBodyEnd
void emitFunctionBodyEnd() override
Targets can override this to emit stuff after the last basic block in the function.
Definition: X86AsmPrinter.cpp:103
llvm::MachineOperand::MO_BlockAddress
@ MO_BlockAddress
Address of a basic block.
Definition: MachineOperand.h:63
MachineModuleInfoImpls.h
llvm::X86MachineFunctionInfo::getArgumentStackSize
unsigned getArgumentStackSize() const
Definition: X86MachineFunctionInfo.h:179
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:103
llvm::MachineOperand::MO_Immediate
@ MO_Immediate
Immediate operand.
Definition: MachineOperand.h:53
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
Reg
unsigned Reg
Definition: MachineSink.cpp:1566
llvm::AsmPrinter::printOffset
void printOffset(int64_t Offset, raw_ostream &OS) const
This is just convenient handler for printing offsets.
Definition: AsmPrinter.cpp:3095
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::X86AsmPrinter::runOnMachineFunction
bool runOnMachineFunction(MachineFunction &MF) override
runOnMachineFunction - Emit the function body.
Definition: X86AsmPrinter.cpp:58
llvm::SectionKind::getMetadata
static SectionKind getMetadata()
Definition: SectionKind.h:182
llvm::N86::ESP
@ ESP
Definition: X86MCTargetDesc.h:51
llvm::MachineModuleInfo::getContext
const MCContext & getContext() const
Definition: MachineModuleInfo.h:167
X86Subtarget.h
llvm::COFF::IMAGE_SYM_CLASS_STATIC
@ IMAGE_SYM_CLASS_STATIC
Static.
Definition: COFF.h:210
emitNonLazyStubs
static void emitNonLazyStubs(MachineModuleInfo *MMI, MCStreamer &OutStreamer)
Definition: X86AsmPrinter.cpp:730
llvm::MachineOperand::getGlobal
const GlobalValue * getGlobal() const
Definition: MachineOperand.h:563
llvm::MachineFunction::getContext
MCContext & getContext() const
Definition: MachineFunction.h:578
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::getTheX86_64Target
Target & getTheX86_64Target()
Definition: X86TargetInfo.cpp:17
llvm::X86Subtarget::getInstrInfo
const X86InstrInfo * getInstrInfo() const override
Definition: X86Subtarget.h:560
llvm::X86II::MO_INDNTPOFF
@ MO_INDNTPOFF
MO_INDNTPOFF - On a symbol operand this indicates that the immediate is the absolute address of the G...
Definition: X86BaseInfo.h:495
MCCodeEmitter.h
llvm::Triple::x86
@ x86
Definition: Triple.h:83
llvm::InlineAsm::AD_ATT
@ AD_ATT
Definition: InlineAsm.h:34
llvm::AsmPrinter::MAI
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:88
llvm::MCConstantExpr::create
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition: MCExpr.cpp:194
contains
return AArch64::GPR64RegClass contains(Reg)
MCSectionELF.h
InlineAsm.h
llvm::Module::getCodeViewFlag
unsigned getCodeViewFlag() const
Returns the CodeView Version by checking module flags.
Definition: Module.cpp:571
llvm::MachineOperand::getBlockAddress
const BlockAddress * getBlockAddress() const
Definition: MachineOperand.h:568
llvm::X86II::MO_GOT_ABSOLUTE_ADDRESS
@ MO_GOT_ABSOLUTE_ADDRESS
MO_GOT_ABSOLUTE_ADDRESS - On a symbol operand, this represents a relocation of: SYMBOL_LABEL + [.
Definition: X86BaseInfo.h:415
llvm::X86Subtarget
Definition: X86Subtarget.h:52
llvm::X86II::MO_TLSGD
@ MO_TLSGD
MO_TLSGD - On a symbol operand this indicates that the immediate is the offset of the GOT entry with ...
Definition: X86BaseInfo.h:458
llvm::COFF::IMAGE_SYM_CLASS_EXTERNAL
@ IMAGE_SYM_CLASS_EXTERNAL
External symbol.
Definition: COFF.h:209
ErrorHandling.h
MCSectionCOFF.h
llvm::X86II::MO_TLSLDM
@ MO_TLSLDM
MO_TLSLDM - On a symbol operand this indicates that the immediate is the offset of the GOT entry with...
Definition: X86BaseInfo.h:478
llvm::COFF::SCT_COMPLEX_TYPE_SHIFT
@ SCT_COMPLEX_TYPE_SHIFT
Type is formed as (base + (derived << SCT_COMPLEX_TYPE_SHIFT))
Definition: COFF.h:265
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:45
COFF.h
llvm::AsmPrinter::emitStackMaps
void emitStackMaps(StackMaps &SM)
Emit the stack maps.
Definition: AsmPrinter.cpp:3434
llvm::MachineModuleInfoImpl::SymbolListTy
std::vector< std::pair< MCSymbol *, StubValueTy > > SymbolListTy
Definition: MachineModuleInfo.h:63
llvm::MCStreamer::emitValue
void emitValue(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc())
Definition: MCStreamer.cpp:177
llvm::MachineModuleInfoImpl::StubValueTy
PointerIntPair< MCSymbol *, 1, bool > StubValueTy
Definition: MachineModuleInfo.h:62
llvm::X86::AddrSegmentReg
@ AddrSegmentReg
AddrSegmentReg - The operand # of the segment in the memory operand.
Definition: X86BaseInfo.h:38
Module.h
llvm::X86II::MO_SECREL
@ MO_SECREL
MO_SECREL - On a symbol operand this indicates that the immediate is the offset from beginning of sec...
Definition: X86BaseInfo.h:560
llvm::Target::createMCCodeEmitter
MCCodeEmitter * createMCCodeEmitter(const MCInstrInfo &II, const MCRegisterInfo &MRI, MCContext &Ctx) const
createMCCodeEmitter - Create a target specific code emitter.
Definition: TargetRegistry.h:510
llvm::X86II::MO_TPOFF
@ MO_TPOFF
MO_TPOFF - On a symbol operand this indicates that the immediate is the thread-pointer offset for the...
Definition: X86BaseInfo.h:503
llvm::X86Subtarget::isPICStyleRIPRel
bool isPICStyleRIPRel() const
Definition: X86Subtarget.h:891
llvm::X86AsmPrinter::emitStartOfAsmFile
void emitStartOfAsmFile(Module &M) override
This virtual method can be overridden by targets that want to emit something at the start of their fi...
Definition: X86AsmPrinter.cpp:625
llvm::MCStreamer::AddBlankLine
virtual void AddBlankLine()
AddBlankLine - Emit a blank line to a .s file to pretty it up.
Definition: MCStreamer.h:363
llvm::X86::AddrDisp
@ AddrDisp
Definition: X86BaseInfo.h:35
llvm::ELF::GNU_PROPERTY_X86_FEATURE_1_SHSTK
@ GNU_PROPERTY_X86_FEATURE_1_SHSTK
Definition: ELF.h:1548
llvm::FaultMaps::serializeToFaultMapSection
void serializeToFaultMapSection()
Definition: FaultMaps.cpp:45
X86AsmPrinter.h
llvm::X86II::MO_GOTOFF
@ MO_GOTOFF
MO_GOTOFF - On a symbol operand this indicates that the immediate is the offset to the location of th...
Definition: X86BaseInfo.h:434
llvm::MachineOperand::getOffset
int64_t getOffset() const
Return the offset from the symbol in this operand.
Definition: MachineOperand.h:600
llvm::ELF::SHT_NOTE
@ SHT_NOTE
Definition: ELF.h:916
llvm::ELF::GNU_PROPERTY_X86_FEATURE_1_IBT
@ GNU_PROPERTY_X86_FEATURE_1_IBT
Definition: ELF.h:1547
llvm::MachineOperand::MO_Register
@ MO_Register
Register operand.
Definition: MachineOperand.h:52
X86ATTInstPrinter.h
llvm::MCContext::getMachOSection
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:420
llvm::X86II::MO_GOT
@ MO_GOT
MO_GOT - On a symbol operand this indicates that the immediate is the offset to the GOT entry for the...
Definition: X86BaseInfo.h:427
MachineValueType.h
llvm::X86AsmPrinter::PrintAsmOperand
bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &O) override
PrintAsmOperand - Print out an operand for an inline asm expression.
Definition: X86AsmPrinter.cpp:487
llvm::MCStreamer
Streaming machine code generation interface.
Definition: MCStreamer.h:199
X86MachineFunctionInfo.h
llvm::MCContext::getOrCreateSymbol
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:191
llvm::X86II::MO_COFFSTUB
@ MO_COFFSTUB
MO_COFFSTUB - On a symbol operand "FOO", this indicates that the reference is actually to the "....
Definition: X86BaseInfo.h:570
ELF.h
TargetMachine.h
llvm::X86::AddrBaseReg
@ AddrBaseReg
Definition: X86BaseInfo.h:32
llvm::MachineOperand::MO_GlobalAddress
@ MO_GlobalAddress
Address of a global value.
Definition: MachineOperand.h:62
llvm::X86II::MO_PLT
@ MO_PLT
MO_PLT - On a symbol operand this indicates that the immediate is offset to the PLT entry of symbol n...
Definition: X86BaseInfo.h:449
llvm::MachineOperand::getImm
int64_t getImm() const
Definition: MachineOperand.h:537
llvm::MachineFunction::getInfo
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
Definition: MachineFunction.h:724
llvm::X86Subtarget::isTargetWin32
bool isTargetWin32() const
Definition: X86Subtarget.h:888
llvm::AsmPrinter::OutStreamer
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:97
llvm::X86Subtarget::getRegisterInfo
const X86RegisterInfo * getRegisterInfo() const override
Definition: X86Subtarget.h:570
MCContext.h
llvm::X86II::MO_GOTPCREL
@ MO_GOTPCREL
MO_GOTPCREL - On a symbol operand this indicates that the immediate is offset to the GOT entry for th...
Definition: X86BaseInfo.h:442
Y
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
llvm::Triple::CODE16
@ CODE16
Definition: Triple.h:214
MCSectionMachO.h
llvm::MCStreamer::emitLabel
virtual void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc())
Emit a label for Symbol into the current section.
Definition: MCStreamer.cpp:415
llvm::AsmPrinter::SetupMachineFunction
virtual void SetupMachineFunction(MachineFunction &MF)
This should be called when a new MachineFunction is being processed from runOnMachineFunction.
Definition: AsmPrinter.cpp:1962
MCSymbol.h
llvm::MCContext::getELFSection
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:540
llvm::MCAF_Code16
@ MCAF_Code16
.code16 (X86) / .code 16 (ARM)
Definition: MCDirectives.h:53
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:49
llvm::MachineModuleInfo
This class contains meta information specific to a module.
Definition: MachineModuleInfo.h:78
llvm::X86II::MO_NO_FLAG
@ MO_NO_FLAG
Definition: X86BaseInfo.h:410
llvm::AsmPrinter::CurrentFnSym
MCSymbol * CurrentFnSym
The symbol for the current function.
Definition: AsmPrinter.h:119
llvm::AsmPrinter::emitAlignment
void emitAlignment(Align Alignment, const GlobalObject *GV=nullptr) const
Emit an alignment directive to the specified power of two boundary.
Definition: AsmPrinter.cpp:2450
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::GlobalValue::hasInternalLinkage
bool hasInternalLinkage() const
Definition: GlobalValue.h:443
llvm::MCSymbol::getName
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:198
llvm::X86II::MO_TLVP_PIC_BASE
@ MO_TLVP_PIC_BASE
MO_TLVP_PIC_BASE - On a symbol operand this indicates that the immediate is some TLS offset from the ...
Definition: X86BaseInfo.h:554
Align
uint64_t Align
Definition: ELFObjHandler.cpp:83
llvm::MachineOperand::getParent
MachineInstr * getParent()
getParent - Return the instruction that this operand belongs to.
Definition: MachineOperand.h:238
llvm::MCSymbol::print
void print(raw_ostream &OS, const MCAsmInfo *MAI) const
print - Print the value to the stream OS.
Definition: MCSymbol.cpp:59
emitNonLazySymbolPointer
static void emitNonLazySymbolPointer(MCStreamer &OutStreamer, MCSymbol *StubLabel, MachineModuleInfoImpl::StubValueTy &MCSym)
Definition: X86AsmPrinter.cpp:708
Type.h
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
llvm::MachO::S_NON_LAZY_SYMBOL_POINTERS
@ S_NON_LAZY_SYMBOL_POINTERS
S_NON_LAZY_SYMBOL_POINTERS - Section with non-lazy symbol pointers.
Definition: MachO.h:137
printAsmVRegister
static bool printAsmVRegister(const MachineOperand &MO, char Mode, raw_ostream &O)
Definition: X86AsmPrinter.cpp:449
llvm::X86AsmPrinter
Definition: X86AsmPrinter.h:28
llvm::PointerIntPair::getPointer
PointerTy getPointer() const
Definition: PointerIntPair.h:59
llvm::MachineFunction::getMMI
MachineModuleInfo & getMMI() const
Definition: MachineFunction.h:577
llvm::MachineFunction::getSubtarget
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Definition: MachineFunction.h:626
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:192
llvm::getTheX86_32Target
Target & getTheX86_32Target()
Definition: X86TargetInfo.cpp:13
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::X86II::MO_DARWIN_NONLAZY_PIC_BASE
@ MO_DARWIN_NONLAZY_PIC_BASE
MO_DARWIN_NONLAZY_PIC_BASE - On a symbol operand "FOO", this indicates that the reference is actually...
Definition: X86BaseInfo.h:542
llvm::X86::AddrScaleAmt
@ AddrScaleAmt
Definition: X86BaseInfo.h:33
llvm::MachineOperand::getTargetFlags
unsigned getTargetFlags() const
Definition: MachineOperand.h:221
llvm::MCAF_SubsectionsViaSymbols
@ MCAF_SubsectionsViaSymbols
.subsections_via_symbols (MachO)
Definition: MCDirectives.h:52
llvm::AsmPrinter::GetCPISymbol
virtual MCSymbol * GetCPISymbol(unsigned CPID) const
Return the symbol for the specified constant pool entry.
Definition: AsmPrinter.cpp:3125
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
llvm::MachineOperand::isReg
bool isReg() const
isReg - Tests if this is a MO_Register operand.
Definition: MachineOperand.h:321
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::X86II::MO_GOTNTPOFF
@ MO_GOTNTPOFF
MO_GOTNTPOFF - On a symbol operand this indicates that the immediate is the offset of the GOT entry w...
Definition: X86BaseInfo.h:527
llvm::X86II::MO_PIC_BASE_OFFSET
@ MO_PIC_BASE_OFFSET
MO_PIC_BASE_OFFSET - On a symbol operand this indicates that the immediate should get the value of th...
Definition: X86BaseInfo.h:420
LLVM_EXTERNAL_VISIBILITY
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:132
llvm::getX86SubSuperRegister
MCRegister getX86SubSuperRegister(MCRegister, unsigned, bool High=false)
Returns the sub or super register of a specific X86 register.
Definition: X86MCTargetDesc.cpp:786
X86TargetStreamer.h
llvm::AsmPrinter::GetBlockAddressSymbol
MCSymbol * GetBlockAddressSymbol(const BlockAddress *BA) const
Return the MCSymbol used to satisfy BlockAddress uses of the specified basic block.
Definition: AsmPrinter.cpp:3116
llvm::AsmPrinter::getSymbolPreferLocal
MCSymbol * getSymbolPreferLocal(const GlobalValue &GV) const
Similar to getSymbol() but preferred for references.
Definition: AsmPrinter.cpp:490
llvm::X86Subtarget::isTargetCOFF
bool isTargetCOFF() const
Definition: X86Subtarget.h:849
llvm::PointerIntPair::getInt
IntType getInt() const
Definition: PointerIntPair.h:61
MachineConstantPool.h
llvm::X86II::MO_DTPOFF
@ MO_DTPOFF
MO_DTPOFF - On a symbol operand this indicates that the immediate is the offset of the GOT entry with...
Definition: X86BaseInfo.h:511
llvm::X86AsmPrinter::X86AsmPrinter
X86AsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > Streamer)
Definition: X86AsmPrinter.cpp:48
llvm::MachineOperand::getType
MachineOperandType getType() const
getType - Returns the MachineOperandType for this operand.
Definition: MachineOperand.h:219
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::AsmPrinter::getSymbol
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:486
llvm::X86ATTInstPrinter::getRegisterName
static const char * getRegisterName(unsigned RegNo)
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:79
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1609
llvm::MCStreamer::emitIntValue
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:133
llvm::GlobalValue::hasLocalLinkage
bool hasLocalLinkage() const
Definition: GlobalValue.h:445
llvm::AsmPrinter::MF
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:100
llvm::AsmPrinter::OutContext
MCContext & OutContext
This is the context for the output file that we are streaming.
Definition: AsmPrinter.h:92
Mode
SI Whole Quad Mode
Definition: SIWholeQuadMode.cpp:262
llvm::X86MachineFunctionInfo
X86MachineFunctionInfo - This class is derived from MachineFunction and contains private X86 target-s...
Definition: X86MachineFunctionInfo.h:25
llvm::MachineInstr::getInlineAsmDialect
InlineAsm::AsmDialect getInlineAsmDialect() const
Definition: MachineInstr.cpp:804
llvm::MachineOperand::getReg
Register getReg() const
getReg - Returns the register number.
Definition: MachineOperand.h:360
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::MachineFunction
Definition: MachineFunction.h:230
Mangler.h
llvm::MachineOperand::MO_JumpTableIndex
@ MO_JumpTableIndex
Address of indexed Jump Table for switch.
Definition: MachineOperand.h:60
llvm::X86II::MO_DLLIMPORT
@ MO_DLLIMPORT
MO_DLLIMPORT - On a symbol operand "FOO", this indicates that the reference is actually to the "__imp...
Definition: X86BaseInfo.h:532
llvm::ELF::SHF_ALLOC
@ SHF_ALLOC
Definition: ELF.h:988
llvm::X86AsmPrinter::PrintAsmMemoryOperand
bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &O) override
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant as...
Definition: X86AsmPrinter.cpp:586
llvm::InlineAsm::AD_Intel
@ AD_Intel
Definition: InlineAsm.h:35
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
this
Analysis the ScalarEvolution expression for r is this
Definition: README.txt:8
LLVMInitializeX86AsmPrinter
LLVM_EXTERNAL_VISIBILITY void LLVMInitializeX86AsmPrinter()
Definition: X86AsmPrinter.cpp:806
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
llvm::X86AsmPrinter::emitEndOfAsmFile
void emitEndOfAsmFile(Module &M) override
This virtual method can be overridden by targets that want to emit something at the end of their file...
Definition: X86AsmPrinter.cpp:753
llvm::MCSection
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
printAsmMRegister
static bool printAsmMRegister(const X86AsmPrinter &P, const MachineOperand &MO, char Mode, raw_ostream &O)
Definition: X86AsmPrinter.cpp:407
llvm::MCSA_IndirectSymbol
@ MCSA_IndirectSymbol
.indirect_symbol (MachO)
Definition: MCDirectives.h:34
LLVM_FALLTHROUGH
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:273
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::AsmPrinter::MMI
MachineModuleInfo * MMI
This is a pointer to the current MachineModuleInfo.
Definition: AsmPrinter.h:103
llvm::AMDGPU::HSAMD::Kernel::Key::SymbolName
constexpr char SymbolName[]
Key for Kernel::Metadata::mSymbolName.
Definition: AMDGPUMetadata.h:381
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::X86AsmPrinter::emitFunctionBodyStart
void emitFunctionBodyStart() override
Targets can override this to emit stuff before the first basic block in the function.
Definition: X86AsmPrinter.cpp:93
std
Definition: BitVector.h:838
llvm::MachineFunction::getFunction
Function & getFunction()
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:592
llvm::MCStreamer::emitSymbolAttribute
virtual bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute)=0
Add the given Attribute to Symbol.
llvm::MachineOperand::MO_ExternalSymbol
@ MO_ExternalSymbol
Name of external global symbol.
Definition: MachineOperand.h:61
llvm::MachineOperand::getIndex
int getIndex() const
Definition: MachineOperand.h:557
llvm::MachineModuleInfoMachO::GetGVStubList
SymbolListTy GetGVStubList()
Accessor methods to return the set of stubs in sorted order.
Definition: MachineModuleInfoImpls.h:55
llvm::X86II::MO_TLSLD
@ MO_TLSLD
MO_TLSLD - On a symbol operand this indicates that the immediate is the offset of the GOT entry with ...
Definition: X86BaseInfo.h:468
llvm::AsmPrinter
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:82
llvm::MCSymbolRefExpr::create
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:385
llvm::MCSA_Global
@ MCSA_Global
.type _foo, @gnu_unique_object
Definition: MCDirectives.h:30
llvm::MachineOperand::isImm
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
Definition: MachineOperand.h:323
llvm::X86TargetStreamer
X86 target streamer implementing x86-only assembly directives.
Definition: X86TargetStreamer.h:17
llvm::MachineFunction::getPICBaseSymbol
MCSymbol * getPICBaseSymbol() const
getPICBaseSymbol - Return a function-local symbol to represent the PIC base.
Definition: MachineFunction.cpp:693
X86BaseInfo.h
llvm::PointerIntPair
PointerIntPair - This class implements a pair of a pointer and small integer.
Definition: PointerIntPair.h:45
llvm::MCStreamer::getContext
MCContext & getContext() const
Definition: MCStreamer.h:280
llvm::AsmPrinter::TM
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:85
llvm::ELF::NT_GNU_PROPERTY_TYPE_0
@ NT_GNU_PROPERTY_TYPE_0
Definition: ELF.h:1520
llvm::COFF::IMAGE_SYM_DTYPE_NULL
@ IMAGE_SYM_DTYPE_NULL
No complex type; simple scalar variable.
Definition: COFF.h:259
llvm::AsmPrinter::getSymbolWithGlobalValueBase
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...
Definition: AsmPrinter.cpp:3166
llvm::AsmPrinter::getObjFileLowering
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:224
MCStreamer.h
llvm::AsmPrinter::emitFunctionBody
void emitFunctionBody()
This method emits the body and trailer for a function.
Definition: AsmPrinter.cpp:1242
llvm::TargetMachine::getTargetTriple
const Triple & getTargetTriple() const
Definition: TargetMachine.h:128
llvm::isMem
static bool isMem(const MachineInstr &MI, unsigned Op)
Definition: X86InstrInfo.h:123
DerivedTypes.h
TM
const char LLVMTargetMachineRef TM
Definition: PassBuilderBindings.cpp:47
llvm::AsmPrinter::emitXRayTable
void emitXRayTable()
Emit a table with all XRay instrumentation points.
Definition: AsmPrinter.cpp:3474
llvm::RegisterAsmPrinter
RegisterAsmPrinter - Helper template for registering a target specific assembly printer,...
Definition: TargetRegistry.h:1338
llvm::TargetMachine::getTarget
const Target & getTarget() const
Definition: TargetMachine.h:126
llvm::X86::AddrIndexReg
@ AddrIndexReg
Definition: X86BaseInfo.h:34
llvm::X86II::MO_NTPOFF
@ MO_NTPOFF
MO_NTPOFF - On a symbol operand this indicates that the immediate is the negative thread-pointer offs...
Definition: X86BaseInfo.h:519
llvm::COFF::IMAGE_SYM_DTYPE_FUNCTION
@ IMAGE_SYM_DTYPE_FUNCTION
A function that returns a base type.
Definition: COFF.h:261
X86InstrInfo.h
X86TargetInfo.h
TargetRegistry.h
llvm::MCStreamer::SwitchSection
virtual void SwitchSection(MCSection *Section, const MCExpr *Subsection=nullptr)
Set the current section where code is being emitted to Section.
Definition: MCStreamer.cpp:1212
MCExpr.h
llvm::MachineModuleInfo::getModule
const Module * getModule() const
Definition: MachineModuleInfo.h:174
Debug.h
llvm::AsmPrinter::PrintAsmOperand
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.
Definition: AsmPrinterInlineAsm.cpp:599
llvm::MachineModuleInfo::getObjFileInfo
Ty & getObjFileInfo()
Keep track of various per-module pieces of information for backends that would like to do so.
Definition: MachineModuleInfo.h:191
llvm::MachineModuleInfoMachO
MachineModuleInfoMachO - This is a MachineModuleInfoImpl implementation for MachO targets.
Definition: MachineModuleInfoImpls.h:28
llvm::MachineModuleInfo::usesMSVCFloatingPoint
bool usesMSVCFloatingPoint() const
Definition: MachineModuleInfo.h:206
llvm::MachineOperand::MO_ConstantPoolIndex
@ MO_ConstantPoolIndex
Address of indexed Constant in Constant Pool.
Definition: MachineOperand.h:58
TargetLoweringObjectFileImpl.h