1 //===- lib/MC/MachObjectWriter.cpp - Mach-O File Writer -------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/MC/MachObjectWriter.h"
11 #include "llvm/ADT/StringMap.h"
12 #include "llvm/ADT/Twine.h"
13 #include "llvm/MC/MCAssembler.h"
14 #include "llvm/MC/MCAsmLayout.h"
15 #include "llvm/MC/MCExpr.h"
16 #include "llvm/MC/MCObjectWriter.h"
17 #include "llvm/MC/MCSectionMachO.h"
18 #include "llvm/MC/MCSymbol.h"
19 #include "llvm/MC/MCMachOSymbolFlags.h"
20 #include "llvm/MC/MCValue.h"
21 #include "llvm/Support/ErrorHandling.h"
22 #include "llvm/Support/MachO.h"
23 #include "llvm/Target/TargetAsmBackend.h"
26 #include "../Target/X86/X86FixupKinds.h"
31 static unsigned getFixupKindLog2Size(unsigned Kind
) {
33 default: llvm_unreachable("invalid fixup kind!");
34 case X86::reloc_pcrel_1byte
:
35 case FK_Data_1
: return 0;
36 case FK_Data_2
: return 1;
37 case X86::reloc_pcrel_4byte
:
38 case X86::reloc_riprel_4byte
:
39 case X86::reloc_riprel_4byte_movq_load
:
40 case FK_Data_4
: return 2;
41 case FK_Data_8
: return 3;
45 static bool isFixupKindPCRel(unsigned Kind
) {
49 case X86::reloc_pcrel_1byte
:
50 case X86::reloc_pcrel_4byte
:
51 case X86::reloc_riprel_4byte
:
52 case X86::reloc_riprel_4byte_movq_load
:
57 static bool isFixupKindRIPRel(unsigned Kind
) {
58 return Kind
== X86::reloc_riprel_4byte
||
59 Kind
== X86::reloc_riprel_4byte_movq_load
;
62 static bool doesSymbolRequireExternRelocation(MCSymbolData
*SD
) {
63 // Undefined symbols are always extern.
64 if (SD
->Symbol
->isUndefined())
67 // References to weak definitions require external relocation entries; the
68 // definition may not always be the one in the same object file.
69 if (SD
->getFlags() & SF_WeakDefinition
)
72 // Otherwise, we can use an internal relocation.
78 class MachObjectWriterImpl
{
79 // See <mach-o/loader.h>.
81 Header_Magic32
= 0xFEEDFACE,
82 Header_Magic64
= 0xFEEDFACF
88 SegmentLoadCommand32Size
= 56,
89 SegmentLoadCommand64Size
= 72,
92 SymtabLoadCommandSize
= 24,
93 DysymtabLoadCommandSize
= 80,
96 RelocationInfoSize
= 8
104 HF_SubsectionsViaSymbols
= 0x2000
107 enum LoadCommandType
{
114 // See <mach-o/nlist.h>.
115 enum SymbolTypeType
{
116 STT_Undefined
= 0x00,
121 enum SymbolTypeFlags
{
122 // If any of these bits are set, then the entry is a stab entry number (see
123 // <mach-o/stab.h>. Otherwise the other masks apply.
124 STF_StabsEntryMask
= 0xe0,
128 STF_PrivateExtern
= 0x10
131 /// IndirectSymbolFlags - Flags for encoding special values in the indirect
133 enum IndirectSymbolFlags
{
134 ISF_Local
= 0x80000000,
135 ISF_Absolute
= 0x40000000
138 /// RelocationFlags - Special flags for addresses.
139 enum RelocationFlags
{
140 RF_Scattered
= 0x80000000
143 enum RelocationInfoType
{
147 RIT_PreboundLazyPointer
= 3,
148 RIT_LocalDifference
= 4
151 /// X86_64 uses its own relocation types.
152 enum RelocationInfoTypeX86_64
{
153 RIT_X86_64_Unsigned
= 0,
154 RIT_X86_64_Signed
= 1,
155 RIT_X86_64_Branch
= 2,
156 RIT_X86_64_GOTLoad
= 3,
158 RIT_X86_64_Subtractor
= 5,
159 RIT_X86_64_Signed1
= 6,
160 RIT_X86_64_Signed2
= 7,
161 RIT_X86_64_Signed4
= 8
164 /// MachSymbolData - Helper struct for containing some precomputed information
166 struct MachSymbolData
{
167 MCSymbolData
*SymbolData
;
168 uint64_t StringIndex
;
169 uint8_t SectionIndex
;
171 // Support lexicographic sorting.
172 bool operator<(const MachSymbolData
&RHS
) const {
173 const std::string
&Name
= SymbolData
->getSymbol().getName();
174 return Name
< RHS
.SymbolData
->getSymbol().getName();
178 /// @name Relocation Data
181 struct MachRelocationEntry
{
186 llvm::DenseMap
<const MCSectionData
*,
187 std::vector
<MachRelocationEntry
> > Relocations
;
188 llvm::DenseMap
<const MCSectionData
*, unsigned> IndirectSymBase
;
191 /// @name Symbol Table Data
194 SmallString
<256> StringTable
;
195 std::vector
<MachSymbolData
> LocalSymbolData
;
196 std::vector
<MachSymbolData
> ExternalSymbolData
;
197 std::vector
<MachSymbolData
> UndefinedSymbolData
;
201 MachObjectWriter
*Writer
;
205 unsigned Is64Bit
: 1;
208 MachObjectWriterImpl(MachObjectWriter
*_Writer
, bool _Is64Bit
)
209 : Writer(_Writer
), OS(Writer
->getStream()), Is64Bit(_Is64Bit
) {
212 void Write8(uint8_t Value
) { Writer
->Write8(Value
); }
213 void Write16(uint16_t Value
) { Writer
->Write16(Value
); }
214 void Write32(uint32_t Value
) { Writer
->Write32(Value
); }
215 void Write64(uint64_t Value
) { Writer
->Write64(Value
); }
216 void WriteZeros(unsigned N
) { Writer
->WriteZeros(N
); }
217 void WriteBytes(StringRef Str
, unsigned ZeroFillSize
= 0) {
218 Writer
->WriteBytes(Str
, ZeroFillSize
);
221 void WriteHeader(unsigned NumLoadCommands
, unsigned LoadCommandsSize
,
222 bool SubsectionsViaSymbols
) {
225 if (SubsectionsViaSymbols
)
226 Flags
|= HF_SubsectionsViaSymbols
;
228 // struct mach_header (28 bytes) or
229 // struct mach_header_64 (32 bytes)
231 uint64_t Start
= OS
.tell();
234 Write32(Is64Bit
? Header_Magic64
: Header_Magic32
);
236 // FIXME: Support cputype.
237 Write32(Is64Bit
? MachO::CPUTypeX86_64
: MachO::CPUTypeI386
);
238 // FIXME: Support cpusubtype.
239 Write32(MachO::CPUSubType_I386_ALL
);
241 Write32(NumLoadCommands
); // Object files have a single load command, the
243 Write32(LoadCommandsSize
);
246 Write32(0); // reserved
248 assert(OS
.tell() - Start
== Is64Bit
? Header64Size
: Header32Size
);
251 /// WriteSegmentLoadCommand - Write a segment load command.
253 /// \arg NumSections - The number of sections in this segment.
254 /// \arg SectionDataSize - The total size of the sections.
255 void WriteSegmentLoadCommand(unsigned NumSections
,
257 uint64_t SectionDataStartOffset
,
258 uint64_t SectionDataSize
) {
259 // struct segment_command (56 bytes) or
260 // struct segment_command_64 (72 bytes)
262 uint64_t Start
= OS
.tell();
265 unsigned SegmentLoadCommandSize
= Is64Bit
? SegmentLoadCommand64Size
:
266 SegmentLoadCommand32Size
;
267 Write32(Is64Bit
? LCT_Segment64
: LCT_Segment
);
268 Write32(SegmentLoadCommandSize
+
269 NumSections
* (Is64Bit
? Section64Size
: Section32Size
));
273 Write64(0); // vmaddr
274 Write64(VMSize
); // vmsize
275 Write64(SectionDataStartOffset
); // file offset
276 Write64(SectionDataSize
); // file size
278 Write32(0); // vmaddr
279 Write32(VMSize
); // vmsize
280 Write32(SectionDataStartOffset
); // file offset
281 Write32(SectionDataSize
); // file size
283 Write32(0x7); // maxprot
284 Write32(0x7); // initprot
285 Write32(NumSections
);
288 assert(OS
.tell() - Start
== SegmentLoadCommandSize
);
291 void WriteSection(const MCAssembler
&Asm
, const MCAsmLayout
&Layout
,
292 const MCSectionData
&SD
, uint64_t FileOffset
,
293 uint64_t RelocationsStart
, unsigned NumRelocations
) {
294 uint64_t SectionSize
= Layout
.getSectionSize(&SD
);
296 // The offset is unused for virtual sections.
297 if (Asm
.getBackend().isVirtualSection(SD
.getSection())) {
298 assert(Layout
.getSectionFileSize(&SD
) == 0 && "Invalid file size!");
302 // struct section (68 bytes) or
303 // struct section_64 (80 bytes)
305 uint64_t Start
= OS
.tell();
308 const MCSectionMachO
&Section
= cast
<MCSectionMachO
>(SD
.getSection());
309 WriteBytes(Section
.getSectionName(), 16);
310 WriteBytes(Section
.getSegmentName(), 16);
312 Write64(Layout
.getSectionAddress(&SD
)); // address
313 Write64(SectionSize
); // size
315 Write32(Layout
.getSectionAddress(&SD
)); // address
316 Write32(SectionSize
); // size
320 unsigned Flags
= Section
.getTypeAndAttributes();
321 if (SD
.hasInstructions())
322 Flags
|= MCSectionMachO::S_ATTR_SOME_INSTRUCTIONS
;
324 assert(isPowerOf2_32(SD
.getAlignment()) && "Invalid alignment!");
325 Write32(Log2_32(SD
.getAlignment()));
326 Write32(NumRelocations
? RelocationsStart
: 0);
327 Write32(NumRelocations
);
329 Write32(IndirectSymBase
.lookup(&SD
)); // reserved1
330 Write32(Section
.getStubSize()); // reserved2
332 Write32(0); // reserved3
334 assert(OS
.tell() - Start
== Is64Bit
? Section64Size
: Section32Size
);
337 void WriteSymtabLoadCommand(uint32_t SymbolOffset
, uint32_t NumSymbols
,
338 uint32_t StringTableOffset
,
339 uint32_t StringTableSize
) {
340 // struct symtab_command (24 bytes)
342 uint64_t Start
= OS
.tell();
346 Write32(SymtabLoadCommandSize
);
347 Write32(SymbolOffset
);
349 Write32(StringTableOffset
);
350 Write32(StringTableSize
);
352 assert(OS
.tell() - Start
== SymtabLoadCommandSize
);
355 void WriteDysymtabLoadCommand(uint32_t FirstLocalSymbol
,
356 uint32_t NumLocalSymbols
,
357 uint32_t FirstExternalSymbol
,
358 uint32_t NumExternalSymbols
,
359 uint32_t FirstUndefinedSymbol
,
360 uint32_t NumUndefinedSymbols
,
361 uint32_t IndirectSymbolOffset
,
362 uint32_t NumIndirectSymbols
) {
363 // struct dysymtab_command (80 bytes)
365 uint64_t Start
= OS
.tell();
368 Write32(LCT_Dysymtab
);
369 Write32(DysymtabLoadCommandSize
);
370 Write32(FirstLocalSymbol
);
371 Write32(NumLocalSymbols
);
372 Write32(FirstExternalSymbol
);
373 Write32(NumExternalSymbols
);
374 Write32(FirstUndefinedSymbol
);
375 Write32(NumUndefinedSymbols
);
376 Write32(0); // tocoff
378 Write32(0); // modtaboff
379 Write32(0); // nmodtab
380 Write32(0); // extrefsymoff
381 Write32(0); // nextrefsyms
382 Write32(IndirectSymbolOffset
);
383 Write32(NumIndirectSymbols
);
384 Write32(0); // extreloff
385 Write32(0); // nextrel
386 Write32(0); // locreloff
387 Write32(0); // nlocrel
389 assert(OS
.tell() - Start
== DysymtabLoadCommandSize
);
392 void WriteNlist(MachSymbolData
&MSD
, const MCAsmLayout
&Layout
) {
393 MCSymbolData
&Data
= *MSD
.SymbolData
;
394 const MCSymbol
&Symbol
= Data
.getSymbol();
396 uint16_t Flags
= Data
.getFlags();
397 uint32_t Address
= 0;
399 // Set the N_TYPE bits. See <mach-o/nlist.h>.
401 // FIXME: Are the prebound or indirect fields possible here?
402 if (Symbol
.isUndefined())
403 Type
= STT_Undefined
;
404 else if (Symbol
.isAbsolute())
409 // FIXME: Set STAB bits.
411 if (Data
.isPrivateExtern())
412 Type
|= STF_PrivateExtern
;
415 if (Data
.isExternal() || Symbol
.isUndefined())
416 Type
|= STF_External
;
418 // Compute the symbol address.
419 if (Symbol
.isDefined()) {
420 if (Symbol
.isAbsolute()) {
421 Address
= cast
<MCConstantExpr
>(Symbol
.getVariableValue())->getValue();
423 Address
= Layout
.getSymbolAddress(&Data
);
425 } else if (Data
.isCommon()) {
426 // Common symbols are encoded with the size in the address
427 // field, and their alignment in the flags.
428 Address
= Data
.getCommonSize();
430 // Common alignment is packed into the 'desc' bits.
431 if (unsigned Align
= Data
.getCommonAlignment()) {
432 unsigned Log2Size
= Log2_32(Align
);
433 assert((1U << Log2Size
) == Align
&& "Invalid 'common' alignment!");
435 report_fatal_error("invalid 'common' alignment '" +
437 // FIXME: Keep this mask with the SymbolFlags enumeration.
438 Flags
= (Flags
& 0xF0FF) | (Log2Size
<< 8);
442 // struct nlist (12 bytes)
444 Write32(MSD
.StringIndex
);
446 Write8(MSD
.SectionIndex
);
448 // The Mach-O streamer uses the lowest 16-bits of the flags for the 'desc'
457 // FIXME: We really need to improve the relocation validation. Basically, we
458 // want to implement a separate computation which evaluates the relocation
459 // entry as the linker would, and verifies that the resultant fixup value is
460 // exactly what the encoder wanted. This will catch several classes of
463 // - Relocation entry bugs, the two algorithms are unlikely to have the same
466 // - Relaxation issues, where we forget to relax something.
468 // - Input errors, where something cannot be correctly encoded. 'as' allows
469 // these through in many cases.
471 void RecordX86_64Relocation(const MCAssembler
&Asm
, const MCAsmLayout
&Layout
,
472 const MCFragment
*Fragment
,
473 const MCAsmFixup
&Fixup
, MCValue Target
,
474 uint64_t &FixedValue
) {
475 unsigned IsPCRel
= isFixupKindPCRel(Fixup
.Kind
);
476 unsigned IsRIPRel
= isFixupKindRIPRel(Fixup
.Kind
);
477 unsigned Log2Size
= getFixupKindLog2Size(Fixup
.Kind
);
480 uint32_t FixupOffset
= Layout
.getFragmentOffset(Fragment
) + Fixup
.Offset
;
481 uint32_t FixupAddress
= Layout
.getFragmentAddress(Fragment
) + Fixup
.Offset
;
484 unsigned IsExtern
= 0;
487 Value
= Target
.getConstant();
490 // Compensate for the relocation offset, Darwin x86_64 relocations only
491 // have the addend and appear to have attempted to define it to be the
492 // actual expression addend without the PCrel bias. However, instructions
493 // with data following the relocation are not accomodated for (see comment
494 // below regarding SIGNED{1,2,4}), so it isn't exactly that either.
495 Value
+= 1LL << Log2Size
;
498 if (Target
.isAbsolute()) { // constant
499 // SymbolNum of 0 indicates the absolute section.
500 Type
= RIT_X86_64_Unsigned
;
503 // FIXME: I believe this is broken, I don't think the linker can
504 // understand it. I think it would require a local relocation, but I'm not
505 // sure if that would work either. The official way to get an absolute
506 // PCrel relocation is to use an absolute symbol (which we don't support
510 Type
= RIT_X86_64_Branch
;
512 } else if (Target
.getSymB()) { // A - B + constant
513 const MCSymbol
*A
= &Target
.getSymA()->getSymbol();
514 MCSymbolData
&A_SD
= Asm
.getSymbolData(*A
);
515 const MCSymbolData
*A_Base
= Asm
.getAtom(Layout
, &A_SD
);
517 const MCSymbol
*B
= &Target
.getSymB()->getSymbol();
518 MCSymbolData
&B_SD
= Asm
.getSymbolData(*B
);
519 const MCSymbolData
*B_Base
= Asm
.getAtom(Layout
, &B_SD
);
521 // Neither symbol can be modified.
522 if (Target
.getSymA()->getKind() != MCSymbolRefExpr::VK_None
||
523 Target
.getSymB()->getKind() != MCSymbolRefExpr::VK_None
)
524 report_fatal_error("unsupported relocation of modified symbol");
526 // We don't support PCrel relocations of differences. Darwin 'as' doesn't
527 // implement most of these correctly.
529 report_fatal_error("unsupported pc-relative relocation of difference");
531 // We don't currently support any situation where one or both of the
532 // symbols would require a local relocation. This is almost certainly
533 // unused and may not be possible to encode correctly.
534 if (!A_Base
|| !B_Base
)
535 report_fatal_error("unsupported local relocations in difference");
537 // Darwin 'as' doesn't emit correct relocations for this (it ends up with
538 // a single SIGNED relocation); reject it for now.
539 if (A_Base
== B_Base
)
540 report_fatal_error("unsupported relocation with identical base");
542 Value
+= Layout
.getSymbolAddress(&A_SD
) - Layout
.getSymbolAddress(A_Base
);
543 Value
-= Layout
.getSymbolAddress(&B_SD
) - Layout
.getSymbolAddress(B_Base
);
545 Index
= A_Base
->getIndex();
547 Type
= RIT_X86_64_Unsigned
;
549 MachRelocationEntry MRE
;
550 MRE
.Word0
= FixupOffset
;
551 MRE
.Word1
= ((Index
<< 0) |
556 Relocations
[Fragment
->getParent()].push_back(MRE
);
558 Index
= B_Base
->getIndex();
560 Type
= RIT_X86_64_Subtractor
;
562 const MCSymbol
*Symbol
= &Target
.getSymA()->getSymbol();
563 MCSymbolData
&SD
= Asm
.getSymbolData(*Symbol
);
564 const MCSymbolData
*Base
= Asm
.getAtom(Layout
, &SD
);
566 // Relocations inside debug sections always use local relocations when
567 // possible. This seems to be done because the debugger doesn't fully
568 // understand x86_64 relocation entries, and expects to find values that
569 // have already been fixed up.
570 if (Symbol
->isInSection()) {
571 const MCSectionMachO
&Section
= static_cast<const MCSectionMachO
&>(
572 Fragment
->getParent()->getSection());
573 if (Section
.hasAttribute(MCSectionMachO::S_ATTR_DEBUG
))
577 // x86_64 almost always uses external relocations, except when there is no
578 // symbol to use as a base address (a local symbol with no preceeding
579 // non-local symbol).
581 Index
= Base
->getIndex();
584 // Add the local offset, if needed.
586 Value
+= Layout
.getSymbolAddress(&SD
) - Layout
.getSymbolAddress(Base
);
587 } else if (Symbol
->isInSection()) {
588 // The index is the section ordinal (1-based).
589 Index
= SD
.getFragment()->getParent()->getOrdinal() + 1;
591 Value
+= Layout
.getSymbolAddress(&SD
);
594 Value
-= FixupAddress
+ (1 << Log2Size
);
596 report_fatal_error("unsupported relocation of undefined symbol '" +
597 Symbol
->getName() + "'");
600 MCSymbolRefExpr::VariantKind Modifier
= Target
.getSymA()->getKind();
603 if (Modifier
== MCSymbolRefExpr::VK_GOTPCREL
) {
604 // x86_64 distinguishes movq foo@GOTPCREL so that the linker can
605 // rewrite the movq to an leaq at link time if the symbol ends up in
606 // the same linkage unit.
607 if (unsigned(Fixup
.Kind
) == X86::reloc_riprel_4byte_movq_load
)
608 Type
= RIT_X86_64_GOTLoad
;
610 Type
= RIT_X86_64_GOT
;
611 } else if (Modifier
!= MCSymbolRefExpr::VK_None
) {
612 report_fatal_error("unsupported symbol modifier in relocation");
614 Type
= RIT_X86_64_Signed
;
616 // The Darwin x86_64 relocation format has a problem where it cannot
617 // encode an address (L<foo> + <constant>) which is outside the atom
618 // containing L<foo>. Generally, this shouldn't occur but it does
619 // happen when we have a RIPrel instruction with data following the
620 // relocation entry (e.g., movb $012, L0(%rip)). Even with the PCrel
621 // adjustment Darwin x86_64 uses, the offset is still negative and
622 // the linker has no way to recognize this.
624 // To work around this, Darwin uses several special relocation types
625 // to indicate the offsets. However, the specification or
626 // implementation of these seems to also be incomplete; they should
627 // adjust the addend as well based on the actual encoded instruction
628 // (the additional bias), but instead appear to just look at the
630 switch (-(Target
.getConstant() + (1LL << Log2Size
))) {
631 case 1: Type
= RIT_X86_64_Signed1
; break;
632 case 2: Type
= RIT_X86_64_Signed2
; break;
633 case 4: Type
= RIT_X86_64_Signed4
; break;
637 if (Modifier
!= MCSymbolRefExpr::VK_None
)
638 report_fatal_error("unsupported symbol modifier in branch "
641 Type
= RIT_X86_64_Branch
;
644 if (Modifier
== MCSymbolRefExpr::VK_GOT
) {
645 Type
= RIT_X86_64_GOT
;
646 } else if (Modifier
== MCSymbolRefExpr::VK_GOTPCREL
) {
647 // GOTPCREL is allowed as a modifier on non-PCrel instructions, in
648 // which case all we do is set the PCrel bit in the relocation entry;
649 // this is used with exception handling, for example. The source is
650 // required to include any necessary offset directly.
651 Type
= RIT_X86_64_GOT
;
653 } else if (Modifier
!= MCSymbolRefExpr::VK_None
)
654 report_fatal_error("unsupported symbol modifier in relocation");
656 Type
= RIT_X86_64_Unsigned
;
660 // x86_64 always writes custom values into the fixups.
663 // struct relocation_info (8 bytes)
664 MachRelocationEntry MRE
;
665 MRE
.Word0
= FixupOffset
;
666 MRE
.Word1
= ((Index
<< 0) |
671 Relocations
[Fragment
->getParent()].push_back(MRE
);
674 void RecordScatteredRelocation(const MCAssembler
&Asm
,
675 const MCAsmLayout
&Layout
,
676 const MCFragment
*Fragment
,
677 const MCAsmFixup
&Fixup
, MCValue Target
,
678 uint64_t &FixedValue
) {
679 uint32_t FixupOffset
= Layout
.getFragmentOffset(Fragment
) + Fixup
.Offset
;
680 unsigned IsPCRel
= isFixupKindPCRel(Fixup
.Kind
);
681 unsigned Log2Size
= getFixupKindLog2Size(Fixup
.Kind
);
682 unsigned Type
= RIT_Vanilla
;
685 const MCSymbol
*A
= &Target
.getSymA()->getSymbol();
686 MCSymbolData
*A_SD
= &Asm
.getSymbolData(*A
);
688 if (!A_SD
->getFragment())
689 report_fatal_error("symbol '" + A
->getName() +
690 "' can not be undefined in a subtraction expression");
692 uint32_t Value
= Layout
.getSymbolAddress(A_SD
);
695 if (const MCSymbolRefExpr
*B
= Target
.getSymB()) {
696 MCSymbolData
*B_SD
= &Asm
.getSymbolData(B
->getSymbol());
698 if (!B_SD
->getFragment())
699 report_fatal_error("symbol '" + B
->getSymbol().getName() +
700 "' can not be undefined in a subtraction expression");
702 // Select the appropriate difference relocation type.
704 // Note that there is no longer any semantic difference between these two
705 // relocation types from the linkers point of view, this is done solely
706 // for pedantic compatibility with 'as'.
707 Type
= A_SD
->isExternal() ? RIT_Difference
: RIT_LocalDifference
;
708 Value2
= Layout
.getSymbolAddress(B_SD
);
711 // Relocations are written out in reverse order, so the PAIR comes first.
712 if (Type
== RIT_Difference
|| Type
== RIT_LocalDifference
) {
713 MachRelocationEntry MRE
;
714 MRE
.Word0
= ((0 << 0) |
720 Relocations
[Fragment
->getParent()].push_back(MRE
);
723 MachRelocationEntry MRE
;
724 MRE
.Word0
= ((FixupOffset
<< 0) |
730 Relocations
[Fragment
->getParent()].push_back(MRE
);
733 void RecordRelocation(const MCAssembler
&Asm
, const MCAsmLayout
&Layout
,
734 const MCFragment
*Fragment
, const MCAsmFixup
&Fixup
,
735 MCValue Target
, uint64_t &FixedValue
) {
737 RecordX86_64Relocation(Asm
, Layout
, Fragment
, Fixup
, Target
, FixedValue
);
741 unsigned IsPCRel
= isFixupKindPCRel(Fixup
.Kind
);
742 unsigned Log2Size
= getFixupKindLog2Size(Fixup
.Kind
);
744 // If this is a difference or a defined symbol plus an offset, then we need
745 // a scattered relocation entry.
746 // Differences always require scattered relocations.
747 if (Target
.getSymB())
748 return RecordScatteredRelocation(Asm
, Layout
, Fragment
, Fixup
,
751 // Get the symbol data, if any.
752 MCSymbolData
*SD
= 0;
753 if (Target
.getSymA())
754 SD
= &Asm
.getSymbolData(Target
.getSymA()->getSymbol());
756 // If this is an internal relocation with an offset, it also needs a
757 // scattered relocation entry.
758 uint32_t Offset
= Target
.getConstant();
760 Offset
+= 1 << Log2Size
;
761 if (Offset
&& SD
&& !doesSymbolRequireExternRelocation(SD
))
762 return RecordScatteredRelocation(Asm
, Layout
, Fragment
, Fixup
,
766 uint32_t FixupOffset
= Layout
.getFragmentOffset(Fragment
) + Fixup
.Offset
;
769 unsigned IsExtern
= 0;
772 if (Target
.isAbsolute()) { // constant
773 // SymbolNum of 0 indicates the absolute section.
775 // FIXME: Currently, these are never generated (see code below). I cannot
776 // find a case where they are actually emitted.
780 // Check whether we need an external or internal relocation.
781 if (doesSymbolRequireExternRelocation(SD
)) {
783 Index
= SD
->getIndex();
784 // For external relocations, make sure to offset the fixup value to
785 // compensate for the addend of the symbol address, if it was
786 // undefined. This occurs with weak definitions, for example.
787 if (!SD
->Symbol
->isUndefined())
788 FixedValue
-= Layout
.getSymbolAddress(SD
);
791 // The index is the section ordinal (1-based).
792 Index
= SD
->getFragment()->getParent()->getOrdinal() + 1;
793 Value
= Layout
.getSymbolAddress(SD
);
799 // struct relocation_info (8 bytes)
800 MachRelocationEntry MRE
;
801 MRE
.Word0
= FixupOffset
;
802 MRE
.Word1
= ((Index
<< 0) |
807 Relocations
[Fragment
->getParent()].push_back(MRE
);
810 void BindIndirectSymbols(MCAssembler
&Asm
) {
811 // This is the point where 'as' creates actual symbols for indirect symbols
812 // (in the following two passes). It would be easier for us to do this
813 // sooner when we see the attribute, but that makes getting the order in the
814 // symbol table much more complicated than it is worth.
816 // FIXME: Revisit this when the dust settles.
818 // Bind non lazy symbol pointers first.
819 unsigned IndirectIndex
= 0;
820 for (MCAssembler::indirect_symbol_iterator it
= Asm
.indirect_symbol_begin(),
821 ie
= Asm
.indirect_symbol_end(); it
!= ie
; ++it
, ++IndirectIndex
) {
822 const MCSectionMachO
&Section
=
823 cast
<MCSectionMachO
>(it
->SectionData
->getSection());
825 if (Section
.getType() != MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS
)
828 // Initialize the section indirect symbol base, if necessary.
829 if (!IndirectSymBase
.count(it
->SectionData
))
830 IndirectSymBase
[it
->SectionData
] = IndirectIndex
;
832 Asm
.getOrCreateSymbolData(*it
->Symbol
);
835 // Then lazy symbol pointers and symbol stubs.
837 for (MCAssembler::indirect_symbol_iterator it
= Asm
.indirect_symbol_begin(),
838 ie
= Asm
.indirect_symbol_end(); it
!= ie
; ++it
, ++IndirectIndex
) {
839 const MCSectionMachO
&Section
=
840 cast
<MCSectionMachO
>(it
->SectionData
->getSection());
842 if (Section
.getType() != MCSectionMachO::S_LAZY_SYMBOL_POINTERS
&&
843 Section
.getType() != MCSectionMachO::S_SYMBOL_STUBS
)
846 // Initialize the section indirect symbol base, if necessary.
847 if (!IndirectSymBase
.count(it
->SectionData
))
848 IndirectSymBase
[it
->SectionData
] = IndirectIndex
;
850 // Set the symbol type to undefined lazy, but only on construction.
852 // FIXME: Do not hardcode.
854 MCSymbolData
&Entry
= Asm
.getOrCreateSymbolData(*it
->Symbol
, &Created
);
856 Entry
.setFlags(Entry
.getFlags() | 0x0001);
860 /// ComputeSymbolTable - Compute the symbol table data
862 /// \param StringTable [out] - The string table data.
863 /// \param StringIndexMap [out] - Map from symbol names to offsets in the
865 void ComputeSymbolTable(MCAssembler
&Asm
, SmallString
<256> &StringTable
,
866 std::vector
<MachSymbolData
> &LocalSymbolData
,
867 std::vector
<MachSymbolData
> &ExternalSymbolData
,
868 std::vector
<MachSymbolData
> &UndefinedSymbolData
) {
869 // Build section lookup table.
870 DenseMap
<const MCSection
*, uint8_t> SectionIndexMap
;
872 for (MCAssembler::iterator it
= Asm
.begin(),
873 ie
= Asm
.end(); it
!= ie
; ++it
, ++Index
)
874 SectionIndexMap
[&it
->getSection()] = Index
;
875 assert(Index
<= 256 && "Too many sections!");
877 // Index 0 is always the empty string.
878 StringMap
<uint64_t> StringIndexMap
;
879 StringTable
+= '\x00';
881 // Build the symbol arrays and the string table, but only for non-local
884 // The particular order that we collect the symbols and create the string
885 // table, then sort the symbols is chosen to match 'as'. Even though it
886 // doesn't matter for correctness, this is important for letting us diff .o
888 for (MCAssembler::symbol_iterator it
= Asm
.symbol_begin(),
889 ie
= Asm
.symbol_end(); it
!= ie
; ++it
) {
890 const MCSymbol
&Symbol
= it
->getSymbol();
892 // Ignore non-linker visible symbols.
893 if (!Asm
.isSymbolLinkerVisible(it
))
896 if (!it
->isExternal() && !Symbol
.isUndefined())
899 uint64_t &Entry
= StringIndexMap
[Symbol
.getName()];
901 Entry
= StringTable
.size();
902 StringTable
+= Symbol
.getName();
903 StringTable
+= '\x00';
908 MSD
.StringIndex
= Entry
;
910 if (Symbol
.isUndefined()) {
911 MSD
.SectionIndex
= 0;
912 UndefinedSymbolData
.push_back(MSD
);
913 } else if (Symbol
.isAbsolute()) {
914 MSD
.SectionIndex
= 0;
915 ExternalSymbolData
.push_back(MSD
);
917 MSD
.SectionIndex
= SectionIndexMap
.lookup(&Symbol
.getSection());
918 assert(MSD
.SectionIndex
&& "Invalid section index!");
919 ExternalSymbolData
.push_back(MSD
);
923 // Now add the data for local symbols.
924 for (MCAssembler::symbol_iterator it
= Asm
.symbol_begin(),
925 ie
= Asm
.symbol_end(); it
!= ie
; ++it
) {
926 const MCSymbol
&Symbol
= it
->getSymbol();
928 // Ignore non-linker visible symbols.
929 if (!Asm
.isSymbolLinkerVisible(it
))
932 if (it
->isExternal() || Symbol
.isUndefined())
935 uint64_t &Entry
= StringIndexMap
[Symbol
.getName()];
937 Entry
= StringTable
.size();
938 StringTable
+= Symbol
.getName();
939 StringTable
+= '\x00';
944 MSD
.StringIndex
= Entry
;
946 if (Symbol
.isAbsolute()) {
947 MSD
.SectionIndex
= 0;
948 LocalSymbolData
.push_back(MSD
);
950 MSD
.SectionIndex
= SectionIndexMap
.lookup(&Symbol
.getSection());
951 assert(MSD
.SectionIndex
&& "Invalid section index!");
952 LocalSymbolData
.push_back(MSD
);
956 // External and undefined symbols are required to be in lexicographic order.
957 std::sort(ExternalSymbolData
.begin(), ExternalSymbolData
.end());
958 std::sort(UndefinedSymbolData
.begin(), UndefinedSymbolData
.end());
960 // Set the symbol indices.
962 for (unsigned i
= 0, e
= LocalSymbolData
.size(); i
!= e
; ++i
)
963 LocalSymbolData
[i
].SymbolData
->setIndex(Index
++);
964 for (unsigned i
= 0, e
= ExternalSymbolData
.size(); i
!= e
; ++i
)
965 ExternalSymbolData
[i
].SymbolData
->setIndex(Index
++);
966 for (unsigned i
= 0, e
= UndefinedSymbolData
.size(); i
!= e
; ++i
)
967 UndefinedSymbolData
[i
].SymbolData
->setIndex(Index
++);
969 // The string table is padded to a multiple of 4.
970 while (StringTable
.size() % 4)
971 StringTable
+= '\x00';
974 void ExecutePostLayoutBinding(MCAssembler
&Asm
) {
975 // Create symbol data for any indirect symbols.
976 BindIndirectSymbols(Asm
);
978 // Compute symbol table information and bind symbol indices.
979 ComputeSymbolTable(Asm
, StringTable
, LocalSymbolData
, ExternalSymbolData
,
980 UndefinedSymbolData
);
983 void WriteObject(const MCAssembler
&Asm
, const MCAsmLayout
&Layout
) {
984 unsigned NumSections
= Asm
.size();
986 // The section data starts after the header, the segment load command (and
987 // section headers) and the symbol table.
988 unsigned NumLoadCommands
= 1;
989 uint64_t LoadCommandsSize
= Is64Bit
?
990 SegmentLoadCommand64Size
+ NumSections
* Section64Size
:
991 SegmentLoadCommand32Size
+ NumSections
* Section32Size
;
993 // Add the symbol table load command sizes, if used.
994 unsigned NumSymbols
= LocalSymbolData
.size() + ExternalSymbolData
.size() +
995 UndefinedSymbolData
.size();
997 NumLoadCommands
+= 2;
998 LoadCommandsSize
+= SymtabLoadCommandSize
+ DysymtabLoadCommandSize
;
1001 // Compute the total size of the section data, as well as its file size and
1003 uint64_t SectionDataStart
= (Is64Bit
? Header64Size
: Header32Size
)
1005 uint64_t SectionDataSize
= 0;
1006 uint64_t SectionDataFileSize
= 0;
1007 uint64_t VMSize
= 0;
1008 for (MCAssembler::const_iterator it
= Asm
.begin(),
1009 ie
= Asm
.end(); it
!= ie
; ++it
) {
1010 const MCSectionData
&SD
= *it
;
1011 uint64_t Address
= Layout
.getSectionAddress(&SD
);
1012 uint64_t Size
= Layout
.getSectionSize(&SD
);
1013 uint64_t FileSize
= Layout
.getSectionFileSize(&SD
);
1015 VMSize
= std::max(VMSize
, Address
+ Size
);
1017 if (Asm
.getBackend().isVirtualSection(SD
.getSection()))
1020 SectionDataSize
= std::max(SectionDataSize
, Address
+ Size
);
1021 SectionDataFileSize
= std::max(SectionDataFileSize
, Address
+ FileSize
);
1024 // The section data is padded to 4 bytes.
1026 // FIXME: Is this machine dependent?
1027 unsigned SectionDataPadding
= OffsetToAlignment(SectionDataFileSize
, 4);
1028 SectionDataFileSize
+= SectionDataPadding
;
1030 // Write the prolog, starting with the header and load command...
1031 WriteHeader(NumLoadCommands
, LoadCommandsSize
,
1032 Asm
.getSubsectionsViaSymbols());
1033 WriteSegmentLoadCommand(NumSections
, VMSize
,
1034 SectionDataStart
, SectionDataSize
);
1036 // ... and then the section headers.
1037 uint64_t RelocTableEnd
= SectionDataStart
+ SectionDataFileSize
;
1038 for (MCAssembler::const_iterator it
= Asm
.begin(),
1039 ie
= Asm
.end(); it
!= ie
; ++it
) {
1040 std::vector
<MachRelocationEntry
> &Relocs
= Relocations
[it
];
1041 unsigned NumRelocs
= Relocs
.size();
1042 uint64_t SectionStart
= SectionDataStart
+ Layout
.getSectionAddress(it
);
1043 WriteSection(Asm
, Layout
, *it
, SectionStart
, RelocTableEnd
, NumRelocs
);
1044 RelocTableEnd
+= NumRelocs
* RelocationInfoSize
;
1047 // Write the symbol table load command, if used.
1049 unsigned FirstLocalSymbol
= 0;
1050 unsigned NumLocalSymbols
= LocalSymbolData
.size();
1051 unsigned FirstExternalSymbol
= FirstLocalSymbol
+ NumLocalSymbols
;
1052 unsigned NumExternalSymbols
= ExternalSymbolData
.size();
1053 unsigned FirstUndefinedSymbol
= FirstExternalSymbol
+ NumExternalSymbols
;
1054 unsigned NumUndefinedSymbols
= UndefinedSymbolData
.size();
1055 unsigned NumIndirectSymbols
= Asm
.indirect_symbol_size();
1056 unsigned NumSymTabSymbols
=
1057 NumLocalSymbols
+ NumExternalSymbols
+ NumUndefinedSymbols
;
1058 uint64_t IndirectSymbolSize
= NumIndirectSymbols
* 4;
1059 uint64_t IndirectSymbolOffset
= 0;
1061 // If used, the indirect symbols are written after the section data.
1062 if (NumIndirectSymbols
)
1063 IndirectSymbolOffset
= RelocTableEnd
;
1065 // The symbol table is written after the indirect symbol data.
1066 uint64_t SymbolTableOffset
= RelocTableEnd
+ IndirectSymbolSize
;
1068 // The string table is written after symbol table.
1069 uint64_t StringTableOffset
=
1070 SymbolTableOffset
+ NumSymTabSymbols
* (Is64Bit
? Nlist64Size
:
1072 WriteSymtabLoadCommand(SymbolTableOffset
, NumSymTabSymbols
,
1073 StringTableOffset
, StringTable
.size());
1075 WriteDysymtabLoadCommand(FirstLocalSymbol
, NumLocalSymbols
,
1076 FirstExternalSymbol
, NumExternalSymbols
,
1077 FirstUndefinedSymbol
, NumUndefinedSymbols
,
1078 IndirectSymbolOffset
, NumIndirectSymbols
);
1081 // Write the actual section data.
1082 for (MCAssembler::const_iterator it
= Asm
.begin(),
1083 ie
= Asm
.end(); it
!= ie
; ++it
)
1084 Asm
.WriteSectionData(it
, Layout
, Writer
);
1086 // Write the extra padding.
1087 WriteZeros(SectionDataPadding
);
1089 // Write the relocation entries.
1090 for (MCAssembler::const_iterator it
= Asm
.begin(),
1091 ie
= Asm
.end(); it
!= ie
; ++it
) {
1092 // Write the section relocation entries, in reverse order to match 'as'
1093 // (approximately, the exact algorithm is more complicated than this).
1094 std::vector
<MachRelocationEntry
> &Relocs
= Relocations
[it
];
1095 for (unsigned i
= 0, e
= Relocs
.size(); i
!= e
; ++i
) {
1096 Write32(Relocs
[e
- i
- 1].Word0
);
1097 Write32(Relocs
[e
- i
- 1].Word1
);
1101 // Write the symbol table data, if used.
1103 // Write the indirect symbol entries.
1104 for (MCAssembler::const_indirect_symbol_iterator
1105 it
= Asm
.indirect_symbol_begin(),
1106 ie
= Asm
.indirect_symbol_end(); it
!= ie
; ++it
) {
1107 // Indirect symbols in the non lazy symbol pointer section have some
1108 // special handling.
1109 const MCSectionMachO
&Section
=
1110 static_cast<const MCSectionMachO
&>(it
->SectionData
->getSection());
1111 if (Section
.getType() == MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS
) {
1112 // If this symbol is defined and internal, mark it as such.
1113 if (it
->Symbol
->isDefined() &&
1114 !Asm
.getSymbolData(*it
->Symbol
).isExternal()) {
1115 uint32_t Flags
= ISF_Local
;
1116 if (it
->Symbol
->isAbsolute())
1117 Flags
|= ISF_Absolute
;
1123 Write32(Asm
.getSymbolData(*it
->Symbol
).getIndex());
1126 // FIXME: Check that offsets match computed ones.
1128 // Write the symbol table entries.
1129 for (unsigned i
= 0, e
= LocalSymbolData
.size(); i
!= e
; ++i
)
1130 WriteNlist(LocalSymbolData
[i
], Layout
);
1131 for (unsigned i
= 0, e
= ExternalSymbolData
.size(); i
!= e
; ++i
)
1132 WriteNlist(ExternalSymbolData
[i
], Layout
);
1133 for (unsigned i
= 0, e
= UndefinedSymbolData
.size(); i
!= e
; ++i
)
1134 WriteNlist(UndefinedSymbolData
[i
], Layout
);
1136 // Write the string table.
1137 OS
<< StringTable
.str();
1144 MachObjectWriter::MachObjectWriter(raw_ostream
&OS
,
1146 bool IsLittleEndian
)
1147 : MCObjectWriter(OS
, IsLittleEndian
)
1149 Impl
= new MachObjectWriterImpl(this, Is64Bit
);
1152 MachObjectWriter::~MachObjectWriter() {
1153 delete (MachObjectWriterImpl
*) Impl
;
1156 void MachObjectWriter::ExecutePostLayoutBinding(MCAssembler
&Asm
) {
1157 ((MachObjectWriterImpl
*) Impl
)->ExecutePostLayoutBinding(Asm
);
1160 void MachObjectWriter::RecordRelocation(const MCAssembler
&Asm
,
1161 const MCAsmLayout
&Layout
,
1162 const MCFragment
*Fragment
,
1163 const MCAsmFixup
&Fixup
, MCValue Target
,
1164 uint64_t &FixedValue
) {
1165 ((MachObjectWriterImpl
*) Impl
)->RecordRelocation(Asm
, Layout
, Fragment
, Fixup
,
1166 Target
, FixedValue
);
1169 void MachObjectWriter::WriteObject(const MCAssembler
&Asm
,
1170 const MCAsmLayout
&Layout
) {
1171 ((MachObjectWriterImpl
*) Impl
)->WriteObject(Asm
, Layout
);