xref: /freebsd/contrib/llvm-project/llvm/lib/MC/MCMachOStreamer.cpp (revision 2e3507c25e42292b45a5482e116d278f5515d04d) 
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"
21 #include "llvm/MC/MCLinkerOptimizationHint.h"
22 #include "llvm/MC/MCObjectFileInfo.h"
23 #include "llvm/MC/MCObjectStreamer.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"
33 #include "llvm/Support/ErrorHandling.h"
34 #include <cassert>
35 #include <vector>
36 
37 namespace llvm {
38 class MCInst;
39 class MCStreamer;
40 class MCSubtargetInfo;
41 class Triple;
42 } // namespace llvm
43 
44 using namespace llvm;
45 
46 namespace {
47 
48 class MCMachOStreamer : public MCObjectStreamer {
49 private:
50   /// LabelSections - true if each section change should emit a linker local
51   /// label for use in relocations for assembler local references. Obviates the
52   /// need for local relocations. False by default.
53   bool LabelSections;
54 
55   bool DWARFMustBeAtTheEnd;
56   bool CreatedADWARFSection;
57 
58   /// HasSectionLabel - map of which sections have already had a non-local
59   /// label emitted to them. Used so we don't emit extraneous linker local
60   /// labels in the middle of the section.
61   DenseMap<const MCSection*, bool> HasSectionLabel;
62 
63   void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &STI) override;
64 
65   void emitDataRegion(DataRegionData::KindTy Kind);
66   void emitDataRegionEnd();
67 
68 public:
69   MCMachOStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
70                   std::unique_ptr<MCObjectWriter> OW,
71                   std::unique_ptr<MCCodeEmitter> Emitter,
72                   bool DWARFMustBeAtTheEnd, bool label)
73       : MCObjectStreamer(Context, std::move(MAB), std::move(OW),
74                          std::move(Emitter)),
75         LabelSections(label), DWARFMustBeAtTheEnd(DWARFMustBeAtTheEnd),
76         CreatedADWARFSection(false) {}
77 
78   /// state management
79   void reset() override {
80     CreatedADWARFSection = false;
81     HasSectionLabel.clear();
82     MCObjectStreamer::reset();
83   }
84 
85   /// @name MCStreamer Interface
86   /// @{
87 
88   void changeSection(MCSection *Sect, const MCExpr *Subsect) override;
89   void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
90   void emitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
91   void emitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol) override;
92   void emitAssemblerFlag(MCAssemblerFlag Flag) override;
93   void emitLinkerOptions(ArrayRef<std::string> Options) override;
94   void emitDataRegion(MCDataRegionType Kind) override;
95   void emitVersionMin(MCVersionMinType Kind, unsigned Major, unsigned Minor,
96                       unsigned Update, VersionTuple SDKVersion) override;
97   void emitBuildVersion(unsigned Platform, unsigned Major, unsigned Minor,
98                         unsigned Update, VersionTuple SDKVersion) override;
99   void emitDarwinTargetVariantBuildVersion(unsigned Platform, unsigned Major,
100                                            unsigned Minor, unsigned Update,
101                                            VersionTuple SDKVersion) override;
102   void emitThumbFunc(MCSymbol *Func) override;
103   bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
104   void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
105   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
106                         Align ByteAlignment) override;
107 
108   void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
109                              Align ByteAlignment) override;
110   void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
111                     uint64_t Size = 0, Align ByteAlignment = Align(1),
112                     SMLoc Loc = SMLoc()) override;
113   void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
114                       Align ByteAlignment = Align(1)) override;
115 
116   void emitIdent(StringRef IdentString) override {
117     llvm_unreachable("macho doesn't support this directive");
118   }
119 
120   void emitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) override {
121     getAssembler().getLOHContainer().addDirective(Kind, Args);
122   }
123   void emitCGProfileEntry(const MCSymbolRefExpr *From,
124                           const MCSymbolRefExpr *To, uint64_t Count) override {
125     if (!From->getSymbol().isTemporary() && !To->getSymbol().isTemporary())
126       getAssembler().CGProfile.push_back({From, To, Count});
127   }
128 
129   void finishImpl() override;
130 
131   void finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE);
132   void finalizeCGProfile();
133   void createAddrSigSection();
134 };
135 
136 } // end anonymous namespace.
137 
138 static bool canGoAfterDWARF(const MCSectionMachO &MSec) {
139   // These sections are created by the assembler itself after the end of
140   // the .s file.
141   StringRef SegName = MSec.getSegmentName();
142   StringRef SecName = MSec.getName();
143 
144   if (SegName == "__LD" && SecName == "__compact_unwind")
145     return true;
146 
147   if (SegName == "__IMPORT") {
148     if (SecName == "__jump_table")
149       return true;
150 
151     if (SecName == "__pointers")
152       return true;
153   }
154 
155   if (SegName == "__TEXT" && SecName == "__eh_frame")
156     return true;
157 
158   if (SegName == "__DATA" && (SecName == "__nl_symbol_ptr" ||
159                               SecName == "__thread_ptr"))
160     return true;
161   if (SegName == "__LLVM" && SecName == "__cg_profile")
162     return true;
163   return false;
164 }
165 
166 void MCMachOStreamer::changeSection(MCSection *Section,
167                                     const MCExpr *Subsection) {
168   // Change the section normally.
169   bool Created = changeSectionImpl(Section, Subsection);
170   const MCSectionMachO &MSec = *cast<MCSectionMachO>(Section);
171   StringRef SegName = MSec.getSegmentName();
172   if (SegName == "__DWARF")
173     CreatedADWARFSection = true;
174   else if (Created && DWARFMustBeAtTheEnd && !canGoAfterDWARF(MSec))
175     assert(!CreatedADWARFSection && "Creating regular section after DWARF");
176 
177   // Output a linker-local symbol so we don't need section-relative local
178   // relocations. The linker hates us when we do that.
179   if (LabelSections && !HasSectionLabel[Section] &&
180       !Section->getBeginSymbol()) {
181     MCSymbol *Label = getContext().createLinkerPrivateTempSymbol();
182     Section->setBeginSymbol(Label);
183     HasSectionLabel[Section] = true;
184   }
185 }
186 
187 void MCMachOStreamer::emitEHSymAttributes(const MCSymbol *Symbol,
188                                           MCSymbol *EHSymbol) {
189   getAssembler().registerSymbol(*Symbol);
190   if (Symbol->isExternal())
191     emitSymbolAttribute(EHSymbol, MCSA_Global);
192   if (cast<MCSymbolMachO>(Symbol)->isWeakDefinition())
193     emitSymbolAttribute(EHSymbol, MCSA_WeakDefinition);
194   if (Symbol->isPrivateExtern())
195     emitSymbolAttribute(EHSymbol, MCSA_PrivateExtern);
196 }
197 
198 void MCMachOStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) {
199   // We have to create a new fragment if this is an atom defining symbol,
200   // fragments cannot span atoms.
201   if (getAssembler().isSymbolLinkerVisible(*Symbol))
202     insert(new MCDataFragment());
203 
204   MCObjectStreamer::emitLabel(Symbol, Loc);
205 
206   // This causes the reference type flag to be cleared. Darwin 'as' was "trying"
207   // to clear the weak reference and weak definition bits too, but the
208   // implementation was buggy. For now we just try to match 'as', for
209   // diffability.
210   //
211   // FIXME: Cleanup this code, these bits should be emitted based on semantic
212   // properties, not on the order of definition, etc.
213   cast<MCSymbolMachO>(Symbol)->clearReferenceType();
214 }
215 
216 void MCMachOStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
217   MCValue Res;
218 
219   if (Value->evaluateAsRelocatable(Res, nullptr, nullptr)) {
220     if (const MCSymbolRefExpr *SymAExpr = Res.getSymA()) {
221       const MCSymbol &SymA = SymAExpr->getSymbol();
222       if (!Res.getSymB() && (SymA.getName() == "" || Res.getConstant() != 0))
223         cast<MCSymbolMachO>(Symbol)->setAltEntry();
224     }
225   }
226   MCObjectStreamer::emitAssignment(Symbol, Value);
227 }
228 
229 void MCMachOStreamer::emitDataRegion(DataRegionData::KindTy Kind) {
230   // Create a temporary label to mark the start of the data region.
231   MCSymbol *Start = getContext().createTempSymbol();
232   emitLabel(Start);
233   // Record the region for the object writer to use.
234   DataRegionData Data = { Kind, Start, nullptr };
235   std::vector<DataRegionData> &Regions = getAssembler().getDataRegions();
236   Regions.push_back(Data);
237 }
238 
239 void MCMachOStreamer::emitDataRegionEnd() {
240   std::vector<DataRegionData> &Regions = getAssembler().getDataRegions();
241   assert(!Regions.empty() && "Mismatched .end_data_region!");
242   DataRegionData &Data = Regions.back();
243   assert(!Data.End && "Mismatched .end_data_region!");
244   // Create a temporary label to mark the end of the data region.
245   Data.End = getContext().createTempSymbol();
246   emitLabel(Data.End);
247 }
248 
249 void MCMachOStreamer::emitAssemblerFlag(MCAssemblerFlag Flag) {
250   // Let the target do whatever target specific stuff it needs to do.
251   getAssembler().getBackend().handleAssemblerFlag(Flag);
252   // Do any generic stuff we need to do.
253   switch (Flag) {
254   case MCAF_SyntaxUnified: return; // no-op here.
255   case MCAF_Code16: return; // Change parsing mode; no-op here.
256   case MCAF_Code32: return; // Change parsing mode; no-op here.
257   case MCAF_Code64: return; // Change parsing mode; no-op here.
258   case MCAF_SubsectionsViaSymbols:
259     getAssembler().setSubsectionsViaSymbols(true);
260     return;
261   }
262 }
263 
264 void MCMachOStreamer::emitLinkerOptions(ArrayRef<std::string> Options) {
265   getAssembler().getLinkerOptions().push_back(Options);
266 }
267 
268 void MCMachOStreamer::emitDataRegion(MCDataRegionType Kind) {
269   switch (Kind) {
270   case MCDR_DataRegion:
271     emitDataRegion(DataRegionData::Data);
272     return;
273   case MCDR_DataRegionJT8:
274     emitDataRegion(DataRegionData::JumpTable8);
275     return;
276   case MCDR_DataRegionJT16:
277     emitDataRegion(DataRegionData::JumpTable16);
278     return;
279   case MCDR_DataRegionJT32:
280     emitDataRegion(DataRegionData::JumpTable32);
281     return;
282   case MCDR_DataRegionEnd:
283     emitDataRegionEnd();
284     return;
285   }
286 }
287 
288 void MCMachOStreamer::emitVersionMin(MCVersionMinType Kind, unsigned Major,
289                                      unsigned Minor, unsigned Update,
290                                      VersionTuple SDKVersion) {
291   getAssembler().setVersionMin(Kind, Major, Minor, Update, SDKVersion);
292 }
293 
294 void MCMachOStreamer::emitBuildVersion(unsigned Platform, unsigned Major,
295                                        unsigned Minor, unsigned Update,
296                                        VersionTuple SDKVersion) {
297   getAssembler().setBuildVersion((MachO::PlatformType)Platform, Major, Minor,
298                                  Update, SDKVersion);
299 }
300 
301 void MCMachOStreamer::emitDarwinTargetVariantBuildVersion(
302     unsigned Platform, unsigned Major, unsigned Minor, unsigned Update,
303     VersionTuple SDKVersion) {
304   getAssembler().setDarwinTargetVariantBuildVersion(
305       (MachO::PlatformType)Platform, Major, Minor, Update, SDKVersion);
306 }
307 
308 void MCMachOStreamer::emitThumbFunc(MCSymbol *Symbol) {
309   // Remember that the function is a thumb function. Fixup and relocation
310   // values will need adjusted.
311   getAssembler().setIsThumbFunc(Symbol);
312   cast<MCSymbolMachO>(Symbol)->setThumbFunc();
313 }
314 
315 bool MCMachOStreamer::emitSymbolAttribute(MCSymbol *Sym,
316                                           MCSymbolAttr Attribute) {
317   MCSymbolMachO *Symbol = cast<MCSymbolMachO>(Sym);
318 
319   // Indirect symbols are handled differently, to match how 'as' handles
320   // them. This makes writing matching .o files easier.
321   if (Attribute == MCSA_IndirectSymbol) {
322     // Note that we intentionally cannot use the symbol data here; this is
323     // important for matching the string table that 'as' generates.
324     IndirectSymbolData ISD;
325     ISD.Symbol = Symbol;
326     ISD.Section = getCurrentSectionOnly();
327     getAssembler().getIndirectSymbols().push_back(ISD);
328     return true;
329   }
330 
331   // Adding a symbol attribute always introduces the symbol, note that an
332   // important side effect of calling registerSymbol here is to register
333   // the symbol with the assembler.
334   getAssembler().registerSymbol(*Symbol);
335 
336   // The implementation of symbol attributes is designed to match 'as', but it
337   // leaves much to desired. It doesn't really make sense to arbitrarily add and
338   // remove flags, but 'as' allows this (in particular, see .desc).
339   //
340   // In the future it might be worth trying to make these operations more well
341   // defined.
342   switch (Attribute) {
343   case MCSA_Invalid:
344   case MCSA_ELF_TypeFunction:
345   case MCSA_ELF_TypeIndFunction:
346   case MCSA_ELF_TypeObject:
347   case MCSA_ELF_TypeTLS:
348   case MCSA_ELF_TypeCommon:
349   case MCSA_ELF_TypeNoType:
350   case MCSA_ELF_TypeGnuUniqueObject:
351   case MCSA_Extern:
352   case MCSA_Hidden:
353   case MCSA_IndirectSymbol:
354   case MCSA_Internal:
355   case MCSA_Protected:
356   case MCSA_Weak:
357   case MCSA_Local:
358   case MCSA_LGlobal:
359   case MCSA_Exported:
360   case MCSA_Memtag:
361   case MCSA_WeakAntiDep:
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 
414   case MCSA_WeakDefAutoPrivate:
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                                        Align 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,
444                                             Align ByteAlignment) {
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,
451                                    uint64_t Size, Align ByteAlignment,
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 
487   SmallVector<MCFixup, 4> Fixups;
488   SmallString<256> Code;
489   getAssembler().getEmitter().encodeInstruction(Inst, Code, Fixups, STI);
490 
491   // Add the fixups and data.
492   for (MCFixup &Fixup : Fixups) {
493     Fixup.setOffset(Fixup.getOffset() + DF->getContents().size());
494     DF->getFixups().push_back(Fixup);
495   }
496   DF->setHasInstructions(STI);
497   DF->getContents().append(Code.begin(), Code.end());
498 }
499 
500 void MCMachOStreamer::finishImpl() {
501   emitFrames(&getAssembler().getBackend());
502 
503   // We have to set the fragment atom associations so we can relax properly for
504   // Mach-O.
505 
506   // First, scan the symbol table to build a lookup table from fragments to
507   // defining symbols.
508   DenseMap<const MCFragment *, const MCSymbol *> DefiningSymbolMap;
509   for (const MCSymbol &Symbol : getAssembler().symbols()) {
510     if (getAssembler().isSymbolLinkerVisible(Symbol) && Symbol.isInSection() &&
511         !Symbol.isVariable()) {
512       // An atom defining symbol should never be internal to a fragment.
513       assert(Symbol.getOffset() == 0 &&
514              "Invalid offset in atom defining symbol!");
515       DefiningSymbolMap[Symbol.getFragment()] = &Symbol;
516     }
517   }
518 
519   // Set the fragment atom associations by tracking the last seen atom defining
520   // symbol.
521   for (MCSection &Sec : getAssembler()) {
522     const MCSymbol *CurrentAtom = nullptr;
523     for (MCFragment &Frag : Sec) {
524       if (const MCSymbol *Symbol = DefiningSymbolMap.lookup(&Frag))
525         CurrentAtom = Symbol;
526       Frag.setAtom(CurrentAtom);
527     }
528   }
529 
530   finalizeCGProfile();
531 
532   createAddrSigSection();
533   this->MCObjectStreamer::finishImpl();
534 }
535 
536 void MCMachOStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE) {
537   const MCSymbol *S = &SRE->getSymbol();
538   if (getAssembler().registerSymbol(*S))
539     S->setExternal(true);
540 }
541 
542 void MCMachOStreamer::finalizeCGProfile() {
543   MCAssembler &Asm = getAssembler();
544   if (Asm.CGProfile.empty())
545     return;
546   for (MCAssembler::CGProfileEntry &E : Asm.CGProfile) {
547     finalizeCGProfileEntry(E.From);
548     finalizeCGProfileEntry(E.To);
549   }
550   // We can't write the section out until symbol indices are finalized which
551   // doesn't happen until after section layout. We need to create the section
552   // and set its size now so that it's accounted for in layout.
553   MCSection *CGProfileSection = Asm.getContext().getMachOSection(
554       "__LLVM", "__cg_profile", 0, SectionKind::getMetadata());
555   Asm.registerSection(*CGProfileSection);
556   auto *Frag = new MCDataFragment(CGProfileSection);
557   // For each entry, reserve space for 2 32-bit indices and a 64-bit count.
558   size_t SectionBytes =
559       Asm.CGProfile.size() * (2 * sizeof(uint32_t) + sizeof(uint64_t));
560   Frag->getContents().resize(SectionBytes);
561 }
562 
563 MCStreamer *llvm::createMachOStreamer(MCContext &Context,
564                                       std::unique_ptr<MCAsmBackend> &&MAB,
565                                       std::unique_ptr<MCObjectWriter> &&OW,
566                                       std::unique_ptr<MCCodeEmitter> &&CE,
567                                       bool RelaxAll, bool DWARFMustBeAtTheEnd,
568                                       bool LabelSections) {
569   MCMachOStreamer *S =
570       new MCMachOStreamer(Context, std::move(MAB), std::move(OW), std::move(CE),
571                           DWARFMustBeAtTheEnd, LabelSections);
572   const Triple &Target = Context.getTargetTriple();
573   S->emitVersionForTarget(
574       Target, Context.getObjectFileInfo()->getSDKVersion(),
575       Context.getObjectFileInfo()->getDarwinTargetVariantTriple(),
576       Context.getObjectFileInfo()->getDarwinTargetVariantSDKVersion());
577   if (RelaxAll)
578     S->getAssembler().setRelaxAll(true);
579   return S;
580 }
581 
582 // The AddrSig section uses a series of relocations to refer to the symbols that
583 // should be considered address-significant. The only interesting content of
584 // these relocations is their symbol; the type, length etc will be ignored by
585 // the linker. The reason we are not referring to the symbol indices directly is
586 // that those indices will be invalidated by tools that update the symbol table.
587 // Symbol relocations OTOH will have their indices updated by e.g. llvm-strip.
588 void MCMachOStreamer::createAddrSigSection() {
589   MCAssembler &Asm = getAssembler();
590   MCObjectWriter &writer = Asm.getWriter();
591   if (!writer.getEmitAddrsigSection())
592     return;
593   // Create the AddrSig section and first data fragment here as its layout needs
594   // to be computed immediately after in order for it to be exported correctly.
595   MCSection *AddrSigSection =
596       Asm.getContext().getObjectFileInfo()->getAddrSigSection();
597   Asm.registerSection(*AddrSigSection);
598   auto *Frag = new MCDataFragment(AddrSigSection);
599   // We will generate a series of pointer-sized symbol relocations at offset
600   // 0x0. Set the section size to be large enough to contain a single pointer
601   // (instead of emitting a zero-sized section) so these relocations are
602   // technically valid, even though we don't expect these relocations to
603   // actually be applied by the linker.
604   Frag->getContents().resize(8);
605 }
606