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