MachObjectWriter.cpp revision 256281 
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>
27using namespace llvm;
28using namespace llvm::object;
29
30void 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
40bool MachObjectWriter::
41doesSymbolRequireExternRelocation(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
55bool MachObjectWriter::
56MachSymbolData::operator<(const MachSymbolData &RHS) const {
57  return SymbolData->getSymbol().getName() <
58    RHS.SymbolData->getSymbol().getName();
59}
60
61bool 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
68uint64_t MachObjectWriter::getFragmentAddress(const MCFragment *Fragment,
69                                              const MCAsmLayout &Layout) const {
70  return getSectionAddress(Fragment->getParent()) +
71    Layout.getFragmentOffset(Fragment);
72}
73
74uint64_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
112uint64_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
125void 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.
159void 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
197void 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
247void 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
266void 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
303void 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
365void 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
379static 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
388void 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
413void 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
423void 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.
476void MachObjectWriter::
477ComputeSymbolTable(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
586void 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
603void 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
623void 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
639bool MachObjectWriter::
640IsSymbolRefDifferenceFullyResolvedImpl(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
718void 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
935MCObjectWriter *llvm::createMachObjectWriter(MCMachObjectTargetWriter *MOTW,
936                                             raw_ostream &OS,
937                                             bool IsLittleEndian) {
938  return new MachObjectWriter(MOTW, OS, IsLittleEndian);
939}
940