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/Object/MachO.h"
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/ADT/StringSwitch.h"
18 #include "llvm/ADT/Triple.h"
19 #include "llvm/Support/DataExtractor.h"
20 #include "llvm/Support/Debug.h"
21 #include "llvm/Support/Format.h"
22 #include "llvm/Support/Host.h"
23 #include "llvm/Support/LEB128.h"
24 #include "llvm/Support/MachO.h"
25 #include "llvm/Support/MemoryBuffer.h"
26 #include "llvm/Support/raw_ostream.h"
32 using namespace object;
41 // FIXME: Replace all uses of this function with getStructOrErr.
43 static T getStruct(const MachOObjectFile *O, const char *P) {
44 // Don't read before the beginning or past the end of the file
45 if (P < O->getData().begin() || P + sizeof(T) > O->getData().end())
46 report_fatal_error("Malformed MachO file.");
49 memcpy(&Cmd, P, sizeof(T));
50 if (O->isLittleEndian() != sys::IsLittleEndianHost)
51 MachO::swapStruct(Cmd);
56 static ErrorOr<T> getStructOrErr(const MachOObjectFile *O, const char *P) {
57 // Don't read before the beginning or past the end of the file
58 if (P < O->getData().begin() || P + sizeof(T) > O->getData().end())
59 return object_error::parse_failed;
62 memcpy(&Cmd, P, sizeof(T));
63 if (O->isLittleEndian() != sys::IsLittleEndianHost)
64 MachO::swapStruct(Cmd);
69 getSectionPtr(const MachOObjectFile *O, MachOObjectFile::LoadCommandInfo L,
71 uintptr_t CommandAddr = reinterpret_cast<uintptr_t>(L.Ptr);
73 bool Is64 = O->is64Bit();
74 unsigned SegmentLoadSize = Is64 ? sizeof(MachO::segment_command_64) :
75 sizeof(MachO::segment_command);
76 unsigned SectionSize = Is64 ? sizeof(MachO::section_64) :
77 sizeof(MachO::section);
79 uintptr_t SectionAddr = CommandAddr + SegmentLoadSize + Sec * SectionSize;
80 return reinterpret_cast<const char*>(SectionAddr);
83 static const char *getPtr(const MachOObjectFile *O, size_t Offset) {
84 return O->getData().substr(Offset, 1).data();
87 static MachO::nlist_base
88 getSymbolTableEntryBase(const MachOObjectFile *O, DataRefImpl DRI) {
89 const char *P = reinterpret_cast<const char *>(DRI.p);
90 return getStruct<MachO::nlist_base>(O, P);
93 static StringRef parseSegmentOrSectionName(const char *P) {
97 // Not null terminated, so this is a 16 char string.
98 return StringRef(P, 16);
101 // Helper to advance a section or symbol iterator multiple increments at a time.
103 static void advance(T &it, size_t Val) {
108 static unsigned getCPUType(const MachOObjectFile *O) {
109 return O->getHeader().cputype;
113 getPlainRelocationAddress(const MachO::any_relocation_info &RE) {
118 getScatteredRelocationAddress(const MachO::any_relocation_info &RE) {
119 return RE.r_word0 & 0xffffff;
122 static bool getPlainRelocationPCRel(const MachOObjectFile *O,
123 const MachO::any_relocation_info &RE) {
124 if (O->isLittleEndian())
125 return (RE.r_word1 >> 24) & 1;
126 return (RE.r_word1 >> 7) & 1;
130 getScatteredRelocationPCRel(const MachOObjectFile *O,
131 const MachO::any_relocation_info &RE) {
132 return (RE.r_word0 >> 30) & 1;
135 static unsigned getPlainRelocationLength(const MachOObjectFile *O,
136 const MachO::any_relocation_info &RE) {
137 if (O->isLittleEndian())
138 return (RE.r_word1 >> 25) & 3;
139 return (RE.r_word1 >> 5) & 3;
143 getScatteredRelocationLength(const MachO::any_relocation_info &RE) {
144 return (RE.r_word0 >> 28) & 3;
147 static unsigned getPlainRelocationType(const MachOObjectFile *O,
148 const MachO::any_relocation_info &RE) {
149 if (O->isLittleEndian())
150 return RE.r_word1 >> 28;
151 return RE.r_word1 & 0xf;
154 static uint32_t getSectionFlags(const MachOObjectFile *O,
157 MachO::section_64 Sect = O->getSection64(Sec);
160 MachO::section Sect = O->getSection(Sec);
164 static ErrorOr<MachOObjectFile::LoadCommandInfo>
165 getLoadCommandInfo(const MachOObjectFile *Obj, const char *Ptr) {
166 auto CmdOrErr = getStructOrErr<MachO::load_command>(Obj, Ptr);
168 return CmdOrErr.getError();
169 if (CmdOrErr->cmdsize < 8)
170 return object_error::macho_small_load_command;
171 MachOObjectFile::LoadCommandInfo Load;
173 Load.C = CmdOrErr.get();
177 static ErrorOr<MachOObjectFile::LoadCommandInfo>
178 getFirstLoadCommandInfo(const MachOObjectFile *Obj) {
179 unsigned HeaderSize = Obj->is64Bit() ? sizeof(MachO::mach_header_64)
180 : sizeof(MachO::mach_header);
181 return getLoadCommandInfo(Obj, getPtr(Obj, HeaderSize));
184 static ErrorOr<MachOObjectFile::LoadCommandInfo>
185 getNextLoadCommandInfo(const MachOObjectFile *Obj,
186 const MachOObjectFile::LoadCommandInfo &L) {
187 return getLoadCommandInfo(Obj, L.Ptr + L.C.cmdsize);
190 template <typename T>
191 static void parseHeader(const MachOObjectFile *Obj, T &Header,
192 std::error_code &EC) {
193 auto HeaderOrErr = getStructOrErr<T>(Obj, getPtr(Obj, 0));
195 Header = HeaderOrErr.get();
197 EC = HeaderOrErr.getError();
200 // Parses LC_SEGMENT or LC_SEGMENT_64 load command, adds addresses of all
201 // sections to \param Sections, and optionally sets
202 // \param IsPageZeroSegment to true.
203 template <typename SegmentCmd>
204 static std::error_code parseSegmentLoadCommand(
205 const MachOObjectFile *Obj, const MachOObjectFile::LoadCommandInfo &Load,
206 SmallVectorImpl<const char *> &Sections, bool &IsPageZeroSegment) {
207 const unsigned SegmentLoadSize = sizeof(SegmentCmd);
208 if (Load.C.cmdsize < SegmentLoadSize)
209 return object_error::macho_load_segment_too_small;
210 auto SegOrErr = getStructOrErr<SegmentCmd>(Obj, Load.Ptr);
212 return SegOrErr.getError();
213 SegmentCmd S = SegOrErr.get();
214 const unsigned SectionSize =
215 Obj->is64Bit() ? sizeof(MachO::section_64) : sizeof(MachO::section);
216 if (S.nsects > std::numeric_limits<uint32_t>::max() / SectionSize ||
217 S.nsects * SectionSize > Load.C.cmdsize - SegmentLoadSize)
218 return object_error::macho_load_segment_too_many_sections;
219 for (unsigned J = 0; J < S.nsects; ++J) {
220 const char *Sec = getSectionPtr(Obj, Load, J);
221 Sections.push_back(Sec);
223 IsPageZeroSegment |= StringRef("__PAGEZERO").equals(S.segname);
224 return std::error_code();
227 MachOObjectFile::MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian,
228 bool Is64bits, std::error_code &EC)
229 : ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object),
230 SymtabLoadCmd(nullptr), DysymtabLoadCmd(nullptr),
231 DataInCodeLoadCmd(nullptr), LinkOptHintsLoadCmd(nullptr),
232 DyldInfoLoadCmd(nullptr), UuidLoadCmd(nullptr),
233 HasPageZeroSegment(false) {
235 parseHeader(this, Header64, EC);
237 parseHeader(this, Header, EC);
241 uint32_t LoadCommandCount = getHeader().ncmds;
242 if (LoadCommandCount == 0)
245 auto LoadOrErr = getFirstLoadCommandInfo(this);
247 EC = LoadOrErr.getError();
250 LoadCommandInfo Load = LoadOrErr.get();
251 for (unsigned I = 0; I < LoadCommandCount; ++I) {
252 LoadCommands.push_back(Load);
253 if (Load.C.cmd == MachO::LC_SYMTAB) {
254 // Multiple symbol tables
256 EC = object_error::parse_failed;
259 SymtabLoadCmd = Load.Ptr;
260 } else if (Load.C.cmd == MachO::LC_DYSYMTAB) {
261 // Multiple dynamic symbol tables
262 if (DysymtabLoadCmd) {
263 EC = object_error::parse_failed;
266 DysymtabLoadCmd = Load.Ptr;
267 } else if (Load.C.cmd == MachO::LC_DATA_IN_CODE) {
268 // Multiple data in code tables
269 if (DataInCodeLoadCmd) {
270 EC = object_error::parse_failed;
273 DataInCodeLoadCmd = Load.Ptr;
274 } else if (Load.C.cmd == MachO::LC_LINKER_OPTIMIZATION_HINT) {
275 // Multiple linker optimization hint tables
276 if (LinkOptHintsLoadCmd) {
277 EC = object_error::parse_failed;
280 LinkOptHintsLoadCmd = Load.Ptr;
281 } else if (Load.C.cmd == MachO::LC_DYLD_INFO ||
282 Load.C.cmd == MachO::LC_DYLD_INFO_ONLY) {
283 // Multiple dyldinfo load commands
284 if (DyldInfoLoadCmd) {
285 EC = object_error::parse_failed;
288 DyldInfoLoadCmd = Load.Ptr;
289 } else if (Load.C.cmd == MachO::LC_UUID) {
290 // Multiple UUID load commands
292 EC = object_error::parse_failed;
295 UuidLoadCmd = Load.Ptr;
296 } else if (Load.C.cmd == MachO::LC_SEGMENT_64) {
297 if ((EC = parseSegmentLoadCommand<MachO::segment_command_64>(
298 this, Load, Sections, HasPageZeroSegment)))
300 } else if (Load.C.cmd == MachO::LC_SEGMENT) {
301 if ((EC = parseSegmentLoadCommand<MachO::segment_command>(
302 this, Load, Sections, HasPageZeroSegment)))
304 } else if (Load.C.cmd == MachO::LC_LOAD_DYLIB ||
305 Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB ||
306 Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB ||
307 Load.C.cmd == MachO::LC_REEXPORT_DYLIB ||
308 Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) {
309 Libraries.push_back(Load.Ptr);
311 if (I < LoadCommandCount - 1) {
312 auto LoadOrErr = getNextLoadCommandInfo(this, Load);
314 EC = LoadOrErr.getError();
317 Load = LoadOrErr.get();
320 assert(LoadCommands.size() == LoadCommandCount);
323 void MachOObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
324 unsigned SymbolTableEntrySize = is64Bit() ?
325 sizeof(MachO::nlist_64) :
326 sizeof(MachO::nlist);
327 Symb.p += SymbolTableEntrySize;
330 ErrorOr<StringRef> MachOObjectFile::getSymbolName(DataRefImpl Symb) const {
331 StringRef StringTable = getStringTableData();
332 MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb);
333 const char *Start = &StringTable.data()[Entry.n_strx];
334 if (Start < getData().begin() || Start >= getData().end())
336 "Symbol name entry points before beginning or past end of file.");
337 return StringRef(Start);
340 unsigned MachOObjectFile::getSectionType(SectionRef Sec) const {
341 DataRefImpl DRI = Sec.getRawDataRefImpl();
342 uint32_t Flags = getSectionFlags(this, DRI);
343 return Flags & MachO::SECTION_TYPE;
346 uint64_t MachOObjectFile::getNValue(DataRefImpl Sym) const {
348 MachO::nlist_64 Entry = getSymbol64TableEntry(Sym);
349 return Entry.n_value;
351 MachO::nlist Entry = getSymbolTableEntry(Sym);
352 return Entry.n_value;
355 // getIndirectName() returns the name of the alias'ed symbol who's string table
356 // index is in the n_value field.
357 std::error_code MachOObjectFile::getIndirectName(DataRefImpl Symb,
358 StringRef &Res) const {
359 StringRef StringTable = getStringTableData();
360 MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb);
361 if ((Entry.n_type & MachO::N_TYPE) != MachO::N_INDR)
362 return object_error::parse_failed;
363 uint64_t NValue = getNValue(Symb);
364 if (NValue >= StringTable.size())
365 return object_error::parse_failed;
366 const char *Start = &StringTable.data()[NValue];
367 Res = StringRef(Start);
368 return std::error_code();
371 uint64_t MachOObjectFile::getSymbolValueImpl(DataRefImpl Sym) const {
372 return getNValue(Sym);
375 ErrorOr<uint64_t> MachOObjectFile::getSymbolAddress(DataRefImpl Sym) const {
376 return getSymbolValue(Sym);
379 uint32_t MachOObjectFile::getSymbolAlignment(DataRefImpl DRI) const {
380 uint32_t flags = getSymbolFlags(DRI);
381 if (flags & SymbolRef::SF_Common) {
382 MachO::nlist_base Entry = getSymbolTableEntryBase(this, DRI);
383 return 1 << MachO::GET_COMM_ALIGN(Entry.n_desc);
388 uint64_t MachOObjectFile::getCommonSymbolSizeImpl(DataRefImpl DRI) const {
389 return getNValue(DRI);
392 SymbolRef::Type MachOObjectFile::getSymbolType(DataRefImpl Symb) const {
393 MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb);
394 uint8_t n_type = Entry.n_type;
396 // If this is a STAB debugging symbol, we can do nothing more.
397 if (n_type & MachO::N_STAB)
398 return SymbolRef::ST_Debug;
400 switch (n_type & MachO::N_TYPE) {
402 return SymbolRef::ST_Unknown;
404 section_iterator Sec = *getSymbolSection(Symb);
405 if (Sec->isData() || Sec->isBSS())
406 return SymbolRef::ST_Data;
407 return SymbolRef::ST_Function;
409 return SymbolRef::ST_Other;
412 uint32_t MachOObjectFile::getSymbolFlags(DataRefImpl DRI) const {
413 MachO::nlist_base Entry = getSymbolTableEntryBase(this, DRI);
415 uint8_t MachOType = Entry.n_type;
416 uint16_t MachOFlags = Entry.n_desc;
418 uint32_t Result = SymbolRef::SF_None;
420 if ((MachOType & MachO::N_TYPE) == MachO::N_INDR)
421 Result |= SymbolRef::SF_Indirect;
423 if (MachOType & MachO::N_STAB)
424 Result |= SymbolRef::SF_FormatSpecific;
426 if (MachOType & MachO::N_EXT) {
427 Result |= SymbolRef::SF_Global;
428 if ((MachOType & MachO::N_TYPE) == MachO::N_UNDF) {
430 Result |= SymbolRef::SF_Common;
432 Result |= SymbolRef::SF_Undefined;
435 if (!(MachOType & MachO::N_PEXT))
436 Result |= SymbolRef::SF_Exported;
439 if (MachOFlags & (MachO::N_WEAK_REF | MachO::N_WEAK_DEF))
440 Result |= SymbolRef::SF_Weak;
442 if (MachOFlags & (MachO::N_ARM_THUMB_DEF))
443 Result |= SymbolRef::SF_Thumb;
445 if ((MachOType & MachO::N_TYPE) == MachO::N_ABS)
446 Result |= SymbolRef::SF_Absolute;
451 ErrorOr<section_iterator>
452 MachOObjectFile::getSymbolSection(DataRefImpl Symb) const {
453 MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb);
454 uint8_t index = Entry.n_sect;
457 return section_end();
460 if (DRI.d.a >= Sections.size())
461 report_fatal_error("getSymbolSection: Invalid section index.");
462 return section_iterator(SectionRef(DRI, this));
465 unsigned MachOObjectFile::getSymbolSectionID(SymbolRef Sym) const {
466 MachO::nlist_base Entry =
467 getSymbolTableEntryBase(this, Sym.getRawDataRefImpl());
468 return Entry.n_sect - 1;
471 void MachOObjectFile::moveSectionNext(DataRefImpl &Sec) const {
475 std::error_code MachOObjectFile::getSectionName(DataRefImpl Sec,
476 StringRef &Result) const {
477 ArrayRef<char> Raw = getSectionRawName(Sec);
478 Result = parseSegmentOrSectionName(Raw.data());
479 return std::error_code();
482 uint64_t MachOObjectFile::getSectionAddress(DataRefImpl Sec) const {
484 return getSection64(Sec).addr;
485 return getSection(Sec).addr;
488 uint64_t MachOObjectFile::getSectionSize(DataRefImpl Sec) const {
489 // In the case if a malformed Mach-O file where the section offset is past
490 // the end of the file or some part of the section size is past the end of
491 // the file return a size of zero or a size that covers the rest of the file
492 // but does not extend past the end of the file.
493 uint32_t SectOffset, SectType;
497 MachO::section_64 Sect = getSection64(Sec);
498 SectOffset = Sect.offset;
499 SectSize = Sect.size;
500 SectType = Sect.flags & MachO::SECTION_TYPE;
502 MachO::section Sect = getSection(Sec);
503 SectOffset = Sect.offset;
504 SectSize = Sect.size;
505 SectType = Sect.flags & MachO::SECTION_TYPE;
507 if (SectType == MachO::S_ZEROFILL || SectType == MachO::S_GB_ZEROFILL)
509 uint64_t FileSize = getData().size();
510 if (SectOffset > FileSize)
512 if (FileSize - SectOffset < SectSize)
513 return FileSize - SectOffset;
517 std::error_code MachOObjectFile::getSectionContents(DataRefImpl Sec,
518 StringRef &Res) const {
523 MachO::section_64 Sect = getSection64(Sec);
524 Offset = Sect.offset;
527 MachO::section Sect = getSection(Sec);
528 Offset = Sect.offset;
532 Res = this->getData().substr(Offset, Size);
533 return std::error_code();
536 uint64_t MachOObjectFile::getSectionAlignment(DataRefImpl Sec) const {
539 MachO::section_64 Sect = getSection64(Sec);
542 MachO::section Sect = getSection(Sec);
546 return uint64_t(1) << Align;
549 bool MachOObjectFile::isSectionText(DataRefImpl Sec) const {
550 uint32_t Flags = getSectionFlags(this, Sec);
551 return Flags & MachO::S_ATTR_PURE_INSTRUCTIONS;
554 bool MachOObjectFile::isSectionData(DataRefImpl Sec) const {
555 uint32_t Flags = getSectionFlags(this, Sec);
556 unsigned SectionType = Flags & MachO::SECTION_TYPE;
557 return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
558 !(SectionType == MachO::S_ZEROFILL ||
559 SectionType == MachO::S_GB_ZEROFILL);
562 bool MachOObjectFile::isSectionBSS(DataRefImpl Sec) const {
563 uint32_t Flags = getSectionFlags(this, Sec);
564 unsigned SectionType = Flags & MachO::SECTION_TYPE;
565 return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
566 (SectionType == MachO::S_ZEROFILL ||
567 SectionType == MachO::S_GB_ZEROFILL);
570 unsigned MachOObjectFile::getSectionID(SectionRef Sec) const {
571 return Sec.getRawDataRefImpl().d.a;
574 bool MachOObjectFile::isSectionVirtual(DataRefImpl Sec) const {
575 // FIXME: Unimplemented.
579 relocation_iterator MachOObjectFile::section_rel_begin(DataRefImpl Sec) const {
583 return relocation_iterator(RelocationRef(Ret, this));
587 MachOObjectFile::section_rel_end(DataRefImpl Sec) const {
590 MachO::section_64 Sect = getSection64(Sec);
593 MachO::section Sect = getSection(Sec);
600 return relocation_iterator(RelocationRef(Ret, this));
603 void MachOObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
607 uint64_t MachOObjectFile::getRelocationOffset(DataRefImpl Rel) const {
608 assert(getHeader().filetype == MachO::MH_OBJECT &&
609 "Only implemented for MH_OBJECT");
610 MachO::any_relocation_info RE = getRelocation(Rel);
611 return getAnyRelocationAddress(RE);
615 MachOObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
616 MachO::any_relocation_info RE = getRelocation(Rel);
617 if (isRelocationScattered(RE))
620 uint32_t SymbolIdx = getPlainRelocationSymbolNum(RE);
621 bool isExtern = getPlainRelocationExternal(RE);
625 MachO::symtab_command S = getSymtabLoadCommand();
626 unsigned SymbolTableEntrySize = is64Bit() ?
627 sizeof(MachO::nlist_64) :
628 sizeof(MachO::nlist);
629 uint64_t Offset = S.symoff + SymbolIdx * SymbolTableEntrySize;
631 Sym.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset));
632 return symbol_iterator(SymbolRef(Sym, this));
636 MachOObjectFile::getRelocationSection(DataRefImpl Rel) const {
637 return section_iterator(getAnyRelocationSection(getRelocation(Rel)));
640 uint64_t MachOObjectFile::getRelocationType(DataRefImpl Rel) const {
641 MachO::any_relocation_info RE = getRelocation(Rel);
642 return getAnyRelocationType(RE);
645 void MachOObjectFile::getRelocationTypeName(
646 DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
648 uint64_t RType = getRelocationType(Rel);
650 unsigned Arch = this->getArch();
654 static const char *const Table[] = {
655 "GENERIC_RELOC_VANILLA",
656 "GENERIC_RELOC_PAIR",
657 "GENERIC_RELOC_SECTDIFF",
658 "GENERIC_RELOC_PB_LA_PTR",
659 "GENERIC_RELOC_LOCAL_SECTDIFF",
660 "GENERIC_RELOC_TLV" };
668 case Triple::x86_64: {
669 static const char *const Table[] = {
670 "X86_64_RELOC_UNSIGNED",
671 "X86_64_RELOC_SIGNED",
672 "X86_64_RELOC_BRANCH",
673 "X86_64_RELOC_GOT_LOAD",
675 "X86_64_RELOC_SUBTRACTOR",
676 "X86_64_RELOC_SIGNED_1",
677 "X86_64_RELOC_SIGNED_2",
678 "X86_64_RELOC_SIGNED_4",
679 "X86_64_RELOC_TLV" };
688 static const char *const Table[] = {
691 "ARM_RELOC_SECTDIFF",
692 "ARM_RELOC_LOCAL_SECTDIFF",
693 "ARM_RELOC_PB_LA_PTR",
695 "ARM_THUMB_RELOC_BR22",
696 "ARM_THUMB_32BIT_BRANCH",
698 "ARM_RELOC_HALF_SECTDIFF" };
706 case Triple::aarch64: {
707 static const char *const Table[] = {
708 "ARM64_RELOC_UNSIGNED", "ARM64_RELOC_SUBTRACTOR",
709 "ARM64_RELOC_BRANCH26", "ARM64_RELOC_PAGE21",
710 "ARM64_RELOC_PAGEOFF12", "ARM64_RELOC_GOT_LOAD_PAGE21",
711 "ARM64_RELOC_GOT_LOAD_PAGEOFF12", "ARM64_RELOC_POINTER_TO_GOT",
712 "ARM64_RELOC_TLVP_LOAD_PAGE21", "ARM64_RELOC_TLVP_LOAD_PAGEOFF12",
716 if (RType >= array_lengthof(Table))
723 static const char *const Table[] = {
732 "PPC_RELOC_SECTDIFF",
733 "PPC_RELOC_PB_LA_PTR",
734 "PPC_RELOC_HI16_SECTDIFF",
735 "PPC_RELOC_LO16_SECTDIFF",
736 "PPC_RELOC_HA16_SECTDIFF",
738 "PPC_RELOC_LO14_SECTDIFF",
739 "PPC_RELOC_LOCAL_SECTDIFF" };
747 case Triple::UnknownArch:
751 Result.append(res.begin(), res.end());
754 uint8_t MachOObjectFile::getRelocationLength(DataRefImpl Rel) const {
755 MachO::any_relocation_info RE = getRelocation(Rel);
756 return getAnyRelocationLength(RE);
760 // guessLibraryShortName() is passed a name of a dynamic library and returns a
761 // guess on what the short name is. Then name is returned as a substring of the
762 // StringRef Name passed in. The name of the dynamic library is recognized as
763 // a framework if it has one of the two following forms:
764 // Foo.framework/Versions/A/Foo
766 // Where A and Foo can be any string. And may contain a trailing suffix
767 // starting with an underbar. If the Name is recognized as a framework then
768 // isFramework is set to true else it is set to false. If the Name has a
769 // suffix then Suffix is set to the substring in Name that contains the suffix
770 // else it is set to a NULL StringRef.
772 // The Name of the dynamic library is recognized as a library name if it has
773 // one of the two following forms:
776 // The library may have a suffix trailing the name Foo of the form:
777 // libFoo_profile.A.dylib
778 // libFoo_profile.dylib
780 // The Name of the dynamic library is also recognized as a library name if it
781 // has the following form:
784 // If the Name of the dynamic library is none of the forms above then a NULL
785 // StringRef is returned.
787 StringRef MachOObjectFile::guessLibraryShortName(StringRef Name,
790 StringRef Foo, F, DotFramework, V, Dylib, Lib, Dot, Qtx;
791 size_t a, b, c, d, Idx;
794 Suffix = StringRef();
796 // Pull off the last component and make Foo point to it
798 if (a == Name.npos || a == 0)
800 Foo = Name.slice(a+1, Name.npos);
802 // Look for a suffix starting with a '_'
803 Idx = Foo.rfind('_');
804 if (Idx != Foo.npos && Foo.size() >= 2) {
805 Suffix = Foo.slice(Idx, Foo.npos);
806 Foo = Foo.slice(0, Idx);
809 // First look for the form Foo.framework/Foo
810 b = Name.rfind('/', a);
815 F = Name.slice(Idx, Idx + Foo.size());
816 DotFramework = Name.slice(Idx + Foo.size(),
817 Idx + Foo.size() + sizeof(".framework/")-1);
818 if (F == Foo && DotFramework == ".framework/") {
823 // Next look for the form Foo.framework/Versions/A/Foo
826 c = Name.rfind('/', b);
827 if (c == Name.npos || c == 0)
829 V = Name.slice(c+1, Name.npos);
830 if (!V.startswith("Versions/"))
832 d = Name.rfind('/', c);
837 F = Name.slice(Idx, Idx + Foo.size());
838 DotFramework = Name.slice(Idx + Foo.size(),
839 Idx + Foo.size() + sizeof(".framework/")-1);
840 if (F == Foo && DotFramework == ".framework/") {
846 // pull off the suffix after the "." and make a point to it
848 if (a == Name.npos || a == 0)
850 Dylib = Name.slice(a, Name.npos);
851 if (Dylib != ".dylib")
854 // First pull off the version letter for the form Foo.A.dylib if any.
856 Dot = Name.slice(a-2, a-1);
861 b = Name.rfind('/', a);
866 // ignore any suffix after an underbar like Foo_profile.A.dylib
867 Idx = Name.find('_', b);
868 if (Idx != Name.npos && Idx != b) {
869 Lib = Name.slice(b, Idx);
870 Suffix = Name.slice(Idx, a);
873 Lib = Name.slice(b, a);
874 // There are incorrect library names of the form:
875 // libATS.A_profile.dylib so check for these.
876 if (Lib.size() >= 3) {
877 Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
879 Lib = Lib.slice(0, Lib.size()-2);
884 Qtx = Name.slice(a, Name.npos);
887 b = Name.rfind('/', a);
889 Lib = Name.slice(0, a);
891 Lib = Name.slice(b+1, a);
892 // There are library names of the form: QT.A.qtx so check for these.
893 if (Lib.size() >= 3) {
894 Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
896 Lib = Lib.slice(0, Lib.size()-2);
901 // getLibraryShortNameByIndex() is used to get the short name of the library
902 // for an undefined symbol in a linked Mach-O binary that was linked with the
903 // normal two-level namespace default (that is MH_TWOLEVEL in the header).
904 // It is passed the index (0 - based) of the library as translated from
905 // GET_LIBRARY_ORDINAL (1 - based).
906 std::error_code MachOObjectFile::getLibraryShortNameByIndex(unsigned Index,
907 StringRef &Res) const {
908 if (Index >= Libraries.size())
909 return object_error::parse_failed;
911 // If the cache of LibrariesShortNames is not built up do that first for
912 // all the Libraries.
913 if (LibrariesShortNames.size() == 0) {
914 for (unsigned i = 0; i < Libraries.size(); i++) {
915 MachO::dylib_command D =
916 getStruct<MachO::dylib_command>(this, Libraries[i]);
917 if (D.dylib.name >= D.cmdsize)
918 return object_error::parse_failed;
919 const char *P = (const char *)(Libraries[i]) + D.dylib.name;
920 StringRef Name = StringRef(P);
921 if (D.dylib.name+Name.size() >= D.cmdsize)
922 return object_error::parse_failed;
925 StringRef shortName = guessLibraryShortName(Name, isFramework, Suffix);
926 if (shortName.empty())
927 LibrariesShortNames.push_back(Name);
929 LibrariesShortNames.push_back(shortName);
933 Res = LibrariesShortNames[Index];
934 return std::error_code();
938 MachOObjectFile::getRelocationRelocatedSection(relocation_iterator Rel) const {
940 Sec.d.a = Rel->getRawDataRefImpl().d.a;
941 return section_iterator(SectionRef(Sec, this));
944 basic_symbol_iterator MachOObjectFile::symbol_begin_impl() const {
945 return getSymbolByIndex(0);
948 basic_symbol_iterator MachOObjectFile::symbol_end_impl() const {
951 return basic_symbol_iterator(SymbolRef(DRI, this));
953 MachO::symtab_command Symtab = getSymtabLoadCommand();
954 unsigned SymbolTableEntrySize = is64Bit() ?
955 sizeof(MachO::nlist_64) :
956 sizeof(MachO::nlist);
957 unsigned Offset = Symtab.symoff +
958 Symtab.nsyms * SymbolTableEntrySize;
959 DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset));
960 return basic_symbol_iterator(SymbolRef(DRI, this));
963 basic_symbol_iterator MachOObjectFile::getSymbolByIndex(unsigned Index) const {
966 return basic_symbol_iterator(SymbolRef(DRI, this));
968 MachO::symtab_command Symtab = getSymtabLoadCommand();
969 if (Index >= Symtab.nsyms)
970 report_fatal_error("Requested symbol index is out of range.");
971 unsigned SymbolTableEntrySize =
972 is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
973 DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Symtab.symoff));
974 DRI.p += Index * SymbolTableEntrySize;
975 return basic_symbol_iterator(SymbolRef(DRI, this));
978 section_iterator MachOObjectFile::section_begin() const {
980 return section_iterator(SectionRef(DRI, this));
983 section_iterator MachOObjectFile::section_end() const {
985 DRI.d.a = Sections.size();
986 return section_iterator(SectionRef(DRI, this));
989 uint8_t MachOObjectFile::getBytesInAddress() const {
990 return is64Bit() ? 8 : 4;
993 StringRef MachOObjectFile::getFileFormatName() const {
994 unsigned CPUType = getCPUType(this);
997 case llvm::MachO::CPU_TYPE_I386:
998 return "Mach-O 32-bit i386";
999 case llvm::MachO::CPU_TYPE_ARM:
1000 return "Mach-O arm";
1001 case llvm::MachO::CPU_TYPE_POWERPC:
1002 return "Mach-O 32-bit ppc";
1004 return "Mach-O 32-bit unknown";
1009 case llvm::MachO::CPU_TYPE_X86_64:
1010 return "Mach-O 64-bit x86-64";
1011 case llvm::MachO::CPU_TYPE_ARM64:
1012 return "Mach-O arm64";
1013 case llvm::MachO::CPU_TYPE_POWERPC64:
1014 return "Mach-O 64-bit ppc64";
1016 return "Mach-O 64-bit unknown";
1020 Triple::ArchType MachOObjectFile::getArch(uint32_t CPUType) {
1022 case llvm::MachO::CPU_TYPE_I386:
1024 case llvm::MachO::CPU_TYPE_X86_64:
1025 return Triple::x86_64;
1026 case llvm::MachO::CPU_TYPE_ARM:
1028 case llvm::MachO::CPU_TYPE_ARM64:
1029 return Triple::aarch64;
1030 case llvm::MachO::CPU_TYPE_POWERPC:
1032 case llvm::MachO::CPU_TYPE_POWERPC64:
1033 return Triple::ppc64;
1035 return Triple::UnknownArch;
1039 Triple MachOObjectFile::getArch(uint32_t CPUType, uint32_t CPUSubType,
1040 const char **McpuDefault) {
1042 *McpuDefault = nullptr;
1045 case MachO::CPU_TYPE_I386:
1046 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
1047 case MachO::CPU_SUBTYPE_I386_ALL:
1048 return Triple("i386-apple-darwin");
1052 case MachO::CPU_TYPE_X86_64:
1053 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
1054 case MachO::CPU_SUBTYPE_X86_64_ALL:
1055 return Triple("x86_64-apple-darwin");
1056 case MachO::CPU_SUBTYPE_X86_64_H:
1057 return Triple("x86_64h-apple-darwin");
1061 case MachO::CPU_TYPE_ARM:
1062 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
1063 case MachO::CPU_SUBTYPE_ARM_V4T:
1064 return Triple("armv4t-apple-darwin");
1065 case MachO::CPU_SUBTYPE_ARM_V5TEJ:
1066 return Triple("armv5e-apple-darwin");
1067 case MachO::CPU_SUBTYPE_ARM_XSCALE:
1068 return Triple("xscale-apple-darwin");
1069 case MachO::CPU_SUBTYPE_ARM_V6:
1070 return Triple("armv6-apple-darwin");
1071 case MachO::CPU_SUBTYPE_ARM_V6M:
1073 *McpuDefault = "cortex-m0";
1074 return Triple("armv6m-apple-darwin");
1075 case MachO::CPU_SUBTYPE_ARM_V7:
1076 return Triple("armv7-apple-darwin");
1077 case MachO::CPU_SUBTYPE_ARM_V7EM:
1079 *McpuDefault = "cortex-m4";
1080 return Triple("armv7em-apple-darwin");
1081 case MachO::CPU_SUBTYPE_ARM_V7K:
1082 return Triple("armv7k-apple-darwin");
1083 case MachO::CPU_SUBTYPE_ARM_V7M:
1085 *McpuDefault = "cortex-m3";
1086 return Triple("armv7m-apple-darwin");
1087 case MachO::CPU_SUBTYPE_ARM_V7S:
1088 return Triple("armv7s-apple-darwin");
1092 case MachO::CPU_TYPE_ARM64:
1093 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
1094 case MachO::CPU_SUBTYPE_ARM64_ALL:
1095 return Triple("arm64-apple-darwin");
1099 case MachO::CPU_TYPE_POWERPC:
1100 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
1101 case MachO::CPU_SUBTYPE_POWERPC_ALL:
1102 return Triple("ppc-apple-darwin");
1106 case MachO::CPU_TYPE_POWERPC64:
1107 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
1108 case MachO::CPU_SUBTYPE_POWERPC_ALL:
1109 return Triple("ppc64-apple-darwin");
1118 Triple MachOObjectFile::getThumbArch(uint32_t CPUType, uint32_t CPUSubType,
1119 const char **McpuDefault) {
1121 *McpuDefault = nullptr;
1124 case MachO::CPU_TYPE_ARM:
1125 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
1126 case MachO::CPU_SUBTYPE_ARM_V4T:
1127 return Triple("thumbv4t-apple-darwin");
1128 case MachO::CPU_SUBTYPE_ARM_V5TEJ:
1129 return Triple("thumbv5e-apple-darwin");
1130 case MachO::CPU_SUBTYPE_ARM_XSCALE:
1131 return Triple("xscale-apple-darwin");
1132 case MachO::CPU_SUBTYPE_ARM_V6:
1133 return Triple("thumbv6-apple-darwin");
1134 case MachO::CPU_SUBTYPE_ARM_V6M:
1136 *McpuDefault = "cortex-m0";
1137 return Triple("thumbv6m-apple-darwin");
1138 case MachO::CPU_SUBTYPE_ARM_V7:
1139 return Triple("thumbv7-apple-darwin");
1140 case MachO::CPU_SUBTYPE_ARM_V7EM:
1142 *McpuDefault = "cortex-m4";
1143 return Triple("thumbv7em-apple-darwin");
1144 case MachO::CPU_SUBTYPE_ARM_V7K:
1145 return Triple("thumbv7k-apple-darwin");
1146 case MachO::CPU_SUBTYPE_ARM_V7M:
1148 *McpuDefault = "cortex-m3";
1149 return Triple("thumbv7m-apple-darwin");
1150 case MachO::CPU_SUBTYPE_ARM_V7S:
1151 return Triple("thumbv7s-apple-darwin");
1160 Triple MachOObjectFile::getArch(uint32_t CPUType, uint32_t CPUSubType,
1161 const char **McpuDefault, Triple *ThumbTriple) {
1162 Triple T = MachOObjectFile::getArch(CPUType, CPUSubType, McpuDefault);
1163 *ThumbTriple = MachOObjectFile::getThumbArch(CPUType, CPUSubType,
1168 Triple MachOObjectFile::getHostArch() {
1169 return Triple(sys::getDefaultTargetTriple());
1172 bool MachOObjectFile::isValidArch(StringRef ArchFlag) {
1173 return StringSwitch<bool>(ArchFlag)
1175 .Case("x86_64", true)
1176 .Case("x86_64h", true)
1177 .Case("armv4t", true)
1179 .Case("armv5e", true)
1180 .Case("armv6", true)
1181 .Case("armv6m", true)
1182 .Case("armv7", true)
1183 .Case("armv7em", true)
1184 .Case("armv7k", true)
1185 .Case("armv7m", true)
1186 .Case("armv7s", true)
1187 .Case("arm64", true)
1189 .Case("ppc64", true)
1193 unsigned MachOObjectFile::getArch() const {
1194 return getArch(getCPUType(this));
1197 Triple MachOObjectFile::getArch(const char **McpuDefault,
1198 Triple *ThumbTriple) const {
1199 *ThumbTriple = getThumbArch(Header.cputype, Header.cpusubtype, McpuDefault);
1200 return getArch(Header.cputype, Header.cpusubtype, McpuDefault);
1203 relocation_iterator MachOObjectFile::section_rel_begin(unsigned Index) const {
1206 return section_rel_begin(DRI);
1209 relocation_iterator MachOObjectFile::section_rel_end(unsigned Index) const {
1212 return section_rel_end(DRI);
1215 dice_iterator MachOObjectFile::begin_dices() const {
1217 if (!DataInCodeLoadCmd)
1218 return dice_iterator(DiceRef(DRI, this));
1220 MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
1221 DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, DicLC.dataoff));
1222 return dice_iterator(DiceRef(DRI, this));
1225 dice_iterator MachOObjectFile::end_dices() const {
1227 if (!DataInCodeLoadCmd)
1228 return dice_iterator(DiceRef(DRI, this));
1230 MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
1231 unsigned Offset = DicLC.dataoff + DicLC.datasize;
1232 DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset));
1233 return dice_iterator(DiceRef(DRI, this));
1236 ExportEntry::ExportEntry(ArrayRef<uint8_t> T)
1237 : Trie(T), Malformed(false), Done(false) {}
1239 void ExportEntry::moveToFirst() {
1241 pushDownUntilBottom();
1244 void ExportEntry::moveToEnd() {
1249 bool ExportEntry::operator==(const ExportEntry &Other) const {
1250 // Common case, one at end, other iterating from begin.
1251 if (Done || Other.Done)
1252 return (Done == Other.Done);
1253 // Not equal if different stack sizes.
1254 if (Stack.size() != Other.Stack.size())
1256 // Not equal if different cumulative strings.
1257 if (!CumulativeString.equals(Other.CumulativeString))
1259 // Equal if all nodes in both stacks match.
1260 for (unsigned i=0; i < Stack.size(); ++i) {
1261 if (Stack[i].Start != Other.Stack[i].Start)
1267 uint64_t ExportEntry::readULEB128(const uint8_t *&Ptr) {
1269 uint64_t Result = decodeULEB128(Ptr, &Count);
1271 if (Ptr > Trie.end()) {
1278 StringRef ExportEntry::name() const {
1279 return CumulativeString;
1282 uint64_t ExportEntry::flags() const {
1283 return Stack.back().Flags;
1286 uint64_t ExportEntry::address() const {
1287 return Stack.back().Address;
1290 uint64_t ExportEntry::other() const {
1291 return Stack.back().Other;
1294 StringRef ExportEntry::otherName() const {
1295 const char* ImportName = Stack.back().ImportName;
1297 return StringRef(ImportName);
1301 uint32_t ExportEntry::nodeOffset() const {
1302 return Stack.back().Start - Trie.begin();
1305 ExportEntry::NodeState::NodeState(const uint8_t *Ptr)
1306 : Start(Ptr), Current(Ptr), Flags(0), Address(0), Other(0),
1307 ImportName(nullptr), ChildCount(0), NextChildIndex(0),
1308 ParentStringLength(0), IsExportNode(false) {}
1310 void ExportEntry::pushNode(uint64_t offset) {
1311 const uint8_t *Ptr = Trie.begin() + offset;
1312 NodeState State(Ptr);
1313 uint64_t ExportInfoSize = readULEB128(State.Current);
1314 State.IsExportNode = (ExportInfoSize != 0);
1315 const uint8_t* Children = State.Current + ExportInfoSize;
1316 if (State.IsExportNode) {
1317 State.Flags = readULEB128(State.Current);
1318 if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT) {
1320 State.Other = readULEB128(State.Current); // dylib ordinal
1321 State.ImportName = reinterpret_cast<const char*>(State.Current);
1323 State.Address = readULEB128(State.Current);
1324 if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER)
1325 State.Other = readULEB128(State.Current);
1328 State.ChildCount = *Children;
1329 State.Current = Children + 1;
1330 State.NextChildIndex = 0;
1331 State.ParentStringLength = CumulativeString.size();
1332 Stack.push_back(State);
1335 void ExportEntry::pushDownUntilBottom() {
1336 while (Stack.back().NextChildIndex < Stack.back().ChildCount) {
1337 NodeState &Top = Stack.back();
1338 CumulativeString.resize(Top.ParentStringLength);
1339 for (;*Top.Current != 0; Top.Current++) {
1340 char C = *Top.Current;
1341 CumulativeString.push_back(C);
1344 uint64_t childNodeIndex = readULEB128(Top.Current);
1345 Top.NextChildIndex += 1;
1346 pushNode(childNodeIndex);
1348 if (!Stack.back().IsExportNode) {
1354 // We have a trie data structure and need a way to walk it that is compatible
1355 // with the C++ iterator model. The solution is a non-recursive depth first
1356 // traversal where the iterator contains a stack of parent nodes along with a
1357 // string that is the accumulation of all edge strings along the parent chain
1360 // There is one "export" node for each exported symbol. But because some
1361 // symbols may be a prefix of another symbol (e.g. _dup and _dup2), an export
1362 // node may have child nodes too.
1364 // The algorithm for moveNext() is to keep moving down the leftmost unvisited
1365 // child until hitting a node with no children (which is an export node or
1366 // else the trie is malformed). On the way down, each node is pushed on the
1367 // stack ivar. If there is no more ways down, it pops up one and tries to go
1368 // down a sibling path until a childless node is reached.
1369 void ExportEntry::moveNext() {
1370 if (Stack.empty() || !Stack.back().IsExportNode) {
1377 while (!Stack.empty()) {
1378 NodeState &Top = Stack.back();
1379 if (Top.NextChildIndex < Top.ChildCount) {
1380 pushDownUntilBottom();
1381 // Now at the next export node.
1384 if (Top.IsExportNode) {
1385 // This node has no children but is itself an export node.
1386 CumulativeString.resize(Top.ParentStringLength);
1395 iterator_range<export_iterator>
1396 MachOObjectFile::exports(ArrayRef<uint8_t> Trie) {
1397 ExportEntry Start(Trie);
1398 if (Trie.size() == 0)
1401 Start.moveToFirst();
1403 ExportEntry Finish(Trie);
1406 return iterator_range<export_iterator>(export_iterator(Start),
1407 export_iterator(Finish));
1410 iterator_range<export_iterator> MachOObjectFile::exports() const {
1411 return exports(getDyldInfoExportsTrie());
1414 MachORebaseEntry::MachORebaseEntry(ArrayRef<uint8_t> Bytes, bool is64Bit)
1415 : Opcodes(Bytes), Ptr(Bytes.begin()), SegmentOffset(0), SegmentIndex(0),
1416 RemainingLoopCount(0), AdvanceAmount(0), RebaseType(0),
1417 PointerSize(is64Bit ? 8 : 4), Malformed(false), Done(false) {}
1419 void MachORebaseEntry::moveToFirst() {
1420 Ptr = Opcodes.begin();
1424 void MachORebaseEntry::moveToEnd() {
1425 Ptr = Opcodes.end();
1426 RemainingLoopCount = 0;
1430 void MachORebaseEntry::moveNext() {
1431 // If in the middle of some loop, move to next rebasing in loop.
1432 SegmentOffset += AdvanceAmount;
1433 if (RemainingLoopCount) {
1434 --RemainingLoopCount;
1437 if (Ptr == Opcodes.end()) {
1442 while (More && !Malformed) {
1443 // Parse next opcode and set up next loop.
1444 uint8_t Byte = *Ptr++;
1445 uint8_t ImmValue = Byte & MachO::REBASE_IMMEDIATE_MASK;
1446 uint8_t Opcode = Byte & MachO::REBASE_OPCODE_MASK;
1448 case MachO::REBASE_OPCODE_DONE:
1452 DEBUG_WITH_TYPE("mach-o-rebase", llvm::dbgs() << "REBASE_OPCODE_DONE\n");
1454 case MachO::REBASE_OPCODE_SET_TYPE_IMM:
1455 RebaseType = ImmValue;
1458 llvm::dbgs() << "REBASE_OPCODE_SET_TYPE_IMM: "
1459 << "RebaseType=" << (int) RebaseType << "\n");
1461 case MachO::REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
1462 SegmentIndex = ImmValue;
1463 SegmentOffset = readULEB128();
1466 llvm::dbgs() << "REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
1467 << "SegmentIndex=" << SegmentIndex << ", "
1468 << format("SegmentOffset=0x%06X", SegmentOffset)
1471 case MachO::REBASE_OPCODE_ADD_ADDR_ULEB:
1472 SegmentOffset += readULEB128();
1473 DEBUG_WITH_TYPE("mach-o-rebase",
1474 llvm::dbgs() << "REBASE_OPCODE_ADD_ADDR_ULEB: "
1475 << format("SegmentOffset=0x%06X",
1476 SegmentOffset) << "\n");
1478 case MachO::REBASE_OPCODE_ADD_ADDR_IMM_SCALED:
1479 SegmentOffset += ImmValue * PointerSize;
1480 DEBUG_WITH_TYPE("mach-o-rebase",
1481 llvm::dbgs() << "REBASE_OPCODE_ADD_ADDR_IMM_SCALED: "
1482 << format("SegmentOffset=0x%06X",
1483 SegmentOffset) << "\n");
1485 case MachO::REBASE_OPCODE_DO_REBASE_IMM_TIMES:
1486 AdvanceAmount = PointerSize;
1487 RemainingLoopCount = ImmValue - 1;
1490 llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_IMM_TIMES: "
1491 << format("SegmentOffset=0x%06X", SegmentOffset)
1492 << ", AdvanceAmount=" << AdvanceAmount
1493 << ", RemainingLoopCount=" << RemainingLoopCount
1496 case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES:
1497 AdvanceAmount = PointerSize;
1498 RemainingLoopCount = readULEB128() - 1;
1501 llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES: "
1502 << format("SegmentOffset=0x%06X", SegmentOffset)
1503 << ", AdvanceAmount=" << AdvanceAmount
1504 << ", RemainingLoopCount=" << RemainingLoopCount
1507 case MachO::REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB:
1508 AdvanceAmount = readULEB128() + PointerSize;
1509 RemainingLoopCount = 0;
1512 llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: "
1513 << format("SegmentOffset=0x%06X", SegmentOffset)
1514 << ", AdvanceAmount=" << AdvanceAmount
1515 << ", RemainingLoopCount=" << RemainingLoopCount
1518 case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB:
1519 RemainingLoopCount = readULEB128() - 1;
1520 AdvanceAmount = readULEB128() + PointerSize;
1523 llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: "
1524 << format("SegmentOffset=0x%06X", SegmentOffset)
1525 << ", AdvanceAmount=" << AdvanceAmount
1526 << ", RemainingLoopCount=" << RemainingLoopCount
1535 uint64_t MachORebaseEntry::readULEB128() {
1537 uint64_t Result = decodeULEB128(Ptr, &Count);
1539 if (Ptr > Opcodes.end()) {
1540 Ptr = Opcodes.end();
1546 uint32_t MachORebaseEntry::segmentIndex() const { return SegmentIndex; }
1548 uint64_t MachORebaseEntry::segmentOffset() const { return SegmentOffset; }
1550 StringRef MachORebaseEntry::typeName() const {
1551 switch (RebaseType) {
1552 case MachO::REBASE_TYPE_POINTER:
1554 case MachO::REBASE_TYPE_TEXT_ABSOLUTE32:
1555 return "text abs32";
1556 case MachO::REBASE_TYPE_TEXT_PCREL32:
1557 return "text rel32";
1562 bool MachORebaseEntry::operator==(const MachORebaseEntry &Other) const {
1563 assert(Opcodes == Other.Opcodes && "compare iterators of different files");
1564 return (Ptr == Other.Ptr) &&
1565 (RemainingLoopCount == Other.RemainingLoopCount) &&
1566 (Done == Other.Done);
1569 iterator_range<rebase_iterator>
1570 MachOObjectFile::rebaseTable(ArrayRef<uint8_t> Opcodes, bool is64) {
1571 MachORebaseEntry Start(Opcodes, is64);
1572 Start.moveToFirst();
1574 MachORebaseEntry Finish(Opcodes, is64);
1577 return iterator_range<rebase_iterator>(rebase_iterator(Start),
1578 rebase_iterator(Finish));
1581 iterator_range<rebase_iterator> MachOObjectFile::rebaseTable() const {
1582 return rebaseTable(getDyldInfoRebaseOpcodes(), is64Bit());
1585 MachOBindEntry::MachOBindEntry(ArrayRef<uint8_t> Bytes, bool is64Bit, Kind BK)
1586 : Opcodes(Bytes), Ptr(Bytes.begin()), SegmentOffset(0), SegmentIndex(0),
1587 Ordinal(0), Flags(0), Addend(0), RemainingLoopCount(0), AdvanceAmount(0),
1588 BindType(0), PointerSize(is64Bit ? 8 : 4),
1589 TableKind(BK), Malformed(false), Done(false) {}
1591 void MachOBindEntry::moveToFirst() {
1592 Ptr = Opcodes.begin();
1596 void MachOBindEntry::moveToEnd() {
1597 Ptr = Opcodes.end();
1598 RemainingLoopCount = 0;
1602 void MachOBindEntry::moveNext() {
1603 // If in the middle of some loop, move to next binding in loop.
1604 SegmentOffset += AdvanceAmount;
1605 if (RemainingLoopCount) {
1606 --RemainingLoopCount;
1609 if (Ptr == Opcodes.end()) {
1614 while (More && !Malformed) {
1615 // Parse next opcode and set up next loop.
1616 uint8_t Byte = *Ptr++;
1617 uint8_t ImmValue = Byte & MachO::BIND_IMMEDIATE_MASK;
1618 uint8_t Opcode = Byte & MachO::BIND_OPCODE_MASK;
1619 int8_t SignExtended;
1620 const uint8_t *SymStart;
1622 case MachO::BIND_OPCODE_DONE:
1623 if (TableKind == Kind::Lazy) {
1624 // Lazying bindings have a DONE opcode between entries. Need to ignore
1625 // it to advance to next entry. But need not if this is last entry.
1626 bool NotLastEntry = false;
1627 for (const uint8_t *P = Ptr; P < Opcodes.end(); ++P) {
1629 NotLastEntry = true;
1638 DEBUG_WITH_TYPE("mach-o-bind", llvm::dbgs() << "BIND_OPCODE_DONE\n");
1640 case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
1644 llvm::dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: "
1645 << "Ordinal=" << Ordinal << "\n");
1647 case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
1648 Ordinal = readULEB128();
1651 llvm::dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: "
1652 << "Ordinal=" << Ordinal << "\n");
1654 case MachO::BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:
1656 SignExtended = MachO::BIND_OPCODE_MASK | ImmValue;
1657 Ordinal = SignExtended;
1662 llvm::dbgs() << "BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: "
1663 << "Ordinal=" << Ordinal << "\n");
1665 case MachO::BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
1671 SymbolName = StringRef(reinterpret_cast<const char*>(SymStart),
1676 llvm::dbgs() << "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: "
1677 << "SymbolName=" << SymbolName << "\n");
1678 if (TableKind == Kind::Weak) {
1679 if (ImmValue & MachO::BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION)
1683 case MachO::BIND_OPCODE_SET_TYPE_IMM:
1684 BindType = ImmValue;
1687 llvm::dbgs() << "BIND_OPCODE_SET_TYPE_IMM: "
1688 << "BindType=" << (int)BindType << "\n");
1690 case MachO::BIND_OPCODE_SET_ADDEND_SLEB:
1691 Addend = readSLEB128();
1692 if (TableKind == Kind::Lazy)
1696 llvm::dbgs() << "BIND_OPCODE_SET_ADDEND_SLEB: "
1697 << "Addend=" << Addend << "\n");
1699 case MachO::BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
1700 SegmentIndex = ImmValue;
1701 SegmentOffset = readULEB128();
1704 llvm::dbgs() << "BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
1705 << "SegmentIndex=" << SegmentIndex << ", "
1706 << format("SegmentOffset=0x%06X", SegmentOffset)
1709 case MachO::BIND_OPCODE_ADD_ADDR_ULEB:
1710 SegmentOffset += readULEB128();
1711 DEBUG_WITH_TYPE("mach-o-bind",
1712 llvm::dbgs() << "BIND_OPCODE_ADD_ADDR_ULEB: "
1713 << format("SegmentOffset=0x%06X",
1714 SegmentOffset) << "\n");
1716 case MachO::BIND_OPCODE_DO_BIND:
1717 AdvanceAmount = PointerSize;
1718 RemainingLoopCount = 0;
1719 DEBUG_WITH_TYPE("mach-o-bind",
1720 llvm::dbgs() << "BIND_OPCODE_DO_BIND: "
1721 << format("SegmentOffset=0x%06X",
1722 SegmentOffset) << "\n");
1724 case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
1725 AdvanceAmount = readULEB128() + PointerSize;
1726 RemainingLoopCount = 0;
1727 if (TableKind == Kind::Lazy)
1731 llvm::dbgs() << "BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: "
1732 << format("SegmentOffset=0x%06X", SegmentOffset)
1733 << ", AdvanceAmount=" << AdvanceAmount
1734 << ", RemainingLoopCount=" << RemainingLoopCount
1737 case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
1738 AdvanceAmount = ImmValue * PointerSize + PointerSize;
1739 RemainingLoopCount = 0;
1740 if (TableKind == Kind::Lazy)
1742 DEBUG_WITH_TYPE("mach-o-bind",
1744 << "BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: "
1745 << format("SegmentOffset=0x%06X",
1746 SegmentOffset) << "\n");
1748 case MachO::BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
1749 RemainingLoopCount = readULEB128() - 1;
1750 AdvanceAmount = readULEB128() + PointerSize;
1751 if (TableKind == Kind::Lazy)
1755 llvm::dbgs() << "BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: "
1756 << format("SegmentOffset=0x%06X", SegmentOffset)
1757 << ", AdvanceAmount=" << AdvanceAmount
1758 << ", RemainingLoopCount=" << RemainingLoopCount
1767 uint64_t MachOBindEntry::readULEB128() {
1769 uint64_t Result = decodeULEB128(Ptr, &Count);
1771 if (Ptr > Opcodes.end()) {
1772 Ptr = Opcodes.end();
1778 int64_t MachOBindEntry::readSLEB128() {
1780 int64_t Result = decodeSLEB128(Ptr, &Count);
1782 if (Ptr > Opcodes.end()) {
1783 Ptr = Opcodes.end();
1789 uint32_t MachOBindEntry::segmentIndex() const { return SegmentIndex; }
1791 uint64_t MachOBindEntry::segmentOffset() const { return SegmentOffset; }
1793 StringRef MachOBindEntry::typeName() const {
1795 case MachO::BIND_TYPE_POINTER:
1797 case MachO::BIND_TYPE_TEXT_ABSOLUTE32:
1798 return "text abs32";
1799 case MachO::BIND_TYPE_TEXT_PCREL32:
1800 return "text rel32";
1805 StringRef MachOBindEntry::symbolName() const { return SymbolName; }
1807 int64_t MachOBindEntry::addend() const { return Addend; }
1809 uint32_t MachOBindEntry::flags() const { return Flags; }
1811 int MachOBindEntry::ordinal() const { return Ordinal; }
1813 bool MachOBindEntry::operator==(const MachOBindEntry &Other) const {
1814 assert(Opcodes == Other.Opcodes && "compare iterators of different files");
1815 return (Ptr == Other.Ptr) &&
1816 (RemainingLoopCount == Other.RemainingLoopCount) &&
1817 (Done == Other.Done);
1820 iterator_range<bind_iterator>
1821 MachOObjectFile::bindTable(ArrayRef<uint8_t> Opcodes, bool is64,
1822 MachOBindEntry::Kind BKind) {
1823 MachOBindEntry Start(Opcodes, is64, BKind);
1824 Start.moveToFirst();
1826 MachOBindEntry Finish(Opcodes, is64, BKind);
1829 return iterator_range<bind_iterator>(bind_iterator(Start),
1830 bind_iterator(Finish));
1833 iterator_range<bind_iterator> MachOObjectFile::bindTable() const {
1834 return bindTable(getDyldInfoBindOpcodes(), is64Bit(),
1835 MachOBindEntry::Kind::Regular);
1838 iterator_range<bind_iterator> MachOObjectFile::lazyBindTable() const {
1839 return bindTable(getDyldInfoLazyBindOpcodes(), is64Bit(),
1840 MachOBindEntry::Kind::Lazy);
1843 iterator_range<bind_iterator> MachOObjectFile::weakBindTable() const {
1844 return bindTable(getDyldInfoWeakBindOpcodes(), is64Bit(),
1845 MachOBindEntry::Kind::Weak);
1848 MachOObjectFile::load_command_iterator
1849 MachOObjectFile::begin_load_commands() const {
1850 return LoadCommands.begin();
1853 MachOObjectFile::load_command_iterator
1854 MachOObjectFile::end_load_commands() const {
1855 return LoadCommands.end();
1858 iterator_range<MachOObjectFile::load_command_iterator>
1859 MachOObjectFile::load_commands() const {
1860 return iterator_range<load_command_iterator>(begin_load_commands(),
1861 end_load_commands());
1865 MachOObjectFile::getSectionFinalSegmentName(DataRefImpl Sec) const {
1866 ArrayRef<char> Raw = getSectionRawFinalSegmentName(Sec);
1867 return parseSegmentOrSectionName(Raw.data());
1871 MachOObjectFile::getSectionRawName(DataRefImpl Sec) const {
1872 assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
1873 const section_base *Base =
1874 reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
1875 return makeArrayRef(Base->sectname);
1879 MachOObjectFile::getSectionRawFinalSegmentName(DataRefImpl Sec) const {
1880 assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
1881 const section_base *Base =
1882 reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
1883 return makeArrayRef(Base->segname);
1887 MachOObjectFile::isRelocationScattered(const MachO::any_relocation_info &RE)
1889 if (getCPUType(this) == MachO::CPU_TYPE_X86_64)
1891 return getPlainRelocationAddress(RE) & MachO::R_SCATTERED;
1894 unsigned MachOObjectFile::getPlainRelocationSymbolNum(
1895 const MachO::any_relocation_info &RE) const {
1896 if (isLittleEndian())
1897 return RE.r_word1 & 0xffffff;
1898 return RE.r_word1 >> 8;
1901 bool MachOObjectFile::getPlainRelocationExternal(
1902 const MachO::any_relocation_info &RE) const {
1903 if (isLittleEndian())
1904 return (RE.r_word1 >> 27) & 1;
1905 return (RE.r_word1 >> 4) & 1;
1908 bool MachOObjectFile::getScatteredRelocationScattered(
1909 const MachO::any_relocation_info &RE) const {
1910 return RE.r_word0 >> 31;
1913 uint32_t MachOObjectFile::getScatteredRelocationValue(
1914 const MachO::any_relocation_info &RE) const {
1918 uint32_t MachOObjectFile::getScatteredRelocationType(
1919 const MachO::any_relocation_info &RE) const {
1920 return (RE.r_word0 >> 24) & 0xf;
1923 unsigned MachOObjectFile::getAnyRelocationAddress(
1924 const MachO::any_relocation_info &RE) const {
1925 if (isRelocationScattered(RE))
1926 return getScatteredRelocationAddress(RE);
1927 return getPlainRelocationAddress(RE);
1930 unsigned MachOObjectFile::getAnyRelocationPCRel(
1931 const MachO::any_relocation_info &RE) const {
1932 if (isRelocationScattered(RE))
1933 return getScatteredRelocationPCRel(this, RE);
1934 return getPlainRelocationPCRel(this, RE);
1937 unsigned MachOObjectFile::getAnyRelocationLength(
1938 const MachO::any_relocation_info &RE) const {
1939 if (isRelocationScattered(RE))
1940 return getScatteredRelocationLength(RE);
1941 return getPlainRelocationLength(this, RE);
1945 MachOObjectFile::getAnyRelocationType(
1946 const MachO::any_relocation_info &RE) const {
1947 if (isRelocationScattered(RE))
1948 return getScatteredRelocationType(RE);
1949 return getPlainRelocationType(this, RE);
1953 MachOObjectFile::getAnyRelocationSection(
1954 const MachO::any_relocation_info &RE) const {
1955 if (isRelocationScattered(RE) || getPlainRelocationExternal(RE))
1956 return *section_end();
1957 unsigned SecNum = getPlainRelocationSymbolNum(RE);
1958 if (SecNum == MachO::R_ABS || SecNum > Sections.size())
1959 return *section_end();
1961 DRI.d.a = SecNum - 1;
1962 return SectionRef(DRI, this);
1965 MachO::section MachOObjectFile::getSection(DataRefImpl DRI) const {
1966 assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
1967 return getStruct<MachO::section>(this, Sections[DRI.d.a]);
1970 MachO::section_64 MachOObjectFile::getSection64(DataRefImpl DRI) const {
1971 assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
1972 return getStruct<MachO::section_64>(this, Sections[DRI.d.a]);
1975 MachO::section MachOObjectFile::getSection(const LoadCommandInfo &L,
1976 unsigned Index) const {
1977 const char *Sec = getSectionPtr(this, L, Index);
1978 return getStruct<MachO::section>(this, Sec);
1981 MachO::section_64 MachOObjectFile::getSection64(const LoadCommandInfo &L,
1982 unsigned Index) const {
1983 const char *Sec = getSectionPtr(this, L, Index);
1984 return getStruct<MachO::section_64>(this, Sec);
1988 MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI) const {
1989 const char *P = reinterpret_cast<const char *>(DRI.p);
1990 return getStruct<MachO::nlist>(this, P);
1994 MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI) const {
1995 const char *P = reinterpret_cast<const char *>(DRI.p);
1996 return getStruct<MachO::nlist_64>(this, P);
1999 MachO::linkedit_data_command
2000 MachOObjectFile::getLinkeditDataLoadCommand(const LoadCommandInfo &L) const {
2001 return getStruct<MachO::linkedit_data_command>(this, L.Ptr);
2004 MachO::segment_command
2005 MachOObjectFile::getSegmentLoadCommand(const LoadCommandInfo &L) const {
2006 return getStruct<MachO::segment_command>(this, L.Ptr);
2009 MachO::segment_command_64
2010 MachOObjectFile::getSegment64LoadCommand(const LoadCommandInfo &L) const {
2011 return getStruct<MachO::segment_command_64>(this, L.Ptr);
2014 MachO::linker_option_command
2015 MachOObjectFile::getLinkerOptionLoadCommand(const LoadCommandInfo &L) const {
2016 return getStruct<MachO::linker_option_command>(this, L.Ptr);
2019 MachO::version_min_command
2020 MachOObjectFile::getVersionMinLoadCommand(const LoadCommandInfo &L) const {
2021 return getStruct<MachO::version_min_command>(this, L.Ptr);
2024 MachO::dylib_command
2025 MachOObjectFile::getDylibIDLoadCommand(const LoadCommandInfo &L) const {
2026 return getStruct<MachO::dylib_command>(this, L.Ptr);
2029 MachO::dyld_info_command
2030 MachOObjectFile::getDyldInfoLoadCommand(const LoadCommandInfo &L) const {
2031 return getStruct<MachO::dyld_info_command>(this, L.Ptr);
2034 MachO::dylinker_command
2035 MachOObjectFile::getDylinkerCommand(const LoadCommandInfo &L) const {
2036 return getStruct<MachO::dylinker_command>(this, L.Ptr);
2040 MachOObjectFile::getUuidCommand(const LoadCommandInfo &L) const {
2041 return getStruct<MachO::uuid_command>(this, L.Ptr);
2044 MachO::rpath_command
2045 MachOObjectFile::getRpathCommand(const LoadCommandInfo &L) const {
2046 return getStruct<MachO::rpath_command>(this, L.Ptr);
2049 MachO::source_version_command
2050 MachOObjectFile::getSourceVersionCommand(const LoadCommandInfo &L) const {
2051 return getStruct<MachO::source_version_command>(this, L.Ptr);
2054 MachO::entry_point_command
2055 MachOObjectFile::getEntryPointCommand(const LoadCommandInfo &L) const {
2056 return getStruct<MachO::entry_point_command>(this, L.Ptr);
2059 MachO::encryption_info_command
2060 MachOObjectFile::getEncryptionInfoCommand(const LoadCommandInfo &L) const {
2061 return getStruct<MachO::encryption_info_command>(this, L.Ptr);
2064 MachO::encryption_info_command_64
2065 MachOObjectFile::getEncryptionInfoCommand64(const LoadCommandInfo &L) const {
2066 return getStruct<MachO::encryption_info_command_64>(this, L.Ptr);
2069 MachO::sub_framework_command
2070 MachOObjectFile::getSubFrameworkCommand(const LoadCommandInfo &L) const {
2071 return getStruct<MachO::sub_framework_command>(this, L.Ptr);
2074 MachO::sub_umbrella_command
2075 MachOObjectFile::getSubUmbrellaCommand(const LoadCommandInfo &L) const {
2076 return getStruct<MachO::sub_umbrella_command>(this, L.Ptr);
2079 MachO::sub_library_command
2080 MachOObjectFile::getSubLibraryCommand(const LoadCommandInfo &L) const {
2081 return getStruct<MachO::sub_library_command>(this, L.Ptr);
2084 MachO::sub_client_command
2085 MachOObjectFile::getSubClientCommand(const LoadCommandInfo &L) const {
2086 return getStruct<MachO::sub_client_command>(this, L.Ptr);
2089 MachO::routines_command
2090 MachOObjectFile::getRoutinesCommand(const LoadCommandInfo &L) const {
2091 return getStruct<MachO::routines_command>(this, L.Ptr);
2094 MachO::routines_command_64
2095 MachOObjectFile::getRoutinesCommand64(const LoadCommandInfo &L) const {
2096 return getStruct<MachO::routines_command_64>(this, L.Ptr);
2099 MachO::thread_command
2100 MachOObjectFile::getThreadCommand(const LoadCommandInfo &L) const {
2101 return getStruct<MachO::thread_command>(this, L.Ptr);
2104 MachO::any_relocation_info
2105 MachOObjectFile::getRelocation(DataRefImpl Rel) const {
2110 MachO::section_64 Sect = getSection64(Sec);
2111 Offset = Sect.reloff;
2113 MachO::section Sect = getSection(Sec);
2114 Offset = Sect.reloff;
2117 auto P = reinterpret_cast<const MachO::any_relocation_info *>(
2118 getPtr(this, Offset)) + Rel.d.b;
2119 return getStruct<MachO::any_relocation_info>(
2120 this, reinterpret_cast<const char *>(P));
2123 MachO::data_in_code_entry
2124 MachOObjectFile::getDice(DataRefImpl Rel) const {
2125 const char *P = reinterpret_cast<const char *>(Rel.p);
2126 return getStruct<MachO::data_in_code_entry>(this, P);
2129 const MachO::mach_header &MachOObjectFile::getHeader() const {
2133 const MachO::mach_header_64 &MachOObjectFile::getHeader64() const {
2138 uint32_t MachOObjectFile::getIndirectSymbolTableEntry(
2139 const MachO::dysymtab_command &DLC,
2140 unsigned Index) const {
2141 uint64_t Offset = DLC.indirectsymoff + Index * sizeof(uint32_t);
2142 return getStruct<uint32_t>(this, getPtr(this, Offset));
2145 MachO::data_in_code_entry
2146 MachOObjectFile::getDataInCodeTableEntry(uint32_t DataOffset,
2147 unsigned Index) const {
2148 uint64_t Offset = DataOffset + Index * sizeof(MachO::data_in_code_entry);
2149 return getStruct<MachO::data_in_code_entry>(this, getPtr(this, Offset));
2152 MachO::symtab_command MachOObjectFile::getSymtabLoadCommand() const {
2154 return getStruct<MachO::symtab_command>(this, SymtabLoadCmd);
2156 // If there is no SymtabLoadCmd return a load command with zero'ed fields.
2157 MachO::symtab_command Cmd;
2158 Cmd.cmd = MachO::LC_SYMTAB;
2159 Cmd.cmdsize = sizeof(MachO::symtab_command);
2167 MachO::dysymtab_command MachOObjectFile::getDysymtabLoadCommand() const {
2168 if (DysymtabLoadCmd)
2169 return getStruct<MachO::dysymtab_command>(this, DysymtabLoadCmd);
2171 // If there is no DysymtabLoadCmd return a load command with zero'ed fields.
2172 MachO::dysymtab_command Cmd;
2173 Cmd.cmd = MachO::LC_DYSYMTAB;
2174 Cmd.cmdsize = sizeof(MachO::dysymtab_command);
2185 Cmd.extrefsymoff = 0;
2186 Cmd.nextrefsyms = 0;
2187 Cmd.indirectsymoff = 0;
2188 Cmd.nindirectsyms = 0;
2196 MachO::linkedit_data_command
2197 MachOObjectFile::getDataInCodeLoadCommand() const {
2198 if (DataInCodeLoadCmd)
2199 return getStruct<MachO::linkedit_data_command>(this, DataInCodeLoadCmd);
2201 // If there is no DataInCodeLoadCmd return a load command with zero'ed fields.
2202 MachO::linkedit_data_command Cmd;
2203 Cmd.cmd = MachO::LC_DATA_IN_CODE;
2204 Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
2210 MachO::linkedit_data_command
2211 MachOObjectFile::getLinkOptHintsLoadCommand() const {
2212 if (LinkOptHintsLoadCmd)
2213 return getStruct<MachO::linkedit_data_command>(this, LinkOptHintsLoadCmd);
2215 // If there is no LinkOptHintsLoadCmd return a load command with zero'ed
2217 MachO::linkedit_data_command Cmd;
2218 Cmd.cmd = MachO::LC_LINKER_OPTIMIZATION_HINT;
2219 Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
2225 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoRebaseOpcodes() const {
2226 if (!DyldInfoLoadCmd)
2229 MachO::dyld_info_command DyldInfo =
2230 getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
2231 const uint8_t *Ptr =
2232 reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.rebase_off));
2233 return makeArrayRef(Ptr, DyldInfo.rebase_size);
2236 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoBindOpcodes() const {
2237 if (!DyldInfoLoadCmd)
2240 MachO::dyld_info_command DyldInfo =
2241 getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
2242 const uint8_t *Ptr =
2243 reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.bind_off));
2244 return makeArrayRef(Ptr, DyldInfo.bind_size);
2247 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoWeakBindOpcodes() const {
2248 if (!DyldInfoLoadCmd)
2251 MachO::dyld_info_command DyldInfo =
2252 getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
2253 const uint8_t *Ptr =
2254 reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.weak_bind_off));
2255 return makeArrayRef(Ptr, DyldInfo.weak_bind_size);
2258 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoLazyBindOpcodes() const {
2259 if (!DyldInfoLoadCmd)
2262 MachO::dyld_info_command DyldInfo =
2263 getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
2264 const uint8_t *Ptr =
2265 reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.lazy_bind_off));
2266 return makeArrayRef(Ptr, DyldInfo.lazy_bind_size);
2269 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoExportsTrie() const {
2270 if (!DyldInfoLoadCmd)
2273 MachO::dyld_info_command DyldInfo =
2274 getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
2275 const uint8_t *Ptr =
2276 reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.export_off));
2277 return makeArrayRef(Ptr, DyldInfo.export_size);
2280 ArrayRef<uint8_t> MachOObjectFile::getUuid() const {
2283 // Returning a pointer is fine as uuid doesn't need endian swapping.
2284 const char *Ptr = UuidLoadCmd + offsetof(MachO::uuid_command, uuid);
2285 return makeArrayRef(reinterpret_cast<const uint8_t *>(Ptr), 16);
2288 StringRef MachOObjectFile::getStringTableData() const {
2289 MachO::symtab_command S = getSymtabLoadCommand();
2290 return getData().substr(S.stroff, S.strsize);
2293 bool MachOObjectFile::is64Bit() const {
2294 return getType() == getMachOType(false, true) ||
2295 getType() == getMachOType(true, true);
2298 void MachOObjectFile::ReadULEB128s(uint64_t Index,
2299 SmallVectorImpl<uint64_t> &Out) const {
2300 DataExtractor extractor(ObjectFile::getData(), true, 0);
2302 uint32_t offset = Index;
2304 while (uint64_t delta = extractor.getULEB128(&offset)) {
2306 Out.push_back(data);
2310 bool MachOObjectFile::isRelocatableObject() const {
2311 return getHeader().filetype == MachO::MH_OBJECT;
2314 ErrorOr<std::unique_ptr<MachOObjectFile>>
2315 ObjectFile::createMachOObjectFile(MemoryBufferRef Buffer) {
2316 StringRef Magic = Buffer.getBuffer().slice(0, 4);
2318 std::unique_ptr<MachOObjectFile> Ret;
2319 if (Magic == "\xFE\xED\xFA\xCE")
2320 Ret.reset(new MachOObjectFile(Buffer, false, false, EC));
2321 else if (Magic == "\xCE\xFA\xED\xFE")
2322 Ret.reset(new MachOObjectFile(Buffer, true, false, EC));
2323 else if (Magic == "\xFE\xED\xFA\xCF")
2324 Ret.reset(new MachOObjectFile(Buffer, false, true, EC));
2325 else if (Magic == "\xCF\xFA\xED\xFE")
2326 Ret.reset(new MachOObjectFile(Buffer, true, true, EC));
2328 return object_error::parse_failed;
2332 return std::move(Ret);