llvm/lib/MC/MCMachOStreamer.cpp

   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   bool Created;
 539   getAssembler().registerSymbol(*S, &Created);
 540   if (Created)
 541     S->setExternal(true);
 542 }
 543
 544 void MCMachOStreamer::finalizeCGProfile() {
 545   MCAssembler &Asm = getAssembler();
 546   if (Asm.CGProfile.empty())
 547     return;
 548   for (MCAssembler::CGProfileEntry &E : Asm.CGProfile) {
 549     finalizeCGProfileEntry(E.From);
 550     finalizeCGProfileEntry(E.To);
 551   }
 552   // We can't write the section out until symbol indices are finalized which
 553   // doesn't happen until after section layout. We need to create the section
 554   // and set its size now so that it's accounted for in layout.
 555   MCSection *CGProfileSection = Asm.getContext().getMachOSection(
 556       "__LLVM", "__cg_profile", 0, SectionKind::getMetadata());
 557   Asm.registerSection(*CGProfileSection);
 558   auto *Frag = new MCDataFragment(CGProfileSection);
 559   // For each entry, reserve space for 2 32-bit indices and a 64-bit count.
 560   size_t SectionBytes =
 561       Asm.CGProfile.size() * (2 * sizeof(uint32_t) + sizeof(uint64_t));
 562   Frag->getContents().resize(SectionBytes);
 563 }
 564
 565 MCStreamer *llvm::createMachOStreamer(MCContext &Context,
 566                                       std::unique_ptr<MCAsmBackend> &&MAB,
 567                                       std::unique_ptr<MCObjectWriter> &&OW,
 568                                       std::unique_ptr<MCCodeEmitter> &&CE,
 569                                       bool RelaxAll, bool DWARFMustBeAtTheEnd,
 570                                       bool LabelSections) {
 571   MCMachOStreamer *S =
 572       new MCMachOStreamer(Context, std::move(MAB), std::move(OW), std::move(CE),
 573                           DWARFMustBeAtTheEnd, LabelSections);
 574   const Triple &Target = Context.getTargetTriple();
 575   S->emitVersionForTarget(
 576       Target, Context.getObjectFileInfo()->getSDKVersion(),
 577       Context.getObjectFileInfo()->getDarwinTargetVariantTriple(),
 578       Context.getObjectFileInfo()->getDarwinTargetVariantSDKVersion());
 579   if (RelaxAll)
 580     S->getAssembler().setRelaxAll(true);
 581   return S;
 582 }
 583
 584 // The AddrSig section uses a series of relocations to refer to the symbols that
 585 // should be considered address-significant. The only interesting content of
 586 // these relocations is their symbol; the type, length etc will be ignored by
 587 // the linker. The reason we are not referring to the symbol indices directly is
 588 // that those indices will be invalidated by tools that update the symbol table.
 589 // Symbol relocations OTOH will have their indices updated by e.g. llvm-strip.
 590 void MCMachOStreamer::createAddrSigSection() {
 591   MCAssembler &Asm = getAssembler();
 592   MCObjectWriter &writer = Asm.getWriter();
 593   if (!writer.getEmitAddrsigSection())
 594     return;
 595   // Create the AddrSig section and first data fragment here as its layout needs
 596   // to be computed immediately after in order for it to be exported correctly.
 597   MCSection *AddrSigSection =
 598       Asm.getContext().getObjectFileInfo()->getAddrSigSection();
 599   Asm.registerSection(*AddrSigSection);
 600   auto *Frag = new MCDataFragment(AddrSigSection);
 601   // We will generate a series of pointer-sized symbol relocations at offset
 602   // 0x0. Set the section size to be large enough to contain a single pointer
 603   // (instead of emitting a zero-sized section) so these relocations are
 604   // technically valid, even though we don't expect these relocations to
 605   // actually be applied by the linker.
 606   Frag->getContents().resize(8);
 607 }