Home | History | Annotate | Download | only in MC 
      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/MC/MCMachObjectWriter.h"
     11 #include "llvm/ADT/StringMap.h"
     12 #include "llvm/ADT/Twine.h"
     13 #include "llvm/MC/MCAsmBackend.h"
     14 #include "llvm/MC/MCAsmLayout.h"
     15 #include "llvm/MC/MCAssembler.h"
     16 #include "llvm/MC/MCExpr.h"
     17 #include "llvm/MC/MCFixupKindInfo.h"
     18 #include "llvm/MC/MCMachOSymbolFlags.h"
     19 #include "llvm/MC/MCObjectWriter.h"
     20 #include "llvm/MC/MCSectionMachO.h"
     21 #include "llvm/MC/MCSymbol.h"
     22 #include "llvm/MC/MCValue.h"
     23 #include "llvm/Object/MachOFormat.h"
     24 #include "llvm/Support/Debug.h"
     25 #include "llvm/Support/ErrorHandling.h"
     26 #include <vector>
     27 using namespace llvm;
     28 using namespace llvm::object;
     29 
     30 void MachObjectWriter::reset() {
     31   Relocations.clear();
     32   IndirectSymBase.clear();
     33   StringTable.clear();
     34   LocalSymbolData.clear();
     35   ExternalSymbolData.clear();
     36   UndefinedSymbolData.clear();
     37   MCObjectWriter::reset();
     38 }
     39 
     40 bool MachObjectWriter::
     41 doesSymbolRequireExternRelocation(const MCSymbolData *SD) {
     42   // Undefined symbols are always extern.
     43   if (SD->Symbol->isUndefined())
     44     return true;
     45 
     46   // References to weak definitions require external relocation entries; the
     47   // definition may not always be the one in the same object file.
     48   if (SD->getFlags() & SF_WeakDefinition)
     49     return true;
     50 
     51   // Otherwise, we can use an internal relocation.
     52   return false;
     53 }
     54 
     55 bool MachObjectWriter::
     56 MachSymbolData::operator<(const MachSymbolData &RHS) const {
     57   return SymbolData->getSymbol().getName() <
     58     RHS.SymbolData->getSymbol().getName();
     59 }
     60 
     61 bool MachObjectWriter::isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind) {
     62   const MCFixupKindInfo &FKI = Asm.getBackend().getFixupKindInfo(
     63     (MCFixupKind) Kind);
     64 
     65   return FKI.Flags & MCFixupKindInfo::FKF_IsPCRel;
     66 }
     67 
     68 uint64_t MachObjectWriter::getFragmentAddress(const MCFragment *Fragment,
     69                                               const MCAsmLayout &Layout) const {
     70   return getSectionAddress(Fragment->getParent()) +
     71     Layout.getFragmentOffset(Fragment);
     72 }
     73 
     74 uint64_t MachObjectWriter::getSymbolAddress(const MCSymbolData* SD,
     75                                             const MCAsmLayout &Layout) const {
     76   const MCSymbol &S = SD->getSymbol();
     77 
     78   // If this is a variable, then recursively evaluate now.
     79   if (S.isVariable()) {
     80     if (const MCConstantExpr *C =
     81           dyn_cast<const MCConstantExpr>(S.getVariableValue()))
     82       return C->getValue();
     83 
     84 
     85     MCValue Target;
     86     if (!S.getVariableValue()->EvaluateAsRelocatable(Target, Layout))
     87       report_fatal_error("unable to evaluate offset for variable '" +
     88                          S.getName() + "'");
     89 
     90     // Verify that any used symbols are defined.
     91     if (Target.getSymA() && Target.getSymA()->getSymbol().isUndefined())
     92       report_fatal_error("unable to evaluate offset to undefined symbol '" +
     93                          Target.getSymA()->getSymbol().getName() + "'");
     94     if (Target.getSymB() && Target.getSymB()->getSymbol().isUndefined())
     95       report_fatal_error("unable to evaluate offset to undefined symbol '" +
     96                          Target.getSymB()->getSymbol().getName() + "'");
     97 
     98     uint64_t Address = Target.getConstant();
     99     if (Target.getSymA())
    100       Address += getSymbolAddress(&Layout.getAssembler().getSymbolData(
    101                                     Target.getSymA()->getSymbol()), Layout);
    102     if (Target.getSymB())
    103       Address += getSymbolAddress(&Layout.getAssembler().getSymbolData(
    104                                     Target.getSymB()->getSymbol()), Layout);
    105     return Address;
    106   }
    107 
    108   return getSectionAddress(SD->getFragment()->getParent()) +
    109     Layout.getSymbolOffset(SD);
    110 }
    111 
    112 uint64_t MachObjectWriter::getPaddingSize(const MCSectionData *SD,
    113                                           const MCAsmLayout &Layout) const {
    114   uint64_t EndAddr = getSectionAddress(SD) + Layout.getSectionAddressSize(SD);
    115   unsigned Next = SD->getLayoutOrder() + 1;
    116   if (Next >= Layout.getSectionOrder().size())
    117     return 0;
    118 
    119   const MCSectionData &NextSD = *Layout.getSectionOrder()[Next];
    120   if (NextSD.getSection().isVirtualSection())
    121     return 0;
    122   return OffsetToAlignment(EndAddr, NextSD.getAlignment());
    123 }
    124 
    125 void MachObjectWriter::WriteHeader(unsigned NumLoadCommands,
    126                                    unsigned LoadCommandsSize,
    127                                    bool SubsectionsViaSymbols) {
    128   uint32_t Flags = 0;
    129 
    130   if (SubsectionsViaSymbols)
    131     Flags |= macho::HF_SubsectionsViaSymbols;
    132 
    133   // struct mach_header (28 bytes) or
    134   // struct mach_header_64 (32 bytes)
    135 
    136   uint64_t Start = OS.tell();
    137   (void) Start;
    138 
    139   Write32(is64Bit() ? macho::HM_Object64 : macho::HM_Object32);
    140 
    141   Write32(TargetObjectWriter->getCPUType());
    142   Write32(TargetObjectWriter->getCPUSubtype());
    143 
    144   Write32(macho::HFT_Object);
    145   Write32(NumLoadCommands);
    146   Write32(LoadCommandsSize);
    147   Write32(Flags);
    148   if (is64Bit())
    149     Write32(0); // reserved
    150 
    151   assert(OS.tell() - Start ==
    152          (is64Bit() ? macho::Header64Size : macho::Header32Size));
    153 }
    154 
    155 /// WriteSegmentLoadCommand - Write a segment load command.
    156 ///
    157 /// \param NumSections The number of sections in this segment.
    158 /// \param SectionDataSize The total size of the sections.
    159 void MachObjectWriter::WriteSegmentLoadCommand(unsigned NumSections,
    160                                                uint64_t VMSize,
    161                                                uint64_t SectionDataStartOffset,
    162                                                uint64_t SectionDataSize) {
    163   // struct segment_command (56 bytes) or
    164   // struct segment_command_64 (72 bytes)
    165 
    166   uint64_t Start = OS.tell();
    167   (void) Start;
    168 
    169   unsigned SegmentLoadCommandSize =
    170     is64Bit() ? macho::SegmentLoadCommand64Size:
    171     macho::SegmentLoadCommand32Size;
    172   Write32(is64Bit() ? macho::LCT_Segment64 : macho::LCT_Segment);
    173   Write32(SegmentLoadCommandSize +
    174           NumSections * (is64Bit() ? macho::Section64Size :
    175                          macho::Section32Size));
    176 
    177   WriteBytes("", 16);
    178   if (is64Bit()) {
    179     Write64(0); // vmaddr
    180     Write64(VMSize); // vmsize
    181     Write64(SectionDataStartOffset); // file offset
    182     Write64(SectionDataSize); // file size
    183   } else {
    184     Write32(0); // vmaddr
    185     Write32(VMSize); // vmsize
    186     Write32(SectionDataStartOffset); // file offset
    187     Write32(SectionDataSize); // file size
    188   }
    189   Write32(0x7); // maxprot
    190   Write32(0x7); // initprot
    191   Write32(NumSections);
    192   Write32(0); // flags
    193 
    194   assert(OS.tell() - Start == SegmentLoadCommandSize);
    195 }
    196 
    197 void MachObjectWriter::WriteSection(const MCAssembler &Asm,
    198                                     const MCAsmLayout &Layout,
    199                                     const MCSectionData &SD,
    200                                     uint64_t FileOffset,
    201                                     uint64_t RelocationsStart,
    202                                     unsigned NumRelocations) {
    203   uint64_t SectionSize = Layout.getSectionAddressSize(&SD);
    204 
    205   // The offset is unused for virtual sections.
    206   if (SD.getSection().isVirtualSection()) {
    207     assert(Layout.getSectionFileSize(&SD) == 0 && "Invalid file size!");
    208     FileOffset = 0;
    209   }
    210 
    211   // struct section (68 bytes) or
    212   // struct section_64 (80 bytes)
    213 
    214   uint64_t Start = OS.tell();
    215   (void) Start;
    216 
    217   const MCSectionMachO &Section = cast<MCSectionMachO>(SD.getSection());
    218   WriteBytes(Section.getSectionName(), 16);
    219   WriteBytes(Section.getSegmentName(), 16);
    220   if (is64Bit()) {
    221     Write64(getSectionAddress(&SD)); // address
    222     Write64(SectionSize); // size
    223   } else {
    224     Write32(getSectionAddress(&SD)); // address
    225     Write32(SectionSize); // size
    226   }
    227   Write32(FileOffset);
    228 
    229   unsigned Flags = Section.getTypeAndAttributes();
    230   if (SD.hasInstructions())
    231     Flags |= MCSectionMachO::S_ATTR_SOME_INSTRUCTIONS;
    232 
    233   assert(isPowerOf2_32(SD.getAlignment()) && "Invalid alignment!");
    234   Write32(Log2_32(SD.getAlignment()));
    235   Write32(NumRelocations ? RelocationsStart : 0);
    236   Write32(NumRelocations);
    237   Write32(Flags);
    238   Write32(IndirectSymBase.lookup(&SD)); // reserved1
    239   Write32(Section.getStubSize()); // reserved2
    240   if (is64Bit())
    241     Write32(0); // reserved3
    242 
    243   assert(OS.tell() - Start == (is64Bit() ? macho::Section64Size :
    244                                macho::Section32Size));
    245 }
    246 
    247 void MachObjectWriter::WriteSymtabLoadCommand(uint32_t SymbolOffset,
    248                                               uint32_t NumSymbols,
    249                                               uint32_t StringTableOffset,
    250                                               uint32_t StringTableSize) {
    251   // struct symtab_command (24 bytes)
    252 
    253   uint64_t Start = OS.tell();
    254   (void) Start;
    255 
    256   Write32(macho::LCT_Symtab);
    257   Write32(macho::SymtabLoadCommandSize);
    258   Write32(SymbolOffset);
    259   Write32(NumSymbols);
    260   Write32(StringTableOffset);
    261   Write32(StringTableSize);
    262 
    263   assert(OS.tell() - Start == macho::SymtabLoadCommandSize);
    264 }
    265 
    266 void MachObjectWriter::WriteDysymtabLoadCommand(uint32_t FirstLocalSymbol,
    267                                                 uint32_t NumLocalSymbols,
    268                                                 uint32_t FirstExternalSymbol,
    269                                                 uint32_t NumExternalSymbols,
    270                                                 uint32_t FirstUndefinedSymbol,
    271                                                 uint32_t NumUndefinedSymbols,
    272                                                 uint32_t IndirectSymbolOffset,
    273                                                 uint32_t NumIndirectSymbols) {
    274   // struct dysymtab_command (80 bytes)
    275 
    276   uint64_t Start = OS.tell();
    277   (void) Start;
    278 
    279   Write32(macho::LCT_Dysymtab);
    280   Write32(macho::DysymtabLoadCommandSize);
    281   Write32(FirstLocalSymbol);
    282   Write32(NumLocalSymbols);
    283   Write32(FirstExternalSymbol);
    284   Write32(NumExternalSymbols);
    285   Write32(FirstUndefinedSymbol);
    286   Write32(NumUndefinedSymbols);
    287   Write32(0); // tocoff
    288   Write32(0); // ntoc
    289   Write32(0); // modtaboff
    290   Write32(0); // nmodtab
    291   Write32(0); // extrefsymoff
    292   Write32(0); // nextrefsyms
    293   Write32(IndirectSymbolOffset);
    294   Write32(NumIndirectSymbols);
    295   Write32(0); // extreloff
    296   Write32(0); // nextrel
    297   Write32(0); // locreloff
    298   Write32(0); // nlocrel
    299 
    300   assert(OS.tell() - Start == macho::DysymtabLoadCommandSize);
    301 }
    302 
    303 void MachObjectWriter::WriteNlist(MachSymbolData &MSD,
    304                                   const MCAsmLayout &Layout) {
    305   MCSymbolData &Data = *MSD.SymbolData;
    306   const MCSymbol &Symbol = Data.getSymbol();
    307   uint8_t Type = 0;
    308   uint16_t Flags = Data.getFlags();
    309   uint64_t Address = 0;
    310 
    311   // Set the N_TYPE bits. See <mach-o/nlist.h>.
    312   //
    313   // FIXME: Are the prebound or indirect fields possible here?
    314   if (Symbol.isUndefined())
    315     Type = macho::STT_Undefined;
    316   else if (Symbol.isAbsolute())
    317     Type = macho::STT_Absolute;
    318   else
    319     Type = macho::STT_Section;
    320 
    321   // FIXME: Set STAB bits.
    322 
    323   if (Data.isPrivateExtern())
    324     Type |= macho::STF_PrivateExtern;
    325 
    326   // Set external bit.
    327   if (Data.isExternal() || Symbol.isUndefined())
    328     Type |= macho::STF_External;
    329 
    330   // Compute the symbol address.
    331   if (Symbol.isDefined()) {
    332     Address = getSymbolAddress(&Data, Layout);
    333   } else if (Data.isCommon()) {
    334     // Common symbols are encoded with the size in the address
    335     // field, and their alignment in the flags.
    336     Address = Data.getCommonSize();
    337 
    338     // Common alignment is packed into the 'desc' bits.
    339     if (unsigned Align = Data.getCommonAlignment()) {
    340       unsigned Log2Size = Log2_32(Align);
    341       assert((1U << Log2Size) == Align && "Invalid 'common' alignment!");
    342       if (Log2Size > 15)
    343         report_fatal_error("invalid 'common' alignment '" +
    344                            Twine(Align) + "'");
    345       // FIXME: Keep this mask with the SymbolFlags enumeration.
    346       Flags = (Flags & 0xF0FF) | (Log2Size << 8);
    347     }
    348   }
    349 
    350   // struct nlist (12 bytes)
    351 
    352   Write32(MSD.StringIndex);
    353   Write8(Type);
    354   Write8(MSD.SectionIndex);
    355 
    356   // The Mach-O streamer uses the lowest 16-bits of the flags for the 'desc'
    357   // value.
    358   Write16(Flags);
    359   if (is64Bit())
    360     Write64(Address);
    361   else
    362     Write32(Address);
    363 }
    364 
    365 void MachObjectWriter::WriteLinkeditLoadCommand(uint32_t Type,
    366                                                 uint32_t DataOffset,
    367                                                 uint32_t DataSize) {
    368   uint64_t Start = OS.tell();
    369   (void) Start;
    370 
    371   Write32(Type);
    372   Write32(macho::LinkeditLoadCommandSize);
    373   Write32(DataOffset);
    374   Write32(DataSize);
    375 
    376   assert(OS.tell() - Start == macho::LinkeditLoadCommandSize);
    377 }
    378 
    379 static unsigned ComputeLinkerOptionsLoadCommandSize(
    380   const std::vector<std::string> &Options, bool is64Bit)
    381 {
    382   unsigned Size = sizeof(macho::LinkerOptionsLoadCommand);
    383   for (unsigned i = 0, e = Options.size(); i != e; ++i)
    384     Size += Options[i].size() + 1;
    385   return RoundUpToAlignment(Size, is64Bit ? 8 : 4);
    386 }
    387 
    388 void MachObjectWriter::WriteLinkerOptionsLoadCommand(
    389   const std::vector<std::string> &Options)
    390 {
    391   unsigned Size = ComputeLinkerOptionsLoadCommandSize(Options, is64Bit());
    392   uint64_t Start = OS.tell();
    393   (void) Start;
    394 
    395   Write32(macho::LCT_LinkerOptions);
    396   Write32(Size);
    397   Write32(Options.size());
    398   uint64_t BytesWritten = sizeof(macho::LinkerOptionsLoadCommand);
    399   for (unsigned i = 0, e = Options.size(); i != e; ++i) {
    400     // Write each string, including the null byte.
    401     const std::string &Option = Options[i];
    402     WriteBytes(Option.c_str(), Option.size() + 1);
    403     BytesWritten += Option.size() + 1;
    404   }
    405 
    406   // Pad to a multiple of the pointer size.
    407   WriteBytes("", OffsetToAlignment(BytesWritten, is64Bit() ? 8 : 4));
    408 
    409   assert(OS.tell() - Start == Size);
    410 }
    411 
    412 
    413 void MachObjectWriter::RecordRelocation(const MCAssembler &Asm,
    414                                         const MCAsmLayout &Layout,
    415                                         const MCFragment *Fragment,
    416                                         const MCFixup &Fixup,
    417                                         MCValue Target,
    418                                         uint64_t &FixedValue) {
    419   TargetObjectWriter->RecordRelocation(this, Asm, Layout, Fragment, Fixup,
    420                                        Target, FixedValue);
    421 }
    422 
    423 void MachObjectWriter::BindIndirectSymbols(MCAssembler &Asm) {
    424   // This is the point where 'as' creates actual symbols for indirect symbols
    425   // (in the following two passes). It would be easier for us to do this sooner
    426   // when we see the attribute, but that makes getting the order in the symbol
    427   // table much more complicated than it is worth.
    428   //
    429   // FIXME: Revisit this when the dust settles.
    430 
    431   // Bind non lazy symbol pointers first.
    432   unsigned IndirectIndex = 0;
    433   for (MCAssembler::indirect_symbol_iterator it = Asm.indirect_symbol_begin(),
    434          ie = Asm.indirect_symbol_end(); it != ie; ++it, ++IndirectIndex) {
    435     const MCSectionMachO &Section =
    436       cast<MCSectionMachO>(it->SectionData->getSection());
    437 
    438     if (Section.getType() != MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS)
    439       continue;
    440 
    441     // Initialize the section indirect symbol base, if necessary.
    442     IndirectSymBase.insert(std::make_pair(it->SectionData, IndirectIndex));
    443 
    444     Asm.getOrCreateSymbolData(*it->Symbol);
    445   }
    446 
    447   // Then lazy symbol pointers and symbol stubs.
    448   IndirectIndex = 0;
    449   for (MCAssembler::indirect_symbol_iterator it = Asm.indirect_symbol_begin(),
    450          ie = Asm.indirect_symbol_end(); it != ie; ++it, ++IndirectIndex) {
    451     const MCSectionMachO &Section =
    452       cast<MCSectionMachO>(it->SectionData->getSection());
    453 
    454     if (Section.getType() != MCSectionMachO::S_LAZY_SYMBOL_POINTERS &&
    455         Section.getType() != MCSectionMachO::S_SYMBOL_STUBS)
    456       continue;
    457 
    458     // Initialize the section indirect symbol base, if necessary.
    459     IndirectSymBase.insert(std::make_pair(it->SectionData, IndirectIndex));
    460 
    461     // Set the symbol type to undefined lazy, but only on construction.
    462     //
    463     // FIXME: Do not hardcode.
    464     bool Created;
    465     MCSymbolData &Entry = Asm.getOrCreateSymbolData(*it->Symbol, &Created);
    466     if (Created)
    467       Entry.setFlags(Entry.getFlags() | 0x0001);
    468   }
    469 }
    470 
    471 /// ComputeSymbolTable - Compute the symbol table data
    472 ///
    473 /// \param StringTable [out] - The string table data.
    474 /// \param StringIndexMap [out] - Map from symbol names to offsets in the
    475 /// string table.
    476 void MachObjectWriter::
    477 ComputeSymbolTable(MCAssembler &Asm, SmallString<256> &StringTable,
    478                    std::vector<MachSymbolData> &LocalSymbolData,
    479                    std::vector<MachSymbolData> &ExternalSymbolData,
    480                    std::vector<MachSymbolData> &UndefinedSymbolData) {
    481   // Build section lookup table.
    482   DenseMap<const MCSection*, uint8_t> SectionIndexMap;
    483   unsigned Index = 1;
    484   for (MCAssembler::iterator it = Asm.begin(),
    485          ie = Asm.end(); it != ie; ++it, ++Index)
    486     SectionIndexMap[&it->getSection()] = Index;
    487   assert(Index <= 256 && "Too many sections!");
    488 
    489   // Index 0 is always the empty string.
    490   StringMap<uint64_t> StringIndexMap;
    491   StringTable += '\x00';
    492 
    493   // Build the symbol arrays and the string table, but only for non-local
    494   // symbols.
    495   //
    496   // The particular order that we collect the symbols and create the string
    497   // table, then sort the symbols is chosen to match 'as'. Even though it
    498   // doesn't matter for correctness, this is important for letting us diff .o
    499   // files.
    500   for (MCAssembler::symbol_iterator it = Asm.symbol_begin(),
    501          ie = Asm.symbol_end(); it != ie; ++it) {
    502     const MCSymbol &Symbol = it->getSymbol();
    503 
    504     // Ignore non-linker visible symbols.
    505     if (!Asm.isSymbolLinkerVisible(it->getSymbol()))
    506       continue;
    507 
    508     if (!it->isExternal() && !Symbol.isUndefined())
    509       continue;
    510 
    511     uint64_t &Entry = StringIndexMap[Symbol.getName()];
    512     if (!Entry) {
    513       Entry = StringTable.size();
    514       StringTable += Symbol.getName();
    515       StringTable += '\x00';
    516     }
    517 
    518     MachSymbolData MSD;
    519     MSD.SymbolData = it;
    520     MSD.StringIndex = Entry;
    521 
    522     if (Symbol.isUndefined()) {
    523       MSD.SectionIndex = 0;
    524       UndefinedSymbolData.push_back(MSD);
    525     } else if (Symbol.isAbsolute()) {
    526       MSD.SectionIndex = 0;
    527       ExternalSymbolData.push_back(MSD);
    528     } else {
    529       MSD.SectionIndex = SectionIndexMap.lookup(&Symbol.getSection());
    530       assert(MSD.SectionIndex && "Invalid section index!");
    531       ExternalSymbolData.push_back(MSD);
    532     }
    533   }
    534 
    535   // Now add the data for local symbols.
    536   for (MCAssembler::symbol_iterator it = Asm.symbol_begin(),
    537          ie = Asm.symbol_end(); it != ie; ++it) {
    538     const MCSymbol &Symbol = it->getSymbol();
    539 
    540     // Ignore non-linker visible symbols.
    541     if (!Asm.isSymbolLinkerVisible(it->getSymbol()))
    542       continue;
    543 
    544     if (it->isExternal() || Symbol.isUndefined())
    545       continue;
    546 
    547     uint64_t &Entry = StringIndexMap[Symbol.getName()];
    548     if (!Entry) {
    549       Entry = StringTable.size();
    550       StringTable += Symbol.getName();
    551       StringTable += '\x00';
    552     }
    553 
    554     MachSymbolData MSD;
    555     MSD.SymbolData = it;
    556     MSD.StringIndex = Entry;
    557 
    558     if (Symbol.isAbsolute()) {
    559       MSD.SectionIndex = 0;
    560       LocalSymbolData.push_back(MSD);
    561     } else {
    562       MSD.SectionIndex = SectionIndexMap.lookup(&Symbol.getSection());
    563       assert(MSD.SectionIndex && "Invalid section index!");
    564       LocalSymbolData.push_back(MSD);
    565     }
    566   }
    567 
    568   // External and undefined symbols are required to be in lexicographic order.
    569   std::sort(ExternalSymbolData.begin(), ExternalSymbolData.end());
    570   std::sort(UndefinedSymbolData.begin(), UndefinedSymbolData.end());
    571 
    572   // Set the symbol indices.
    573   Index = 0;
    574   for (unsigned i = 0, e = LocalSymbolData.size(); i != e; ++i)
    575     LocalSymbolData[i].SymbolData->setIndex(Index++);
    576   for (unsigned i = 0, e = ExternalSymbolData.size(); i != e; ++i)
    577     ExternalSymbolData[i].SymbolData->setIndex(Index++);
    578   for (unsigned i = 0, e = UndefinedSymbolData.size(); i != e; ++i)
    579     UndefinedSymbolData[i].SymbolData->setIndex(Index++);
    580 
    581   // The string table is padded to a multiple of 4.
    582   while (StringTable.size() % 4)
    583     StringTable += '\x00';
    584 }
    585 
    586 void MachObjectWriter::computeSectionAddresses(const MCAssembler &Asm,
    587                                                const MCAsmLayout &Layout) {
    588   uint64_t StartAddress = 0;
    589   const SmallVectorImpl<MCSectionData*> &Order = Layout.getSectionOrder();
    590   for (int i = 0, n = Order.size(); i != n ; ++i) {
    591     const MCSectionData *SD = Order[i];
    592     StartAddress = RoundUpToAlignment(StartAddress, SD->getAlignment());
    593     SectionAddress[SD] = StartAddress;
    594     StartAddress += Layout.getSectionAddressSize(SD);
    595 
    596     // Explicitly pad the section to match the alignment requirements of the
    597     // following one. This is for 'gas' compatibility, it shouldn't
    598     /// strictly be necessary.
    599     StartAddress += getPaddingSize(SD, Layout);
    600   }
    601 }
    602 
    603 void MachObjectWriter::markAbsoluteVariableSymbols(MCAssembler &Asm,
    604                                                    const MCAsmLayout &Layout) {
    605   for (MCAssembler::symbol_iterator i = Asm.symbol_begin(),
    606                                     e = Asm.symbol_end();
    607       i != e; ++i) {
    608     MCSymbolData &SD = *i;
    609     if (!SD.getSymbol().isVariable())
    610       continue;
    611 
    612     // Is the variable is a symbol difference (SA - SB + C) expression,
    613     // and neither symbol is external, mark the variable as absolute.
    614     const MCExpr *Expr = SD.getSymbol().getVariableValue();
    615     MCValue Value;
    616     if (Expr->EvaluateAsRelocatable(Value, Layout)) {
    617       if (Value.getSymA() && Value.getSymB())
    618         const_cast<MCSymbol*>(&SD.getSymbol())->setAbsolute();
    619     }
    620   }
    621 }
    622 
    623 void MachObjectWriter::ExecutePostLayoutBinding(MCAssembler &Asm,
    624                                                 const MCAsmLayout &Layout) {
    625   computeSectionAddresses(Asm, Layout);
    626 
    627   // Create symbol data for any indirect symbols.
    628   BindIndirectSymbols(Asm);
    629 
    630   // Mark symbol difference expressions in variables (from .set or = directives)
    631   // as absolute.
    632   markAbsoluteVariableSymbols(Asm, Layout);
    633 
    634   // Compute symbol table information and bind symbol indices.
    635   ComputeSymbolTable(Asm, StringTable, LocalSymbolData, ExternalSymbolData,
    636                      UndefinedSymbolData);
    637 }
    638 
    639 bool MachObjectWriter::
    640 IsSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
    641                                        const MCSymbolData &DataA,
    642                                        const MCFragment &FB,
    643                                        bool InSet,
    644                                        bool IsPCRel) const {
    645   if (InSet)
    646     return true;
    647 
    648   // The effective address is
    649   //     addr(atom(A)) + offset(A)
    650   //   - addr(atom(B)) - offset(B)
    651   // and the offsets are not relocatable, so the fixup is fully resolved when
    652   //  addr(atom(A)) - addr(atom(B)) == 0.
    653   const MCSymbolData *A_Base = 0, *B_Base = 0;
    654 
    655   const MCSymbol &SA = DataA.getSymbol().AliasedSymbol();
    656   const MCSection &SecA = SA.getSection();
    657   const MCSection &SecB = FB.getParent()->getSection();
    658 
    659   if (IsPCRel) {
    660     // The simple (Darwin, except on x86_64) way of dealing with this was to
    661     // assume that any reference to a temporary symbol *must* be a temporary
    662     // symbol in the same atom, unless the sections differ. Therefore, any PCrel
    663     // relocation to a temporary symbol (in the same section) is fully
    664     // resolved. This also works in conjunction with absolutized .set, which
    665     // requires the compiler to use .set to absolutize the differences between
    666     // symbols which the compiler knows to be assembly time constants, so we
    667     // don't need to worry about considering symbol differences fully resolved.
    668     //
    669     // If the file isn't using sub-sections-via-symbols, we can make the
    670     // same assumptions about any symbol that we normally make about
    671     // assembler locals.
    672 
    673     if (!Asm.getBackend().hasReliableSymbolDifference()) {
    674       if (!SA.isInSection() || &SecA != &SecB ||
    675           (!SA.isTemporary() &&
    676            FB.getAtom() != Asm.getSymbolData(SA).getFragment()->getAtom() &&
    677            Asm.getSubsectionsViaSymbols()))
    678         return false;
    679       return true;
    680     }
    681     // For Darwin x86_64, there is one special case when the reference IsPCRel.
    682     // If the fragment with the reference does not have a base symbol but meets
    683     // the simple way of dealing with this, in that it is a temporary symbol in
    684     // the same atom then it is assumed to be fully resolved.  This is needed so
    685     // a relocation entry is not created and so the static linker does not
    686     // mess up the reference later.
    687     else if(!FB.getAtom() &&
    688             SA.isTemporary() && SA.isInSection() && &SecA == &SecB){
    689       return true;
    690     }
    691   } else {
    692     if (!TargetObjectWriter->useAggressiveSymbolFolding())
    693       return false;
    694   }
    695 
    696   const MCFragment *FA = Asm.getSymbolData(SA).getFragment();
    697 
    698   // Bail if the symbol has no fragment.
    699   if (!FA)
    700     return false;
    701 
    702   A_Base = FA->getAtom();
    703   if (!A_Base)
    704     return false;
    705 
    706   B_Base = FB.getAtom();
    707   if (!B_Base)
    708     return false;
    709 
    710   // If the atoms are the same, they are guaranteed to have the same address.
    711   if (A_Base == B_Base)
    712     return true;
    713 
    714   // Otherwise, we can't prove this is fully resolved.
    715   return false;
    716 }
    717 
    718 void MachObjectWriter::WriteObject(MCAssembler &Asm,
    719                                    const MCAsmLayout &Layout) {
    720   unsigned NumSections = Asm.size();
    721 
    722   // The section data starts after the header, the segment load command (and
    723   // section headers) and the symbol table.
    724   unsigned NumLoadCommands = 1;
    725   uint64_t LoadCommandsSize = is64Bit() ?
    726     macho::SegmentLoadCommand64Size + NumSections * macho::Section64Size :
    727     macho::SegmentLoadCommand32Size + NumSections * macho::Section32Size;
    728 
    729   // Add the data-in-code load command size, if used.
    730   unsigned NumDataRegions = Asm.getDataRegions().size();
    731   if (NumDataRegions) {
    732     ++NumLoadCommands;
    733     LoadCommandsSize += macho::LinkeditLoadCommandSize;
    734   }
    735 
    736   // Add the symbol table load command sizes, if used.
    737   unsigned NumSymbols = LocalSymbolData.size() + ExternalSymbolData.size() +
    738     UndefinedSymbolData.size();
    739   if (NumSymbols) {
    740     NumLoadCommands += 2;
    741     LoadCommandsSize += (macho::SymtabLoadCommandSize +
    742                          macho::DysymtabLoadCommandSize);
    743   }
    744 
    745   // Add the linker option load commands sizes.
    746   const std::vector<std::vector<std::string> > &LinkerOptions =
    747     Asm.getLinkerOptions();
    748   for (unsigned i = 0, e = LinkerOptions.size(); i != e; ++i) {
    749     ++NumLoadCommands;
    750     LoadCommandsSize += ComputeLinkerOptionsLoadCommandSize(LinkerOptions[i],
    751                                                             is64Bit());
    752   }
    753 
    754   // Compute the total size of the section data, as well as its file size and vm
    755   // size.
    756   uint64_t SectionDataStart = (is64Bit() ? macho::Header64Size :
    757                                macho::Header32Size) + LoadCommandsSize;
    758   uint64_t SectionDataSize = 0;
    759   uint64_t SectionDataFileSize = 0;
    760   uint64_t VMSize = 0;
    761   for (MCAssembler::const_iterator it = Asm.begin(),
    762          ie = Asm.end(); it != ie; ++it) {
    763     const MCSectionData &SD = *it;
    764     uint64_t Address = getSectionAddress(&SD);
    765     uint64_t Size = Layout.getSectionAddressSize(&SD);
    766     uint64_t FileSize = Layout.getSectionFileSize(&SD);
    767     FileSize += getPaddingSize(&SD, Layout);
    768 
    769     VMSize = std::max(VMSize, Address + Size);
    770 
    771     if (SD.getSection().isVirtualSection())
    772       continue;
    773 
    774     SectionDataSize = std::max(SectionDataSize, Address + Size);
    775     SectionDataFileSize = std::max(SectionDataFileSize, Address + FileSize);
    776   }
    777 
    778   // The section data is padded to 4 bytes.
    779   //
    780   // FIXME: Is this machine dependent?
    781   unsigned SectionDataPadding = OffsetToAlignment(SectionDataFileSize, 4);
    782   SectionDataFileSize += SectionDataPadding;
    783 
    784   // Write the prolog, starting with the header and load command...
    785   WriteHeader(NumLoadCommands, LoadCommandsSize,
    786               Asm.getSubsectionsViaSymbols());
    787   WriteSegmentLoadCommand(NumSections, VMSize,
    788                           SectionDataStart, SectionDataSize);
    789 
    790   // ... and then the section headers.
    791   uint64_t RelocTableEnd = SectionDataStart + SectionDataFileSize;
    792   for (MCAssembler::const_iterator it = Asm.begin(),
    793          ie = Asm.end(); it != ie; ++it) {
    794     std::vector<macho::RelocationEntry> &Relocs = Relocations[it];
    795     unsigned NumRelocs = Relocs.size();
    796     uint64_t SectionStart = SectionDataStart + getSectionAddress(it);
    797     WriteSection(Asm, Layout, *it, SectionStart, RelocTableEnd, NumRelocs);
    798     RelocTableEnd += NumRelocs * macho::RelocationInfoSize;
    799   }
    800 
    801   // Write the data-in-code load command, if used.
    802   uint64_t DataInCodeTableEnd = RelocTableEnd + NumDataRegions * 8;
    803   if (NumDataRegions) {
    804     uint64_t DataRegionsOffset = RelocTableEnd;
    805     uint64_t DataRegionsSize = NumDataRegions * 8;
    806     WriteLinkeditLoadCommand(macho::LCT_DataInCode, DataRegionsOffset,
    807                              DataRegionsSize);
    808   }
    809 
    810   // Write the symbol table load command, if used.
    811   if (NumSymbols) {
    812     unsigned FirstLocalSymbol = 0;
    813     unsigned NumLocalSymbols = LocalSymbolData.size();
    814     unsigned FirstExternalSymbol = FirstLocalSymbol + NumLocalSymbols;
    815     unsigned NumExternalSymbols = ExternalSymbolData.size();
    816     unsigned FirstUndefinedSymbol = FirstExternalSymbol + NumExternalSymbols;
    817     unsigned NumUndefinedSymbols = UndefinedSymbolData.size();
    818     unsigned NumIndirectSymbols = Asm.indirect_symbol_size();
    819     unsigned NumSymTabSymbols =
    820       NumLocalSymbols + NumExternalSymbols + NumUndefinedSymbols;
    821     uint64_t IndirectSymbolSize = NumIndirectSymbols * 4;
    822     uint64_t IndirectSymbolOffset = 0;
    823 
    824     // If used, the indirect symbols are written after the section data.
    825     if (NumIndirectSymbols)
    826       IndirectSymbolOffset = DataInCodeTableEnd;
    827 
    828     // The symbol table is written after the indirect symbol data.
    829     uint64_t SymbolTableOffset = DataInCodeTableEnd + IndirectSymbolSize;
    830 
    831     // The string table is written after symbol table.
    832     uint64_t StringTableOffset =
    833       SymbolTableOffset + NumSymTabSymbols * (is64Bit() ? macho::Nlist64Size :
    834                                               macho::Nlist32Size);
    835     WriteSymtabLoadCommand(SymbolTableOffset, NumSymTabSymbols,
    836                            StringTableOffset, StringTable.size());
    837 
    838     WriteDysymtabLoadCommand(FirstLocalSymbol, NumLocalSymbols,
    839                              FirstExternalSymbol, NumExternalSymbols,
    840                              FirstUndefinedSymbol, NumUndefinedSymbols,
    841                              IndirectSymbolOffset, NumIndirectSymbols);
    842   }
    843 
    844   // Write the linker options load commands.
    845   for (unsigned i = 0, e = LinkerOptions.size(); i != e; ++i) {
    846     WriteLinkerOptionsLoadCommand(LinkerOptions[i]);
    847   }
    848 
    849   // Write the actual section data.
    850   for (MCAssembler::const_iterator it = Asm.begin(),
    851          ie = Asm.end(); it != ie; ++it) {
    852     Asm.writeSectionData(it, Layout);
    853 
    854     uint64_t Pad = getPaddingSize(it, Layout);
    855     for (unsigned int i = 0; i < Pad; ++i)
    856       Write8(0);
    857   }
    858 
    859   // Write the extra padding.
    860   WriteZeros(SectionDataPadding);
    861 
    862   // Write the relocation entries.
    863   for (MCAssembler::const_iterator it = Asm.begin(),
    864          ie = Asm.end(); it != ie; ++it) {
    865     // Write the section relocation entries, in reverse order to match 'as'
    866     // (approximately, the exact algorithm is more complicated than this).
    867     std::vector<macho::RelocationEntry> &Relocs = Relocations[it];
    868     for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
    869       Write32(Relocs[e - i - 1].Word0);
    870       Write32(Relocs[e - i - 1].Word1);
    871     }
    872   }
    873 
    874   // Write out the data-in-code region payload, if there is one.
    875   for (MCAssembler::const_data_region_iterator
    876          it = Asm.data_region_begin(), ie = Asm.data_region_end();
    877          it != ie; ++it) {
    878     const DataRegionData *Data = &(*it);
    879     uint64_t Start =
    880       getSymbolAddress(&Layout.getAssembler().getSymbolData(*Data->Start),
    881                        Layout);
    882     uint64_t End =
    883       getSymbolAddress(&Layout.getAssembler().getSymbolData(*Data->End),
    884                        Layout);
    885     DEBUG(dbgs() << "data in code region-- kind: " << Data->Kind
    886                  << "  start: " << Start << "(" << Data->Start->getName() << ")"
    887                  << "  end: " << End << "(" << Data->End->getName() << ")"
    888                  << "  size: " << End - Start
    889                  << "\n");
    890     Write32(Start);
    891     Write16(End - Start);
    892     Write16(Data->Kind);
    893   }
    894 
    895   // Write the symbol table data, if used.
    896   if (NumSymbols) {
    897     // Write the indirect symbol entries.
    898     for (MCAssembler::const_indirect_symbol_iterator
    899            it = Asm.indirect_symbol_begin(),
    900            ie = Asm.indirect_symbol_end(); it != ie; ++it) {
    901       // Indirect symbols in the non lazy symbol pointer section have some
    902       // special handling.
    903       const MCSectionMachO &Section =
    904         static_cast<const MCSectionMachO&>(it->SectionData->getSection());
    905       if (Section.getType() == MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS) {
    906         // If this symbol is defined and internal, mark it as such.
    907         if (it->Symbol->isDefined() &&
    908             !Asm.getSymbolData(*it->Symbol).isExternal()) {
    909           uint32_t Flags = macho::ISF_Local;
    910           if (it->Symbol->isAbsolute())
    911             Flags |= macho::ISF_Absolute;
    912           Write32(Flags);
    913           continue;
    914         }
    915       }
    916 
    917       Write32(Asm.getSymbolData(*it->Symbol).getIndex());
    918     }
    919 
    920     // FIXME: Check that offsets match computed ones.
    921 
    922     // Write the symbol table entries.
    923     for (unsigned i = 0, e = LocalSymbolData.size(); i != e; ++i)
    924       WriteNlist(LocalSymbolData[i], Layout);
    925     for (unsigned i = 0, e = ExternalSymbolData.size(); i != e; ++i)
    926       WriteNlist(ExternalSymbolData[i], Layout);
    927     for (unsigned i = 0, e = UndefinedSymbolData.size(); i != e; ++i)
    928       WriteNlist(UndefinedSymbolData[i], Layout);
    929 
    930     // Write the string table.
    931     OS << StringTable.str();
    932   }
    933 }
    934 
    935 MCObjectWriter *llvm::createMachObjectWriter(MCMachObjectTargetWriter *MOTW,
    936                                              raw_ostream &OS,
    937                                              bool IsLittleEndian) {
    938   return new MachObjectWriter(MOTW, OS, IsLittleEndian);
    939 }
    940