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 "llvm/Support/raw_ostream.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();
83     MCObjectStreamer::reset();
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                              unsigned ByteAlignment) override;
111   void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
112                     uint64_t Size = 0, unsigned ByteAlignment = 0,
113                     SMLoc Loc = SMLoc()) override;
114   void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
115                       unsigned ByteAlignment = 0) 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 ||
177             Section == getContext().getObjectFileInfo()->getStackMapSection())
178            && "Creating regular section after DWARF");
179 
180   // Output a linker-local symbol so we don't need section-relative local
181   // relocations. The linker hates us when we do that.
182   if (LabelSections && !HasSectionLabel[Section] &&
183       !Section->getBeginSymbol()) {
184     MCSymbol *Label = getContext().createLinkerPrivateTempSymbol();
185     Section->setBeginSymbol(Label);
186     HasSectionLabel[Section] = true;
187   }
188 }
189 
190 void MCMachOStreamer::emitEHSymAttributes(const MCSymbol *Symbol,
191                                           MCSymbol *EHSymbol) {
192   getAssembler().registerSymbol(*Symbol);
193   if (Symbol->isExternal())
194     emitSymbolAttribute(EHSymbol, MCSA_Global);
195   if (cast<MCSymbolMachO>(Symbol)->isWeakDefinition())
196     emitSymbolAttribute(EHSymbol, MCSA_WeakDefinition);
197   if (Symbol->isPrivateExtern())
198     emitSymbolAttribute(EHSymbol, MCSA_PrivateExtern);
199 }
200 
201 void MCMachOStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) {
202   // We have to create a new fragment if this is an atom defining symbol,
203   // fragments cannot span atoms.
204   if (getAssembler().isSymbolLinkerVisible(*Symbol))
205     insert(new MCDataFragment());
206 
207   MCObjectStreamer::emitLabel(Symbol, Loc);
208 
209   // This causes the reference type flag to be cleared. Darwin 'as' was "trying"
210   // to clear the weak reference and weak definition bits too, but the
211   // implementation was buggy. For now we just try to match 'as', for
212   // diffability.
213   //
214   // FIXME: Cleanup this code, these bits should be emitted based on semantic
215   // properties, not on the order of definition, etc.
216   cast<MCSymbolMachO>(Symbol)->clearReferenceType();
217 }
218 
219 void MCMachOStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
220   MCValue Res;
221 
222   if (Value->evaluateAsRelocatable(Res, nullptr, nullptr)) {
223     if (const MCSymbolRefExpr *SymAExpr = Res.getSymA()) {
224       const MCSymbol &SymA = SymAExpr->getSymbol();
225       if (!Res.getSymB() && (SymA.getName() == "" || Res.getConstant() != 0))
226         cast<MCSymbolMachO>(Symbol)->setAltEntry();
227     }
228   }
229   MCObjectStreamer::emitAssignment(Symbol, Value);
230 }
231 
232 void MCMachOStreamer::emitDataRegion(DataRegionData::KindTy Kind) {
233   // Create a temporary label to mark the start of the data region.
234   MCSymbol *Start = getContext().createTempSymbol();
235   emitLabel(Start);
236   // Record the region for the object writer to use.
237   DataRegionData Data = { Kind, Start, nullptr };
238   std::vector<DataRegionData> &Regions = getAssembler().getDataRegions();
239   Regions.push_back(Data);
240 }
241 
242 void MCMachOStreamer::emitDataRegionEnd() {
243   std::vector<DataRegionData> &Regions = getAssembler().getDataRegions();
244   assert(!Regions.empty() && "Mismatched .end_data_region!");
245   DataRegionData &Data = Regions.back();
246   assert(!Data.End && "Mismatched .end_data_region!");
247   // Create a temporary label to mark the end of the data region.
248   Data.End = getContext().createTempSymbol();
249   emitLabel(Data.End);
250 }
251 
252 void MCMachOStreamer::emitAssemblerFlag(MCAssemblerFlag Flag) {
253   // Let the target do whatever target specific stuff it needs to do.
254   getAssembler().getBackend().handleAssemblerFlag(Flag);
255   // Do any generic stuff we need to do.
256   switch (Flag) {
257   case MCAF_SyntaxUnified: return; // no-op here.
258   case MCAF_Code16: return; // Change parsing mode; no-op here.
259   case MCAF_Code32: return; // Change parsing mode; no-op here.
260   case MCAF_Code64: return; // Change parsing mode; no-op here.
261   case MCAF_SubsectionsViaSymbols:
262     getAssembler().setSubsectionsViaSymbols(true);
263     return;
264   }
265 }
266 
267 void MCMachOStreamer::emitLinkerOptions(ArrayRef<std::string> Options) {
268   getAssembler().getLinkerOptions().push_back(Options);
269 }
270 
271 void MCMachOStreamer::emitDataRegion(MCDataRegionType Kind) {
272   switch (Kind) {
273   case MCDR_DataRegion:
274     emitDataRegion(DataRegionData::Data);
275     return;
276   case MCDR_DataRegionJT8:
277     emitDataRegion(DataRegionData::JumpTable8);
278     return;
279   case MCDR_DataRegionJT16:
280     emitDataRegion(DataRegionData::JumpTable16);
281     return;
282   case MCDR_DataRegionJT32:
283     emitDataRegion(DataRegionData::JumpTable32);
284     return;
285   case MCDR_DataRegionEnd:
286     emitDataRegionEnd();
287     return;
288   }
289 }
290 
291 void MCMachOStreamer::emitVersionMin(MCVersionMinType Kind, unsigned Major,
292                                      unsigned Minor, unsigned Update,
293                                      VersionTuple SDKVersion) {
294   getAssembler().setVersionMin(Kind, Major, Minor, Update, SDKVersion);
295 }
296 
297 void MCMachOStreamer::emitBuildVersion(unsigned Platform, unsigned Major,
298                                        unsigned Minor, unsigned Update,
299                                        VersionTuple SDKVersion) {
300   getAssembler().setBuildVersion((MachO::PlatformType)Platform, Major, Minor,
301                                  Update, SDKVersion);
302 }
303 
304 void MCMachOStreamer::emitDarwinTargetVariantBuildVersion(
305     unsigned Platform, unsigned Major, unsigned Minor, unsigned Update,
306     VersionTuple SDKVersion) {
307   getAssembler().setDarwinTargetVariantBuildVersion(
308       (MachO::PlatformType)Platform, Major, Minor, Update, SDKVersion);
309 }
310 
311 void MCMachOStreamer::emitThumbFunc(MCSymbol *Symbol) {
312   // Remember that the function is a thumb function. Fixup and relocation
313   // values will need adjusted.
314   getAssembler().setIsThumbFunc(Symbol);
315   cast<MCSymbolMachO>(Symbol)->setThumbFunc();
316 }
317 
318 bool MCMachOStreamer::emitSymbolAttribute(MCSymbol *Sym,
319                                           MCSymbolAttr Attribute) {
320   MCSymbolMachO *Symbol = cast<MCSymbolMachO>(Sym);
321 
322   // Indirect symbols are handled differently, to match how 'as' handles
323   // them. This makes writing matching .o files easier.
324   if (Attribute == MCSA_IndirectSymbol) {
325     // Note that we intentionally cannot use the symbol data here; this is
326     // important for matching the string table that 'as' generates.
327     IndirectSymbolData ISD;
328     ISD.Symbol = Symbol;
329     ISD.Section = getCurrentSectionOnly();
330     getAssembler().getIndirectSymbols().push_back(ISD);
331     return true;
332   }
333 
334   // Adding a symbol attribute always introduces the symbol, note that an
335   // important side effect of calling registerSymbol here is to register
336   // the symbol with the assembler.
337   getAssembler().registerSymbol(*Symbol);
338 
339   // The implementation of symbol attributes is designed to match 'as', but it
340   // leaves much to desired. It doesn't really make sense to arbitrarily add and
341   // remove flags, but 'as' allows this (in particular, see .desc).
342   //
343   // In the future it might be worth trying to make these operations more well
344   // defined.
345   switch (Attribute) {
346   case MCSA_Invalid:
347   case MCSA_ELF_TypeFunction:
348   case MCSA_ELF_TypeIndFunction:
349   case MCSA_ELF_TypeObject:
350   case MCSA_ELF_TypeTLS:
351   case MCSA_ELF_TypeCommon:
352   case MCSA_ELF_TypeNoType:
353   case MCSA_ELF_TypeGnuUniqueObject:
354   case MCSA_Extern:
355   case MCSA_Hidden:
356   case MCSA_IndirectSymbol:
357   case MCSA_Internal:
358   case MCSA_Protected:
359   case MCSA_Weak:
360   case MCSA_Local:
361   case MCSA_LGlobal:
362   case MCSA_Exported:
363     return false;
364 
365   case MCSA_Global:
366     Symbol->setExternal(true);
367     // This effectively clears the undefined lazy bit, in Darwin 'as', although
368     // it isn't very consistent because it implements this as part of symbol
369     // lookup.
370     //
371     // FIXME: Cleanup this code, these bits should be emitted based on semantic
372     // properties, not on the order of definition, etc.
373     Symbol->setReferenceTypeUndefinedLazy(false);
374     break;
375 
376   case MCSA_LazyReference:
377     // FIXME: This requires -dynamic.
378     Symbol->setNoDeadStrip();
379     if (Symbol->isUndefined())
380       Symbol->setReferenceTypeUndefinedLazy(true);
381     break;
382 
383     // Since .reference sets the no dead strip bit, it is equivalent to
384     // .no_dead_strip in practice.
385   case MCSA_Reference:
386   case MCSA_NoDeadStrip:
387     Symbol->setNoDeadStrip();
388     break;
389 
390   case MCSA_SymbolResolver:
391     Symbol->setSymbolResolver();
392     break;
393 
394   case MCSA_AltEntry:
395     Symbol->setAltEntry();
396     break;
397 
398   case MCSA_PrivateExtern:
399     Symbol->setExternal(true);
400     Symbol->setPrivateExtern(true);
401     break;
402 
403   case MCSA_WeakReference:
404     // FIXME: This requires -dynamic.
405     if (Symbol->isUndefined())
406       Symbol->setWeakReference();
407     break;
408 
409   case MCSA_WeakDefinition:
410     // FIXME: 'as' enforces that this is defined and global. The manual claims
411     // it has to be in a coalesced section, but this isn't enforced.
412     Symbol->setWeakDefinition();
413     break;
414 
415   case MCSA_WeakDefAutoPrivate:
416     Symbol->setWeakDefinition();
417     Symbol->setWeakReference();
418     break;
419 
420   case MCSA_Cold:
421     Symbol->setCold();
422     break;
423   }
424 
425   return true;
426 }
427 
428 void MCMachOStreamer::emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
429   // Encode the 'desc' value into the lowest implementation defined bits.
430   getAssembler().registerSymbol(*Symbol);
431   cast<MCSymbolMachO>(Symbol)->setDesc(DescValue);
432 }
433 
434 void MCMachOStreamer::emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
435                                        unsigned ByteAlignment) {
436   // FIXME: Darwin 'as' does appear to allow redef of a .comm by itself.
437   assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
438 
439   getAssembler().registerSymbol(*Symbol);
440   Symbol->setExternal(true);
441   Symbol->setCommon(Size, ByteAlignment);
442 }
443 
444 void MCMachOStreamer::emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
445                                             unsigned ByteAlignment) {
446   // '.lcomm' is equivalent to '.zerofill'.
447   return emitZerofill(getContext().getObjectFileInfo()->getDataBSSSection(),
448                       Symbol, Size, ByteAlignment);
449 }
450 
451 void MCMachOStreamer::emitZerofill(MCSection *Section, MCSymbol *Symbol,
452                                    uint64_t Size, unsigned ByteAlignment,
453                                    SMLoc Loc) {
454   // On darwin all virtual sections have zerofill type. Disallow the usage of
455   // .zerofill in non-virtual functions. If something similar is needed, use
456   // .space or .zero.
457   if (!Section->isVirtualSection()) {
458     getContext().reportError(
459         Loc, "The usage of .zerofill is restricted to sections of "
460              "ZEROFILL type. Use .zero or .space instead.");
461     return; // Early returning here shouldn't harm. EmitZeros should work on any
462             // section.
463   }
464 
465   pushSection();
466   switchSection(Section);
467 
468   // The symbol may not be present, which only creates the section.
469   if (Symbol) {
470     emitValueToAlignment(ByteAlignment, 0, 1, 0);
471     emitLabel(Symbol);
472     emitZeros(Size);
473   }
474   popSection();
475 }
476 
477 // This should always be called with the thread local bss section.  Like the
478 // .zerofill directive this doesn't actually switch sections on us.
479 void MCMachOStreamer::emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
480                                      uint64_t Size, unsigned ByteAlignment) {
481   emitZerofill(Section, Symbol, Size, ByteAlignment);
482 }
483 
484 void MCMachOStreamer::emitInstToData(const MCInst &Inst,
485                                      const MCSubtargetInfo &STI) {
486   MCDataFragment *DF = getOrCreateDataFragment();
487 
488   SmallVector<MCFixup, 4> Fixups;
489   SmallString<256> Code;
490   raw_svector_ostream VecOS(Code);
491   getAssembler().getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI);
492 
493   // Add the fixups and data.
494   for (MCFixup &Fixup : Fixups) {
495     Fixup.setOffset(Fixup.getOffset() + DF->getContents().size());
496     DF->getFixups().push_back(Fixup);
497   }
498   DF->setHasInstructions(STI);
499   DF->getContents().append(Code.begin(), Code.end());
500 }
501 
502 void MCMachOStreamer::finishImpl() {
503   emitFrames(&getAssembler().getBackend());
504 
505   // We have to set the fragment atom associations so we can relax properly for
506   // Mach-O.
507 
508   // First, scan the symbol table to build a lookup table from fragments to
509   // defining symbols.
510   DenseMap<const MCFragment *, const MCSymbol *> DefiningSymbolMap;
511   for (const MCSymbol &Symbol : getAssembler().symbols()) {
512     if (getAssembler().isSymbolLinkerVisible(Symbol) && Symbol.isInSection() &&
513         !Symbol.isVariable()) {
514       // An atom defining symbol should never be internal to a fragment.
515       assert(Symbol.getOffset() == 0 &&
516              "Invalid offset in atom defining symbol!");
517       DefiningSymbolMap[Symbol.getFragment()] = &Symbol;
518     }
519   }
520 
521   // Set the fragment atom associations by tracking the last seen atom defining
522   // symbol.
523   for (MCSection &Sec : getAssembler()) {
524     const MCSymbol *CurrentAtom = nullptr;
525     for (MCFragment &Frag : Sec) {
526       if (const MCSymbol *Symbol = DefiningSymbolMap.lookup(&Frag))
527         CurrentAtom = Symbol;
528       Frag.setAtom(CurrentAtom);
529     }
530   }
531 
532   finalizeCGProfile();
533 
534   createAddrSigSection();
535   this->MCObjectStreamer::finishImpl();
536 }
537 
538 void MCMachOStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE) {
539   const MCSymbol *S = &SRE->getSymbol();
540   bool Created;
541   getAssembler().registerSymbol(*S, &Created);
542   if (Created)
543     S->setExternal(true);
544 }
545 
546 void MCMachOStreamer::finalizeCGProfile() {
547   MCAssembler &Asm = getAssembler();
548   if (Asm.CGProfile.empty())
549     return;
550   for (MCAssembler::CGProfileEntry &E : Asm.CGProfile) {
551     finalizeCGProfileEntry(E.From);
552     finalizeCGProfileEntry(E.To);
553   }
554   // We can't write the section out until symbol indices are finalized which
555   // doesn't happen until after section layout. We need to create the section
556   // and set its size now so that it's accounted for in layout.
557   MCSection *CGProfileSection = Asm.getContext().getMachOSection(
558       "__LLVM", "__cg_profile", 0, SectionKind::getMetadata());
559   Asm.registerSection(*CGProfileSection);
560   auto *Frag = new MCDataFragment(CGProfileSection);
561   // For each entry, reserve space for 2 32-bit indices and a 64-bit count.
562   size_t SectionBytes =
563       Asm.CGProfile.size() * (2 * sizeof(uint32_t) + sizeof(uint64_t));
564   Frag->getContents().resize(SectionBytes);
565 }
566 
567 MCStreamer *llvm::createMachOStreamer(MCContext &Context,
568                                       std::unique_ptr<MCAsmBackend> &&MAB,
569                                       std::unique_ptr<MCObjectWriter> &&OW,
570                                       std::unique_ptr<MCCodeEmitter> &&CE,
571                                       bool RelaxAll, bool DWARFMustBeAtTheEnd,
572                                       bool LabelSections) {
573   MCMachOStreamer *S =
574       new MCMachOStreamer(Context, std::move(MAB), std::move(OW), std::move(CE),
575                           DWARFMustBeAtTheEnd, LabelSections);
576   const Triple &Target = Context.getTargetTriple();
577   S->emitVersionForTarget(
578       Target, Context.getObjectFileInfo()->getSDKVersion(),
579       Context.getObjectFileInfo()->getDarwinTargetVariantTriple(),
580       Context.getObjectFileInfo()->getDarwinTargetVariantSDKVersion());
581   if (RelaxAll)
582     S->getAssembler().setRelaxAll(true);
583   return S;
584 }
585 
586 // The AddrSig section uses a series of relocations to refer to the symbols that
587 // should be considered address-significant. The only interesting content of
588 // these relocations is their symbol; the type, length etc will be ignored by
589 // the linker. The reason we are not referring to the symbol indices directly is
590 // that those indices will be invalidated by tools that update the symbol table.
591 // Symbol relocations OTOH will have their indices updated by e.g. llvm-strip.
592 void MCMachOStreamer::createAddrSigSection() {
593   MCAssembler &Asm = getAssembler();
594   MCObjectWriter &writer = Asm.getWriter();
595   if (!writer.getEmitAddrsigSection())
596     return;
597   // Create the AddrSig section and first data fragment here as its layout needs
598   // to be computed immediately after in order for it to be exported correctly.
599   MCSection *AddrSigSection =
600       Asm.getContext().getObjectFileInfo()->getAddrSigSection();
601   Asm.registerSection(*AddrSigSection);
602   auto *Frag = new MCDataFragment(AddrSigSection);
603   // We will generate a series of pointer-sized symbol relocations at offset
604   // 0x0. Set the section size to be large enough to contain a single pointer
605   // (instead of emitting a zero-sized section) so these relocations are
606   // technically valid, even though we don't expect these relocations to
607   // actually be applied by the linker.
608   Frag->getContents().resize(8);
609 }
610