contrib/llvm/lib/MC/MachObjectWriter.cpp

   1 //===- lib/MC/MachObjectWriter.cpp - Mach-O File Writer -------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/ADT/DenseMap.h"
  11 #include "llvm/ADT/Twine.h"
  12 #include "llvm/ADT/iterator_range.h"
  13 #include "llvm/BinaryFormat/MachO.h"
  14 #include "llvm/MC/MCAsmBackend.h"
  15 #include "llvm/MC/MCAsmLayout.h"
  16 #include "llvm/MC/MCAssembler.h"
  17 #include "llvm/MC/MCDirectives.h"
  18 #include "llvm/MC/MCExpr.h"
  19 #include "llvm/MC/MCFixupKindInfo.h"
  20 #include "llvm/MC/MCFragment.h"
  21 #include "llvm/MC/MCMachObjectWriter.h"
  22 #include "llvm/MC/MCObjectWriter.h"
  23 #include "llvm/MC/MCSection.h"
  24 #include "llvm/MC/MCSectionMachO.h"
  25 #include "llvm/MC/MCSymbol.h"
  26 #include "llvm/MC/MCSymbolMachO.h"
  27 #include "llvm/MC/MCValue.h"
  28 #include "llvm/Support/Casting.h"
  29 #include "llvm/Support/Debug.h"
  30 #include "llvm/Support/ErrorHandling.h"
  31 #include "llvm/Support/MathExtras.h"
  32 #include "llvm/Support/raw_ostream.h"
  33 #include <algorithm>
  34 #include <cassert>
  35 #include <cstdint>
  36 #include <string>
  37 #include <utility>
  38 #include <vector>
  39
  40 using namespace llvm;
  41
  42 #define DEBUG_TYPE "mc"
  43
  44 void MachObjectWriter::reset() {
  45   Relocations.clear();
  46   IndirectSymBase.clear();
  47   StringTable.clear();
  48   LocalSymbolData.clear();
  49   ExternalSymbolData.clear();
  50   UndefinedSymbolData.clear();
  51   MCObjectWriter::reset();
  52 }
  53
  54 bool MachObjectWriter::doesSymbolRequireExternRelocation(const MCSymbol &S) {
  55   // Undefined symbols are always extern.
  56   if (S.isUndefined())
  57     return true;
  58
  59   // References to weak definitions require external relocation entries; the
  60   // definition may not always be the one in the same object file.
  61   if (cast<MCSymbolMachO>(S).isWeakDefinition())
  62     return true;
  63
  64   // Otherwise, we can use an internal relocation.
  65   return false;
  66 }
  67
  68 bool MachObjectWriter::
  69 MachSymbolData::operator<(const MachSymbolData &RHS) const {
  70   return Symbol->getName() < RHS.Symbol->getName();
  71 }
  72
  73 bool MachObjectWriter::isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind) {
  74   const MCFixupKindInfo &FKI = Asm.getBackend().getFixupKindInfo(
  75     (MCFixupKind) Kind);
  76
  77   return FKI.Flags & MCFixupKindInfo::FKF_IsPCRel;
  78 }
  79
  80 uint64_t MachObjectWriter::getFragmentAddress(const MCFragment *Fragment,
  81                                               const MCAsmLayout &Layout) const {
  82   return getSectionAddress(Fragment->getParent()) +
  83          Layout.getFragmentOffset(Fragment);
  84 }
  85
  86 uint64_t MachObjectWriter::getSymbolAddress(const MCSymbol &S,
  87                                             const MCAsmLayout &Layout) const {
  88   // If this is a variable, then recursively evaluate now.
  89   if (S.isVariable()) {
  90     if (const MCConstantExpr *C =
  91           dyn_cast<const MCConstantExpr>(S.getVariableValue()))
  92       return C->getValue();
  93
  94     MCValue Target;
  95     if (!S.getVariableValue()->evaluateAsRelocatable(Target, &Layout, nullptr))
  96       report_fatal_error("unable to evaluate offset for variable '" +
  97                          S.getName() + "'");
  98
  99     // Verify that any used symbols are defined.
 100     if (Target.getSymA() && Target.getSymA()->getSymbol().isUndefined())
 101       report_fatal_error("unable to evaluate offset to undefined symbol '" +
 102                          Target.getSymA()->getSymbol().getName() + "'");
 103     if (Target.getSymB() && Target.getSymB()->getSymbol().isUndefined())
 104       report_fatal_error("unable to evaluate offset to undefined symbol '" +
 105                          Target.getSymB()->getSymbol().getName() + "'");
 106
 107     uint64_t Address = Target.getConstant();
 108     if (Target.getSymA())
 109       Address += getSymbolAddress(Target.getSymA()->getSymbol(), Layout);
 110     if (Target.getSymB())
 111       Address += getSymbolAddress(Target.getSymB()->getSymbol(), Layout);
 112     return Address;
 113   }
 114
 115   return getSectionAddress(S.getFragment()->getParent()) +
 116          Layout.getSymbolOffset(S);
 117 }
 118
 119 uint64_t MachObjectWriter::getPaddingSize(const MCSection *Sec,
 120                                           const MCAsmLayout &Layout) const {
 121   uint64_t EndAddr = getSectionAddress(Sec) + Layout.getSectionAddressSize(Sec);
 122   unsigned Next = Sec->getLayoutOrder() + 1;
 123   if (Next >= Layout.getSectionOrder().size())
 124     return 0;
 125
 126   const MCSection &NextSec = *Layout.getSectionOrder()[Next];
 127   if (NextSec.isVirtualSection())
 128     return 0;
 129   return OffsetToAlignment(EndAddr, NextSec.getAlignment());
 130 }
 131
 132 void MachObjectWriter::writeHeader(MachO::HeaderFileType Type,
 133                                    unsigned NumLoadCommands,
 134                                    unsigned LoadCommandsSize,
 135                                    bool SubsectionsViaSymbols) {
 136   uint32_t Flags = 0;
 137
 138   if (SubsectionsViaSymbols)
 139     Flags |= MachO::MH_SUBSECTIONS_VIA_SYMBOLS;
 140
 141   // struct mach_header (28 bytes) or
 142   // struct mach_header_64 (32 bytes)
 143
 144   uint64_t Start = getStream().tell();
 145   (void) Start;
 146
 147   write32(is64Bit() ? MachO::MH_MAGIC_64 : MachO::MH_MAGIC);
 148
 149   write32(TargetObjectWriter->getCPUType());
 150   write32(TargetObjectWriter->getCPUSubtype());
 151
 152   write32(Type);
 153   write32(NumLoadCommands);
 154   write32(LoadCommandsSize);
 155   write32(Flags);
 156   if (is64Bit())
 157     write32(0); // reserved
 158
 159   assert(
 160       getStream().tell() - Start ==
 161       (is64Bit() ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header)));
 162 }
 163
 164 /// writeSegmentLoadCommand - Write a segment load command.
 165 ///
 166 /// \param NumSections The number of sections in this segment.
 167 /// \param SectionDataSize The total size of the sections.
 168 void MachObjectWriter::writeSegmentLoadCommand(
 169     StringRef Name, unsigned NumSections, uint64_t VMAddr, uint64_t VMSize,
 170     uint64_t SectionDataStartOffset, uint64_t SectionDataSize, uint32_t MaxProt,
 171     uint32_t InitProt) {
 172   // struct segment_command (56 bytes) or
 173   // struct segment_command_64 (72 bytes)
 174
 175   uint64_t Start = getStream().tell();
 176   (void) Start;
 177
 178   unsigned SegmentLoadCommandSize =
 179     is64Bit() ? sizeof(MachO::segment_command_64):
 180     sizeof(MachO::segment_command);
 181   write32(is64Bit() ? MachO::LC_SEGMENT_64 : MachO::LC_SEGMENT);
 182   write32(SegmentLoadCommandSize +
 183           NumSections * (is64Bit() ? sizeof(MachO::section_64) :
 184                          sizeof(MachO::section)));
 185
 186   assert(Name.size() <= 16);
 187   writeBytes(Name, 16);
 188   if (is64Bit()) {
 189     write64(VMAddr);                 // vmaddr
 190     write64(VMSize); // vmsize
 191     write64(SectionDataStartOffset); // file offset
 192     write64(SectionDataSize); // file size
 193   } else {
 194     write32(VMAddr);                 // vmaddr
 195     write32(VMSize); // vmsize
 196     write32(SectionDataStartOffset); // file offset
 197     write32(SectionDataSize); // file size
 198   }
 199   // maxprot
 200   write32(MaxProt);
 201   // initprot
 202   write32(InitProt);
 203   write32(NumSections);
 204   write32(0); // flags
 205
 206   assert(getStream().tell() - Start == SegmentLoadCommandSize);
 207 }
 208
 209 void MachObjectWriter::writeSection(const MCAsmLayout &Layout,
 210                                     const MCSection &Sec, uint64_t VMAddr,
 211                                     uint64_t FileOffset, unsigned Flags,
 212                                     uint64_t RelocationsStart,
 213                                     unsigned NumRelocations) {
 214   uint64_t SectionSize = Layout.getSectionAddressSize(&Sec);
 215   const MCSectionMachO &Section = cast<MCSectionMachO>(Sec);
 216
 217   // The offset is unused for virtual sections.
 218   if (Section.isVirtualSection()) {
 219     assert(Layout.getSectionFileSize(&Sec) == 0 && "Invalid file size!");
 220     FileOffset = 0;
 221   }
 222
 223   // struct section (68 bytes) or
 224   // struct section_64 (80 bytes)
 225
 226   uint64_t Start = getStream().tell();
 227   (void) Start;
 228
 229   writeBytes(Section.getSectionName(), 16);
 230   writeBytes(Section.getSegmentName(), 16);
 231   if (is64Bit()) {
 232     write64(VMAddr);      // address
 233     write64(SectionSize); // size
 234   } else {
 235     write32(VMAddr);      // address
 236     write32(SectionSize); // size
 237   }
 238   write32(FileOffset);
 239
 240   assert(isPowerOf2_32(Section.getAlignment()) && "Invalid alignment!");
 241   write32(Log2_32(Section.getAlignment()));
 242   write32(NumRelocations ? RelocationsStart : 0);
 243   write32(NumRelocations);
 244   write32(Flags);
 245   write32(IndirectSymBase.lookup(&Sec)); // reserved1
 246   write32(Section.getStubSize()); // reserved2
 247   if (is64Bit())
 248     write32(0); // reserved3
 249
 250   assert(getStream().tell() - Start ==
 251          (is64Bit() ? sizeof(MachO::section_64) : sizeof(MachO::section)));
 252 }
 253
 254 void MachObjectWriter::writeSymtabLoadCommand(uint32_t SymbolOffset,
 255                                               uint32_t NumSymbols,
 256                                               uint32_t StringTableOffset,
 257                                               uint32_t StringTableSize) {
 258   // struct symtab_command (24 bytes)
 259
 260   uint64_t Start = getStream().tell();
 261   (void) Start;
 262
 263   write32(MachO::LC_SYMTAB);
 264   write32(sizeof(MachO::symtab_command));
 265   write32(SymbolOffset);
 266   write32(NumSymbols);
 267   write32(StringTableOffset);
 268   write32(StringTableSize);
 269
 270   assert(getStream().tell() - Start == sizeof(MachO::symtab_command));
 271 }
 272
 273 void MachObjectWriter::writeDysymtabLoadCommand(uint32_t FirstLocalSymbol,
 274                                                 uint32_t NumLocalSymbols,
 275                                                 uint32_t FirstExternalSymbol,
 276                                                 uint32_t NumExternalSymbols,
 277                                                 uint32_t FirstUndefinedSymbol,
 278                                                 uint32_t NumUndefinedSymbols,
 279                                                 uint32_t IndirectSymbolOffset,
 280                                                 uint32_t NumIndirectSymbols) {
 281   // struct dysymtab_command (80 bytes)
 282
 283   uint64_t Start = getStream().tell();
 284   (void) Start;
 285
 286   write32(MachO::LC_DYSYMTAB);
 287   write32(sizeof(MachO::dysymtab_command));
 288   write32(FirstLocalSymbol);
 289   write32(NumLocalSymbols);
 290   write32(FirstExternalSymbol);
 291   write32(NumExternalSymbols);
 292   write32(FirstUndefinedSymbol);
 293   write32(NumUndefinedSymbols);
 294   write32(0); // tocoff
 295   write32(0); // ntoc
 296   write32(0); // modtaboff
 297   write32(0); // nmodtab
 298   write32(0); // extrefsymoff
 299   write32(0); // nextrefsyms
 300   write32(IndirectSymbolOffset);
 301   write32(NumIndirectSymbols);
 302   write32(0); // extreloff
 303   write32(0); // nextrel
 304   write32(0); // locreloff
 305   write32(0); // nlocrel
 306
 307   assert(getStream().tell() - Start == sizeof(MachO::dysymtab_command));
 308 }
 309
 310 MachObjectWriter::MachSymbolData *
 311 MachObjectWriter::findSymbolData(const MCSymbol &Sym) {
 312   for (auto *SymbolData :
 313        {&LocalSymbolData, &ExternalSymbolData, &UndefinedSymbolData})
 314     for (MachSymbolData &Entry : *SymbolData)
 315       if (Entry.Symbol == &Sym)
 316         return &Entry;
 317
 318   return nullptr;
 319 }
 320
 321 const MCSymbol &MachObjectWriter::findAliasedSymbol(const MCSymbol &Sym) const {
 322   const MCSymbol *S = &Sym;
 323   while (S->isVariable()) {
 324     const MCExpr *Value = S->getVariableValue();
 325     const auto *Ref = dyn_cast<MCSymbolRefExpr>(Value);
 326     if (!Ref)
 327       return *S;
 328     S = &Ref->getSymbol();
 329   }
 330   return *S;
 331 }
 332
 333 void MachObjectWriter::writeNlist(MachSymbolData &MSD,
 334                                   const MCAsmLayout &Layout) {
 335   const MCSymbol *Symbol = MSD.Symbol;
 336   const MCSymbol &Data = *Symbol;
 337   const MCSymbol *AliasedSymbol = &findAliasedSymbol(*Symbol);
 338   uint8_t SectionIndex = MSD.SectionIndex;
 339   uint8_t Type = 0;
 340   uint64_t Address = 0;
 341   bool IsAlias = Symbol != AliasedSymbol;
 342
 343   const MCSymbol &OrigSymbol = *Symbol;
 344   MachSymbolData *AliaseeInfo;
 345   if (IsAlias) {
 346     AliaseeInfo = findSymbolData(*AliasedSymbol);
 347     if (AliaseeInfo)
 348       SectionIndex = AliaseeInfo->SectionIndex;
 349     Symbol = AliasedSymbol;
 350     // FIXME: Should this update Data as well?
 351   }
 352
 353   // Set the N_TYPE bits. See <mach-o/nlist.h>.
 354   //
 355   // FIXME: Are the prebound or indirect fields possible here?
 356   if (IsAlias && Symbol->isUndefined())
 357     Type = MachO::N_INDR;
 358   else if (Symbol->isUndefined())
 359     Type = MachO::N_UNDF;
 360   else if (Symbol->isAbsolute())
 361     Type = MachO::N_ABS;
 362   else
 363     Type = MachO::N_SECT;
 364
 365   // FIXME: Set STAB bits.
 366
 367   if (Data.isPrivateExtern())
 368     Type |= MachO::N_PEXT;
 369
 370   // Set external bit.
 371   if (Data.isExternal() || (!IsAlias && Symbol->isUndefined()))
 372     Type |= MachO::N_EXT;
 373
 374   // Compute the symbol address.
 375   if (IsAlias && Symbol->isUndefined())
 376     Address = AliaseeInfo->StringIndex;
 377   else if (Symbol->isDefined())
 378     Address = getSymbolAddress(OrigSymbol, Layout);
 379   else if (Symbol->isCommon()) {
 380     // Common symbols are encoded with the size in the address
 381     // field, and their alignment in the flags.
 382     Address = Symbol->getCommonSize();
 383   }
 384
 385   // struct nlist (12 bytes)
 386
 387   write32(MSD.StringIndex);
 388   write8(Type);
 389   write8(SectionIndex);
 390
 391   // The Mach-O streamer uses the lowest 16-bits of the flags for the 'desc'
 392   // value.
 393   bool EncodeAsAltEntry =
 394     IsAlias && cast<MCSymbolMachO>(OrigSymbol).isAltEntry();
 395   write16(cast<MCSymbolMachO>(Symbol)->getEncodedFlags(EncodeAsAltEntry));
 396   if (is64Bit())
 397     write64(Address);
 398   else
 399     write32(Address);
 400 }
 401
 402 void MachObjectWriter::writeLinkeditLoadCommand(uint32_t Type,
 403                                                 uint32_t DataOffset,
 404                                                 uint32_t DataSize) {
 405   uint64_t Start = getStream().tell();
 406   (void) Start;
 407
 408   write32(Type);
 409   write32(sizeof(MachO::linkedit_data_command));
 410   write32(DataOffset);
 411   write32(DataSize);
 412
 413   assert(getStream().tell() - Start == sizeof(MachO::linkedit_data_command));
 414 }
 415
 416 static unsigned ComputeLinkerOptionsLoadCommandSize(
 417   const std::vector<std::string> &Options, bool is64Bit)
 418 {
 419   unsigned Size = sizeof(MachO::linker_option_command);
 420   for (const std::string &Option : Options)
 421     Size += Option.size() + 1;
 422   return alignTo(Size, is64Bit ? 8 : 4);
 423 }
 424
 425 void MachObjectWriter::writeLinkerOptionsLoadCommand(
 426   const std::vector<std::string> &Options)
 427 {
 428   unsigned Size = ComputeLinkerOptionsLoadCommandSize(Options, is64Bit());
 429   uint64_t Start = getStream().tell();
 430   (void) Start;
 431
 432   write32(MachO::LC_LINKER_OPTION);
 433   write32(Size);
 434   write32(Options.size());
 435   uint64_t BytesWritten = sizeof(MachO::linker_option_command);
 436   for (const std::string &Option : Options) {
 437     // Write each string, including the null byte.
 438     writeBytes(Option, Option.size() + 1);
 439     BytesWritten += Option.size() + 1;
 440   }
 441
 442   // Pad to a multiple of the pointer size.
 443   writeBytes("", OffsetToAlignment(BytesWritten, is64Bit() ? 8 : 4));
 444
 445   assert(getStream().tell() - Start == Size);
 446 }
 447
 448 void MachObjectWriter::recordRelocation(MCAssembler &Asm,
 449                                         const MCAsmLayout &Layout,
 450                                         const MCFragment *Fragment,
 451                                         const MCFixup &Fixup, MCValue Target,
 452                                         uint64_t &FixedValue) {
 453   TargetObjectWriter->recordRelocation(this, Asm, Layout, Fragment, Fixup,
 454                                        Target, FixedValue);
 455 }
 456
 457 void MachObjectWriter::bindIndirectSymbols(MCAssembler &Asm) {
 458   // This is the point where 'as' creates actual symbols for indirect symbols
 459   // (in the following two passes). It would be easier for us to do this sooner
 460   // when we see the attribute, but that makes getting the order in the symbol
 461   // table much more complicated than it is worth.
 462   //
 463   // FIXME: Revisit this when the dust settles.
 464
 465   // Report errors for use of .indirect_symbol not in a symbol pointer section
 466   // or stub section.
 467   for (MCAssembler::indirect_symbol_iterator it = Asm.indirect_symbol_begin(),
 468          ie = Asm.indirect_symbol_end(); it != ie; ++it) {
 469     const MCSectionMachO &Section = cast<MCSectionMachO>(*it->Section);
 470
 471     if (Section.getType() != MachO::S_NON_LAZY_SYMBOL_POINTERS &&
 472         Section.getType() != MachO::S_LAZY_SYMBOL_POINTERS &&
 473         Section.getType() != MachO::S_THREAD_LOCAL_VARIABLE_POINTERS &&
 474         Section.getType() != MachO::S_SYMBOL_STUBS) {
 475       MCSymbol &Symbol = *it->Symbol;
 476       report_fatal_error("indirect symbol '" + Symbol.getName() +
 477                          "' not in a symbol pointer or stub section");
 478     }
 479   }
 480
 481   // Bind non-lazy symbol pointers first.
 482   unsigned IndirectIndex = 0;
 483   for (MCAssembler::indirect_symbol_iterator it = Asm.indirect_symbol_begin(),
 484          ie = Asm.indirect_symbol_end(); it != ie; ++it, ++IndirectIndex) {
 485     const MCSectionMachO &Section = cast<MCSectionMachO>(*it->Section);
 486
 487     if (Section.getType() != MachO::S_NON_LAZY_SYMBOL_POINTERS &&
 488         Section.getType() !=  MachO::S_THREAD_LOCAL_VARIABLE_POINTERS)
 489       continue;
 490
 491     // Initialize the section indirect symbol base, if necessary.
 492     IndirectSymBase.insert(std::make_pair(it->Section, IndirectIndex));
 493
 494     Asm.registerSymbol(*it->Symbol);
 495   }
 496
 497   // Then lazy symbol pointers and symbol stubs.
 498   IndirectIndex = 0;
 499   for (MCAssembler::indirect_symbol_iterator it = Asm.indirect_symbol_begin(),
 500          ie = Asm.indirect_symbol_end(); it != ie; ++it, ++IndirectIndex) {
 501     const MCSectionMachO &Section = cast<MCSectionMachO>(*it->Section);
 502
 503     if (Section.getType() != MachO::S_LAZY_SYMBOL_POINTERS &&
 504         Section.getType() != MachO::S_SYMBOL_STUBS)
 505       continue;
 506
 507     // Initialize the section indirect symbol base, if necessary.
 508     IndirectSymBase.insert(std::make_pair(it->Section, IndirectIndex));
 509
 510     // Set the symbol type to undefined lazy, but only on construction.
 511     //
 512     // FIXME: Do not hardcode.
 513     bool Created;
 514     Asm.registerSymbol(*it->Symbol, &Created);
 515     if (Created)
 516       cast<MCSymbolMachO>(it->Symbol)->setReferenceTypeUndefinedLazy(true);
 517   }
 518 }
 519
 520 /// computeSymbolTable - Compute the symbol table data
 521 void MachObjectWriter::computeSymbolTable(
 522     MCAssembler &Asm, std::vector<MachSymbolData> &LocalSymbolData,
 523     std::vector<MachSymbolData> &ExternalSymbolData,
 524     std::vector<MachSymbolData> &UndefinedSymbolData) {
 525   // Build section lookup table.
 526   DenseMap<const MCSection*, uint8_t> SectionIndexMap;
 527   unsigned Index = 1;
 528   for (MCAssembler::iterator it = Asm.begin(),
 529          ie = Asm.end(); it != ie; ++it, ++Index)
 530     SectionIndexMap[&*it] = Index;
 531   assert(Index <= 256 && "Too many sections!");
 532
 533   // Build the string table.
 534   for (const MCSymbol &Symbol : Asm.symbols()) {
 535     if (!Asm.isSymbolLinkerVisible(Symbol))
 536       continue;
 537
 538     StringTable.add(Symbol.getName());
 539   }
 540   StringTable.finalize();
 541
 542   // Build the symbol arrays but only for non-local symbols.
 543   //
 544   // The particular order that we collect and then sort the symbols is chosen to
 545   // match 'as'. Even though it doesn't matter for correctness, this is
 546   // important for letting us diff .o files.
 547   for (const MCSymbol &Symbol : Asm.symbols()) {
 548     // Ignore non-linker visible symbols.
 549     if (!Asm.isSymbolLinkerVisible(Symbol))
 550       continue;
 551
 552     if (!Symbol.isExternal() && !Symbol.isUndefined())
 553       continue;
 554
 555     MachSymbolData MSD;
 556     MSD.Symbol = &Symbol;
 557     MSD.StringIndex = StringTable.getOffset(Symbol.getName());
 558
 559     if (Symbol.isUndefined()) {
 560       MSD.SectionIndex = 0;
 561       UndefinedSymbolData.push_back(MSD);
 562     } else if (Symbol.isAbsolute()) {
 563       MSD.SectionIndex = 0;
 564       ExternalSymbolData.push_back(MSD);
 565     } else {
 566       MSD.SectionIndex = SectionIndexMap.lookup(&Symbol.getSection());
 567       assert(MSD.SectionIndex && "Invalid section index!");
 568       ExternalSymbolData.push_back(MSD);
 569     }
 570   }
 571
 572   // Now add the data for local symbols.
 573   for (const MCSymbol &Symbol : Asm.symbols()) {
 574     // Ignore non-linker visible symbols.
 575     if (!Asm.isSymbolLinkerVisible(Symbol))
 576       continue;
 577
 578     if (Symbol.isExternal() || Symbol.isUndefined())
 579       continue;
 580
 581     MachSymbolData MSD;
 582     MSD.Symbol = &Symbol;
 583     MSD.StringIndex = StringTable.getOffset(Symbol.getName());
 584
 585     if (Symbol.isAbsolute()) {
 586       MSD.SectionIndex = 0;
 587       LocalSymbolData.push_back(MSD);
 588     } else {
 589       MSD.SectionIndex = SectionIndexMap.lookup(&Symbol.getSection());
 590       assert(MSD.SectionIndex && "Invalid section index!");
 591       LocalSymbolData.push_back(MSD);
 592     }
 593   }
 594
 595   // External and undefined symbols are required to be in lexicographic order.
 596   std::sort(ExternalSymbolData.begin(), ExternalSymbolData.end());
 597   std::sort(UndefinedSymbolData.begin(), UndefinedSymbolData.end());
 598
 599   // Set the symbol indices.
 600   Index = 0;
 601   for (auto *SymbolData :
 602        {&LocalSymbolData, &ExternalSymbolData, &UndefinedSymbolData})
 603     for (MachSymbolData &Entry : *SymbolData)
 604       Entry.Symbol->setIndex(Index++);
 605
 606   for (const MCSection &Section : Asm) {
 607     for (RelAndSymbol &Rel : Relocations[&Section]) {
 608       if (!Rel.Sym)
 609         continue;
 610
 611       // Set the Index and the IsExtern bit.
 612       unsigned Index = Rel.Sym->getIndex();
 613       assert(isInt<24>(Index));
 614       if (IsLittleEndian)
 615         Rel.MRE.r_word1 = (Rel.MRE.r_word1 & (~0U << 24)) | Index | (1 << 27);
 616       else
 617         Rel.MRE.r_word1 = (Rel.MRE.r_word1 & 0xff) | Index << 8 | (1 << 4);
 618     }
 619   }
 620 }
 621
 622 void MachObjectWriter::computeSectionAddresses(const MCAssembler &Asm,
 623                                                const MCAsmLayout &Layout) {
 624   uint64_t StartAddress = 0;
 625   for (const MCSection *Sec : Layout.getSectionOrder()) {
 626     StartAddress = alignTo(StartAddress, Sec->getAlignment());
 627     SectionAddress[Sec] = StartAddress;
 628     StartAddress += Layout.getSectionAddressSize(Sec);
 629
 630     // Explicitly pad the section to match the alignment requirements of the
 631     // following one. This is for 'gas' compatibility, it shouldn't
 632     /// strictly be necessary.
 633     StartAddress += getPaddingSize(Sec, Layout);
 634   }
 635 }
 636
 637 void MachObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
 638                                                 const MCAsmLayout &Layout) {
 639   computeSectionAddresses(Asm, Layout);
 640
 641   // Create symbol data for any indirect symbols.
 642   bindIndirectSymbols(Asm);
 643 }
 644
 645 bool MachObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(
 646     const MCAssembler &Asm, const MCSymbol &A, const MCSymbol &B,
 647     bool InSet) const {
 648   // FIXME: We don't handle things like
 649   // foo = .
 650   // creating atoms.
 651   if (A.isVariable() || B.isVariable())
 652     return false;
 653   return MCObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(Asm, A, B,
 654                                                                 InSet);
 655 }
 656
 657 bool MachObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(
 658     const MCAssembler &Asm, const MCSymbol &SymA, const MCFragment &FB,
 659     bool InSet, bool IsPCRel) const {
 660   if (InSet)
 661     return true;
 662
 663   // The effective address is
 664   //     addr(atom(A)) + offset(A)
 665   //   - addr(atom(B)) - offset(B)
 666   // and the offsets are not relocatable, so the fixup is fully resolved when
 667   //  addr(atom(A)) - addr(atom(B)) == 0.
 668   const MCSymbol &SA = findAliasedSymbol(SymA);
 669   const MCSection &SecA = SA.getSection();
 670   const MCSection &SecB = *FB.getParent();
 671
 672   if (IsPCRel) {
 673     // The simple (Darwin, except on x86_64) way of dealing with this was to
 674     // assume that any reference to a temporary symbol *must* be a temporary
 675     // symbol in the same atom, unless the sections differ. Therefore, any PCrel
 676     // relocation to a temporary symbol (in the same section) is fully
 677     // resolved. This also works in conjunction with absolutized .set, which
 678     // requires the compiler to use .set to absolutize the differences between
 679     // symbols which the compiler knows to be assembly time constants, so we
 680     // don't need to worry about considering symbol differences fully resolved.
 681     //
 682     // If the file isn't using sub-sections-via-symbols, we can make the
 683     // same assumptions about any symbol that we normally make about
 684     // assembler locals.
 685
 686     bool hasReliableSymbolDifference = isX86_64();
 687     if (!hasReliableSymbolDifference) {
 688       if (!SA.isInSection() || &SecA != &SecB ||
 689           (!SA.isTemporary() && FB.getAtom() != SA.getFragment()->getAtom() &&
 690            Asm.getSubsectionsViaSymbols()))
 691         return false;
 692       return true;
 693     }
 694     // For Darwin x86_64, there is one special case when the reference IsPCRel.
 695     // If the fragment with the reference does not have a base symbol but meets
 696     // the simple way of dealing with this, in that it is a temporary symbol in
 697     // the same atom then it is assumed to be fully resolved.  This is needed so
 698     // a relocation entry is not created and so the static linker does not
 699     // mess up the reference later.
 700     else if(!FB.getAtom() &&
 701             SA.isTemporary() && SA.isInSection() && &SecA == &SecB){
 702       return true;
 703     }
 704   }
 705
 706   // If they are not in the same section, we can't compute the diff.
 707   if (&SecA != &SecB)
 708     return false;
 709
 710   const MCFragment *FA = SA.getFragment();
 711
 712   // Bail if the symbol has no fragment.
 713   if (!FA)
 714     return false;
 715
 716   // If the atoms are the same, they are guaranteed to have the same address.
 717   if (FA->getAtom() == FB.getAtom())
 718     return true;
 719
 720   // Otherwise, we can't prove this is fully resolved.
 721   return false;
 722 }
 723
 724 static MachO::LoadCommandType getLCFromMCVM(MCVersionMinType Type) {
 725   switch (Type) {
 726   case MCVM_OSXVersionMin:     return MachO::LC_VERSION_MIN_MACOSX;
 727   case MCVM_IOSVersionMin:     return MachO::LC_VERSION_MIN_IPHONEOS;
 728   case MCVM_TvOSVersionMin:    return MachO::LC_VERSION_MIN_TVOS;
 729   case MCVM_WatchOSVersionMin: return MachO::LC_VERSION_MIN_WATCHOS;
 730   }
 731   llvm_unreachable("Invalid mc version min type");
 732 }
 733
 734 void MachObjectWriter::writeObject(MCAssembler &Asm,
 735                                    const MCAsmLayout &Layout) {
 736   // Compute symbol table information and bind symbol indices.
 737   computeSymbolTable(Asm, LocalSymbolData, ExternalSymbolData,
 738                      UndefinedSymbolData);
 739
 740   unsigned NumSections = Asm.size();
 741   const MCAssembler::VersionInfoType &VersionInfo =
 742     Layout.getAssembler().getVersionInfo();
 743
 744   // The section data starts after the header, the segment load command (and
 745   // section headers) and the symbol table.
 746   unsigned NumLoadCommands = 1;
 747   uint64_t LoadCommandsSize = is64Bit() ?
 748     sizeof(MachO::segment_command_64) + NumSections * sizeof(MachO::section_64):
 749     sizeof(MachO::segment_command) + NumSections * sizeof(MachO::section);
 750
 751   // Add the deployment target version info load command size, if used.
 752   if (VersionInfo.Major != 0) {
 753     ++NumLoadCommands;
 754     if (VersionInfo.EmitBuildVersion)
 755       LoadCommandsSize += sizeof(MachO::build_version_command);
 756     else
 757       LoadCommandsSize += sizeof(MachO::version_min_command);
 758   }
 759
 760   // Add the data-in-code load command size, if used.
 761   unsigned NumDataRegions = Asm.getDataRegions().size();
 762   if (NumDataRegions) {
 763     ++NumLoadCommands;
 764     LoadCommandsSize += sizeof(MachO::linkedit_data_command);
 765   }
 766
 767   // Add the loh load command size, if used.
 768   uint64_t LOHRawSize = Asm.getLOHContainer().getEmitSize(*this, Layout);
 769   uint64_t LOHSize = alignTo(LOHRawSize, is64Bit() ? 8 : 4);
 770   if (LOHSize) {
 771     ++NumLoadCommands;
 772     LoadCommandsSize += sizeof(MachO::linkedit_data_command);
 773   }
 774
 775   // Add the symbol table load command sizes, if used.
 776   unsigned NumSymbols = LocalSymbolData.size() + ExternalSymbolData.size() +
 777     UndefinedSymbolData.size();
 778   if (NumSymbols) {
 779     NumLoadCommands += 2;
 780     LoadCommandsSize += (sizeof(MachO::symtab_command) +
 781                          sizeof(MachO::dysymtab_command));
 782   }
 783
 784   // Add the linker option load commands sizes.
 785   for (const auto &Option : Asm.getLinkerOptions()) {
 786     ++NumLoadCommands;
 787     LoadCommandsSize += ComputeLinkerOptionsLoadCommandSize(Option, is64Bit());
 788   }
 789
 790   // Compute the total size of the section data, as well as its file size and vm
 791   // size.
 792   uint64_t SectionDataStart = (is64Bit() ? sizeof(MachO::mach_header_64) :
 793                                sizeof(MachO::mach_header)) + LoadCommandsSize;
 794   uint64_t SectionDataSize = 0;
 795   uint64_t SectionDataFileSize = 0;
 796   uint64_t VMSize = 0;
 797   for (const MCSection &Sec : Asm) {
 798     uint64_t Address = getSectionAddress(&Sec);
 799     uint64_t Size = Layout.getSectionAddressSize(&Sec);
 800     uint64_t FileSize = Layout.getSectionFileSize(&Sec);
 801     FileSize += getPaddingSize(&Sec, Layout);
 802
 803     VMSize = std::max(VMSize, Address + Size);
 804
 805     if (Sec.isVirtualSection())
 806       continue;
 807
 808     SectionDataSize = std::max(SectionDataSize, Address + Size);
 809     SectionDataFileSize = std::max(SectionDataFileSize, Address + FileSize);
 810   }
 811
 812   // The section data is padded to 4 bytes.
 813   //
 814   // FIXME: Is this machine dependent?
 815   unsigned SectionDataPadding = OffsetToAlignment(SectionDataFileSize, 4);
 816   SectionDataFileSize += SectionDataPadding;
 817
 818   // Write the prolog, starting with the header and load command...
 819   writeHeader(MachO::MH_OBJECT, NumLoadCommands, LoadCommandsSize,
 820               Asm.getSubsectionsViaSymbols());
 821   uint32_t Prot =
 822       MachO::VM_PROT_READ | MachO::VM_PROT_WRITE | MachO::VM_PROT_EXECUTE;
 823   writeSegmentLoadCommand("", NumSections, 0, VMSize, SectionDataStart,
 824                           SectionDataSize, Prot, Prot);
 825
 826   // ... and then the section headers.
 827   uint64_t RelocTableEnd = SectionDataStart + SectionDataFileSize;
 828   for (const MCSection &Section : Asm) {
 829     const auto &Sec = cast<MCSectionMachO>(Section);
 830     std::vector<RelAndSymbol> &Relocs = Relocations[&Sec];
 831     unsigned NumRelocs = Relocs.size();
 832     uint64_t SectionStart = SectionDataStart + getSectionAddress(&Sec);
 833     unsigned Flags = Sec.getTypeAndAttributes();
 834     if (Sec.hasInstructions())
 835       Flags |= MachO::S_ATTR_SOME_INSTRUCTIONS;
 836     writeSection(Layout, Sec, getSectionAddress(&Sec), SectionStart, Flags,
 837                  RelocTableEnd, NumRelocs);
 838     RelocTableEnd += NumRelocs * sizeof(MachO::any_relocation_info);
 839   }
 840
 841   // Write out the deployment target information, if it's available.
 842   if (VersionInfo.Major != 0) {
 843     assert(VersionInfo.Update < 256 && "unencodable update target version");
 844     assert(VersionInfo.Minor < 256 && "unencodable minor target version");
 845     assert(VersionInfo.Major < 65536 && "unencodable major target version");
 846     uint32_t EncodedVersion = VersionInfo.Update | (VersionInfo.Minor << 8) |
 847       (VersionInfo.Major << 16);
 848     if (VersionInfo.EmitBuildVersion) {
 849       // FIXME: Currently empty tools. Add clang version in the future.
 850       write32(MachO::LC_BUILD_VERSION);
 851       write32(sizeof(MachO::build_version_command));
 852       write32(VersionInfo.TypeOrPlatform.Platform);
 853       write32(EncodedVersion);
 854       write32(0);         // SDK version.
 855       write32(0);         // Empty tools list.
 856     } else {
 857       MachO::LoadCommandType LCType
 858         = getLCFromMCVM(VersionInfo.TypeOrPlatform.Type);
 859       write32(LCType);
 860       write32(sizeof(MachO::version_min_command));
 861       write32(EncodedVersion);
 862       write32(0);         // reserved.
 863     }
 864   }
 865
 866   // Write the data-in-code load command, if used.
 867   uint64_t DataInCodeTableEnd = RelocTableEnd + NumDataRegions * 8;
 868   if (NumDataRegions) {
 869     uint64_t DataRegionsOffset = RelocTableEnd;
 870     uint64_t DataRegionsSize = NumDataRegions * 8;
 871     writeLinkeditLoadCommand(MachO::LC_DATA_IN_CODE, DataRegionsOffset,
 872                              DataRegionsSize);
 873   }
 874
 875   // Write the loh load command, if used.
 876   uint64_t LOHTableEnd = DataInCodeTableEnd + LOHSize;
 877   if (LOHSize)
 878     writeLinkeditLoadCommand(MachO::LC_LINKER_OPTIMIZATION_HINT,
 879                              DataInCodeTableEnd, LOHSize);
 880
 881   // Write the symbol table load command, if used.
 882   if (NumSymbols) {
 883     unsigned FirstLocalSymbol = 0;
 884     unsigned NumLocalSymbols = LocalSymbolData.size();
 885     unsigned FirstExternalSymbol = FirstLocalSymbol + NumLocalSymbols;
 886     unsigned NumExternalSymbols = ExternalSymbolData.size();
 887     unsigned FirstUndefinedSymbol = FirstExternalSymbol + NumExternalSymbols;
 888     unsigned NumUndefinedSymbols = UndefinedSymbolData.size();
 889     unsigned NumIndirectSymbols = Asm.indirect_symbol_size();
 890     unsigned NumSymTabSymbols =
 891       NumLocalSymbols + NumExternalSymbols + NumUndefinedSymbols;
 892     uint64_t IndirectSymbolSize = NumIndirectSymbols * 4;
 893     uint64_t IndirectSymbolOffset = 0;
 894
 895     // If used, the indirect symbols are written after the section data.
 896     if (NumIndirectSymbols)
 897       IndirectSymbolOffset = LOHTableEnd;
 898
 899     // The symbol table is written after the indirect symbol data.
 900     uint64_t SymbolTableOffset = LOHTableEnd + IndirectSymbolSize;
 901
 902     // The string table is written after symbol table.
 903     uint64_t StringTableOffset =
 904       SymbolTableOffset + NumSymTabSymbols * (is64Bit() ?
 905                                               sizeof(MachO::nlist_64) :
 906                                               sizeof(MachO::nlist));
 907     writeSymtabLoadCommand(SymbolTableOffset, NumSymTabSymbols,
 908                            StringTableOffset, StringTable.getSize());
 909
 910     writeDysymtabLoadCommand(FirstLocalSymbol, NumLocalSymbols,
 911                              FirstExternalSymbol, NumExternalSymbols,
 912                              FirstUndefinedSymbol, NumUndefinedSymbols,
 913                              IndirectSymbolOffset, NumIndirectSymbols);
 914   }
 915
 916   // Write the linker options load commands.
 917   for (const auto &Option : Asm.getLinkerOptions())
 918     writeLinkerOptionsLoadCommand(Option);
 919
 920   // Write the actual section data.
 921   for (const MCSection &Sec : Asm) {
 922     Asm.writeSectionData(&Sec, Layout);
 923
 924     uint64_t Pad = getPaddingSize(&Sec, Layout);
 925     WriteZeros(Pad);
 926   }
 927
 928   // Write the extra padding.
 929   WriteZeros(SectionDataPadding);
 930
 931   // Write the relocation entries.
 932   for (const MCSection &Sec : Asm) {
 933     // Write the section relocation entries, in reverse order to match 'as'
 934     // (approximately, the exact algorithm is more complicated than this).
 935     std::vector<RelAndSymbol> &Relocs = Relocations[&Sec];
 936     for (const RelAndSymbol &Rel : make_range(Relocs.rbegin(), Relocs.rend())) {
 937       write32(Rel.MRE.r_word0);
 938       write32(Rel.MRE.r_word1);
 939     }
 940   }
 941
 942   // Write out the data-in-code region payload, if there is one.
 943   for (MCAssembler::const_data_region_iterator
 944          it = Asm.data_region_begin(), ie = Asm.data_region_end();
 945          it != ie; ++it) {
 946     const DataRegionData *Data = &(*it);
 947     uint64_t Start = getSymbolAddress(*Data->Start, Layout);
 948     uint64_t End = getSymbolAddress(*Data->End, Layout);
 949     DEBUG(dbgs() << "data in code region-- kind: " << Data->Kind
 950                  << "  start: " << Start << "(" << Data->Start->getName() << ")"
 951                  << "  end: " << End << "(" << Data->End->getName() << ")"
 952                  << "  size: " << End - Start
 953                  << "\n");
 954     write32(Start);
 955     write16(End - Start);
 956     write16(Data->Kind);
 957   }
 958
 959   // Write out the loh commands, if there is one.
 960   if (LOHSize) {
 961 #ifndef NDEBUG
 962     unsigned Start = getStream().tell();
 963 #endif
 964     Asm.getLOHContainer().emit(*this, Layout);
 965     // Pad to a multiple of the pointer size.
 966     writeBytes("", OffsetToAlignment(LOHRawSize, is64Bit() ? 8 : 4));
 967     assert(getStream().tell() - Start == LOHSize);
 968   }
 969
 970   // Write the symbol table data, if used.
 971   if (NumSymbols) {
 972     // Write the indirect symbol entries.
 973     for (MCAssembler::const_indirect_symbol_iterator
 974            it = Asm.indirect_symbol_begin(),
 975            ie = Asm.indirect_symbol_end(); it != ie; ++it) {
 976       // Indirect symbols in the non-lazy symbol pointer section have some
 977       // special handling.
 978       const MCSectionMachO &Section =
 979           static_cast<const MCSectionMachO &>(*it->Section);
 980       if (Section.getType() == MachO::S_NON_LAZY_SYMBOL_POINTERS) {
 981         // If this symbol is defined and internal, mark it as such.
 982         if (it->Symbol->isDefined() && !it->Symbol->isExternal()) {
 983           uint32_t Flags = MachO::INDIRECT_SYMBOL_LOCAL;
 984           if (it->Symbol->isAbsolute())
 985             Flags |= MachO::INDIRECT_SYMBOL_ABS;
 986           write32(Flags);
 987           continue;
 988         }
 989       }
 990
 991       write32(it->Symbol->getIndex());
 992     }
 993
 994     // FIXME: Check that offsets match computed ones.
 995
 996     // Write the symbol table entries.
 997     for (auto *SymbolData :
 998          {&LocalSymbolData, &ExternalSymbolData, &UndefinedSymbolData})
 999       for (MachSymbolData &Entry : *SymbolData)
1000         writeNlist(Entry, Layout);
1001
1002     // Write the string table.
1003     StringTable.write(getStream());
1004   }
1005 }
1006
1007 std::unique_ptr<MCObjectWriter>
1008 llvm::createMachObjectWriter(std::unique_ptr<MCMachObjectTargetWriter> MOTW,
1009                              raw_pwrite_stream &OS, bool IsLittleEndian) {
1010   return llvm::make_unique<MachObjectWriter>(std::move(MOTW), OS,
1011                                              IsLittleEndian);
1012 }