1 //===- MachOObjectFile.cpp - Mach-O object file binding ---------*- C++ -*-===//
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 // This file defines the MachOObjectFile class, which binds the MachOObject
11 // class to the generic ObjectFile wrapper.
13 //===----------------------------------------------------------------------===//
15 #include "llvm/ADT/Triple.h"
16 #include "llvm/Object/MachO.h"
17 #include "llvm/Object/MachOFormat.h"
18 #include "llvm/Support/Format.h"
19 #include "llvm/Support/MemoryBuffer.h"
26 using namespace object;
31 MachOObjectFile::MachOObjectFile(MemoryBuffer *Object, MachOObject *MOO,
33 : ObjectFile(Binary::ID_MachO, Object, ec),
35 RegisteredStringTable(std::numeric_limits<uint32_t>::max()) {
37 moveToNextSection(DRI);
38 uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands;
39 while (DRI.d.a < LoadCommandCount) {
40 Sections.push_back(DRI);
42 moveToNextSection(DRI);
47 ObjectFile *ObjectFile::createMachOObjectFile(MemoryBuffer *Buffer) {
50 MachOObject *MachOObj = MachOObject::LoadFromBuffer(Buffer, &Err);
53 return new MachOObjectFile(Buffer, MachOObj, ec);
56 /*===-- Symbols -----------------------------------------------------------===*/
58 void MachOObjectFile::moveToNextSymbol(DataRefImpl &DRI) const {
59 uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands;
60 while (DRI.d.a < LoadCommandCount) {
61 LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
62 if (LCI.Command.Type == macho::LCT_Symtab) {
63 InMemoryStruct<macho::SymtabLoadCommand> SymtabLoadCmd;
64 MachOObj->ReadSymtabLoadCommand(LCI, SymtabLoadCmd);
65 if (DRI.d.b < SymtabLoadCmd->NumSymbolTableEntries)
74 void MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI,
75 InMemoryStruct<macho::SymbolTableEntry> &Res) const {
76 InMemoryStruct<macho::SymtabLoadCommand> SymtabLoadCmd;
77 LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
78 MachOObj->ReadSymtabLoadCommand(LCI, SymtabLoadCmd);
80 if (RegisteredStringTable != DRI.d.a) {
81 MachOObj->RegisterStringTable(*SymtabLoadCmd);
82 RegisteredStringTable = DRI.d.a;
85 MachOObj->ReadSymbolTableEntry(SymtabLoadCmd->SymbolTableOffset, DRI.d.b,
89 void MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI,
90 InMemoryStruct<macho::Symbol64TableEntry> &Res) const {
91 InMemoryStruct<macho::SymtabLoadCommand> SymtabLoadCmd;
92 LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
93 MachOObj->ReadSymtabLoadCommand(LCI, SymtabLoadCmd);
95 if (RegisteredStringTable != DRI.d.a) {
96 MachOObj->RegisterStringTable(*SymtabLoadCmd);
97 RegisteredStringTable = DRI.d.a;
100 MachOObj->ReadSymbol64TableEntry(SymtabLoadCmd->SymbolTableOffset, DRI.d.b,
105 error_code MachOObjectFile::getSymbolNext(DataRefImpl DRI,
106 SymbolRef &Result) const {
108 moveToNextSymbol(DRI);
109 Result = SymbolRef(DRI, this);
110 return object_error::success;
113 error_code MachOObjectFile::getSymbolName(DataRefImpl DRI,
114 StringRef &Result) const {
115 if (MachOObj->is64Bit()) {
116 InMemoryStruct<macho::Symbol64TableEntry> Entry;
117 getSymbol64TableEntry(DRI, Entry);
118 Result = MachOObj->getStringAtIndex(Entry->StringIndex);
120 InMemoryStruct<macho::SymbolTableEntry> Entry;
121 getSymbolTableEntry(DRI, Entry);
122 Result = MachOObj->getStringAtIndex(Entry->StringIndex);
124 return object_error::success;
127 error_code MachOObjectFile::getSymbolFileOffset(DataRefImpl DRI,
128 uint64_t &Result) const {
129 if (MachOObj->is64Bit()) {
130 InMemoryStruct<macho::Symbol64TableEntry> Entry;
131 getSymbol64TableEntry(DRI, Entry);
132 Result = Entry->Value;
133 if (Entry->SectionIndex) {
134 InMemoryStruct<macho::Section64> Section;
135 getSection64(Sections[Entry->SectionIndex-1], Section);
136 Result += Section->Offset - Section->Address;
139 InMemoryStruct<macho::SymbolTableEntry> Entry;
140 getSymbolTableEntry(DRI, Entry);
141 Result = Entry->Value;
142 if (Entry->SectionIndex) {
143 InMemoryStruct<macho::Section> Section;
144 getSection(Sections[Entry->SectionIndex-1], Section);
145 Result += Section->Offset - Section->Address;
149 return object_error::success;
152 error_code MachOObjectFile::getSymbolAddress(DataRefImpl DRI,
153 uint64_t &Result) const {
154 if (MachOObj->is64Bit()) {
155 InMemoryStruct<macho::Symbol64TableEntry> Entry;
156 getSymbol64TableEntry(DRI, Entry);
157 Result = Entry->Value;
159 InMemoryStruct<macho::SymbolTableEntry> Entry;
160 getSymbolTableEntry(DRI, Entry);
161 Result = Entry->Value;
163 return object_error::success;
166 error_code MachOObjectFile::getSymbolSize(DataRefImpl DRI,
167 uint64_t &Result) const {
168 uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands;
169 uint64_t BeginOffset;
170 uint64_t EndOffset = 0;
171 uint8_t SectionIndex;
172 if (MachOObj->is64Bit()) {
173 InMemoryStruct<macho::Symbol64TableEntry> Entry;
174 getSymbol64TableEntry(DRI, Entry);
175 BeginOffset = Entry->Value;
176 SectionIndex = Entry->SectionIndex;
178 Result = UnknownAddressOrSize;
179 return object_error::success;
181 // Unfortunately symbols are unsorted so we need to touch all
182 // symbols from load command
184 uint32_t Command = DRI.d.a;
185 while (Command == DRI.d.a) {
186 moveToNextSymbol(DRI);
187 if (DRI.d.a < LoadCommandCount) {
188 getSymbol64TableEntry(DRI, Entry);
189 if (Entry->SectionIndex == SectionIndex && Entry->Value > BeginOffset)
190 if (!EndOffset || Entry->Value < EndOffset)
191 EndOffset = Entry->Value;
196 InMemoryStruct<macho::SymbolTableEntry> Entry;
197 getSymbolTableEntry(DRI, Entry);
198 BeginOffset = Entry->Value;
199 SectionIndex = Entry->SectionIndex;
201 Result = UnknownAddressOrSize;
202 return object_error::success;
204 // Unfortunately symbols are unsorted so we need to touch all
205 // symbols from load command
207 uint32_t Command = DRI.d.a;
208 while (Command == DRI.d.a) {
209 moveToNextSymbol(DRI);
210 if (DRI.d.a < LoadCommandCount) {
211 getSymbolTableEntry(DRI, Entry);
212 if (Entry->SectionIndex == SectionIndex && Entry->Value > BeginOffset)
213 if (!EndOffset || Entry->Value < EndOffset)
214 EndOffset = Entry->Value;
221 getSectionSize(Sections[SectionIndex-1], Size);
222 getSectionAddress(Sections[SectionIndex-1], EndOffset);
225 Result = EndOffset - BeginOffset;
226 return object_error::success;
229 error_code MachOObjectFile::getSymbolNMTypeChar(DataRefImpl DRI,
230 char &Result) const {
232 if (MachOObj->is64Bit()) {
233 InMemoryStruct<macho::Symbol64TableEntry> Entry;
234 getSymbol64TableEntry(DRI, Entry);
236 Flags = Entry->Flags;
238 InMemoryStruct<macho::SymbolTableEntry> Entry;
239 getSymbolTableEntry(DRI, Entry);
241 Flags = Entry->Flags;
245 switch (Type & macho::STF_TypeMask) {
246 case macho::STT_Undefined:
249 case macho::STT_Absolute:
250 case macho::STT_Section:
258 if (Flags & (macho::STF_External | macho::STF_PrivateExtern))
259 Char = toupper(Char);
261 return object_error::success;
264 error_code MachOObjectFile::getSymbolFlags(DataRefImpl DRI,
265 uint32_t &Result) const {
268 if (MachOObj->is64Bit()) {
269 InMemoryStruct<macho::Symbol64TableEntry> Entry;
270 getSymbol64TableEntry(DRI, Entry);
271 MachOFlags = Entry->Flags;
272 MachOType = Entry->Type;
274 InMemoryStruct<macho::SymbolTableEntry> Entry;
275 getSymbolTableEntry(DRI, Entry);
276 MachOFlags = Entry->Flags;
277 MachOType = Entry->Type;
280 // TODO: Correctly set SF_ThreadLocal and SF_Common.
281 Result = SymbolRef::SF_None;
283 if ((MachOType & MachO::NlistMaskType) == MachO::NListTypeUndefined)
284 Result |= SymbolRef::SF_Undefined;
286 if (MachOFlags & macho::STF_StabsEntryMask)
287 Result |= SymbolRef::SF_FormatSpecific;
289 if (MachOType & MachO::NlistMaskExternal)
290 Result |= SymbolRef::SF_Global;
292 if (MachOFlags & (MachO::NListDescWeakRef | MachO::NListDescWeakDef))
293 Result |= SymbolRef::SF_Weak;
295 if ((MachOType & MachO::NlistMaskType) == MachO::NListTypeAbsolute)
296 Result |= SymbolRef::SF_Absolute;
298 return object_error::success;
301 error_code MachOObjectFile::getSymbolSection(DataRefImpl Symb,
302 section_iterator &Res) const {
304 if (MachOObj->is64Bit()) {
305 InMemoryStruct<macho::Symbol64TableEntry> Entry;
306 getSymbol64TableEntry(Symb, Entry);
307 index = Entry->SectionIndex;
309 InMemoryStruct<macho::SymbolTableEntry> Entry;
310 getSymbolTableEntry(Symb, Entry);
311 index = Entry->SectionIndex;
315 Res = end_sections();
317 Res = section_iterator(SectionRef(Sections[index-1], this));
319 return object_error::success;
322 error_code MachOObjectFile::getSymbolType(DataRefImpl Symb,
323 SymbolRef::Type &Res) const {
325 if (MachOObj->is64Bit()) {
326 InMemoryStruct<macho::Symbol64TableEntry> Entry;
327 getSymbol64TableEntry(Symb, Entry);
328 n_type = Entry->Type;
330 InMemoryStruct<macho::SymbolTableEntry> Entry;
331 getSymbolTableEntry(Symb, Entry);
332 n_type = Entry->Type;
334 Res = SymbolRef::ST_Other;
336 // If this is a STAB debugging symbol, we can do nothing more.
337 if (n_type & MachO::NlistMaskStab) {
338 Res = SymbolRef::ST_Debug;
339 return object_error::success;
342 switch (n_type & MachO::NlistMaskType) {
343 case MachO::NListTypeUndefined :
344 Res = SymbolRef::ST_Unknown;
346 case MachO::NListTypeSection :
347 Res = SymbolRef::ST_Function;
350 return object_error::success;
354 symbol_iterator MachOObjectFile::begin_symbols() const {
355 // DRI.d.a = segment number; DRI.d.b = symbol index.
357 moveToNextSymbol(DRI);
358 return symbol_iterator(SymbolRef(DRI, this));
361 symbol_iterator MachOObjectFile::end_symbols() const {
363 DRI.d.a = MachOObj->getHeader().NumLoadCommands;
364 return symbol_iterator(SymbolRef(DRI, this));
367 symbol_iterator MachOObjectFile::begin_dynamic_symbols() const {
369 report_fatal_error("Dynamic symbols unimplemented in MachOObjectFile");
372 symbol_iterator MachOObjectFile::end_dynamic_symbols() const {
374 report_fatal_error("Dynamic symbols unimplemented in MachOObjectFile");
377 library_iterator MachOObjectFile::begin_libraries_needed() const {
379 report_fatal_error("Needed libraries unimplemented in MachOObjectFile");
382 library_iterator MachOObjectFile::end_libraries_needed() const {
384 report_fatal_error("Needed libraries unimplemented in MachOObjectFile");
387 StringRef MachOObjectFile::getLoadName() const {
389 report_fatal_error("get_load_name() unimplemented in MachOObjectFile");
392 /*===-- Sections ----------------------------------------------------------===*/
394 void MachOObjectFile::moveToNextSection(DataRefImpl &DRI) const {
395 uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands;
396 while (DRI.d.a < LoadCommandCount) {
397 LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
398 if (LCI.Command.Type == macho::LCT_Segment) {
399 InMemoryStruct<macho::SegmentLoadCommand> SegmentLoadCmd;
400 MachOObj->ReadSegmentLoadCommand(LCI, SegmentLoadCmd);
401 if (DRI.d.b < SegmentLoadCmd->NumSections)
403 } else if (LCI.Command.Type == macho::LCT_Segment64) {
404 InMemoryStruct<macho::Segment64LoadCommand> Segment64LoadCmd;
405 MachOObj->ReadSegment64LoadCommand(LCI, Segment64LoadCmd);
406 if (DRI.d.b < Segment64LoadCmd->NumSections)
415 error_code MachOObjectFile::getSectionNext(DataRefImpl DRI,
416 SectionRef &Result) const {
418 moveToNextSection(DRI);
419 Result = SectionRef(DRI, this);
420 return object_error::success;
424 MachOObjectFile::getSection(DataRefImpl DRI,
425 InMemoryStruct<macho::Section> &Res) const {
426 InMemoryStruct<macho::SegmentLoadCommand> SLC;
427 LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
428 MachOObj->ReadSegmentLoadCommand(LCI, SLC);
429 MachOObj->ReadSection(LCI, DRI.d.b, Res);
432 std::size_t MachOObjectFile::getSectionIndex(DataRefImpl Sec) const {
433 SectionList::const_iterator loc =
434 std::find(Sections.begin(), Sections.end(), Sec);
435 assert(loc != Sections.end() && "Sec is not a valid section!");
436 return std::distance(Sections.begin(), loc);
440 MachOObjectFile::getSection64(DataRefImpl DRI,
441 InMemoryStruct<macho::Section64> &Res) const {
442 InMemoryStruct<macho::Segment64LoadCommand> SLC;
443 LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
444 MachOObj->ReadSegment64LoadCommand(LCI, SLC);
445 MachOObj->ReadSection64(LCI, DRI.d.b, Res);
448 static bool is64BitLoadCommand(const MachOObject *MachOObj, DataRefImpl DRI) {
449 LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
450 if (LCI.Command.Type == macho::LCT_Segment64)
452 assert(LCI.Command.Type == macho::LCT_Segment && "Unexpected Type.");
456 error_code MachOObjectFile::getSectionName(DataRefImpl DRI,
457 StringRef &Result) const {
458 // FIXME: thread safety.
459 static char result[34];
460 if (is64BitLoadCommand(MachOObj, DRI)) {
461 InMemoryStruct<macho::Segment64LoadCommand> SLC;
462 LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
463 MachOObj->ReadSegment64LoadCommand(LCI, SLC);
464 InMemoryStruct<macho::Section64> Sect;
465 MachOObj->ReadSection64(LCI, DRI.d.b, Sect);
467 strcpy(result, Sect->SegmentName);
469 strcat(result, Sect->Name);
471 InMemoryStruct<macho::SegmentLoadCommand> SLC;
472 LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
473 MachOObj->ReadSegmentLoadCommand(LCI, SLC);
474 InMemoryStruct<macho::Section> Sect;
475 MachOObj->ReadSection(LCI, DRI.d.b, Sect);
477 strcpy(result, Sect->SegmentName);
479 strcat(result, Sect->Name);
481 Result = StringRef(result);
482 return object_error::success;
485 error_code MachOObjectFile::getSectionAddress(DataRefImpl DRI,
486 uint64_t &Result) const {
487 if (is64BitLoadCommand(MachOObj, DRI)) {
488 InMemoryStruct<macho::Section64> Sect;
489 getSection64(DRI, Sect);
490 Result = Sect->Address;
492 InMemoryStruct<macho::Section> Sect;
493 getSection(DRI, Sect);
494 Result = Sect->Address;
496 return object_error::success;
499 error_code MachOObjectFile::getSectionSize(DataRefImpl DRI,
500 uint64_t &Result) const {
501 if (is64BitLoadCommand(MachOObj, DRI)) {
502 InMemoryStruct<macho::Section64> Sect;
503 getSection64(DRI, Sect);
506 InMemoryStruct<macho::Section> Sect;
507 getSection(DRI, Sect);
510 return object_error::success;
513 error_code MachOObjectFile::getSectionContents(DataRefImpl DRI,
514 StringRef &Result) const {
515 if (is64BitLoadCommand(MachOObj, DRI)) {
516 InMemoryStruct<macho::Section64> Sect;
517 getSection64(DRI, Sect);
518 Result = MachOObj->getData(Sect->Offset, Sect->Size);
520 InMemoryStruct<macho::Section> Sect;
521 getSection(DRI, Sect);
522 Result = MachOObj->getData(Sect->Offset, Sect->Size);
524 return object_error::success;
527 error_code MachOObjectFile::getSectionAlignment(DataRefImpl DRI,
528 uint64_t &Result) const {
529 if (is64BitLoadCommand(MachOObj, DRI)) {
530 InMemoryStruct<macho::Section64> Sect;
531 getSection64(DRI, Sect);
532 Result = uint64_t(1) << Sect->Align;
534 InMemoryStruct<macho::Section> Sect;
535 getSection(DRI, Sect);
536 Result = uint64_t(1) << Sect->Align;
538 return object_error::success;
541 error_code MachOObjectFile::isSectionText(DataRefImpl DRI,
542 bool &Result) const {
543 if (is64BitLoadCommand(MachOObj, DRI)) {
544 InMemoryStruct<macho::Section64> Sect;
545 getSection64(DRI, Sect);
546 Result = !strcmp(Sect->Name, "__text");
548 InMemoryStruct<macho::Section> Sect;
549 getSection(DRI, Sect);
550 Result = !strcmp(Sect->Name, "__text");
552 return object_error::success;
555 error_code MachOObjectFile::isSectionData(DataRefImpl DRI,
556 bool &Result) const {
557 // FIXME: Unimplemented.
559 return object_error::success;
562 error_code MachOObjectFile::isSectionBSS(DataRefImpl DRI,
563 bool &Result) const {
564 // FIXME: Unimplemented.
566 return object_error::success;
569 error_code MachOObjectFile::sectionContainsSymbol(DataRefImpl Sec,
571 bool &Result) const {
573 getSymbolType(Symb, ST);
574 if (ST == SymbolRef::ST_Unknown) {
576 return object_error::success;
579 uint64_t SectBegin, SectEnd;
580 getSectionAddress(Sec, SectBegin);
581 getSectionSize(Sec, SectEnd);
582 SectEnd += SectBegin;
584 if (MachOObj->is64Bit()) {
585 InMemoryStruct<macho::Symbol64TableEntry> Entry;
586 getSymbol64TableEntry(Symb, Entry);
587 uint64_t SymAddr= Entry->Value;
588 Result = (SymAddr >= SectBegin) && (SymAddr < SectEnd);
590 InMemoryStruct<macho::SymbolTableEntry> Entry;
591 getSymbolTableEntry(Symb, Entry);
592 uint64_t SymAddr= Entry->Value;
593 Result = (SymAddr >= SectBegin) && (SymAddr < SectEnd);
596 return object_error::success;
599 relocation_iterator MachOObjectFile::getSectionRelBegin(DataRefImpl Sec) const {
601 ret.d.b = getSectionIndex(Sec);
602 return relocation_iterator(RelocationRef(ret, this));
604 relocation_iterator MachOObjectFile::getSectionRelEnd(DataRefImpl Sec) const {
606 if (is64BitLoadCommand(MachOObj, Sec)) {
607 InMemoryStruct<macho::Section64> Sect;
608 getSection64(Sec, Sect);
609 last_reloc = Sect->NumRelocationTableEntries;
611 InMemoryStruct<macho::Section> Sect;
612 getSection(Sec, Sect);
613 last_reloc = Sect->NumRelocationTableEntries;
616 ret.d.a = last_reloc;
617 ret.d.b = getSectionIndex(Sec);
618 return relocation_iterator(RelocationRef(ret, this));
621 section_iterator MachOObjectFile::begin_sections() const {
623 moveToNextSection(DRI);
624 return section_iterator(SectionRef(DRI, this));
627 section_iterator MachOObjectFile::end_sections() const {
629 DRI.d.a = MachOObj->getHeader().NumLoadCommands;
630 return section_iterator(SectionRef(DRI, this));
633 /*===-- Relocations -------------------------------------------------------===*/
635 void MachOObjectFile::
636 getRelocation(DataRefImpl Rel,
637 InMemoryStruct<macho::RelocationEntry> &Res) const {
639 if (MachOObj->is64Bit()) {
640 InMemoryStruct<macho::Section64> Sect;
641 getSection64(Sections[Rel.d.b], Sect);
642 relOffset = Sect->RelocationTableOffset;
644 InMemoryStruct<macho::Section> Sect;
645 getSection(Sections[Rel.d.b], Sect);
646 relOffset = Sect->RelocationTableOffset;
648 MachOObj->ReadRelocationEntry(relOffset, Rel.d.a, Res);
650 error_code MachOObjectFile::getRelocationNext(DataRefImpl Rel,
651 RelocationRef &Res) const {
653 Res = RelocationRef(Rel, this);
654 return object_error::success;
656 error_code MachOObjectFile::getRelocationAddress(DataRefImpl Rel,
657 uint64_t &Res) const {
658 const uint8_t* sectAddress = 0;
659 if (MachOObj->is64Bit()) {
660 InMemoryStruct<macho::Section64> Sect;
661 getSection64(Sections[Rel.d.b], Sect);
662 sectAddress += Sect->Address;
664 InMemoryStruct<macho::Section> Sect;
665 getSection(Sections[Rel.d.b], Sect);
666 sectAddress += Sect->Address;
668 InMemoryStruct<macho::RelocationEntry> RE;
669 getRelocation(Rel, RE);
671 unsigned Arch = getArch();
672 bool isScattered = (Arch != Triple::x86_64) &&
673 (RE->Word0 & macho::RF_Scattered);
674 uint64_t RelAddr = 0;
676 RelAddr = RE->Word0 & 0xFFFFFF;
680 Res = reinterpret_cast<uintptr_t>(sectAddress + RelAddr);
681 return object_error::success;
683 error_code MachOObjectFile::getRelocationOffset(DataRefImpl Rel,
684 uint64_t &Res) const {
685 InMemoryStruct<macho::RelocationEntry> RE;
686 getRelocation(Rel, RE);
688 unsigned Arch = getArch();
689 bool isScattered = (Arch != Triple::x86_64) &&
690 (RE->Word0 & macho::RF_Scattered);
692 Res = RE->Word0 & 0xFFFFFF;
695 return object_error::success;
697 error_code MachOObjectFile::getRelocationSymbol(DataRefImpl Rel,
698 SymbolRef &Res) const {
699 InMemoryStruct<macho::RelocationEntry> RE;
700 getRelocation(Rel, RE);
701 uint32_t SymbolIdx = RE->Word1 & 0xffffff;
702 bool isExtern = (RE->Word1 >> 27) & 1;
705 moveToNextSymbol(Sym);
707 for (unsigned i = 0; i < SymbolIdx; i++) {
709 moveToNextSymbol(Sym);
710 assert(Sym.d.a < MachOObj->getHeader().NumLoadCommands &&
711 "Relocation symbol index out of range!");
714 Res = SymbolRef(Sym, this);
715 return object_error::success;
717 error_code MachOObjectFile::getRelocationType(DataRefImpl Rel,
718 uint64_t &Res) const {
719 InMemoryStruct<macho::RelocationEntry> RE;
720 getRelocation(Rel, RE);
724 return object_error::success;
726 error_code MachOObjectFile::getRelocationTypeName(DataRefImpl Rel,
727 SmallVectorImpl<char> &Result) const {
728 // TODO: Support scattered relocations.
730 InMemoryStruct<macho::RelocationEntry> RE;
731 getRelocation(Rel, RE);
733 unsigned Arch = getArch();
734 bool isScattered = (Arch != Triple::x86_64) &&
735 (RE->Word0 & macho::RF_Scattered);
739 r_type = (RE->Word0 >> 24) & 0xF;
741 r_type = (RE->Word1 >> 28) & 0xF;
745 const char* Table[] = {
746 "GENERIC_RELOC_VANILLA",
747 "GENERIC_RELOC_PAIR",
748 "GENERIC_RELOC_SECTDIFF",
749 "GENERIC_RELOC_PB_LA_PTR",
750 "GENERIC_RELOC_LOCAL_SECTDIFF",
751 "GENERIC_RELOC_TLV" };
759 case Triple::x86_64: {
760 const char* Table[] = {
761 "X86_64_RELOC_UNSIGNED",
762 "X86_64_RELOC_SIGNED",
763 "X86_64_RELOC_BRANCH",
764 "X86_64_RELOC_GOT_LOAD",
766 "X86_64_RELOC_SUBTRACTOR",
767 "X86_64_RELOC_SIGNED_1",
768 "X86_64_RELOC_SIGNED_2",
769 "X86_64_RELOC_SIGNED_4",
770 "X86_64_RELOC_TLV" };
779 const char* Table[] = {
782 "ARM_RELOC_SECTDIFF",
783 "ARM_RELOC_LOCAL_SECTDIFF",
784 "ARM_RELOC_PB_LA_PTR",
786 "ARM_THUMB_RELOC_BR22",
787 "ARM_THUMB_32BIT_BRANCH",
789 "ARM_RELOC_HALF_SECTDIFF" };
798 const char* Table[] = {
807 "PPC_RELOC_SECTDIFF",
808 "PPC_RELOC_PB_LA_PTR",
809 "PPC_RELOC_HI16_SECTDIFF",
810 "PPC_RELOC_LO16_SECTDIFF",
811 "PPC_RELOC_HA16_SECTDIFF",
813 "PPC_RELOC_LO14_SECTDIFF",
814 "PPC_RELOC_LOCAL_SECTDIFF" };
819 case Triple::UnknownArch:
823 Result.append(res.begin(), res.end());
824 return object_error::success;
826 error_code MachOObjectFile::getRelocationAdditionalInfo(DataRefImpl Rel,
827 int64_t &Res) const {
828 InMemoryStruct<macho::RelocationEntry> RE;
829 getRelocation(Rel, RE);
830 bool isExtern = (RE->Word1 >> 27) & 1;
833 const uint8_t* sectAddress = base();
834 if (MachOObj->is64Bit()) {
835 InMemoryStruct<macho::Section64> Sect;
836 getSection64(Sections[Rel.d.b], Sect);
837 sectAddress += Sect->Offset;
839 InMemoryStruct<macho::Section> Sect;
840 getSection(Sections[Rel.d.b], Sect);
841 sectAddress += Sect->Offset;
843 Res = reinterpret_cast<uintptr_t>(sectAddress);
845 return object_error::success;
848 // Helper to advance a section or symbol iterator multiple increments at a time.
850 error_code advance(T &it, size_t Val) {
859 void advanceTo(T &it, size_t Val) {
860 if (error_code ec = advance(it, Val))
861 report_fatal_error(ec.message());
864 void MachOObjectFile::printRelocationTargetName(
865 InMemoryStruct<macho::RelocationEntry>& RE,
866 raw_string_ostream &fmt) const {
867 unsigned Arch = getArch();
868 bool isScattered = (Arch != Triple::x86_64) &&
869 (RE->Word0 & macho::RF_Scattered);
871 // Target of a scattered relocation is an address. In the interest of
872 // generating pretty output, scan through the symbol table looking for a
873 // symbol that aligns with that address. If we find one, print it.
874 // Otherwise, we just print the hex address of the target.
876 uint32_t Val = RE->Word1;
879 for (symbol_iterator SI = begin_symbols(), SE = end_symbols(); SI != SE;
881 if (ec) report_fatal_error(ec.message());
886 if ((ec = SI->getAddress(Addr)))
887 report_fatal_error(ec.message());
888 if (Addr != Val) continue;
889 if ((ec = SI->getName(Name)))
890 report_fatal_error(ec.message());
895 // If we couldn't find a symbol that this relocation refers to, try
896 // to find a section beginning instead.
897 for (section_iterator SI = begin_sections(), SE = end_sections(); SI != SE;
899 if (ec) report_fatal_error(ec.message());
904 if ((ec = SI->getAddress(Addr)))
905 report_fatal_error(ec.message());
906 if (Addr != Val) continue;
907 if ((ec = SI->getName(Name)))
908 report_fatal_error(ec.message());
913 fmt << format("0x%x", Val);
918 bool isExtern = (RE->Word1 >> 27) & 1;
919 uint32_t Val = RE->Word1 & 0xFFFFFF;
922 symbol_iterator SI = begin_symbols();
926 section_iterator SI = begin_sections();
934 error_code MachOObjectFile::getRelocationValueString(DataRefImpl Rel,
935 SmallVectorImpl<char> &Result) const {
936 InMemoryStruct<macho::RelocationEntry> RE;
937 getRelocation(Rel, RE);
939 unsigned Arch = getArch();
940 bool isScattered = (Arch != Triple::x86_64) &&
941 (RE->Word0 & macho::RF_Scattered);
944 raw_string_ostream fmt(fmtbuf);
948 Type = (RE->Word0 >> 24) & 0xF;
950 Type = (RE->Word1 >> 28) & 0xF;
954 isPCRel = ((RE->Word0 >> 30) & 1);
956 isPCRel = ((RE->Word1 >> 24) & 1);
958 // Determine any addends that should be displayed with the relocation.
959 // These require decoding the relocation type, which is triple-specific.
961 // X86_64 has entirely custom relocation types.
962 if (Arch == Triple::x86_64) {
963 bool isPCRel = ((RE->Word1 >> 24) & 1);
966 case macho::RIT_X86_64_GOTLoad: // X86_64_RELOC_GOT_LOAD
967 case macho::RIT_X86_64_GOT: { // X86_64_RELOC_GOT
968 printRelocationTargetName(RE, fmt);
970 if (isPCRel) fmt << "PCREL";
973 case macho::RIT_X86_64_Subtractor: { // X86_64_RELOC_SUBTRACTOR
974 InMemoryStruct<macho::RelocationEntry> RENext;
975 DataRefImpl RelNext = Rel;
977 getRelocation(RelNext, RENext);
979 // X86_64_SUBTRACTOR must be followed by a relocation of type
980 // X86_64_RELOC_UNSIGNED.
981 // NOTE: Scattered relocations don't exist on x86_64.
982 unsigned RType = (RENext->Word1 >> 28) & 0xF;
984 report_fatal_error("Expected X86_64_RELOC_UNSIGNED after "
985 "X86_64_RELOC_SUBTRACTOR.");
987 // The X86_64_RELOC_UNSIGNED contains the minuend symbol,
988 // X86_64_SUBTRACTOR contains to the subtrahend.
989 printRelocationTargetName(RENext, fmt);
991 printRelocationTargetName(RE, fmt);
993 case macho::RIT_X86_64_TLV:
994 printRelocationTargetName(RE, fmt);
996 if (isPCRel) fmt << "P";
998 case macho::RIT_X86_64_Signed1: // X86_64_RELOC_SIGNED1
999 printRelocationTargetName(RE, fmt);
1002 case macho::RIT_X86_64_Signed2: // X86_64_RELOC_SIGNED2
1003 printRelocationTargetName(RE, fmt);
1006 case macho::RIT_X86_64_Signed4: // X86_64_RELOC_SIGNED4
1007 printRelocationTargetName(RE, fmt);
1011 printRelocationTargetName(RE, fmt);
1014 // X86 and ARM share some relocation types in common.
1015 } else if (Arch == Triple::x86 || Arch == Triple::arm) {
1016 // Generic relocation types...
1018 case macho::RIT_Pair: // GENERIC_RELOC_PAIR - prints no info
1019 return object_error::success;
1020 case macho::RIT_Difference: { // GENERIC_RELOC_SECTDIFF
1021 InMemoryStruct<macho::RelocationEntry> RENext;
1022 DataRefImpl RelNext = Rel;
1024 getRelocation(RelNext, RENext);
1026 // X86 sect diff's must be followed by a relocation of type
1027 // GENERIC_RELOC_PAIR.
1028 bool isNextScattered = (Arch != Triple::x86_64) &&
1029 (RENext->Word0 & macho::RF_Scattered);
1031 if (isNextScattered)
1032 RType = (RENext->Word0 >> 24) & 0xF;
1034 RType = (RENext->Word1 >> 28) & 0xF;
1036 report_fatal_error("Expected GENERIC_RELOC_PAIR after "
1037 "GENERIC_RELOC_SECTDIFF.");
1039 printRelocationTargetName(RE, fmt);
1041 printRelocationTargetName(RENext, fmt);
1046 if (Arch == Triple::x86) {
1047 // All X86 relocations that need special printing were already
1048 // handled in the generic code.
1050 case macho::RIT_Generic_LocalDifference:{// GENERIC_RELOC_LOCAL_SECTDIFF
1051 InMemoryStruct<macho::RelocationEntry> RENext;
1052 DataRefImpl RelNext = Rel;
1054 getRelocation(RelNext, RENext);
1056 // X86 sect diff's must be followed by a relocation of type
1057 // GENERIC_RELOC_PAIR.
1058 bool isNextScattered = (Arch != Triple::x86_64) &&
1059 (RENext->Word0 & macho::RF_Scattered);
1061 if (isNextScattered)
1062 RType = (RENext->Word0 >> 24) & 0xF;
1064 RType = (RENext->Word1 >> 28) & 0xF;
1066 report_fatal_error("Expected GENERIC_RELOC_PAIR after "
1067 "GENERIC_RELOC_LOCAL_SECTDIFF.");
1069 printRelocationTargetName(RE, fmt);
1071 printRelocationTargetName(RENext, fmt);
1074 case macho::RIT_Generic_TLV: {
1075 printRelocationTargetName(RE, fmt);
1077 if (isPCRel) fmt << "P";
1081 printRelocationTargetName(RE, fmt);
1083 } else { // ARM-specific relocations
1085 case macho::RIT_ARM_Half: // ARM_RELOC_HALF
1086 case macho::RIT_ARM_HalfDifference: { // ARM_RELOC_HALF_SECTDIFF
1087 // Half relocations steal a bit from the length field to encode
1088 // whether this is an upper16 or a lower16 relocation.
1091 isUpper = (RE->Word0 >> 28) & 1;
1093 isUpper = (RE->Word1 >> 25) & 1;
1096 fmt << ":upper16:(";
1098 fmt << ":lower16:(";
1099 printRelocationTargetName(RE, fmt);
1101 InMemoryStruct<macho::RelocationEntry> RENext;
1102 DataRefImpl RelNext = Rel;
1104 getRelocation(RelNext, RENext);
1106 // ARM half relocs must be followed by a relocation of type
1108 bool isNextScattered = (Arch != Triple::x86_64) &&
1109 (RENext->Word0 & macho::RF_Scattered);
1111 if (isNextScattered)
1112 RType = (RENext->Word0 >> 24) & 0xF;
1114 RType = (RENext->Word1 >> 28) & 0xF;
1117 report_fatal_error("Expected ARM_RELOC_PAIR after "
1118 "GENERIC_RELOC_HALF");
1120 // NOTE: The half of the target virtual address is stashed in the
1121 // address field of the secondary relocation, but we can't reverse
1122 // engineer the constant offset from it without decoding the movw/movt
1123 // instruction to find the other half in its immediate field.
1125 // ARM_RELOC_HALF_SECTDIFF encodes the second section in the
1126 // symbol/section pointer of the follow-on relocation.
1127 if (Type == macho::RIT_ARM_HalfDifference) {
1129 printRelocationTargetName(RENext, fmt);
1136 printRelocationTargetName(RE, fmt);
1141 printRelocationTargetName(RE, fmt);
1144 Result.append(fmtbuf.begin(), fmtbuf.end());
1145 return object_error::success;
1148 error_code MachOObjectFile::getRelocationHidden(DataRefImpl Rel,
1149 bool &Result) const {
1150 InMemoryStruct<macho::RelocationEntry> RE;
1151 getRelocation(Rel, RE);
1153 unsigned Arch = getArch();
1154 bool isScattered = (Arch != Triple::x86_64) &&
1155 (RE->Word0 & macho::RF_Scattered);
1158 Type = (RE->Word0 >> 24) & 0xF;
1160 Type = (RE->Word1 >> 28) & 0xF;
1164 // On arches that use the generic relocations, GENERIC_RELOC_PAIR
1165 // is always hidden.
1166 if (Arch == Triple::x86 || Arch == Triple::arm) {
1167 if (Type == macho::RIT_Pair) Result = true;
1168 } else if (Arch == Triple::x86_64) {
1169 // On x86_64, X86_64_RELOC_UNSIGNED is hidden only when it follows
1170 // an X864_64_RELOC_SUBTRACTOR.
1171 if (Type == macho::RIT_X86_64_Unsigned && Rel.d.a > 0) {
1172 DataRefImpl RelPrev = Rel;
1174 InMemoryStruct<macho::RelocationEntry> REPrev;
1175 getRelocation(RelPrev, REPrev);
1177 unsigned PrevType = (REPrev->Word1 >> 28) & 0xF;
1179 if (PrevType == macho::RIT_X86_64_Subtractor) Result = true;
1183 return object_error::success;
1186 error_code MachOObjectFile::getLibraryNext(DataRefImpl LibData,
1187 LibraryRef &Res) const {
1188 report_fatal_error("Needed libraries unimplemented in MachOObjectFile");
1191 error_code MachOObjectFile::getLibraryPath(DataRefImpl LibData,
1192 StringRef &Res) const {
1193 report_fatal_error("Needed libraries unimplemented in MachOObjectFile");
1197 /*===-- Miscellaneous -----------------------------------------------------===*/
1199 uint8_t MachOObjectFile::getBytesInAddress() const {
1200 return MachOObj->is64Bit() ? 8 : 4;
1203 StringRef MachOObjectFile::getFileFormatName() const {
1204 if (!MachOObj->is64Bit()) {
1205 switch (MachOObj->getHeader().CPUType) {
1206 case llvm::MachO::CPUTypeI386:
1207 return "Mach-O 32-bit i386";
1208 case llvm::MachO::CPUTypeARM:
1209 return "Mach-O arm";
1210 case llvm::MachO::CPUTypePowerPC:
1211 return "Mach-O 32-bit ppc";
1213 assert((MachOObj->getHeader().CPUType & llvm::MachO::CPUArchABI64) == 0 &&
1214 "64-bit object file when we're not 64-bit?");
1215 return "Mach-O 32-bit unknown";
1219 switch (MachOObj->getHeader().CPUType) {
1220 case llvm::MachO::CPUTypeX86_64:
1221 return "Mach-O 64-bit x86-64";
1222 case llvm::MachO::CPUTypePowerPC64:
1223 return "Mach-O 64-bit ppc64";
1225 assert((MachOObj->getHeader().CPUType & llvm::MachO::CPUArchABI64) == 1 &&
1226 "32-bit object file when we're 64-bit?");
1227 return "Mach-O 64-bit unknown";
1231 unsigned MachOObjectFile::getArch() const {
1232 switch (MachOObj->getHeader().CPUType) {
1233 case llvm::MachO::CPUTypeI386:
1235 case llvm::MachO::CPUTypeX86_64:
1236 return Triple::x86_64;
1237 case llvm::MachO::CPUTypeARM:
1239 case llvm::MachO::CPUTypePowerPC:
1241 case llvm::MachO::CPUTypePowerPC64:
1242 return Triple::ppc64;
1244 return Triple::UnknownArch;
1248 } // end namespace object
1249 } // end namespace llvm