LLVM  16.0.0git
MCMachOStreamer.cpp
Go to the documentation of this file.
1 //===- MCMachOStreamer.cpp - MachO Streamer -------------------------------===//
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 #include "llvm/ADT/DenseMap.h"
10 #include "llvm/ADT/SmallString.h"
11 #include "llvm/ADT/SmallVector.h"
12 #include "llvm/ADT/StringRef.h"
13 #include "llvm/MC/MCAsmBackend.h"
14 #include "llvm/MC/MCAssembler.h"
15 #include "llvm/MC/MCCodeEmitter.h"
16 #include "llvm/MC/MCContext.h"
17 #include "llvm/MC/MCDirectives.h"
18 #include "llvm/MC/MCExpr.h"
19 #include "llvm/MC/MCFixup.h"
20 #include "llvm/MC/MCFragment.h"
24 #include "llvm/MC/MCObjectWriter.h"
25 #include "llvm/MC/MCSection.h"
26 #include "llvm/MC/MCSectionMachO.h"
27 #include "llvm/MC/MCSymbol.h"
28 #include "llvm/MC/MCSymbolMachO.h"
29 #include "llvm/MC/MCValue.h"
30 #include "llvm/MC/SectionKind.h"
31 #include "llvm/MC/TargetRegistry.h"
32 #include "llvm/Support/Casting.h"
35 #include <cassert>
36 #include <vector>
37 
38 namespace llvm {
39 class MCInst;
40 class MCStreamer;
41 class MCSubtargetInfo;
42 class Triple;
43 } // namespace llvm
44 
45 using namespace llvm;
46 
47 namespace {
48 
49 class MCMachOStreamer : public MCObjectStreamer {
50 private:
51  /// LabelSections - true if each section change should emit a linker local
52  /// label for use in relocations for assembler local references. Obviates the
53  /// need for local relocations. False by default.
54  bool LabelSections;
55 
56  bool DWARFMustBeAtTheEnd;
57  bool CreatedADWARFSection;
58 
59  /// HasSectionLabel - map of which sections have already had a non-local
60  /// label emitted to them. Used so we don't emit extraneous linker local
61  /// labels in the middle of the section.
62  DenseMap<const MCSection*, bool> HasSectionLabel;
63 
64  void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &STI) override;
65 
66  void emitDataRegion(DataRegionData::KindTy Kind);
67  void emitDataRegionEnd();
68 
69 public:
70  MCMachOStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
71  std::unique_ptr<MCObjectWriter> OW,
72  std::unique_ptr<MCCodeEmitter> Emitter,
73  bool DWARFMustBeAtTheEnd, bool label)
74  : MCObjectStreamer(Context, std::move(MAB), std::move(OW),
75  std::move(Emitter)),
76  LabelSections(label), DWARFMustBeAtTheEnd(DWARFMustBeAtTheEnd),
77  CreatedADWARFSection(false) {}
78 
79  /// state management
80  void reset() override {
81  CreatedADWARFSection = false;
82  HasSectionLabel.clear();
84  }
85 
86  /// @name MCStreamer Interface
87  /// @{
88 
89  void changeSection(MCSection *Sect, const MCExpr *Subsect) override;
90  void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
91  void emitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
92  void emitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol) override;
93  void emitAssemblerFlag(MCAssemblerFlag Flag) override;
94  void emitLinkerOptions(ArrayRef<std::string> Options) override;
95  void emitDataRegion(MCDataRegionType Kind) override;
96  void emitVersionMin(MCVersionMinType Kind, unsigned Major, unsigned Minor,
97  unsigned Update, VersionTuple SDKVersion) override;
98  void emitBuildVersion(unsigned Platform, unsigned Major, unsigned Minor,
99  unsigned Update, VersionTuple SDKVersion) override;
100  void emitDarwinTargetVariantBuildVersion(unsigned Platform, unsigned Major,
101  unsigned Minor, unsigned Update,
102  VersionTuple SDKVersion) override;
103  void emitThumbFunc(MCSymbol *Func) override;
104  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
105  void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
106  void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
107  unsigned ByteAlignment) override;
108 
109  void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
110  Align ByteAlignment) override;
111  void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
112  uint64_t Size = 0, Align ByteAlignment = Align(1),
113  SMLoc Loc = SMLoc()) override;
114  void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
115  Align ByteAlignment = Align(1)) override;
116 
117  void emitIdent(StringRef IdentString) override {
118  llvm_unreachable("macho doesn't support this directive");
119  }
120 
121  void emitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) override {
122  getAssembler().getLOHContainer().addDirective(Kind, Args);
123  }
124  void emitCGProfileEntry(const MCSymbolRefExpr *From,
125  const MCSymbolRefExpr *To, uint64_t Count) override {
126  if (!From->getSymbol().isTemporary() && !To->getSymbol().isTemporary())
127  getAssembler().CGProfile.push_back({From, To, Count});
128  }
129 
130  void finishImpl() override;
131 
132  void finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE);
133  void finalizeCGProfile();
134  void createAddrSigSection();
135 };
136 
137 } // end anonymous namespace.
138 
139 static bool canGoAfterDWARF(const MCSectionMachO &MSec) {
140  // These sections are created by the assembler itself after the end of
141  // the .s file.
142  StringRef SegName = MSec.getSegmentName();
143  StringRef SecName = MSec.getName();
144 
145  if (SegName == "__LD" && SecName == "__compact_unwind")
146  return true;
147 
148  if (SegName == "__IMPORT") {
149  if (SecName == "__jump_table")
150  return true;
151 
152  if (SecName == "__pointers")
153  return true;
154  }
155 
156  if (SegName == "__TEXT" && SecName == "__eh_frame")
157  return true;
158 
159  if (SegName == "__DATA" && (SecName == "__nl_symbol_ptr" ||
160  SecName == "__thread_ptr"))
161  return true;
162  if (SegName == "__LLVM" && SecName == "__cg_profile")
163  return true;
164  return false;
165 }
166 
167 void MCMachOStreamer::changeSection(MCSection *Section,
168  const MCExpr *Subsection) {
169  // Change the section normally.
170  bool Created = changeSectionImpl(Section, Subsection);
171  const MCSectionMachO &MSec = *cast<MCSectionMachO>(Section);
172  StringRef SegName = MSec.getSegmentName();
173  if (SegName == "__DWARF")
174  CreatedADWARFSection = true;
175  else if (Created && DWARFMustBeAtTheEnd && !canGoAfterDWARF(MSec))
176  assert(!CreatedADWARFSection && "Creating regular section after DWARF");
177 
178  // Output a linker-local symbol so we don't need section-relative local
179  // relocations. The linker hates us when we do that.
180  if (LabelSections && !HasSectionLabel[Section] &&
181  !Section->getBeginSymbol()) {
182  MCSymbol *Label = getContext().createLinkerPrivateTempSymbol();
183  Section->setBeginSymbol(Label);
184  HasSectionLabel[Section] = true;
185  }
186 }
187 
188 void MCMachOStreamer::emitEHSymAttributes(const MCSymbol *Symbol,
189  MCSymbol *EHSymbol) {
190  getAssembler().registerSymbol(*Symbol);
191  if (Symbol->isExternal())
192  emitSymbolAttribute(EHSymbol, MCSA_Global);
193  if (cast<MCSymbolMachO>(Symbol)->isWeakDefinition())
194  emitSymbolAttribute(EHSymbol, MCSA_WeakDefinition);
195  if (Symbol->isPrivateExtern())
196  emitSymbolAttribute(EHSymbol, MCSA_PrivateExtern);
197 }
198 
199 void MCMachOStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) {
200  // We have to create a new fragment if this is an atom defining symbol,
201  // fragments cannot span atoms.
202  if (getAssembler().isSymbolLinkerVisible(*Symbol))
203  insert(new MCDataFragment());
204 
205  MCObjectStreamer::emitLabel(Symbol, Loc);
206 
207  // This causes the reference type flag to be cleared. Darwin 'as' was "trying"
208  // to clear the weak reference and weak definition bits too, but the
209  // implementation was buggy. For now we just try to match 'as', for
210  // diffability.
211  //
212  // FIXME: Cleanup this code, these bits should be emitted based on semantic
213  // properties, not on the order of definition, etc.
214  cast<MCSymbolMachO>(Symbol)->clearReferenceType();
215 }
216 
217 void MCMachOStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
218  MCValue Res;
219 
220  if (Value->evaluateAsRelocatable(Res, nullptr, nullptr)) {
221  if (const MCSymbolRefExpr *SymAExpr = Res.getSymA()) {
222  const MCSymbol &SymA = SymAExpr->getSymbol();
223  if (!Res.getSymB() && (SymA.getName() == "" || Res.getConstant() != 0))
224  cast<MCSymbolMachO>(Symbol)->setAltEntry();
225  }
226  }
228 }
229 
230 void MCMachOStreamer::emitDataRegion(DataRegionData::KindTy Kind) {
231  // Create a temporary label to mark the start of the data region.
232  MCSymbol *Start = getContext().createTempSymbol();
233  emitLabel(Start);
234  // Record the region for the object writer to use.
235  DataRegionData Data = { Kind, Start, nullptr };
236  std::vector<DataRegionData> &Regions = getAssembler().getDataRegions();
237  Regions.push_back(Data);
238 }
239 
240 void MCMachOStreamer::emitDataRegionEnd() {
241  std::vector<DataRegionData> &Regions = getAssembler().getDataRegions();
242  assert(!Regions.empty() && "Mismatched .end_data_region!");
243  DataRegionData &Data = Regions.back();
244  assert(!Data.End && "Mismatched .end_data_region!");
245  // Create a temporary label to mark the end of the data region.
246  Data.End = getContext().createTempSymbol();
247  emitLabel(Data.End);
248 }
249 
250 void MCMachOStreamer::emitAssemblerFlag(MCAssemblerFlag Flag) {
251  // Let the target do whatever target specific stuff it needs to do.
252  getAssembler().getBackend().handleAssemblerFlag(Flag);
253  // Do any generic stuff we need to do.
254  switch (Flag) {
255  case MCAF_SyntaxUnified: return; // no-op here.
256  case MCAF_Code16: return; // Change parsing mode; no-op here.
257  case MCAF_Code32: return; // Change parsing mode; no-op here.
258  case MCAF_Code64: return; // Change parsing mode; no-op here.
260  getAssembler().setSubsectionsViaSymbols(true);
261  return;
262  }
263 }
264 
265 void MCMachOStreamer::emitLinkerOptions(ArrayRef<std::string> Options) {
266  getAssembler().getLinkerOptions().push_back(Options);
267 }
268 
269 void MCMachOStreamer::emitDataRegion(MCDataRegionType Kind) {
270  switch (Kind) {
271  case MCDR_DataRegion:
272  emitDataRegion(DataRegionData::Data);
273  return;
274  case MCDR_DataRegionJT8:
275  emitDataRegion(DataRegionData::JumpTable8);
276  return;
277  case MCDR_DataRegionJT16:
278  emitDataRegion(DataRegionData::JumpTable16);
279  return;
280  case MCDR_DataRegionJT32:
281  emitDataRegion(DataRegionData::JumpTable32);
282  return;
283  case MCDR_DataRegionEnd:
284  emitDataRegionEnd();
285  return;
286  }
287 }
288 
289 void MCMachOStreamer::emitVersionMin(MCVersionMinType Kind, unsigned Major,
290  unsigned Minor, unsigned Update,
291  VersionTuple SDKVersion) {
292  getAssembler().setVersionMin(Kind, Major, Minor, Update, SDKVersion);
293 }
294 
295 void MCMachOStreamer::emitBuildVersion(unsigned Platform, unsigned Major,
296  unsigned Minor, unsigned Update,
297  VersionTuple SDKVersion) {
298  getAssembler().setBuildVersion((MachO::PlatformType)Platform, Major, Minor,
299  Update, SDKVersion);
300 }
301 
302 void MCMachOStreamer::emitDarwinTargetVariantBuildVersion(
303  unsigned Platform, unsigned Major, unsigned Minor, unsigned Update,
304  VersionTuple SDKVersion) {
305  getAssembler().setDarwinTargetVariantBuildVersion(
306  (MachO::PlatformType)Platform, Major, Minor, Update, SDKVersion);
307 }
308 
309 void MCMachOStreamer::emitThumbFunc(MCSymbol *Symbol) {
310  // Remember that the function is a thumb function. Fixup and relocation
311  // values will need adjusted.
312  getAssembler().setIsThumbFunc(Symbol);
313  cast<MCSymbolMachO>(Symbol)->setThumbFunc();
314 }
315 
316 bool MCMachOStreamer::emitSymbolAttribute(MCSymbol *Sym,
318  MCSymbolMachO *Symbol = cast<MCSymbolMachO>(Sym);
319 
320  // Indirect symbols are handled differently, to match how 'as' handles
321  // them. This makes writing matching .o files easier.
323  // Note that we intentionally cannot use the symbol data here; this is
324  // important for matching the string table that 'as' generates.
325  IndirectSymbolData ISD;
326  ISD.Symbol = Symbol;
327  ISD.Section = getCurrentSectionOnly();
328  getAssembler().getIndirectSymbols().push_back(ISD);
329  return true;
330  }
331 
332  // Adding a symbol attribute always introduces the symbol, note that an
333  // important side effect of calling registerSymbol here is to register
334  // the symbol with the assembler.
335  getAssembler().registerSymbol(*Symbol);
336 
337  // The implementation of symbol attributes is designed to match 'as', but it
338  // leaves much to desired. It doesn't really make sense to arbitrarily add and
339  // remove flags, but 'as' allows this (in particular, see .desc).
340  //
341  // In the future it might be worth trying to make these operations more well
342  // defined.
343  switch (Attribute) {
344  case MCSA_Invalid:
347  case MCSA_ELF_TypeObject:
348  case MCSA_ELF_TypeTLS:
349  case MCSA_ELF_TypeCommon:
350  case MCSA_ELF_TypeNoType:
352  case MCSA_Extern:
353  case MCSA_Hidden:
354  case MCSA_IndirectSymbol:
355  case MCSA_Internal:
356  case MCSA_Protected:
357  case MCSA_Weak:
358  case MCSA_Local:
359  case MCSA_LGlobal:
360  case MCSA_Exported:
361  case MCSA_Memtag:
362  return false;
363 
364  case MCSA_Global:
365  Symbol->setExternal(true);
366  // This effectively clears the undefined lazy bit, in Darwin 'as', although
367  // it isn't very consistent because it implements this as part of symbol
368  // lookup.
369  //
370  // FIXME: Cleanup this code, these bits should be emitted based on semantic
371  // properties, not on the order of definition, etc.
372  Symbol->setReferenceTypeUndefinedLazy(false);
373  break;
374 
375  case MCSA_LazyReference:
376  // FIXME: This requires -dynamic.
377  Symbol->setNoDeadStrip();
378  if (Symbol->isUndefined())
379  Symbol->setReferenceTypeUndefinedLazy(true);
380  break;
381 
382  // Since .reference sets the no dead strip bit, it is equivalent to
383  // .no_dead_strip in practice.
384  case MCSA_Reference:
385  case MCSA_NoDeadStrip:
386  Symbol->setNoDeadStrip();
387  break;
388 
389  case MCSA_SymbolResolver:
390  Symbol->setSymbolResolver();
391  break;
392 
393  case MCSA_AltEntry:
394  Symbol->setAltEntry();
395  break;
396 
397  case MCSA_PrivateExtern:
398  Symbol->setExternal(true);
399  Symbol->setPrivateExtern(true);
400  break;
401 
402  case MCSA_WeakReference:
403  // FIXME: This requires -dynamic.
404  if (Symbol->isUndefined())
405  Symbol->setWeakReference();
406  break;
407 
408  case MCSA_WeakDefinition:
409  // FIXME: 'as' enforces that this is defined and global. The manual claims
410  // it has to be in a coalesced section, but this isn't enforced.
411  Symbol->setWeakDefinition();
412  break;
413 
415  Symbol->setWeakDefinition();
416  Symbol->setWeakReference();
417  break;
418 
419  case MCSA_Cold:
420  Symbol->setCold();
421  break;
422  }
423 
424  return true;
425 }
426 
427 void MCMachOStreamer::emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
428  // Encode the 'desc' value into the lowest implementation defined bits.
429  getAssembler().registerSymbol(*Symbol);
430  cast<MCSymbolMachO>(Symbol)->setDesc(DescValue);
431 }
432 
433 void MCMachOStreamer::emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
434  unsigned ByteAlignment) {
435  // FIXME: Darwin 'as' does appear to allow redef of a .comm by itself.
436  assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
437 
438  getAssembler().registerSymbol(*Symbol);
439  Symbol->setExternal(true);
440  Symbol->setCommon(Size, ByteAlignment);
441 }
442 
443 void MCMachOStreamer::emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
445  // '.lcomm' is equivalent to '.zerofill'.
446  return emitZerofill(getContext().getObjectFileInfo()->getDataBSSSection(),
447  Symbol, Size, ByteAlignment);
448 }
449 
450 void MCMachOStreamer::emitZerofill(MCSection *Section, MCSymbol *Symbol,
452  SMLoc Loc) {
453  // On darwin all virtual sections have zerofill type. Disallow the usage of
454  // .zerofill in non-virtual functions. If something similar is needed, use
455  // .space or .zero.
456  if (!Section->isVirtualSection()) {
457  getContext().reportError(
458  Loc, "The usage of .zerofill is restricted to sections of "
459  "ZEROFILL type. Use .zero or .space instead.");
460  return; // Early returning here shouldn't harm. EmitZeros should work on any
461  // section.
462  }
463 
464  pushSection();
465  switchSection(Section);
466 
467  // The symbol may not be present, which only creates the section.
468  if (Symbol) {
469  emitValueToAlignment(ByteAlignment, 0, 1, 0);
470  emitLabel(Symbol);
471  emitZeros(Size);
472  }
473  popSection();
474 }
475 
476 // This should always be called with the thread local bss section. Like the
477 // .zerofill directive this doesn't actually switch sections on us.
478 void MCMachOStreamer::emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
479  uint64_t Size, Align ByteAlignment) {
480  emitZerofill(Section, Symbol, Size, ByteAlignment);
481 }
482 
483 void MCMachOStreamer::emitInstToData(const MCInst &Inst,
484  const MCSubtargetInfo &STI) {
485  MCDataFragment *DF = getOrCreateDataFragment();
486 
489  raw_svector_ostream VecOS(Code);
490  getAssembler().getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI);
491 
492  // Add the fixups and data.
493  for (MCFixup &Fixup : Fixups) {
494  Fixup.setOffset(Fixup.getOffset() + DF->getContents().size());
495  DF->getFixups().push_back(Fixup);
496  }
497  DF->setHasInstructions(STI);
498  DF->getContents().append(Code.begin(), Code.end());
499 }
500 
501 void MCMachOStreamer::finishImpl() {
502  emitFrames(&getAssembler().getBackend());
503 
504  // We have to set the fragment atom associations so we can relax properly for
505  // Mach-O.
506 
507  // First, scan the symbol table to build a lookup table from fragments to
508  // defining symbols.
510  for (const MCSymbol &Symbol : getAssembler().symbols()) {
511  if (getAssembler().isSymbolLinkerVisible(Symbol) && Symbol.isInSection() &&
512  !Symbol.isVariable()) {
513  // An atom defining symbol should never be internal to a fragment.
514  assert(Symbol.getOffset() == 0 &&
515  "Invalid offset in atom defining symbol!");
516  DefiningSymbolMap[Symbol.getFragment()] = &Symbol;
517  }
518  }
519 
520  // Set the fragment atom associations by tracking the last seen atom defining
521  // symbol.
522  for (MCSection &Sec : getAssembler()) {
523  const MCSymbol *CurrentAtom = nullptr;
524  for (MCFragment &Frag : Sec) {
525  if (const MCSymbol *Symbol = DefiningSymbolMap.lookup(&Frag))
526  CurrentAtom = Symbol;
527  Frag.setAtom(CurrentAtom);
528  }
529  }
530 
531  finalizeCGProfile();
532 
533  createAddrSigSection();
535 }
536 
537 void MCMachOStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE) {
538  const MCSymbol *S = &SRE->getSymbol();
539  bool Created;
540  getAssembler().registerSymbol(*S, &Created);
541  if (Created)
542  S->setExternal(true);
543 }
544 
545 void MCMachOStreamer::finalizeCGProfile() {
546  MCAssembler &Asm = getAssembler();
547  if (Asm.CGProfile.empty())
548  return;
549  for (MCAssembler::CGProfileEntry &E : Asm.CGProfile) {
550  finalizeCGProfileEntry(E.From);
551  finalizeCGProfileEntry(E.To);
552  }
553  // We can't write the section out until symbol indices are finalized which
554  // doesn't happen until after section layout. We need to create the section
555  // and set its size now so that it's accounted for in layout.
556  MCSection *CGProfileSection = Asm.getContext().getMachOSection(
557  "__LLVM", "__cg_profile", 0, SectionKind::getMetadata());
558  Asm.registerSection(*CGProfileSection);
559  auto *Frag = new MCDataFragment(CGProfileSection);
560  // For each entry, reserve space for 2 32-bit indices and a 64-bit count.
561  size_t SectionBytes =
562  Asm.CGProfile.size() * (2 * sizeof(uint32_t) + sizeof(uint64_t));
563  Frag->getContents().resize(SectionBytes);
564 }
565 
567  std::unique_ptr<MCAsmBackend> &&MAB,
568  std::unique_ptr<MCObjectWriter> &&OW,
569  std::unique_ptr<MCCodeEmitter> &&CE,
570  bool RelaxAll, bool DWARFMustBeAtTheEnd,
571  bool LabelSections) {
572  MCMachOStreamer *S =
573  new MCMachOStreamer(Context, std::move(MAB), std::move(OW), std::move(CE),
574  DWARFMustBeAtTheEnd, LabelSections);
575  const Triple &Target = Context.getTargetTriple();
576  S->emitVersionForTarget(
577  Target, Context.getObjectFileInfo()->getSDKVersion(),
578  Context.getObjectFileInfo()->getDarwinTargetVariantTriple(),
579  Context.getObjectFileInfo()->getDarwinTargetVariantSDKVersion());
580  if (RelaxAll)
581  S->getAssembler().setRelaxAll(true);
582  return S;
583 }
584 
585 // The AddrSig section uses a series of relocations to refer to the symbols that
586 // should be considered address-significant. The only interesting content of
587 // these relocations is their symbol; the type, length etc will be ignored by
588 // the linker. The reason we are not referring to the symbol indices directly is
589 // that those indices will be invalidated by tools that update the symbol table.
590 // Symbol relocations OTOH will have their indices updated by e.g. llvm-strip.
591 void MCMachOStreamer::createAddrSigSection() {
592  MCAssembler &Asm = getAssembler();
593  MCObjectWriter &writer = Asm.getWriter();
594  if (!writer.getEmitAddrsigSection())
595  return;
596  // Create the AddrSig section and first data fragment here as its layout needs
597  // to be computed immediately after in order for it to be exported correctly.
598  MCSection *AddrSigSection =
599  Asm.getContext().getObjectFileInfo()->getAddrSigSection();
600  Asm.registerSection(*AddrSigSection);
601  auto *Frag = new MCDataFragment(AddrSigSection);
602  // We will generate a series of pointer-sized symbol relocations at offset
603  // 0x0. Set the section size to be large enough to contain a single pointer
604  // (instead of emitting a zero-sized section) so these relocations are
605  // technically valid, even though we don't expect these relocations to
606  // actually be applied by the linker.
607  Frag->getContents().resize(8);
608 }
llvm::DataRegionData::Data
@ Data
Definition: MCAssembler.h:68
llvm::MCVersionMinType
MCVersionMinType
Definition: MCDirectives.h:68
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::MCDataRegionType
MCDataRegionType
Definition: MCDirectives.h:60
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
llvm::SectionKind::getMetadata
static SectionKind getMetadata()
Definition: SectionKind.h:188
llvm::MCObjectStreamer::emitLabel
void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
Definition: MCObjectStreamer.cpp:286
llvm::MCSymbol::isTemporary
bool isTemporary() const
isTemporary - Check if this is an assembler temporary symbol.
Definition: MCSymbol.h:215
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:76
llvm::Attribute
Definition: Attributes.h:67
llvm::MCLOHType
MCLOHType
Linker Optimization Hint Type.
Definition: MCLinkerOptimizationHint.h:33
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::lookup
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:197
StringRef.h
llvm::MCSA_ELF_TypeObject
@ MCSA_ELF_TypeObject
.type _foo, STT_OBJECT # aka @object
Definition: MCDirectives.h:25
MCCodeEmitter.h
MCDirectives.h
llvm::MCSA_Invalid
@ MCSA_Invalid
Not a valid directive.
Definition: MCDirectives.h:19
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:149
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1199
llvm::tgtok::Code
@ Code
Definition: TGLexer.h:50
llvm::DataRegionData::JumpTable32
@ JumpTable32
Definition: MCAssembler.h:68
ErrorHandling.h
MCFragment.h
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
MCAssembler.h
llvm::DataRegionData::JumpTable8
@ JumpTable8
Definition: MCAssembler.h:68
MCObjectFileInfo.h
DenseMap.h
llvm::createMachOStreamer
MCStreamer * createMachOStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll, bool DWARFMustBeAtTheEnd, bool LabelSections=false)
Definition: MCMachOStreamer.cpp:566
llvm::DataRegionData::KindTy
KindTy
Definition: MCAssembler.h:68
llvm::MCSA_ELF_TypeNoType
@ MCSA_ELF_TypeNoType
.type _foo, STT_NOTYPE # aka @notype
Definition: MCDirectives.h:28
llvm::MCInst
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
llvm::MCAssemblerFlag
MCAssemblerFlag
Definition: MCDirectives.h:52
llvm::MCObjectStreamer::reset
void reset() override
state management
Definition: MCObjectStreamer.cpp:179
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::MCSymbolAttr
MCSymbolAttr
Definition: MCDirectives.h:18
llvm::MCSA_Cold
@ MCSA_Cold
.cold (MachO)
Definition: MCDirectives.h:22
llvm::MCDR_DataRegionJT16
@ MCDR_DataRegionJT16
.data_region jt16
Definition: MCDirectives.h:63
llvm::MCSA_Local
@ MCSA_Local
.local (ELF)
Definition: MCDirectives.h:38
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::ARMBuildAttrs::Section
@ Section
Legacy Tags.
Definition: ARMBuildAttributes.h:82
llvm::MCSA_NoDeadStrip
@ MCSA_NoDeadStrip
.no_dead_strip (MachO)
Definition: MCDirectives.h:39
MCObjectStreamer.h
llvm::MCFragment
Definition: MCFragment.h:30
llvm::MCSA_Memtag
@ MCSA_Memtag
.memtag (ELF)
Definition: MCDirectives.h:49
llvm::MCStreamer
Streaming machine code generation interface.
Definition: MCStreamer.h:212
llvm::MCDR_DataRegion
@ MCDR_DataRegion
.data_region
Definition: MCDirectives.h:61
Emitter
dxil DXContainer Global Emitter
Definition: DXContainerGlobals.cpp:108
MCAsmBackend.h
llvm::SMLoc
Represents a location in source code.
Definition: SMLoc.h:23
SmallString.h
canGoAfterDWARF
static bool canGoAfterDWARF(const MCSectionMachO &MSec)
Definition: MCMachOStreamer.cpp:139
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::MCSA_Extern
@ MCSA_Extern
.extern (XCOFF)
Definition: MCDirectives.h:32
llvm::MCSA_AltEntry
@ MCSA_AltEntry
.alt_entry (MachO)
Definition: MCDirectives.h:41
llvm::MCSA_Protected
@ MCSA_Protected
.protected (ELF)
Definition: MCDirectives.h:43
MCContext.h
MCSectionMachO.h
MCSymbol.h
llvm::MCSA_LazyReference
@ MCSA_LazyReference
.lazy_reference (MachO)
Definition: MCDirectives.h:37
llvm::MCSA_LGlobal
@ MCSA_LGlobal
.lglobl (XCOFF)
Definition: MCDirectives.h:31
llvm::MCAF_Code16
@ MCAF_Code16
.code16 (X86) / .code 16 (ARM)
Definition: MCDirectives.h:55
false
Definition: StackSlotColoring.cpp:141
llvm::MCObjectStreamer
Streaming object file generation interface.
Definition: MCObjectStreamer.h:42
llvm::DataRegionData
Definition: MCAssembler.h:65
llvm::MCSA_ELF_TypeIndFunction
@ MCSA_ELF_TypeIndFunction
.type _foo, STT_GNU_IFUNC
Definition: MCDirectives.h:24
llvm::AArch64::Fixups
Fixups
Definition: AArch64FixupKinds.h:17
llvm::MCSA_Reference
@ MCSA_Reference
.reference (MachO)
Definition: MCDirectives.h:44
llvm::MCID::Flag
Flag
These should be considered private to the implementation of the MCInstrDesc class.
Definition: MCInstrDesc.h:147
Options
const char LLVMTargetMachineRef LLVMPassBuilderOptionsRef Options
Definition: PassBuilderBindings.cpp:48
llvm::MachO::PlatformType
PlatformType
Definition: MachO.h:497
llvm::MCSymbolRefExpr::getSymbol
const MCSymbol & getSymbol() const
Definition: MCExpr.h:399
llvm::MCValue::getConstant
int64_t getConstant() const
Definition: MCValue.h:43
llvm::VersionTuple
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:31
llvm::MCSA_Hidden
@ MCSA_Hidden
.hidden (ELF)
Definition: MCDirectives.h:33
llvm::MCSymbol::getName
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:198
llvm::MCValue::getSymA
const MCSymbolRefExpr * getSymA() const
Definition: MCValue.h:44
llvm::MCSA_ELF_TypeGnuUniqueObject
@ MCSA_ELF_TypeGnuUniqueObject
Definition: MCDirectives.h:29
llvm::MCObjectStreamer::emitAssignment
void emitAssignment(MCSymbol *Symbol, const MCExpr *Value) override
Emit an assignment of Value to Symbol.
Definition: MCObjectStreamer.cpp:387
Align
uint64_t Align
Definition: ELFObjHandler.cpp:82
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
DF
static RegisterPass< DebugifyFunctionPass > DF("debugify-function", "Attach debug info to a function")
llvm::SmallString< 256 >
llvm::MCSA_Exported
@ MCSA_Exported
.globl _foo, exported (XCOFF)
Definition: MCDirectives.h:34
llvm::MCDR_DataRegionJT32
@ MCDR_DataRegionJT32
.data_region jt32
Definition: MCDirectives.h:64
llvm::MCSA_WeakDefAutoPrivate
@ MCSA_WeakDefAutoPrivate
.weak_def_can_be_hidden (MachO)
Definition: MCDirectives.h:48
llvm::IndirectSymbolData::Symbol
MCSymbol * Symbol
Definition: MCAssembler.h:59
llvm::MCAssembler
Definition: MCAssembler.h:73
llvm::MCAF_SubsectionsViaSymbols
@ MCAF_SubsectionsViaSymbols
.subsections_via_symbols (MachO)
Definition: MCDirectives.h:54
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::clear
void clear()
Definition: DenseMap.h:110
uint64_t
llvm::MCSA_WeakReference
@ MCSA_WeakReference
.weak_reference (MachO)
Definition: MCDirectives.h:47
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
symbols
Itanium Name Demangler i e convert the string _Z1fv into and both[sub] projects need to demangle symbols
Definition: README.txt:20
llvm::DenseMap
Definition: DenseMap.h:714
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
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:1861
MCSymbolMachO.h
llvm::MCSymbolRefExpr
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:192
MCSection.h
llvm::ArrayRef< std::string >
llvm::IndirectSymbolData
Definition: MCAssembler.h:58
Fixup
PowerPC TLS Dynamic Call Fixup
Definition: PPCTLSDynamicCall.cpp:215
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
uint32_t
MCFixup.h
llvm::MCObjectWriter
Defines the object file and target independent interfaces used by the assembler backend to write nati...
Definition: MCObjectWriter.h:34
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
llvm::MCSA_ELF_TypeTLS
@ MCSA_ELF_TypeTLS
.type _foo, STT_TLS # aka @tls_object
Definition: MCDirectives.h:26
llvm::MCSA_IndirectSymbol
@ MCSA_IndirectSymbol
.indirect_symbol (MachO)
Definition: MCDirectives.h:35
writer
we should consider alternate ways to model stack dependencies Lots of things could be done in WebAssemblyTargetTransformInfo cpp there are numerous optimization related hooks that can be overridden in WebAssemblyTargetLowering Instead of the OptimizeReturned which should consider preserving the returned attribute through to MachineInstrs and extending the MemIntrinsicResults pass to do this optimization on calls too That would also let the WebAssemblyPeephole pass clean up dead defs for such as it does for stores Consider implementing and or getMachineCombinerPatterns Find a clean way to fix the problem which leads to the Shrink Wrapping pass being run after the WebAssembly PEI pass When setting multiple variables to the same we currently get code like const It could be done with a smaller encoding like local tee $pop5 local $pop6 WebAssembly registers are implicitly initialized to zero Explicit zeroing is therefore often redundant and could be optimized away Small indices may use smaller encodings than large indices WebAssemblyRegColoring and or WebAssemblyRegRenumbering should sort registers according to their usage frequency to maximize the usage of smaller encodings Many cases of irreducible control flow could be transformed more optimally than via the transform in WebAssemblyFixIrreducibleControlFlow cpp It may also be worthwhile to do transforms before register particularly when duplicating to allow register coloring to be aware of the duplication WebAssemblyRegStackify could use AliasAnalysis to reorder loads and stores more aggressively WebAssemblyRegStackify is currently a greedy algorithm This means for a binary however wasm doesn t actually require this WebAssemblyRegStackify could be or possibly to take full advantage of what WebAssembly permits Add support for mergeable sections in the Wasm writer
Definition: README.txt:154
llvm::MCSA_Internal
@ MCSA_Internal
.internal (ELF)
Definition: MCDirectives.h:36
llvm::MCSection::getName
StringRef getName() const
Definition: MCSection.h:124
llvm::MCAF_Code32
@ MCAF_Code32
.code32 (X86) / .code 32 (ARM)
Definition: MCDirectives.h:56
llvm::MCSA_ELF_TypeCommon
@ MCSA_ELF_TypeCommon
.type _foo, STT_COMMON # aka @common
Definition: MCDirectives.h:27
llvm::DataRegionData::JumpTable16
@ JumpTable16
Definition: MCAssembler.h:68
llvm::MCAF_Code64
@ MCAF_Code64
.code64 (X86)
Definition: MCDirectives.h:57
MCObjectWriter.h
llvm::MCAF_SyntaxUnified
@ MCAF_SyntaxUnified
.syntax (ARM/ELF)
Definition: MCDirectives.h:53
llvm::pdb::PDB_SymType::Label
@ Label
std
Definition: BitVector.h:851
llvm::MCSA_SymbolResolver
@ MCSA_SymbolResolver
.symbol_resolver (MachO)
Definition: MCDirectives.h:40
llvm::MCSectionMachO
This represents a section on a Mach-O system (used by Mac OS X).
Definition: MCSectionMachO.h:24
Casting.h
llvm::MCSectionMachO::getSegmentName
StringRef getSegmentName() const
Definition: MCSectionMachO.h:40
llvm::MCSA_Global
@ MCSA_Global
.type _foo, @gnu_unique_object
Definition: MCDirectives.h:30
MCValue.h
llvm::MCSA_WeakDefinition
@ MCSA_WeakDefinition
.weak_definition (MachO)
Definition: MCDirectives.h:46
llvm::LCOMM::ByteAlignment
@ ByteAlignment
Definition: MCAsmInfo.h:50
SectionKind.h
llvm::MCSA_ELF_TypeFunction
@ MCSA_ELF_TypeFunction
.type _foo, STT_FUNC # aka @function
Definition: MCDirectives.h:23
llvm::ARMBuildAttrs::Symbol
@ Symbol
Definition: ARMBuildAttributes.h:83
MCLinkerOptimizationHint.h
llvm::MCSA_Weak
@ MCSA_Weak
.weak
Definition: MCDirectives.h:45
llvm::MCDR_DataRegionJT8
@ MCDR_DataRegionJT8
.data_region jt8
Definition: MCDirectives.h:62
SmallVector.h
llvm::IndirectSymbolData::Section
MCSection * Section
Definition: MCAssembler.h:60
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:659
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
llvm::MCSA_PrivateExtern
@ MCSA_PrivateExtern
.private_extern (MachO)
Definition: MCDirectives.h:42
llvm::HexStyle::Asm
@ Asm
0ffh
Definition: MCInstPrinter.h:34
llvm::MCValue
This represents an "assembler immediate".
Definition: MCValue.h:36
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:394
llvm::MCSymbolMachO
Definition: MCSymbolMachO.h:15
llvm::MCObjectStreamer::finishImpl
void finishImpl() override
Streamer specific finalization.
Definition: MCObjectStreamer.cpp:916
raw_ostream.h
llvm::MCDataFragment
Fragment for data and encoded instructions.
Definition: MCFragment.h:241
llvm::MCDR_DataRegionEnd
@ MCDR_DataRegionEnd
.end_data_region
Definition: MCDirectives.h:65
TargetRegistry.h
MCExpr.h
llvm::MCSubtargetInfo
Generic base class for all target subtargets.
Definition: MCSubtargetInfo.h:76
llvm::MCFixup
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:71
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::MCExpr
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
llvm::MCValue::getSymB
const MCSymbolRefExpr * getSymB() const
Definition: MCValue.h:45
llvm::MCAssembler::CGProfileEntry
Definition: MCAssembler.h:465