1 //===- MachOObjectFile.cpp - Mach-O object file binding -------------------===//
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/ArrayRef.h"
16 #include "llvm/ADT/None.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/ADT/StringSwitch.h"
21 #include "llvm/ADT/Triple.h"
22 #include "llvm/ADT/Twine.h"
23 #include "llvm/BinaryFormat/MachO.h"
24 #include "llvm/Object/Error.h"
25 #include "llvm/Object/MachO.h"
26 #include "llvm/Object/ObjectFile.h"
27 #include "llvm/Object/SymbolicFile.h"
28 #include "llvm/Support/DataExtractor.h"
29 #include "llvm/Support/Debug.h"
30 #include "llvm/Support/Error.h"
31 #include "llvm/Support/ErrorHandling.h"
32 #include "llvm/Support/Format.h"
33 #include "llvm/Support/Host.h"
34 #include "llvm/Support/LEB128.h"
35 #include "llvm/Support/MemoryBuffer.h"
36 #include "llvm/Support/SwapByteOrder.h"
37 #include "llvm/Support/raw_ostream.h"
47 #include <system_error>
50 using namespace object;
59 } // end anonymous namespace
61 static Error malformedError(const Twine &Msg) {
62 return make_error<GenericBinaryError>("truncated or malformed object (" +
64 object_error::parse_failed);
67 // FIXME: Replace all uses of this function with getStructOrErr.
69 static T getStruct(const MachOObjectFile &O, const char *P) {
70 // Don't read before the beginning or past the end of the file
71 if (P < O.getData().begin() || P + sizeof(T) > O.getData().end())
72 report_fatal_error("Malformed MachO file.");
75 memcpy(&Cmd, P, sizeof(T));
76 if (O.isLittleEndian() != sys::IsLittleEndianHost)
77 MachO::swapStruct(Cmd);
82 static Expected<T> getStructOrErr(const MachOObjectFile &O, const char *P) {
83 // Don't read before the beginning or past the end of the file
84 if (P < O.getData().begin() || P + sizeof(T) > O.getData().end())
85 return malformedError("Structure read out-of-range");
88 memcpy(&Cmd, P, sizeof(T));
89 if (O.isLittleEndian() != sys::IsLittleEndianHost)
90 MachO::swapStruct(Cmd);
95 getSectionPtr(const MachOObjectFile &O, MachOObjectFile::LoadCommandInfo L,
97 uintptr_t CommandAddr = reinterpret_cast<uintptr_t>(L.Ptr);
99 bool Is64 = O.is64Bit();
100 unsigned SegmentLoadSize = Is64 ? sizeof(MachO::segment_command_64) :
101 sizeof(MachO::segment_command);
102 unsigned SectionSize = Is64 ? sizeof(MachO::section_64) :
103 sizeof(MachO::section);
105 uintptr_t SectionAddr = CommandAddr + SegmentLoadSize + Sec * SectionSize;
106 return reinterpret_cast<const char*>(SectionAddr);
109 static const char *getPtr(const MachOObjectFile &O, size_t Offset) {
110 return O.getData().substr(Offset, 1).data();
113 static MachO::nlist_base
114 getSymbolTableEntryBase(const MachOObjectFile &O, DataRefImpl DRI) {
115 const char *P = reinterpret_cast<const char *>(DRI.p);
116 return getStruct<MachO::nlist_base>(O, P);
119 static StringRef parseSegmentOrSectionName(const char *P) {
123 // Not null terminated, so this is a 16 char string.
124 return StringRef(P, 16);
127 static unsigned getCPUType(const MachOObjectFile &O) {
128 return O.getHeader().cputype;
132 getPlainRelocationAddress(const MachO::any_relocation_info &RE) {
137 getScatteredRelocationAddress(const MachO::any_relocation_info &RE) {
138 return RE.r_word0 & 0xffffff;
141 static bool getPlainRelocationPCRel(const MachOObjectFile &O,
142 const MachO::any_relocation_info &RE) {
143 if (O.isLittleEndian())
144 return (RE.r_word1 >> 24) & 1;
145 return (RE.r_word1 >> 7) & 1;
149 getScatteredRelocationPCRel(const MachO::any_relocation_info &RE) {
150 return (RE.r_word0 >> 30) & 1;
153 static unsigned getPlainRelocationLength(const MachOObjectFile &O,
154 const MachO::any_relocation_info &RE) {
155 if (O.isLittleEndian())
156 return (RE.r_word1 >> 25) & 3;
157 return (RE.r_word1 >> 5) & 3;
161 getScatteredRelocationLength(const MachO::any_relocation_info &RE) {
162 return (RE.r_word0 >> 28) & 3;
165 static unsigned getPlainRelocationType(const MachOObjectFile &O,
166 const MachO::any_relocation_info &RE) {
167 if (O.isLittleEndian())
168 return RE.r_word1 >> 28;
169 return RE.r_word1 & 0xf;
172 static uint32_t getSectionFlags(const MachOObjectFile &O,
175 MachO::section_64 Sect = O.getSection64(Sec);
178 MachO::section Sect = O.getSection(Sec);
182 static Expected<MachOObjectFile::LoadCommandInfo>
183 getLoadCommandInfo(const MachOObjectFile &Obj, const char *Ptr,
184 uint32_t LoadCommandIndex) {
185 if (auto CmdOrErr = getStructOrErr<MachO::load_command>(Obj, Ptr)) {
186 if (CmdOrErr->cmdsize + Ptr > Obj.getData().end())
187 return malformedError("load command " + Twine(LoadCommandIndex) +
188 " extends past end of file");
189 if (CmdOrErr->cmdsize < 8)
190 return malformedError("load command " + Twine(LoadCommandIndex) +
191 " with size less than 8 bytes");
192 return MachOObjectFile::LoadCommandInfo({Ptr, *CmdOrErr});
194 return CmdOrErr.takeError();
197 static Expected<MachOObjectFile::LoadCommandInfo>
198 getFirstLoadCommandInfo(const MachOObjectFile &Obj) {
199 unsigned HeaderSize = Obj.is64Bit() ? sizeof(MachO::mach_header_64)
200 : sizeof(MachO::mach_header);
201 if (sizeof(MachO::load_command) > Obj.getHeader().sizeofcmds)
202 return malformedError("load command 0 extends past the end all load "
203 "commands in the file");
204 return getLoadCommandInfo(Obj, getPtr(Obj, HeaderSize), 0);
207 static Expected<MachOObjectFile::LoadCommandInfo>
208 getNextLoadCommandInfo(const MachOObjectFile &Obj, uint32_t LoadCommandIndex,
209 const MachOObjectFile::LoadCommandInfo &L) {
210 unsigned HeaderSize = Obj.is64Bit() ? sizeof(MachO::mach_header_64)
211 : sizeof(MachO::mach_header);
212 if (L.Ptr + L.C.cmdsize + sizeof(MachO::load_command) >
213 Obj.getData().data() + HeaderSize + Obj.getHeader().sizeofcmds)
214 return malformedError("load command " + Twine(LoadCommandIndex + 1) +
215 " extends past the end all load commands in the file");
216 return getLoadCommandInfo(Obj, L.Ptr + L.C.cmdsize, LoadCommandIndex + 1);
219 template <typename T>
220 static void parseHeader(const MachOObjectFile &Obj, T &Header,
222 if (sizeof(T) > Obj.getData().size()) {
223 Err = malformedError("the mach header extends past the end of the "
227 if (auto HeaderOrErr = getStructOrErr<T>(Obj, getPtr(Obj, 0)))
228 Header = *HeaderOrErr;
230 Err = HeaderOrErr.takeError();
233 // This is used to check for overlapping of Mach-O elements.
234 struct MachOElement {
240 static Error checkOverlappingElement(std::list<MachOElement> &Elements,
241 uint64_t Offset, uint64_t Size,
244 return Error::success();
246 for (auto it=Elements.begin() ; it != Elements.end(); ++it) {
248 if ((Offset >= E.Offset && Offset < E.Offset + E.Size) ||
249 (Offset + Size > E.Offset && Offset + Size < E.Offset + E.Size) ||
250 (Offset <= E.Offset && Offset + Size >= E.Offset + E.Size))
251 return malformedError(Twine(Name) + " at offset " + Twine(Offset) +
252 " with a size of " + Twine(Size) + ", overlaps " +
253 E.Name + " at offset " + Twine(E.Offset) + " with "
254 "a size of " + Twine(E.Size));
257 if (nt != Elements.end()) {
259 if (Offset + Size <= N.Offset) {
260 Elements.insert(nt, {Offset, Size, Name});
261 return Error::success();
265 Elements.push_back({Offset, Size, Name});
266 return Error::success();
269 // Parses LC_SEGMENT or LC_SEGMENT_64 load command, adds addresses of all
270 // sections to \param Sections, and optionally sets
271 // \param IsPageZeroSegment to true.
272 template <typename Segment, typename Section>
273 static Error parseSegmentLoadCommand(
274 const MachOObjectFile &Obj, const MachOObjectFile::LoadCommandInfo &Load,
275 SmallVectorImpl<const char *> &Sections, bool &IsPageZeroSegment,
276 uint32_t LoadCommandIndex, const char *CmdName, uint64_t SizeOfHeaders,
277 std::list<MachOElement> &Elements) {
278 const unsigned SegmentLoadSize = sizeof(Segment);
279 if (Load.C.cmdsize < SegmentLoadSize)
280 return malformedError("load command " + Twine(LoadCommandIndex) +
281 " " + CmdName + " cmdsize too small");
282 if (auto SegOrErr = getStructOrErr<Segment>(Obj, Load.Ptr)) {
283 Segment S = SegOrErr.get();
284 const unsigned SectionSize = sizeof(Section);
285 uint64_t FileSize = Obj.getData().size();
286 if (S.nsects > std::numeric_limits<uint32_t>::max() / SectionSize ||
287 S.nsects * SectionSize > Load.C.cmdsize - SegmentLoadSize)
288 return malformedError("load command " + Twine(LoadCommandIndex) +
289 " inconsistent cmdsize in " + CmdName +
290 " for the number of sections");
291 for (unsigned J = 0; J < S.nsects; ++J) {
292 const char *Sec = getSectionPtr(Obj, Load, J);
293 Sections.push_back(Sec);
294 Section s = getStruct<Section>(Obj, Sec);
295 if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
296 Obj.getHeader().filetype != MachO::MH_DSYM &&
297 s.flags != MachO::S_ZEROFILL &&
298 s.flags != MachO::S_THREAD_LOCAL_ZEROFILL &&
300 return malformedError("offset field of section " + Twine(J) + " in " +
301 CmdName + " command " + Twine(LoadCommandIndex) +
302 " extends past the end of the file");
303 if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
304 Obj.getHeader().filetype != MachO::MH_DSYM &&
305 s.flags != MachO::S_ZEROFILL &&
306 s.flags != MachO::S_THREAD_LOCAL_ZEROFILL && S.fileoff == 0 &&
307 s.offset < SizeOfHeaders && s.size != 0)
308 return malformedError("offset field of section " + Twine(J) + " in " +
309 CmdName + " command " + Twine(LoadCommandIndex) +
310 " not past the headers of the file");
311 uint64_t BigSize = s.offset;
313 if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
314 Obj.getHeader().filetype != MachO::MH_DSYM &&
315 s.flags != MachO::S_ZEROFILL &&
316 s.flags != MachO::S_THREAD_LOCAL_ZEROFILL &&
318 return malformedError("offset field plus size field of section " +
319 Twine(J) + " in " + CmdName + " command " +
320 Twine(LoadCommandIndex) +
321 " extends past the end of the file");
322 if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
323 Obj.getHeader().filetype != MachO::MH_DSYM &&
324 s.flags != MachO::S_ZEROFILL &&
325 s.flags != MachO::S_THREAD_LOCAL_ZEROFILL &&
327 return malformedError("size field of section " +
328 Twine(J) + " in " + CmdName + " command " +
329 Twine(LoadCommandIndex) +
330 " greater than the segment");
331 if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
332 Obj.getHeader().filetype != MachO::MH_DSYM && s.size != 0 &&
334 return malformedError("addr field of section " + Twine(J) + " in " +
335 CmdName + " command " + Twine(LoadCommandIndex) +
336 " less than the segment's vmaddr");
339 uint64_t BigEnd = S.vmaddr;
341 if (S.vmsize != 0 && s.size != 0 && BigSize > BigEnd)
342 return malformedError("addr field plus size of section " + Twine(J) +
343 " in " + CmdName + " command " +
344 Twine(LoadCommandIndex) +
345 " greater than than "
346 "the segment's vmaddr plus vmsize");
347 if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
348 Obj.getHeader().filetype != MachO::MH_DSYM &&
349 s.flags != MachO::S_ZEROFILL &&
350 s.flags != MachO::S_THREAD_LOCAL_ZEROFILL)
351 if (Error Err = checkOverlappingElement(Elements, s.offset, s.size,
354 if (s.reloff > FileSize)
355 return malformedError("reloff field of section " + Twine(J) + " in " +
356 CmdName + " command " + Twine(LoadCommandIndex) +
357 " extends past the end of the file");
359 BigSize *= sizeof(struct MachO::relocation_info);
361 if (BigSize > FileSize)
362 return malformedError("reloff field plus nreloc field times sizeof("
363 "struct relocation_info) of section " +
364 Twine(J) + " in " + CmdName + " command " +
365 Twine(LoadCommandIndex) +
366 " extends past the end of the file");
367 if (Error Err = checkOverlappingElement(Elements, s.reloff, s.nreloc *
369 MachO::relocation_info),
370 "section relocation entries"))
373 if (S.fileoff > FileSize)
374 return malformedError("load command " + Twine(LoadCommandIndex) +
375 " fileoff field in " + CmdName +
376 " extends past the end of the file");
377 uint64_t BigSize = S.fileoff;
378 BigSize += S.filesize;
379 if (BigSize > FileSize)
380 return malformedError("load command " + Twine(LoadCommandIndex) +
381 " fileoff field plus filesize field in " +
382 CmdName + " extends past the end of the file");
383 if (S.vmsize != 0 && S.filesize > S.vmsize)
384 return malformedError("load command " + Twine(LoadCommandIndex) +
385 " filesize field in " + CmdName +
386 " greater than vmsize field");
387 IsPageZeroSegment |= StringRef("__PAGEZERO").equals(S.segname);
389 return SegOrErr.takeError();
391 return Error::success();
394 static Error checkSymtabCommand(const MachOObjectFile &Obj,
395 const MachOObjectFile::LoadCommandInfo &Load,
396 uint32_t LoadCommandIndex,
397 const char **SymtabLoadCmd,
398 std::list<MachOElement> &Elements) {
399 if (Load.C.cmdsize < sizeof(MachO::symtab_command))
400 return malformedError("load command " + Twine(LoadCommandIndex) +
401 " LC_SYMTAB cmdsize too small");
402 if (*SymtabLoadCmd != nullptr)
403 return malformedError("more than one LC_SYMTAB command");
404 MachO::symtab_command Symtab =
405 getStruct<MachO::symtab_command>(Obj, Load.Ptr);
406 if (Symtab.cmdsize != sizeof(MachO::symtab_command))
407 return malformedError("LC_SYMTAB command " + Twine(LoadCommandIndex) +
408 " has incorrect cmdsize");
409 uint64_t FileSize = Obj.getData().size();
410 if (Symtab.symoff > FileSize)
411 return malformedError("symoff field of LC_SYMTAB command " +
412 Twine(LoadCommandIndex) + " extends past the end "
414 uint64_t SymtabSize = Symtab.nsyms;
415 const char *struct_nlist_name;
417 SymtabSize *= sizeof(MachO::nlist_64);
418 struct_nlist_name = "struct nlist_64";
420 SymtabSize *= sizeof(MachO::nlist);
421 struct_nlist_name = "struct nlist";
423 uint64_t BigSize = SymtabSize;
424 BigSize += Symtab.symoff;
425 if (BigSize > FileSize)
426 return malformedError("symoff field plus nsyms field times sizeof(" +
427 Twine(struct_nlist_name) + ") of LC_SYMTAB command " +
428 Twine(LoadCommandIndex) + " extends past the end "
430 if (Error Err = checkOverlappingElement(Elements, Symtab.symoff, SymtabSize,
433 if (Symtab.stroff > FileSize)
434 return malformedError("stroff field of LC_SYMTAB command " +
435 Twine(LoadCommandIndex) + " extends past the end "
437 BigSize = Symtab.stroff;
438 BigSize += Symtab.strsize;
439 if (BigSize > FileSize)
440 return malformedError("stroff field plus strsize field of LC_SYMTAB "
441 "command " + Twine(LoadCommandIndex) + " extends "
442 "past the end of the file");
443 if (Error Err = checkOverlappingElement(Elements, Symtab.stroff,
444 Symtab.strsize, "string table"))
446 *SymtabLoadCmd = Load.Ptr;
447 return Error::success();
450 static Error checkDysymtabCommand(const MachOObjectFile &Obj,
451 const MachOObjectFile::LoadCommandInfo &Load,
452 uint32_t LoadCommandIndex,
453 const char **DysymtabLoadCmd,
454 std::list<MachOElement> &Elements) {
455 if (Load.C.cmdsize < sizeof(MachO::dysymtab_command))
456 return malformedError("load command " + Twine(LoadCommandIndex) +
457 " LC_DYSYMTAB cmdsize too small");
458 if (*DysymtabLoadCmd != nullptr)
459 return malformedError("more than one LC_DYSYMTAB command");
460 MachO::dysymtab_command Dysymtab =
461 getStruct<MachO::dysymtab_command>(Obj, Load.Ptr);
462 if (Dysymtab.cmdsize != sizeof(MachO::dysymtab_command))
463 return malformedError("LC_DYSYMTAB command " + Twine(LoadCommandIndex) +
464 " has incorrect cmdsize");
465 uint64_t FileSize = Obj.getData().size();
466 if (Dysymtab.tocoff > FileSize)
467 return malformedError("tocoff field of LC_DYSYMTAB command " +
468 Twine(LoadCommandIndex) + " extends past the end of "
470 uint64_t BigSize = Dysymtab.ntoc;
471 BigSize *= sizeof(MachO::dylib_table_of_contents);
472 BigSize += Dysymtab.tocoff;
473 if (BigSize > FileSize)
474 return malformedError("tocoff field plus ntoc field times sizeof(struct "
475 "dylib_table_of_contents) of LC_DYSYMTAB command " +
476 Twine(LoadCommandIndex) + " extends past the end of "
478 if (Error Err = checkOverlappingElement(Elements, Dysymtab.tocoff,
479 Dysymtab.ntoc * sizeof(struct
480 MachO::dylib_table_of_contents),
481 "table of contents"))
483 if (Dysymtab.modtaboff > FileSize)
484 return malformedError("modtaboff field of LC_DYSYMTAB command " +
485 Twine(LoadCommandIndex) + " extends past the end of "
487 BigSize = Dysymtab.nmodtab;
488 const char *struct_dylib_module_name;
489 uint64_t sizeof_modtab;
491 sizeof_modtab = sizeof(MachO::dylib_module_64);
492 struct_dylib_module_name = "struct dylib_module_64";
494 sizeof_modtab = sizeof(MachO::dylib_module);
495 struct_dylib_module_name = "struct dylib_module";
497 BigSize *= sizeof_modtab;
498 BigSize += Dysymtab.modtaboff;
499 if (BigSize > FileSize)
500 return malformedError("modtaboff field plus nmodtab field times sizeof(" +
501 Twine(struct_dylib_module_name) + ") of LC_DYSYMTAB "
502 "command " + Twine(LoadCommandIndex) + " extends "
503 "past the end of the file");
504 if (Error Err = checkOverlappingElement(Elements, Dysymtab.modtaboff,
505 Dysymtab.nmodtab * sizeof_modtab,
508 if (Dysymtab.extrefsymoff > FileSize)
509 return malformedError("extrefsymoff field of LC_DYSYMTAB command " +
510 Twine(LoadCommandIndex) + " extends past the end of "
512 BigSize = Dysymtab.nextrefsyms;
513 BigSize *= sizeof(MachO::dylib_reference);
514 BigSize += Dysymtab.extrefsymoff;
515 if (BigSize > FileSize)
516 return malformedError("extrefsymoff field plus nextrefsyms field times "
517 "sizeof(struct dylib_reference) of LC_DYSYMTAB "
518 "command " + Twine(LoadCommandIndex) + " extends "
519 "past the end of the file");
520 if (Error Err = checkOverlappingElement(Elements, Dysymtab.extrefsymoff,
521 Dysymtab.nextrefsyms *
522 sizeof(MachO::dylib_reference),
525 if (Dysymtab.indirectsymoff > FileSize)
526 return malformedError("indirectsymoff field of LC_DYSYMTAB command " +
527 Twine(LoadCommandIndex) + " extends past the end of "
529 BigSize = Dysymtab.nindirectsyms;
530 BigSize *= sizeof(uint32_t);
531 BigSize += Dysymtab.indirectsymoff;
532 if (BigSize > FileSize)
533 return malformedError("indirectsymoff field plus nindirectsyms field times "
534 "sizeof(uint32_t) of LC_DYSYMTAB command " +
535 Twine(LoadCommandIndex) + " extends past the end of "
537 if (Error Err = checkOverlappingElement(Elements, Dysymtab.indirectsymoff,
538 Dysymtab.nindirectsyms *
542 if (Dysymtab.extreloff > FileSize)
543 return malformedError("extreloff field of LC_DYSYMTAB command " +
544 Twine(LoadCommandIndex) + " extends past the end of "
546 BigSize = Dysymtab.nextrel;
547 BigSize *= sizeof(MachO::relocation_info);
548 BigSize += Dysymtab.extreloff;
549 if (BigSize > FileSize)
550 return malformedError("extreloff field plus nextrel field times sizeof"
551 "(struct relocation_info) of LC_DYSYMTAB command " +
552 Twine(LoadCommandIndex) + " extends past the end of "
554 if (Error Err = checkOverlappingElement(Elements, Dysymtab.extreloff,
556 sizeof(MachO::relocation_info),
557 "external relocation table"))
559 if (Dysymtab.locreloff > FileSize)
560 return malformedError("locreloff field of LC_DYSYMTAB command " +
561 Twine(LoadCommandIndex) + " extends past the end of "
563 BigSize = Dysymtab.nlocrel;
564 BigSize *= sizeof(MachO::relocation_info);
565 BigSize += Dysymtab.locreloff;
566 if (BigSize > FileSize)
567 return malformedError("locreloff field plus nlocrel field times sizeof"
568 "(struct relocation_info) of LC_DYSYMTAB command " +
569 Twine(LoadCommandIndex) + " extends past the end of "
571 if (Error Err = checkOverlappingElement(Elements, Dysymtab.locreloff,
573 sizeof(MachO::relocation_info),
574 "local relocation table"))
576 *DysymtabLoadCmd = Load.Ptr;
577 return Error::success();
580 static Error checkLinkeditDataCommand(const MachOObjectFile &Obj,
581 const MachOObjectFile::LoadCommandInfo &Load,
582 uint32_t LoadCommandIndex,
583 const char **LoadCmd, const char *CmdName,
584 std::list<MachOElement> &Elements,
585 const char *ElementName) {
586 if (Load.C.cmdsize < sizeof(MachO::linkedit_data_command))
587 return malformedError("load command " + Twine(LoadCommandIndex) + " " +
588 CmdName + " cmdsize too small");
589 if (*LoadCmd != nullptr)
590 return malformedError("more than one " + Twine(CmdName) + " command");
591 MachO::linkedit_data_command LinkData =
592 getStruct<MachO::linkedit_data_command>(Obj, Load.Ptr);
593 if (LinkData.cmdsize != sizeof(MachO::linkedit_data_command))
594 return malformedError(Twine(CmdName) + " command " +
595 Twine(LoadCommandIndex) + " has incorrect cmdsize");
596 uint64_t FileSize = Obj.getData().size();
597 if (LinkData.dataoff > FileSize)
598 return malformedError("dataoff field of " + Twine(CmdName) + " command " +
599 Twine(LoadCommandIndex) + " extends past the end of "
601 uint64_t BigSize = LinkData.dataoff;
602 BigSize += LinkData.datasize;
603 if (BigSize > FileSize)
604 return malformedError("dataoff field plus datasize field of " +
605 Twine(CmdName) + " command " +
606 Twine(LoadCommandIndex) + " extends past the end of "
608 if (Error Err = checkOverlappingElement(Elements, LinkData.dataoff,
609 LinkData.datasize, ElementName))
612 return Error::success();
615 static Error checkDyldInfoCommand(const MachOObjectFile &Obj,
616 const MachOObjectFile::LoadCommandInfo &Load,
617 uint32_t LoadCommandIndex,
618 const char **LoadCmd, const char *CmdName,
619 std::list<MachOElement> &Elements) {
620 if (Load.C.cmdsize < sizeof(MachO::dyld_info_command))
621 return malformedError("load command " + Twine(LoadCommandIndex) + " " +
622 CmdName + " cmdsize too small");
623 if (*LoadCmd != nullptr)
624 return malformedError("more than one LC_DYLD_INFO and or LC_DYLD_INFO_ONLY "
626 MachO::dyld_info_command DyldInfo =
627 getStruct<MachO::dyld_info_command>(Obj, Load.Ptr);
628 if (DyldInfo.cmdsize != sizeof(MachO::dyld_info_command))
629 return malformedError(Twine(CmdName) + " command " +
630 Twine(LoadCommandIndex) + " has incorrect cmdsize");
631 uint64_t FileSize = Obj.getData().size();
632 if (DyldInfo.rebase_off > FileSize)
633 return malformedError("rebase_off field of " + Twine(CmdName) +
634 " command " + Twine(LoadCommandIndex) + " extends "
635 "past the end of the file");
636 uint64_t BigSize = DyldInfo.rebase_off;
637 BigSize += DyldInfo.rebase_size;
638 if (BigSize > FileSize)
639 return malformedError("rebase_off field plus rebase_size field of " +
640 Twine(CmdName) + " command " +
641 Twine(LoadCommandIndex) + " extends past the end of "
643 if (Error Err = checkOverlappingElement(Elements, DyldInfo.rebase_off,
644 DyldInfo.rebase_size,
647 if (DyldInfo.bind_off > FileSize)
648 return malformedError("bind_off field of " + Twine(CmdName) +
649 " command " + Twine(LoadCommandIndex) + " extends "
650 "past the end of the file");
651 BigSize = DyldInfo.bind_off;
652 BigSize += DyldInfo.bind_size;
653 if (BigSize > FileSize)
654 return malformedError("bind_off field plus bind_size field of " +
655 Twine(CmdName) + " command " +
656 Twine(LoadCommandIndex) + " extends past the end of "
658 if (Error Err = checkOverlappingElement(Elements, DyldInfo.bind_off,
662 if (DyldInfo.weak_bind_off > FileSize)
663 return malformedError("weak_bind_off field of " + Twine(CmdName) +
664 " command " + Twine(LoadCommandIndex) + " extends "
665 "past the end of the file");
666 BigSize = DyldInfo.weak_bind_off;
667 BigSize += DyldInfo.weak_bind_size;
668 if (BigSize > FileSize)
669 return malformedError("weak_bind_off field plus weak_bind_size field of " +
670 Twine(CmdName) + " command " +
671 Twine(LoadCommandIndex) + " extends past the end of "
673 if (Error Err = checkOverlappingElement(Elements, DyldInfo.weak_bind_off,
674 DyldInfo.weak_bind_size,
675 "dyld weak bind info"))
677 if (DyldInfo.lazy_bind_off > FileSize)
678 return malformedError("lazy_bind_off field of " + Twine(CmdName) +
679 " command " + Twine(LoadCommandIndex) + " extends "
680 "past the end of the file");
681 BigSize = DyldInfo.lazy_bind_off;
682 BigSize += DyldInfo.lazy_bind_size;
683 if (BigSize > FileSize)
684 return malformedError("lazy_bind_off field plus lazy_bind_size field of " +
685 Twine(CmdName) + " command " +
686 Twine(LoadCommandIndex) + " extends past the end of "
688 if (Error Err = checkOverlappingElement(Elements, DyldInfo.lazy_bind_off,
689 DyldInfo.lazy_bind_size,
690 "dyld lazy bind info"))
692 if (DyldInfo.export_off > FileSize)
693 return malformedError("export_off field of " + Twine(CmdName) +
694 " command " + Twine(LoadCommandIndex) + " extends "
695 "past the end of the file");
696 BigSize = DyldInfo.export_off;
697 BigSize += DyldInfo.export_size;
698 if (BigSize > FileSize)
699 return malformedError("export_off field plus export_size field of " +
700 Twine(CmdName) + " command " +
701 Twine(LoadCommandIndex) + " extends past the end of "
703 if (Error Err = checkOverlappingElement(Elements, DyldInfo.export_off,
704 DyldInfo.export_size,
708 return Error::success();
711 static Error checkDylibCommand(const MachOObjectFile &Obj,
712 const MachOObjectFile::LoadCommandInfo &Load,
713 uint32_t LoadCommandIndex, const char *CmdName) {
714 if (Load.C.cmdsize < sizeof(MachO::dylib_command))
715 return malformedError("load command " + Twine(LoadCommandIndex) + " " +
716 CmdName + " cmdsize too small");
717 MachO::dylib_command D = getStruct<MachO::dylib_command>(Obj, Load.Ptr);
718 if (D.dylib.name < sizeof(MachO::dylib_command))
719 return malformedError("load command " + Twine(LoadCommandIndex) + " " +
720 CmdName + " name.offset field too small, not past "
721 "the end of the dylib_command struct");
722 if (D.dylib.name >= D.cmdsize)
723 return malformedError("load command " + Twine(LoadCommandIndex) + " " +
724 CmdName + " name.offset field extends past the end "
725 "of the load command");
726 // Make sure there is a null between the starting offset of the name and
727 // the end of the load command.
729 const char *P = (const char *)Load.Ptr;
730 for (i = D.dylib.name; i < D.cmdsize; i++)
734 return malformedError("load command " + Twine(LoadCommandIndex) + " " +
735 CmdName + " library name extends past the end of the "
737 return Error::success();
740 static Error checkDylibIdCommand(const MachOObjectFile &Obj,
741 const MachOObjectFile::LoadCommandInfo &Load,
742 uint32_t LoadCommandIndex,
743 const char **LoadCmd) {
744 if (Error Err = checkDylibCommand(Obj, Load, LoadCommandIndex,
747 if (*LoadCmd != nullptr)
748 return malformedError("more than one LC_ID_DYLIB command");
749 if (Obj.getHeader().filetype != MachO::MH_DYLIB &&
750 Obj.getHeader().filetype != MachO::MH_DYLIB_STUB)
751 return malformedError("LC_ID_DYLIB load command in non-dynamic library "
754 return Error::success();
757 static Error checkDyldCommand(const MachOObjectFile &Obj,
758 const MachOObjectFile::LoadCommandInfo &Load,
759 uint32_t LoadCommandIndex, const char *CmdName) {
760 if (Load.C.cmdsize < sizeof(MachO::dylinker_command))
761 return malformedError("load command " + Twine(LoadCommandIndex) + " " +
762 CmdName + " cmdsize too small");
763 MachO::dylinker_command D = getStruct<MachO::dylinker_command>(Obj, Load.Ptr);
764 if (D.name < sizeof(MachO::dylinker_command))
765 return malformedError("load command " + Twine(LoadCommandIndex) + " " +
766 CmdName + " name.offset field too small, not past "
767 "the end of the dylinker_command struct");
768 if (D.name >= D.cmdsize)
769 return malformedError("load command " + Twine(LoadCommandIndex) + " " +
770 CmdName + " name.offset field extends past the end "
771 "of the load command");
772 // Make sure there is a null between the starting offset of the name and
773 // the end of the load command.
775 const char *P = (const char *)Load.Ptr;
776 for (i = D.name; i < D.cmdsize; i++)
780 return malformedError("load command " + Twine(LoadCommandIndex) + " " +
781 CmdName + " dyld name extends past the end of the "
783 return Error::success();
786 static Error checkVersCommand(const MachOObjectFile &Obj,
787 const MachOObjectFile::LoadCommandInfo &Load,
788 uint32_t LoadCommandIndex,
789 const char **LoadCmd, const char *CmdName) {
790 if (Load.C.cmdsize != sizeof(MachO::version_min_command))
791 return malformedError("load command " + Twine(LoadCommandIndex) + " " +
792 CmdName + " has incorrect cmdsize");
793 if (*LoadCmd != nullptr)
794 return malformedError("more than one LC_VERSION_MIN_MACOSX, "
795 "LC_VERSION_MIN_IPHONEOS, LC_VERSION_MIN_TVOS or "
796 "LC_VERSION_MIN_WATCHOS command");
798 return Error::success();
801 static Error checkNoteCommand(const MachOObjectFile &Obj,
802 const MachOObjectFile::LoadCommandInfo &Load,
803 uint32_t LoadCommandIndex,
804 std::list<MachOElement> &Elements) {
805 if (Load.C.cmdsize != sizeof(MachO::note_command))
806 return malformedError("load command " + Twine(LoadCommandIndex) +
807 " LC_NOTE has incorrect cmdsize");
808 MachO::note_command Nt = getStruct<MachO::note_command>(Obj, Load.Ptr);
809 uint64_t FileSize = Obj.getData().size();
810 if (Nt.offset > FileSize)
811 return malformedError("offset field of LC_NOTE command " +
812 Twine(LoadCommandIndex) + " extends "
813 "past the end of the file");
814 uint64_t BigSize = Nt.offset;
816 if (BigSize > FileSize)
817 return malformedError("size field plus offset field of LC_NOTE command " +
818 Twine(LoadCommandIndex) + " extends past the end of "
820 if (Error Err = checkOverlappingElement(Elements, Nt.offset, Nt.size,
823 return Error::success();
827 parseBuildVersionCommand(const MachOObjectFile &Obj,
828 const MachOObjectFile::LoadCommandInfo &Load,
829 SmallVectorImpl<const char*> &BuildTools,
830 uint32_t LoadCommandIndex) {
831 MachO::build_version_command BVC =
832 getStruct<MachO::build_version_command>(Obj, Load.Ptr);
833 if (Load.C.cmdsize !=
834 sizeof(MachO::build_version_command) +
835 BVC.ntools * sizeof(MachO::build_tool_version))
836 return malformedError("load command " + Twine(LoadCommandIndex) +
837 " LC_BUILD_VERSION_COMMAND has incorrect cmdsize");
839 auto Start = Load.Ptr + sizeof(MachO::build_version_command);
840 BuildTools.resize(BVC.ntools);
841 for (unsigned i = 0; i < BVC.ntools; ++i)
842 BuildTools[i] = Start + i * sizeof(MachO::build_tool_version);
844 return Error::success();
847 static Error checkRpathCommand(const MachOObjectFile &Obj,
848 const MachOObjectFile::LoadCommandInfo &Load,
849 uint32_t LoadCommandIndex) {
850 if (Load.C.cmdsize < sizeof(MachO::rpath_command))
851 return malformedError("load command " + Twine(LoadCommandIndex) +
852 " LC_RPATH cmdsize too small");
853 MachO::rpath_command R = getStruct<MachO::rpath_command>(Obj, Load.Ptr);
854 if (R.path < sizeof(MachO::rpath_command))
855 return malformedError("load command " + Twine(LoadCommandIndex) +
856 " LC_RPATH path.offset field too small, not past "
857 "the end of the rpath_command struct");
858 if (R.path >= R.cmdsize)
859 return malformedError("load command " + Twine(LoadCommandIndex) +
860 " LC_RPATH path.offset field extends past the end "
861 "of the load command");
862 // Make sure there is a null between the starting offset of the path and
863 // the end of the load command.
865 const char *P = (const char *)Load.Ptr;
866 for (i = R.path; i < R.cmdsize; i++)
870 return malformedError("load command " + Twine(LoadCommandIndex) +
871 " LC_RPATH library name extends past the end of the "
873 return Error::success();
876 static Error checkEncryptCommand(const MachOObjectFile &Obj,
877 const MachOObjectFile::LoadCommandInfo &Load,
878 uint32_t LoadCommandIndex,
879 uint64_t cryptoff, uint64_t cryptsize,
880 const char **LoadCmd, const char *CmdName) {
881 if (*LoadCmd != nullptr)
882 return malformedError("more than one LC_ENCRYPTION_INFO and or "
883 "LC_ENCRYPTION_INFO_64 command");
884 uint64_t FileSize = Obj.getData().size();
885 if (cryptoff > FileSize)
886 return malformedError("cryptoff field of " + Twine(CmdName) +
887 " command " + Twine(LoadCommandIndex) + " extends "
888 "past the end of the file");
889 uint64_t BigSize = cryptoff;
890 BigSize += cryptsize;
891 if (BigSize > FileSize)
892 return malformedError("cryptoff field plus cryptsize field of " +
893 Twine(CmdName) + " command " +
894 Twine(LoadCommandIndex) + " extends past the end of "
897 return Error::success();
900 static Error checkLinkerOptCommand(const MachOObjectFile &Obj,
901 const MachOObjectFile::LoadCommandInfo &Load,
902 uint32_t LoadCommandIndex) {
903 if (Load.C.cmdsize < sizeof(MachO::linker_option_command))
904 return malformedError("load command " + Twine(LoadCommandIndex) +
905 " LC_LINKER_OPTION cmdsize too small");
906 MachO::linker_option_command L =
907 getStruct<MachO::linker_option_command>(Obj, Load.Ptr);
908 // Make sure the count of strings is correct.
909 const char *string = (const char *)Load.Ptr +
910 sizeof(struct MachO::linker_option_command);
911 uint32_t left = L.cmdsize - sizeof(struct MachO::linker_option_command);
914 while (*string == '\0' && left > 0) {
920 uint32_t NullPos = StringRef(string, left).find('\0');
921 uint32_t len = std::min(NullPos, left) + 1;
927 return malformedError("load command " + Twine(LoadCommandIndex) +
928 " LC_LINKER_OPTION string count " + Twine(L.count) +
929 " does not match number of strings");
930 return Error::success();
933 static Error checkSubCommand(const MachOObjectFile &Obj,
934 const MachOObjectFile::LoadCommandInfo &Load,
935 uint32_t LoadCommandIndex, const char *CmdName,
936 size_t SizeOfCmd, const char *CmdStructName,
937 uint32_t PathOffset, const char *PathFieldName) {
938 if (PathOffset < SizeOfCmd)
939 return malformedError("load command " + Twine(LoadCommandIndex) + " " +
940 CmdName + " " + PathFieldName + ".offset field too "
941 "small, not past the end of the " + CmdStructName);
942 if (PathOffset >= Load.C.cmdsize)
943 return malformedError("load command " + Twine(LoadCommandIndex) + " " +
944 CmdName + " " + PathFieldName + ".offset field "
945 "extends past the end of the load command");
946 // Make sure there is a null between the starting offset of the path and
947 // the end of the load command.
949 const char *P = (const char *)Load.Ptr;
950 for (i = PathOffset; i < Load.C.cmdsize; i++)
953 if (i >= Load.C.cmdsize)
954 return malformedError("load command " + Twine(LoadCommandIndex) + " " +
955 CmdName + " " + PathFieldName + " name extends past "
956 "the end of the load command");
957 return Error::success();
960 static Error checkThreadCommand(const MachOObjectFile &Obj,
961 const MachOObjectFile::LoadCommandInfo &Load,
962 uint32_t LoadCommandIndex,
963 const char *CmdName) {
964 if (Load.C.cmdsize < sizeof(MachO::thread_command))
965 return malformedError("load command " + Twine(LoadCommandIndex) +
966 CmdName + " cmdsize too small");
967 MachO::thread_command T =
968 getStruct<MachO::thread_command>(Obj, Load.Ptr);
969 const char *state = Load.Ptr + sizeof(MachO::thread_command);
970 const char *end = Load.Ptr + T.cmdsize;
971 uint32_t nflavor = 0;
972 uint32_t cputype = getCPUType(Obj);
973 while (state < end) {
974 if(state + sizeof(uint32_t) > end)
975 return malformedError("load command " + Twine(LoadCommandIndex) +
976 "flavor in " + CmdName + " extends past end of "
979 memcpy(&flavor, state, sizeof(uint32_t));
980 if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
981 sys::swapByteOrder(flavor);
982 state += sizeof(uint32_t);
984 if(state + sizeof(uint32_t) > end)
985 return malformedError("load command " + Twine(LoadCommandIndex) +
986 " count in " + CmdName + " extends past end of "
989 memcpy(&count, state, sizeof(uint32_t));
990 if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
991 sys::swapByteOrder(count);
992 state += sizeof(uint32_t);
994 if (cputype == MachO::CPU_TYPE_I386) {
995 if (flavor == MachO::x86_THREAD_STATE32) {
996 if (count != MachO::x86_THREAD_STATE32_COUNT)
997 return malformedError("load command " + Twine(LoadCommandIndex) +
998 " count not x86_THREAD_STATE32_COUNT for "
999 "flavor number " + Twine(nflavor) + " which is "
1000 "a x86_THREAD_STATE32 flavor in " + CmdName +
1002 if (state + sizeof(MachO::x86_thread_state32_t) > end)
1003 return malformedError("load command " + Twine(LoadCommandIndex) +
1004 " x86_THREAD_STATE32 extends past end of "
1005 "command in " + CmdName + " command");
1006 state += sizeof(MachO::x86_thread_state32_t);
1008 return malformedError("load command " + Twine(LoadCommandIndex) +
1009 " unknown flavor (" + Twine(flavor) + ") for "
1010 "flavor number " + Twine(nflavor) + " in " +
1011 CmdName + " command");
1013 } else if (cputype == MachO::CPU_TYPE_X86_64) {
1014 if (flavor == MachO::x86_THREAD_STATE64) {
1015 if (count != MachO::x86_THREAD_STATE64_COUNT)
1016 return malformedError("load command " + Twine(LoadCommandIndex) +
1017 " count not x86_THREAD_STATE64_COUNT for "
1018 "flavor number " + Twine(nflavor) + " which is "
1019 "a x86_THREAD_STATE64 flavor in " + CmdName +
1021 if (state + sizeof(MachO::x86_thread_state64_t) > end)
1022 return malformedError("load command " + Twine(LoadCommandIndex) +
1023 " x86_THREAD_STATE64 extends past end of "
1024 "command in " + CmdName + " command");
1025 state += sizeof(MachO::x86_thread_state64_t);
1027 return malformedError("load command " + Twine(LoadCommandIndex) +
1028 " unknown flavor (" + Twine(flavor) + ") for "
1029 "flavor number " + Twine(nflavor) + " in " +
1030 CmdName + " command");
1032 } else if (cputype == MachO::CPU_TYPE_ARM) {
1033 if (flavor == MachO::ARM_THREAD_STATE) {
1034 if (count != MachO::ARM_THREAD_STATE_COUNT)
1035 return malformedError("load command " + Twine(LoadCommandIndex) +
1036 " count not ARM_THREAD_STATE_COUNT for "
1037 "flavor number " + Twine(nflavor) + " which is "
1038 "a ARM_THREAD_STATE flavor in " + CmdName +
1040 if (state + sizeof(MachO::arm_thread_state32_t) > end)
1041 return malformedError("load command " + Twine(LoadCommandIndex) +
1042 " ARM_THREAD_STATE extends past end of "
1043 "command in " + CmdName + " command");
1044 state += sizeof(MachO::arm_thread_state32_t);
1046 return malformedError("load command " + Twine(LoadCommandIndex) +
1047 " unknown flavor (" + Twine(flavor) + ") for "
1048 "flavor number " + Twine(nflavor) + " in " +
1049 CmdName + " command");
1051 } else if (cputype == MachO::CPU_TYPE_ARM64) {
1052 if (flavor == MachO::ARM_THREAD_STATE64) {
1053 if (count != MachO::ARM_THREAD_STATE64_COUNT)
1054 return malformedError("load command " + Twine(LoadCommandIndex) +
1055 " count not ARM_THREAD_STATE64_COUNT for "
1056 "flavor number " + Twine(nflavor) + " which is "
1057 "a ARM_THREAD_STATE64 flavor in " + CmdName +
1059 if (state + sizeof(MachO::arm_thread_state64_t) > end)
1060 return malformedError("load command " + Twine(LoadCommandIndex) +
1061 " ARM_THREAD_STATE64 extends past end of "
1062 "command in " + CmdName + " command");
1063 state += sizeof(MachO::arm_thread_state64_t);
1065 return malformedError("load command " + Twine(LoadCommandIndex) +
1066 " unknown flavor (" + Twine(flavor) + ") for "
1067 "flavor number " + Twine(nflavor) + " in " +
1068 CmdName + " command");
1070 } else if (cputype == MachO::CPU_TYPE_POWERPC) {
1071 if (flavor == MachO::PPC_THREAD_STATE) {
1072 if (count != MachO::PPC_THREAD_STATE_COUNT)
1073 return malformedError("load command " + Twine(LoadCommandIndex) +
1074 " count not PPC_THREAD_STATE_COUNT for "
1075 "flavor number " + Twine(nflavor) + " which is "
1076 "a PPC_THREAD_STATE flavor in " + CmdName +
1078 if (state + sizeof(MachO::ppc_thread_state32_t) > end)
1079 return malformedError("load command " + Twine(LoadCommandIndex) +
1080 " PPC_THREAD_STATE extends past end of "
1081 "command in " + CmdName + " command");
1082 state += sizeof(MachO::ppc_thread_state32_t);
1084 return malformedError("load command " + Twine(LoadCommandIndex) +
1085 " unknown flavor (" + Twine(flavor) + ") for "
1086 "flavor number " + Twine(nflavor) + " in " +
1087 CmdName + " command");
1090 return malformedError("unknown cputype (" + Twine(cputype) + ") load "
1091 "command " + Twine(LoadCommandIndex) + " for " +
1092 CmdName + " command can't be checked");
1096 return Error::success();
1099 static Error checkTwoLevelHintsCommand(const MachOObjectFile &Obj,
1100 const MachOObjectFile::LoadCommandInfo
1102 uint32_t LoadCommandIndex,
1103 const char **LoadCmd,
1104 std::list<MachOElement> &Elements) {
1105 if (Load.C.cmdsize != sizeof(MachO::twolevel_hints_command))
1106 return malformedError("load command " + Twine(LoadCommandIndex) +
1107 " LC_TWOLEVEL_HINTS has incorrect cmdsize");
1108 if (*LoadCmd != nullptr)
1109 return malformedError("more than one LC_TWOLEVEL_HINTS command");
1110 MachO::twolevel_hints_command Hints =
1111 getStruct<MachO::twolevel_hints_command>(Obj, Load.Ptr);
1112 uint64_t FileSize = Obj.getData().size();
1113 if (Hints.offset > FileSize)
1114 return malformedError("offset field of LC_TWOLEVEL_HINTS command " +
1115 Twine(LoadCommandIndex) + " extends past the end of "
1117 uint64_t BigSize = Hints.nhints;
1118 BigSize *= sizeof(MachO::twolevel_hint);
1119 BigSize += Hints.offset;
1120 if (BigSize > FileSize)
1121 return malformedError("offset field plus nhints times sizeof(struct "
1122 "twolevel_hint) field of LC_TWOLEVEL_HINTS command " +
1123 Twine(LoadCommandIndex) + " extends past the end of "
1125 if (Error Err = checkOverlappingElement(Elements, Hints.offset, Hints.nhints *
1126 sizeof(MachO::twolevel_hint),
1129 *LoadCmd = Load.Ptr;
1130 return Error::success();
1133 // Returns true if the libObject code does not support the load command and its
1134 // contents. The cmd value it is treated as an unknown load command but with
1135 // an error message that says the cmd value is obsolete.
1136 static bool isLoadCommandObsolete(uint32_t cmd) {
1137 if (cmd == MachO::LC_SYMSEG ||
1138 cmd == MachO::LC_LOADFVMLIB ||
1139 cmd == MachO::LC_IDFVMLIB ||
1140 cmd == MachO::LC_IDENT ||
1141 cmd == MachO::LC_FVMFILE ||
1142 cmd == MachO::LC_PREPAGE ||
1143 cmd == MachO::LC_PREBOUND_DYLIB ||
1144 cmd == MachO::LC_TWOLEVEL_HINTS ||
1145 cmd == MachO::LC_PREBIND_CKSUM)
1150 Expected<std::unique_ptr<MachOObjectFile>>
1151 MachOObjectFile::create(MemoryBufferRef Object, bool IsLittleEndian,
1152 bool Is64Bits, uint32_t UniversalCputype,
1153 uint32_t UniversalIndex) {
1154 Error Err = Error::success();
1155 std::unique_ptr<MachOObjectFile> Obj(
1156 new MachOObjectFile(std::move(Object), IsLittleEndian,
1157 Is64Bits, Err, UniversalCputype,
1160 return std::move(Err);
1161 return std::move(Obj);
1164 MachOObjectFile::MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian,
1165 bool Is64bits, Error &Err,
1166 uint32_t UniversalCputype,
1167 uint32_t UniversalIndex)
1168 : ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object) {
1169 ErrorAsOutParameter ErrAsOutParam(&Err);
1170 uint64_t SizeOfHeaders;
1173 parseHeader(*this, Header64, Err);
1174 SizeOfHeaders = sizeof(MachO::mach_header_64);
1175 cputype = Header64.cputype;
1177 parseHeader(*this, Header, Err);
1178 SizeOfHeaders = sizeof(MachO::mach_header);
1179 cputype = Header.cputype;
1183 SizeOfHeaders += getHeader().sizeofcmds;
1184 if (getData().data() + SizeOfHeaders > getData().end()) {
1185 Err = malformedError("load commands extend past the end of the file");
1188 if (UniversalCputype != 0 && cputype != UniversalCputype) {
1189 Err = malformedError("universal header architecture: " +
1190 Twine(UniversalIndex) + "'s cputype does not match "
1191 "object file's mach header");
1194 std::list<MachOElement> Elements;
1195 Elements.push_back({0, SizeOfHeaders, "Mach-O headers"});
1197 uint32_t LoadCommandCount = getHeader().ncmds;
1198 LoadCommandInfo Load;
1199 if (LoadCommandCount != 0) {
1200 if (auto LoadOrErr = getFirstLoadCommandInfo(*this))
1203 Err = LoadOrErr.takeError();
1208 const char *DyldIdLoadCmd = nullptr;
1209 const char *FuncStartsLoadCmd = nullptr;
1210 const char *SplitInfoLoadCmd = nullptr;
1211 const char *CodeSignDrsLoadCmd = nullptr;
1212 const char *CodeSignLoadCmd = nullptr;
1213 const char *VersLoadCmd = nullptr;
1214 const char *SourceLoadCmd = nullptr;
1215 const char *EntryPointLoadCmd = nullptr;
1216 const char *EncryptLoadCmd = nullptr;
1217 const char *RoutinesLoadCmd = nullptr;
1218 const char *UnixThreadLoadCmd = nullptr;
1219 const char *TwoLevelHintsLoadCmd = nullptr;
1220 for (unsigned I = 0; I < LoadCommandCount; ++I) {
1222 if (Load.C.cmdsize % 8 != 0) {
1223 // We have a hack here to allow 64-bit Mach-O core files to have
1224 // LC_THREAD commands that are only a multiple of 4 and not 8 to be
1225 // allowed since the macOS kernel produces them.
1226 if (getHeader().filetype != MachO::MH_CORE ||
1227 Load.C.cmd != MachO::LC_THREAD || Load.C.cmdsize % 4) {
1228 Err = malformedError("load command " + Twine(I) + " cmdsize not a "
1234 if (Load.C.cmdsize % 4 != 0) {
1235 Err = malformedError("load command " + Twine(I) + " cmdsize not a "
1240 LoadCommands.push_back(Load);
1241 if (Load.C.cmd == MachO::LC_SYMTAB) {
1242 if ((Err = checkSymtabCommand(*this, Load, I, &SymtabLoadCmd, Elements)))
1244 } else if (Load.C.cmd == MachO::LC_DYSYMTAB) {
1245 if ((Err = checkDysymtabCommand(*this, Load, I, &DysymtabLoadCmd,
1248 } else if (Load.C.cmd == MachO::LC_DATA_IN_CODE) {
1249 if ((Err = checkLinkeditDataCommand(*this, Load, I, &DataInCodeLoadCmd,
1250 "LC_DATA_IN_CODE", Elements,
1251 "data in code info")))
1253 } else if (Load.C.cmd == MachO::LC_LINKER_OPTIMIZATION_HINT) {
1254 if ((Err = checkLinkeditDataCommand(*this, Load, I, &LinkOptHintsLoadCmd,
1255 "LC_LINKER_OPTIMIZATION_HINT",
1256 Elements, "linker optimization "
1259 } else if (Load.C.cmd == MachO::LC_FUNCTION_STARTS) {
1260 if ((Err = checkLinkeditDataCommand(*this, Load, I, &FuncStartsLoadCmd,
1261 "LC_FUNCTION_STARTS", Elements,
1262 "function starts data")))
1264 } else if (Load.C.cmd == MachO::LC_SEGMENT_SPLIT_INFO) {
1265 if ((Err = checkLinkeditDataCommand(*this, Load, I, &SplitInfoLoadCmd,
1266 "LC_SEGMENT_SPLIT_INFO", Elements,
1267 "split info data")))
1269 } else if (Load.C.cmd == MachO::LC_DYLIB_CODE_SIGN_DRS) {
1270 if ((Err = checkLinkeditDataCommand(*this, Load, I, &CodeSignDrsLoadCmd,
1271 "LC_DYLIB_CODE_SIGN_DRS", Elements,
1272 "code signing RDs data")))
1274 } else if (Load.C.cmd == MachO::LC_CODE_SIGNATURE) {
1275 if ((Err = checkLinkeditDataCommand(*this, Load, I, &CodeSignLoadCmd,
1276 "LC_CODE_SIGNATURE", Elements,
1277 "code signature data")))
1279 } else if (Load.C.cmd == MachO::LC_DYLD_INFO) {
1280 if ((Err = checkDyldInfoCommand(*this, Load, I, &DyldInfoLoadCmd,
1281 "LC_DYLD_INFO", Elements)))
1283 } else if (Load.C.cmd == MachO::LC_DYLD_INFO_ONLY) {
1284 if ((Err = checkDyldInfoCommand(*this, Load, I, &DyldInfoLoadCmd,
1285 "LC_DYLD_INFO_ONLY", Elements)))
1287 } else if (Load.C.cmd == MachO::LC_UUID) {
1288 if (Load.C.cmdsize != sizeof(MachO::uuid_command)) {
1289 Err = malformedError("LC_UUID command " + Twine(I) + " has incorrect "
1294 Err = malformedError("more than one LC_UUID command");
1297 UuidLoadCmd = Load.Ptr;
1298 } else if (Load.C.cmd == MachO::LC_SEGMENT_64) {
1299 if ((Err = parseSegmentLoadCommand<MachO::segment_command_64,
1301 *this, Load, Sections, HasPageZeroSegment, I,
1302 "LC_SEGMENT_64", SizeOfHeaders, Elements)))
1304 } else if (Load.C.cmd == MachO::LC_SEGMENT) {
1305 if ((Err = parseSegmentLoadCommand<MachO::segment_command,
1307 *this, Load, Sections, HasPageZeroSegment, I,
1308 "LC_SEGMENT", SizeOfHeaders, Elements)))
1310 } else if (Load.C.cmd == MachO::LC_ID_DYLIB) {
1311 if ((Err = checkDylibIdCommand(*this, Load, I, &DyldIdLoadCmd)))
1313 } else if (Load.C.cmd == MachO::LC_LOAD_DYLIB) {
1314 if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_DYLIB")))
1316 Libraries.push_back(Load.Ptr);
1317 } else if (Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB) {
1318 if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_WEAK_DYLIB")))
1320 Libraries.push_back(Load.Ptr);
1321 } else if (Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB) {
1322 if ((Err = checkDylibCommand(*this, Load, I, "LC_LAZY_LOAD_DYLIB")))
1324 Libraries.push_back(Load.Ptr);
1325 } else if (Load.C.cmd == MachO::LC_REEXPORT_DYLIB) {
1326 if ((Err = checkDylibCommand(*this, Load, I, "LC_REEXPORT_DYLIB")))
1328 Libraries.push_back(Load.Ptr);
1329 } else if (Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) {
1330 if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_UPWARD_DYLIB")))
1332 Libraries.push_back(Load.Ptr);
1333 } else if (Load.C.cmd == MachO::LC_ID_DYLINKER) {
1334 if ((Err = checkDyldCommand(*this, Load, I, "LC_ID_DYLINKER")))
1336 } else if (Load.C.cmd == MachO::LC_LOAD_DYLINKER) {
1337 if ((Err = checkDyldCommand(*this, Load, I, "LC_LOAD_DYLINKER")))
1339 } else if (Load.C.cmd == MachO::LC_DYLD_ENVIRONMENT) {
1340 if ((Err = checkDyldCommand(*this, Load, I, "LC_DYLD_ENVIRONMENT")))
1342 } else if (Load.C.cmd == MachO::LC_VERSION_MIN_MACOSX) {
1343 if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1344 "LC_VERSION_MIN_MACOSX")))
1346 } else if (Load.C.cmd == MachO::LC_VERSION_MIN_IPHONEOS) {
1347 if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1348 "LC_VERSION_MIN_IPHONEOS")))
1350 } else if (Load.C.cmd == MachO::LC_VERSION_MIN_TVOS) {
1351 if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1352 "LC_VERSION_MIN_TVOS")))
1354 } else if (Load.C.cmd == MachO::LC_VERSION_MIN_WATCHOS) {
1355 if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1356 "LC_VERSION_MIN_WATCHOS")))
1358 } else if (Load.C.cmd == MachO::LC_NOTE) {
1359 if ((Err = checkNoteCommand(*this, Load, I, Elements)))
1361 } else if (Load.C.cmd == MachO::LC_BUILD_VERSION) {
1362 if ((Err = parseBuildVersionCommand(*this, Load, BuildTools, I)))
1364 } else if (Load.C.cmd == MachO::LC_RPATH) {
1365 if ((Err = checkRpathCommand(*this, Load, I)))
1367 } else if (Load.C.cmd == MachO::LC_SOURCE_VERSION) {
1368 if (Load.C.cmdsize != sizeof(MachO::source_version_command)) {
1369 Err = malformedError("LC_SOURCE_VERSION command " + Twine(I) +
1370 " has incorrect cmdsize");
1373 if (SourceLoadCmd) {
1374 Err = malformedError("more than one LC_SOURCE_VERSION command");
1377 SourceLoadCmd = Load.Ptr;
1378 } else if (Load.C.cmd == MachO::LC_MAIN) {
1379 if (Load.C.cmdsize != sizeof(MachO::entry_point_command)) {
1380 Err = malformedError("LC_MAIN command " + Twine(I) +
1381 " has incorrect cmdsize");
1384 if (EntryPointLoadCmd) {
1385 Err = malformedError("more than one LC_MAIN command");
1388 EntryPointLoadCmd = Load.Ptr;
1389 } else if (Load.C.cmd == MachO::LC_ENCRYPTION_INFO) {
1390 if (Load.C.cmdsize != sizeof(MachO::encryption_info_command)) {
1391 Err = malformedError("LC_ENCRYPTION_INFO command " + Twine(I) +
1392 " has incorrect cmdsize");
1395 MachO::encryption_info_command E =
1396 getStruct<MachO::encryption_info_command>(*this, Load.Ptr);
1397 if ((Err = checkEncryptCommand(*this, Load, I, E.cryptoff, E.cryptsize,
1398 &EncryptLoadCmd, "LC_ENCRYPTION_INFO")))
1400 } else if (Load.C.cmd == MachO::LC_ENCRYPTION_INFO_64) {
1401 if (Load.C.cmdsize != sizeof(MachO::encryption_info_command_64)) {
1402 Err = malformedError("LC_ENCRYPTION_INFO_64 command " + Twine(I) +
1403 " has incorrect cmdsize");
1406 MachO::encryption_info_command_64 E =
1407 getStruct<MachO::encryption_info_command_64>(*this, Load.Ptr);
1408 if ((Err = checkEncryptCommand(*this, Load, I, E.cryptoff, E.cryptsize,
1409 &EncryptLoadCmd, "LC_ENCRYPTION_INFO_64")))
1411 } else if (Load.C.cmd == MachO::LC_LINKER_OPTION) {
1412 if ((Err = checkLinkerOptCommand(*this, Load, I)))
1414 } else if (Load.C.cmd == MachO::LC_SUB_FRAMEWORK) {
1415 if (Load.C.cmdsize < sizeof(MachO::sub_framework_command)) {
1416 Err = malformedError("load command " + Twine(I) +
1417 " LC_SUB_FRAMEWORK cmdsize too small");
1420 MachO::sub_framework_command S =
1421 getStruct<MachO::sub_framework_command>(*this, Load.Ptr);
1422 if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_FRAMEWORK",
1423 sizeof(MachO::sub_framework_command),
1424 "sub_framework_command", S.umbrella,
1427 } else if (Load.C.cmd == MachO::LC_SUB_UMBRELLA) {
1428 if (Load.C.cmdsize < sizeof(MachO::sub_umbrella_command)) {
1429 Err = malformedError("load command " + Twine(I) +
1430 " LC_SUB_UMBRELLA cmdsize too small");
1433 MachO::sub_umbrella_command S =
1434 getStruct<MachO::sub_umbrella_command>(*this, Load.Ptr);
1435 if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_UMBRELLA",
1436 sizeof(MachO::sub_umbrella_command),
1437 "sub_umbrella_command", S.sub_umbrella,
1440 } else if (Load.C.cmd == MachO::LC_SUB_LIBRARY) {
1441 if (Load.C.cmdsize < sizeof(MachO::sub_library_command)) {
1442 Err = malformedError("load command " + Twine(I) +
1443 " LC_SUB_LIBRARY cmdsize too small");
1446 MachO::sub_library_command S =
1447 getStruct<MachO::sub_library_command>(*this, Load.Ptr);
1448 if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_LIBRARY",
1449 sizeof(MachO::sub_library_command),
1450 "sub_library_command", S.sub_library,
1453 } else if (Load.C.cmd == MachO::LC_SUB_CLIENT) {
1454 if (Load.C.cmdsize < sizeof(MachO::sub_client_command)) {
1455 Err = malformedError("load command " + Twine(I) +
1456 " LC_SUB_CLIENT cmdsize too small");
1459 MachO::sub_client_command S =
1460 getStruct<MachO::sub_client_command>(*this, Load.Ptr);
1461 if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_CLIENT",
1462 sizeof(MachO::sub_client_command),
1463 "sub_client_command", S.client, "client")))
1465 } else if (Load.C.cmd == MachO::LC_ROUTINES) {
1466 if (Load.C.cmdsize != sizeof(MachO::routines_command)) {
1467 Err = malformedError("LC_ROUTINES command " + Twine(I) +
1468 " has incorrect cmdsize");
1471 if (RoutinesLoadCmd) {
1472 Err = malformedError("more than one LC_ROUTINES and or LC_ROUTINES_64 "
1476 RoutinesLoadCmd = Load.Ptr;
1477 } else if (Load.C.cmd == MachO::LC_ROUTINES_64) {
1478 if (Load.C.cmdsize != sizeof(MachO::routines_command_64)) {
1479 Err = malformedError("LC_ROUTINES_64 command " + Twine(I) +
1480 " has incorrect cmdsize");
1483 if (RoutinesLoadCmd) {
1484 Err = malformedError("more than one LC_ROUTINES_64 and or LC_ROUTINES "
1488 RoutinesLoadCmd = Load.Ptr;
1489 } else if (Load.C.cmd == MachO::LC_UNIXTHREAD) {
1490 if ((Err = checkThreadCommand(*this, Load, I, "LC_UNIXTHREAD")))
1492 if (UnixThreadLoadCmd) {
1493 Err = malformedError("more than one LC_UNIXTHREAD command");
1496 UnixThreadLoadCmd = Load.Ptr;
1497 } else if (Load.C.cmd == MachO::LC_THREAD) {
1498 if ((Err = checkThreadCommand(*this, Load, I, "LC_THREAD")))
1500 // Note: LC_TWOLEVEL_HINTS is really obsolete and is not supported.
1501 } else if (Load.C.cmd == MachO::LC_TWOLEVEL_HINTS) {
1502 if ((Err = checkTwoLevelHintsCommand(*this, Load, I,
1503 &TwoLevelHintsLoadCmd, Elements)))
1505 } else if (isLoadCommandObsolete(Load.C.cmd)) {
1506 Err = malformedError("load command " + Twine(I) + " for cmd value of: " +
1507 Twine(Load.C.cmd) + " is obsolete and not "
1511 // TODO: generate a error for unknown load commands by default. But still
1512 // need work out an approach to allow or not allow unknown values like this
1513 // as an option for some uses like lldb.
1514 if (I < LoadCommandCount - 1) {
1515 if (auto LoadOrErr = getNextLoadCommandInfo(*this, I, Load))
1518 Err = LoadOrErr.takeError();
1523 if (!SymtabLoadCmd) {
1524 if (DysymtabLoadCmd) {
1525 Err = malformedError("contains LC_DYSYMTAB load command without a "
1526 "LC_SYMTAB load command");
1529 } else if (DysymtabLoadCmd) {
1530 MachO::symtab_command Symtab =
1531 getStruct<MachO::symtab_command>(*this, SymtabLoadCmd);
1532 MachO::dysymtab_command Dysymtab =
1533 getStruct<MachO::dysymtab_command>(*this, DysymtabLoadCmd);
1534 if (Dysymtab.nlocalsym != 0 && Dysymtab.ilocalsym > Symtab.nsyms) {
1535 Err = malformedError("ilocalsym in LC_DYSYMTAB load command "
1536 "extends past the end of the symbol table");
1539 uint64_t BigSize = Dysymtab.ilocalsym;
1540 BigSize += Dysymtab.nlocalsym;
1541 if (Dysymtab.nlocalsym != 0 && BigSize > Symtab.nsyms) {
1542 Err = malformedError("ilocalsym plus nlocalsym in LC_DYSYMTAB load "
1543 "command extends past the end of the symbol table");
1546 if (Dysymtab.nextdefsym != 0 && Dysymtab.ilocalsym > Symtab.nsyms) {
1547 Err = malformedError("nextdefsym in LC_DYSYMTAB load command "
1548 "extends past the end of the symbol table");
1551 BigSize = Dysymtab.iextdefsym;
1552 BigSize += Dysymtab.nextdefsym;
1553 if (Dysymtab.nextdefsym != 0 && BigSize > Symtab.nsyms) {
1554 Err = malformedError("iextdefsym plus nextdefsym in LC_DYSYMTAB "
1555 "load command extends past the end of the symbol "
1559 if (Dysymtab.nundefsym != 0 && Dysymtab.iundefsym > Symtab.nsyms) {
1560 Err = malformedError("nundefsym in LC_DYSYMTAB load command "
1561 "extends past the end of the symbol table");
1564 BigSize = Dysymtab.iundefsym;
1565 BigSize += Dysymtab.nundefsym;
1566 if (Dysymtab.nundefsym != 0 && BigSize > Symtab.nsyms) {
1567 Err = malformedError("iundefsym plus nundefsym in LC_DYSYMTAB load "
1568 " command extends past the end of the symbol table");
1572 if ((getHeader().filetype == MachO::MH_DYLIB ||
1573 getHeader().filetype == MachO::MH_DYLIB_STUB) &&
1574 DyldIdLoadCmd == nullptr) {
1575 Err = malformedError("no LC_ID_DYLIB load command in dynamic library "
1579 assert(LoadCommands.size() == LoadCommandCount);
1581 Err = Error::success();
1584 Error MachOObjectFile::checkSymbolTable() const {
1587 MachO::mach_header_64 H_64 = MachOObjectFile::getHeader64();
1590 MachO::mach_header H = MachOObjectFile::getHeader();
1597 uint64_t NValue = 0;
1598 uint32_t SymbolIndex = 0;
1599 MachO::symtab_command S = getSymtabLoadCommand();
1600 for (const SymbolRef &Symbol : symbols()) {
1601 DataRefImpl SymDRI = Symbol.getRawDataRefImpl();
1603 MachO::nlist_64 STE_64 = getSymbol64TableEntry(SymDRI);
1604 NType = STE_64.n_type;
1605 NSect = STE_64.n_sect;
1606 NDesc = STE_64.n_desc;
1607 NStrx = STE_64.n_strx;
1608 NValue = STE_64.n_value;
1610 MachO::nlist STE = getSymbolTableEntry(SymDRI);
1616 NValue = STE.n_value;
1618 if ((NType & MachO::N_STAB) == 0 &&
1619 (NType & MachO::N_TYPE) == MachO::N_SECT) {
1620 if (NSect == 0 || NSect > Sections.size())
1621 return malformedError("bad section index: " + Twine((int)NSect) +
1622 " for symbol at index " + Twine(SymbolIndex));
1624 if ((NType & MachO::N_STAB) == 0 &&
1625 (NType & MachO::N_TYPE) == MachO::N_INDR) {
1626 if (NValue >= S.strsize)
1627 return malformedError("bad n_value: " + Twine((int)NValue) + " past "
1628 "the end of string table, for N_INDR symbol at "
1629 "index " + Twine(SymbolIndex));
1631 if ((Flags & MachO::MH_TWOLEVEL) == MachO::MH_TWOLEVEL &&
1632 (((NType & MachO::N_TYPE) == MachO::N_UNDF && NValue == 0) ||
1633 (NType & MachO::N_TYPE) == MachO::N_PBUD)) {
1634 uint32_t LibraryOrdinal = MachO::GET_LIBRARY_ORDINAL(NDesc);
1635 if (LibraryOrdinal != 0 &&
1636 LibraryOrdinal != MachO::EXECUTABLE_ORDINAL &&
1637 LibraryOrdinal != MachO::DYNAMIC_LOOKUP_ORDINAL &&
1638 LibraryOrdinal - 1 >= Libraries.size() ) {
1639 return malformedError("bad library ordinal: " + Twine(LibraryOrdinal) +
1640 " for symbol at index " + Twine(SymbolIndex));
1643 if (NStrx >= S.strsize)
1644 return malformedError("bad string table index: " + Twine((int)NStrx) +
1645 " past the end of string table, for symbol at "
1646 "index " + Twine(SymbolIndex));
1649 return Error::success();
1652 void MachOObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
1653 unsigned SymbolTableEntrySize = is64Bit() ?
1654 sizeof(MachO::nlist_64) :
1655 sizeof(MachO::nlist);
1656 Symb.p += SymbolTableEntrySize;
1659 Expected<StringRef> MachOObjectFile::getSymbolName(DataRefImpl Symb) const {
1660 StringRef StringTable = getStringTableData();
1661 MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1662 const char *Start = &StringTable.data()[Entry.n_strx];
1663 if (Start < getData().begin() || Start >= getData().end()) {
1664 return malformedError("bad string index: " + Twine(Entry.n_strx) +
1665 " for symbol at index " + Twine(getSymbolIndex(Symb)));
1667 return StringRef(Start);
1670 unsigned MachOObjectFile::getSectionType(SectionRef Sec) const {
1671 DataRefImpl DRI = Sec.getRawDataRefImpl();
1672 uint32_t Flags = getSectionFlags(*this, DRI);
1673 return Flags & MachO::SECTION_TYPE;
1676 uint64_t MachOObjectFile::getNValue(DataRefImpl Sym) const {
1678 MachO::nlist_64 Entry = getSymbol64TableEntry(Sym);
1679 return Entry.n_value;
1681 MachO::nlist Entry = getSymbolTableEntry(Sym);
1682 return Entry.n_value;
1685 // getIndirectName() returns the name of the alias'ed symbol who's string table
1686 // index is in the n_value field.
1687 std::error_code MachOObjectFile::getIndirectName(DataRefImpl Symb,
1688 StringRef &Res) const {
1689 StringRef StringTable = getStringTableData();
1690 MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1691 if ((Entry.n_type & MachO::N_TYPE) != MachO::N_INDR)
1692 return object_error::parse_failed;
1693 uint64_t NValue = getNValue(Symb);
1694 if (NValue >= StringTable.size())
1695 return object_error::parse_failed;
1696 const char *Start = &StringTable.data()[NValue];
1697 Res = StringRef(Start);
1698 return std::error_code();
1701 uint64_t MachOObjectFile::getSymbolValueImpl(DataRefImpl Sym) const {
1702 return getNValue(Sym);
1705 Expected<uint64_t> MachOObjectFile::getSymbolAddress(DataRefImpl Sym) const {
1706 return getSymbolValue(Sym);
1709 uint32_t MachOObjectFile::getSymbolAlignment(DataRefImpl DRI) const {
1710 uint32_t flags = getSymbolFlags(DRI);
1711 if (flags & SymbolRef::SF_Common) {
1712 MachO::nlist_base Entry = getSymbolTableEntryBase(*this, DRI);
1713 return 1 << MachO::GET_COMM_ALIGN(Entry.n_desc);
1718 uint64_t MachOObjectFile::getCommonSymbolSizeImpl(DataRefImpl DRI) const {
1719 return getNValue(DRI);
1722 Expected<SymbolRef::Type>
1723 MachOObjectFile::getSymbolType(DataRefImpl Symb) const {
1724 MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1725 uint8_t n_type = Entry.n_type;
1727 // If this is a STAB debugging symbol, we can do nothing more.
1728 if (n_type & MachO::N_STAB)
1729 return SymbolRef::ST_Debug;
1731 switch (n_type & MachO::N_TYPE) {
1732 case MachO::N_UNDF :
1733 return SymbolRef::ST_Unknown;
1734 case MachO::N_SECT :
1735 Expected<section_iterator> SecOrError = getSymbolSection(Symb);
1737 return SecOrError.takeError();
1738 section_iterator Sec = *SecOrError;
1739 if (Sec->isData() || Sec->isBSS())
1740 return SymbolRef::ST_Data;
1741 return SymbolRef::ST_Function;
1743 return SymbolRef::ST_Other;
1746 uint32_t MachOObjectFile::getSymbolFlags(DataRefImpl DRI) const {
1747 MachO::nlist_base Entry = getSymbolTableEntryBase(*this, DRI);
1749 uint8_t MachOType = Entry.n_type;
1750 uint16_t MachOFlags = Entry.n_desc;
1752 uint32_t Result = SymbolRef::SF_None;
1754 if ((MachOType & MachO::N_TYPE) == MachO::N_INDR)
1755 Result |= SymbolRef::SF_Indirect;
1757 if (MachOType & MachO::N_STAB)
1758 Result |= SymbolRef::SF_FormatSpecific;
1760 if (MachOType & MachO::N_EXT) {
1761 Result |= SymbolRef::SF_Global;
1762 if ((MachOType & MachO::N_TYPE) == MachO::N_UNDF) {
1764 Result |= SymbolRef::SF_Common;
1766 Result |= SymbolRef::SF_Undefined;
1769 if (!(MachOType & MachO::N_PEXT))
1770 Result |= SymbolRef::SF_Exported;
1773 if (MachOFlags & (MachO::N_WEAK_REF | MachO::N_WEAK_DEF))
1774 Result |= SymbolRef::SF_Weak;
1776 if (MachOFlags & (MachO::N_ARM_THUMB_DEF))
1777 Result |= SymbolRef::SF_Thumb;
1779 if ((MachOType & MachO::N_TYPE) == MachO::N_ABS)
1780 Result |= SymbolRef::SF_Absolute;
1785 Expected<section_iterator>
1786 MachOObjectFile::getSymbolSection(DataRefImpl Symb) const {
1787 MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1788 uint8_t index = Entry.n_sect;
1791 return section_end();
1793 DRI.d.a = index - 1;
1794 if (DRI.d.a >= Sections.size()){
1795 return malformedError("bad section index: " + Twine((int)index) +
1796 " for symbol at index " + Twine(getSymbolIndex(Symb)));
1798 return section_iterator(SectionRef(DRI, this));
1801 unsigned MachOObjectFile::getSymbolSectionID(SymbolRef Sym) const {
1802 MachO::nlist_base Entry =
1803 getSymbolTableEntryBase(*this, Sym.getRawDataRefImpl());
1804 return Entry.n_sect - 1;
1807 void MachOObjectFile::moveSectionNext(DataRefImpl &Sec) const {
1811 std::error_code MachOObjectFile::getSectionName(DataRefImpl Sec,
1812 StringRef &Result) const {
1813 ArrayRef<char> Raw = getSectionRawName(Sec);
1814 Result = parseSegmentOrSectionName(Raw.data());
1815 return std::error_code();
1818 uint64_t MachOObjectFile::getSectionAddress(DataRefImpl Sec) const {
1820 return getSection64(Sec).addr;
1821 return getSection(Sec).addr;
1824 uint64_t MachOObjectFile::getSectionIndex(DataRefImpl Sec) const {
1828 uint64_t MachOObjectFile::getSectionSize(DataRefImpl Sec) const {
1829 // In the case if a malformed Mach-O file where the section offset is past
1830 // the end of the file or some part of the section size is past the end of
1831 // the file return a size of zero or a size that covers the rest of the file
1832 // but does not extend past the end of the file.
1833 uint32_t SectOffset, SectType;
1837 MachO::section_64 Sect = getSection64(Sec);
1838 SectOffset = Sect.offset;
1839 SectSize = Sect.size;
1840 SectType = Sect.flags & MachO::SECTION_TYPE;
1842 MachO::section Sect = getSection(Sec);
1843 SectOffset = Sect.offset;
1844 SectSize = Sect.size;
1845 SectType = Sect.flags & MachO::SECTION_TYPE;
1847 if (SectType == MachO::S_ZEROFILL || SectType == MachO::S_GB_ZEROFILL)
1849 uint64_t FileSize = getData().size();
1850 if (SectOffset > FileSize)
1852 if (FileSize - SectOffset < SectSize)
1853 return FileSize - SectOffset;
1857 std::error_code MachOObjectFile::getSectionContents(DataRefImpl Sec,
1858 StringRef &Res) const {
1863 MachO::section_64 Sect = getSection64(Sec);
1864 Offset = Sect.offset;
1867 MachO::section Sect = getSection(Sec);
1868 Offset = Sect.offset;
1872 Res = this->getData().substr(Offset, Size);
1873 return std::error_code();
1876 uint64_t MachOObjectFile::getSectionAlignment(DataRefImpl Sec) const {
1879 MachO::section_64 Sect = getSection64(Sec);
1882 MachO::section Sect = getSection(Sec);
1886 return uint64_t(1) << Align;
1889 bool MachOObjectFile::isSectionCompressed(DataRefImpl Sec) const {
1893 bool MachOObjectFile::isSectionText(DataRefImpl Sec) const {
1894 uint32_t Flags = getSectionFlags(*this, Sec);
1895 return Flags & MachO::S_ATTR_PURE_INSTRUCTIONS;
1898 bool MachOObjectFile::isSectionData(DataRefImpl Sec) const {
1899 uint32_t Flags = getSectionFlags(*this, Sec);
1900 unsigned SectionType = Flags & MachO::SECTION_TYPE;
1901 return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
1902 !(SectionType == MachO::S_ZEROFILL ||
1903 SectionType == MachO::S_GB_ZEROFILL);
1906 bool MachOObjectFile::isSectionBSS(DataRefImpl Sec) const {
1907 uint32_t Flags = getSectionFlags(*this, Sec);
1908 unsigned SectionType = Flags & MachO::SECTION_TYPE;
1909 return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
1910 (SectionType == MachO::S_ZEROFILL ||
1911 SectionType == MachO::S_GB_ZEROFILL);
1914 unsigned MachOObjectFile::getSectionID(SectionRef Sec) const {
1915 return Sec.getRawDataRefImpl().d.a;
1918 bool MachOObjectFile::isSectionVirtual(DataRefImpl Sec) const {
1919 // FIXME: Unimplemented.
1923 bool MachOObjectFile::isSectionBitcode(DataRefImpl Sec) const {
1924 StringRef SegmentName = getSectionFinalSegmentName(Sec);
1926 if (!getSectionName(Sec, SectName))
1927 return (SegmentName == "__LLVM" && SectName == "__bitcode");
1931 bool MachOObjectFile::isSectionStripped(DataRefImpl Sec) const {
1933 return getSection64(Sec).offset == 0;
1934 return getSection(Sec).offset == 0;
1937 relocation_iterator MachOObjectFile::section_rel_begin(DataRefImpl Sec) const {
1941 return relocation_iterator(RelocationRef(Ret, this));
1945 MachOObjectFile::section_rel_end(DataRefImpl Sec) const {
1948 MachO::section_64 Sect = getSection64(Sec);
1951 MachO::section Sect = getSection(Sec);
1958 return relocation_iterator(RelocationRef(Ret, this));
1961 relocation_iterator MachOObjectFile::extrel_begin() const {
1963 // for DYSYMTAB symbols, Ret.d.a == 0 for external relocations
1964 Ret.d.a = 0; // Would normally be a section index.
1965 Ret.d.b = 0; // Index into the external relocations
1966 return relocation_iterator(RelocationRef(Ret, this));
1969 relocation_iterator MachOObjectFile::extrel_end() const {
1970 MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
1972 // for DYSYMTAB symbols, Ret.d.a == 0 for external relocations
1973 Ret.d.a = 0; // Would normally be a section index.
1974 Ret.d.b = DysymtabLoadCmd.nextrel; // Index into the external relocations
1975 return relocation_iterator(RelocationRef(Ret, this));
1978 relocation_iterator MachOObjectFile::locrel_begin() const {
1980 // for DYSYMTAB symbols, Ret.d.a == 1 for local relocations
1981 Ret.d.a = 1; // Would normally be a section index.
1982 Ret.d.b = 0; // Index into the local relocations
1983 return relocation_iterator(RelocationRef(Ret, this));
1986 relocation_iterator MachOObjectFile::locrel_end() const {
1987 MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
1989 // for DYSYMTAB symbols, Ret.d.a == 1 for local relocations
1990 Ret.d.a = 1; // Would normally be a section index.
1991 Ret.d.b = DysymtabLoadCmd.nlocrel; // Index into the local relocations
1992 return relocation_iterator(RelocationRef(Ret, this));
1995 void MachOObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
1999 uint64_t MachOObjectFile::getRelocationOffset(DataRefImpl Rel) const {
2000 assert((getHeader().filetype == MachO::MH_OBJECT ||
2001 getHeader().filetype == MachO::MH_KEXT_BUNDLE) &&
2002 "Only implemented for MH_OBJECT && MH_KEXT_BUNDLE");
2003 MachO::any_relocation_info RE = getRelocation(Rel);
2004 return getAnyRelocationAddress(RE);
2008 MachOObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
2009 MachO::any_relocation_info RE = getRelocation(Rel);
2010 if (isRelocationScattered(RE))
2011 return symbol_end();
2013 uint32_t SymbolIdx = getPlainRelocationSymbolNum(RE);
2014 bool isExtern = getPlainRelocationExternal(RE);
2016 return symbol_end();
2018 MachO::symtab_command S = getSymtabLoadCommand();
2019 unsigned SymbolTableEntrySize = is64Bit() ?
2020 sizeof(MachO::nlist_64) :
2021 sizeof(MachO::nlist);
2022 uint64_t Offset = S.symoff + SymbolIdx * SymbolTableEntrySize;
2024 Sym.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2025 return symbol_iterator(SymbolRef(Sym, this));
2029 MachOObjectFile::getRelocationSection(DataRefImpl Rel) const {
2030 return section_iterator(getAnyRelocationSection(getRelocation(Rel)));
2033 uint64_t MachOObjectFile::getRelocationType(DataRefImpl Rel) const {
2034 MachO::any_relocation_info RE = getRelocation(Rel);
2035 return getAnyRelocationType(RE);
2038 void MachOObjectFile::getRelocationTypeName(
2039 DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
2041 uint64_t RType = getRelocationType(Rel);
2043 unsigned Arch = this->getArch();
2047 static const char *const Table[] = {
2048 "GENERIC_RELOC_VANILLA",
2049 "GENERIC_RELOC_PAIR",
2050 "GENERIC_RELOC_SECTDIFF",
2051 "GENERIC_RELOC_PB_LA_PTR",
2052 "GENERIC_RELOC_LOCAL_SECTDIFF",
2053 "GENERIC_RELOC_TLV" };
2061 case Triple::x86_64: {
2062 static const char *const Table[] = {
2063 "X86_64_RELOC_UNSIGNED",
2064 "X86_64_RELOC_SIGNED",
2065 "X86_64_RELOC_BRANCH",
2066 "X86_64_RELOC_GOT_LOAD",
2068 "X86_64_RELOC_SUBTRACTOR",
2069 "X86_64_RELOC_SIGNED_1",
2070 "X86_64_RELOC_SIGNED_2",
2071 "X86_64_RELOC_SIGNED_4",
2072 "X86_64_RELOC_TLV" };
2081 static const char *const Table[] = {
2082 "ARM_RELOC_VANILLA",
2084 "ARM_RELOC_SECTDIFF",
2085 "ARM_RELOC_LOCAL_SECTDIFF",
2086 "ARM_RELOC_PB_LA_PTR",
2088 "ARM_THUMB_RELOC_BR22",
2089 "ARM_THUMB_32BIT_BRANCH",
2091 "ARM_RELOC_HALF_SECTDIFF" };
2099 case Triple::aarch64: {
2100 static const char *const Table[] = {
2101 "ARM64_RELOC_UNSIGNED", "ARM64_RELOC_SUBTRACTOR",
2102 "ARM64_RELOC_BRANCH26", "ARM64_RELOC_PAGE21",
2103 "ARM64_RELOC_PAGEOFF12", "ARM64_RELOC_GOT_LOAD_PAGE21",
2104 "ARM64_RELOC_GOT_LOAD_PAGEOFF12", "ARM64_RELOC_POINTER_TO_GOT",
2105 "ARM64_RELOC_TLVP_LOAD_PAGE21", "ARM64_RELOC_TLVP_LOAD_PAGEOFF12",
2106 "ARM64_RELOC_ADDEND"
2109 if (RType >= array_lengthof(Table))
2116 static const char *const Table[] = {
2117 "PPC_RELOC_VANILLA",
2125 "PPC_RELOC_SECTDIFF",
2126 "PPC_RELOC_PB_LA_PTR",
2127 "PPC_RELOC_HI16_SECTDIFF",
2128 "PPC_RELOC_LO16_SECTDIFF",
2129 "PPC_RELOC_HA16_SECTDIFF",
2131 "PPC_RELOC_LO14_SECTDIFF",
2132 "PPC_RELOC_LOCAL_SECTDIFF" };
2140 case Triple::UnknownArch:
2144 Result.append(res.begin(), res.end());
2147 uint8_t MachOObjectFile::getRelocationLength(DataRefImpl Rel) const {
2148 MachO::any_relocation_info RE = getRelocation(Rel);
2149 return getAnyRelocationLength(RE);
2153 // guessLibraryShortName() is passed a name of a dynamic library and returns a
2154 // guess on what the short name is. Then name is returned as a substring of the
2155 // StringRef Name passed in. The name of the dynamic library is recognized as
2156 // a framework if it has one of the two following forms:
2157 // Foo.framework/Versions/A/Foo
2158 // Foo.framework/Foo
2159 // Where A and Foo can be any string. And may contain a trailing suffix
2160 // starting with an underbar. If the Name is recognized as a framework then
2161 // isFramework is set to true else it is set to false. If the Name has a
2162 // suffix then Suffix is set to the substring in Name that contains the suffix
2163 // else it is set to a NULL StringRef.
2165 // The Name of the dynamic library is recognized as a library name if it has
2166 // one of the two following forms:
2169 // The library may have a suffix trailing the name Foo of the form:
2170 // libFoo_profile.A.dylib
2171 // libFoo_profile.dylib
2173 // The Name of the dynamic library is also recognized as a library name if it
2174 // has the following form:
2177 // If the Name of the dynamic library is none of the forms above then a NULL
2178 // StringRef is returned.
2180 StringRef MachOObjectFile::guessLibraryShortName(StringRef Name,
2182 StringRef &Suffix) {
2183 StringRef Foo, F, DotFramework, V, Dylib, Lib, Dot, Qtx;
2184 size_t a, b, c, d, Idx;
2186 isFramework = false;
2187 Suffix = StringRef();
2189 // Pull off the last component and make Foo point to it
2190 a = Name.rfind('/');
2191 if (a == Name.npos || a == 0)
2193 Foo = Name.slice(a+1, Name.npos);
2195 // Look for a suffix starting with a '_'
2196 Idx = Foo.rfind('_');
2197 if (Idx != Foo.npos && Foo.size() >= 2) {
2198 Suffix = Foo.slice(Idx, Foo.npos);
2199 Foo = Foo.slice(0, Idx);
2202 // First look for the form Foo.framework/Foo
2203 b = Name.rfind('/', a);
2208 F = Name.slice(Idx, Idx + Foo.size());
2209 DotFramework = Name.slice(Idx + Foo.size(),
2210 Idx + Foo.size() + sizeof(".framework/")-1);
2211 if (F == Foo && DotFramework == ".framework/") {
2216 // Next look for the form Foo.framework/Versions/A/Foo
2219 c = Name.rfind('/', b);
2220 if (c == Name.npos || c == 0)
2222 V = Name.slice(c+1, Name.npos);
2223 if (!V.startswith("Versions/"))
2225 d = Name.rfind('/', c);
2230 F = Name.slice(Idx, Idx + Foo.size());
2231 DotFramework = Name.slice(Idx + Foo.size(),
2232 Idx + Foo.size() + sizeof(".framework/")-1);
2233 if (F == Foo && DotFramework == ".framework/") {
2239 // pull off the suffix after the "." and make a point to it
2240 a = Name.rfind('.');
2241 if (a == Name.npos || a == 0)
2243 Dylib = Name.slice(a, Name.npos);
2244 if (Dylib != ".dylib")
2247 // First pull off the version letter for the form Foo.A.dylib if any.
2249 Dot = Name.slice(a-2, a-1);
2254 b = Name.rfind('/', a);
2259 // ignore any suffix after an underbar like Foo_profile.A.dylib
2260 Idx = Name.find('_', b);
2261 if (Idx != Name.npos && Idx != b) {
2262 Lib = Name.slice(b, Idx);
2263 Suffix = Name.slice(Idx, a);
2266 Lib = Name.slice(b, a);
2267 // There are incorrect library names of the form:
2268 // libATS.A_profile.dylib so check for these.
2269 if (Lib.size() >= 3) {
2270 Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
2272 Lib = Lib.slice(0, Lib.size()-2);
2277 Qtx = Name.slice(a, Name.npos);
2280 b = Name.rfind('/', a);
2282 Lib = Name.slice(0, a);
2284 Lib = Name.slice(b+1, a);
2285 // There are library names of the form: QT.A.qtx so check for these.
2286 if (Lib.size() >= 3) {
2287 Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
2289 Lib = Lib.slice(0, Lib.size()-2);
2294 // getLibraryShortNameByIndex() is used to get the short name of the library
2295 // for an undefined symbol in a linked Mach-O binary that was linked with the
2296 // normal two-level namespace default (that is MH_TWOLEVEL in the header).
2297 // It is passed the index (0 - based) of the library as translated from
2298 // GET_LIBRARY_ORDINAL (1 - based).
2299 std::error_code MachOObjectFile::getLibraryShortNameByIndex(unsigned Index,
2300 StringRef &Res) const {
2301 if (Index >= Libraries.size())
2302 return object_error::parse_failed;
2304 // If the cache of LibrariesShortNames is not built up do that first for
2305 // all the Libraries.
2306 if (LibrariesShortNames.size() == 0) {
2307 for (unsigned i = 0; i < Libraries.size(); i++) {
2308 MachO::dylib_command D =
2309 getStruct<MachO::dylib_command>(*this, Libraries[i]);
2310 if (D.dylib.name >= D.cmdsize)
2311 return object_error::parse_failed;
2312 const char *P = (const char *)(Libraries[i]) + D.dylib.name;
2313 StringRef Name = StringRef(P);
2314 if (D.dylib.name+Name.size() >= D.cmdsize)
2315 return object_error::parse_failed;
2318 StringRef shortName = guessLibraryShortName(Name, isFramework, Suffix);
2319 if (shortName.empty())
2320 LibrariesShortNames.push_back(Name);
2322 LibrariesShortNames.push_back(shortName);
2326 Res = LibrariesShortNames[Index];
2327 return std::error_code();
2330 uint32_t MachOObjectFile::getLibraryCount() const {
2331 return Libraries.size();
2335 MachOObjectFile::getRelocationRelocatedSection(relocation_iterator Rel) const {
2337 Sec.d.a = Rel->getRawDataRefImpl().d.a;
2338 return section_iterator(SectionRef(Sec, this));
2341 basic_symbol_iterator MachOObjectFile::symbol_begin() const {
2343 MachO::symtab_command Symtab = getSymtabLoadCommand();
2344 if (!SymtabLoadCmd || Symtab.nsyms == 0)
2345 return basic_symbol_iterator(SymbolRef(DRI, this));
2347 return getSymbolByIndex(0);
2350 basic_symbol_iterator MachOObjectFile::symbol_end() const {
2352 MachO::symtab_command Symtab = getSymtabLoadCommand();
2353 if (!SymtabLoadCmd || Symtab.nsyms == 0)
2354 return basic_symbol_iterator(SymbolRef(DRI, this));
2356 unsigned SymbolTableEntrySize = is64Bit() ?
2357 sizeof(MachO::nlist_64) :
2358 sizeof(MachO::nlist);
2359 unsigned Offset = Symtab.symoff +
2360 Symtab.nsyms * SymbolTableEntrySize;
2361 DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2362 return basic_symbol_iterator(SymbolRef(DRI, this));
2365 basic_symbol_iterator MachOObjectFile::getSymbolByIndex(unsigned Index) const {
2366 MachO::symtab_command Symtab = getSymtabLoadCommand();
2367 if (!SymtabLoadCmd || Index >= Symtab.nsyms)
2368 report_fatal_error("Requested symbol index is out of range.");
2369 unsigned SymbolTableEntrySize =
2370 is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
2372 DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Symtab.symoff));
2373 DRI.p += Index * SymbolTableEntrySize;
2374 return basic_symbol_iterator(SymbolRef(DRI, this));
2377 uint64_t MachOObjectFile::getSymbolIndex(DataRefImpl Symb) const {
2378 MachO::symtab_command Symtab = getSymtabLoadCommand();
2380 report_fatal_error("getSymbolIndex() called with no symbol table symbol");
2381 unsigned SymbolTableEntrySize =
2382 is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
2383 DataRefImpl DRIstart;
2384 DRIstart.p = reinterpret_cast<uintptr_t>(getPtr(*this, Symtab.symoff));
2385 uint64_t Index = (Symb.p - DRIstart.p) / SymbolTableEntrySize;
2389 section_iterator MachOObjectFile::section_begin() const {
2391 return section_iterator(SectionRef(DRI, this));
2394 section_iterator MachOObjectFile::section_end() const {
2396 DRI.d.a = Sections.size();
2397 return section_iterator(SectionRef(DRI, this));
2400 uint8_t MachOObjectFile::getBytesInAddress() const {
2401 return is64Bit() ? 8 : 4;
2404 StringRef MachOObjectFile::getFileFormatName() const {
2405 unsigned CPUType = getCPUType(*this);
2408 case MachO::CPU_TYPE_I386:
2409 return "Mach-O 32-bit i386";
2410 case MachO::CPU_TYPE_ARM:
2411 return "Mach-O arm";
2412 case MachO::CPU_TYPE_POWERPC:
2413 return "Mach-O 32-bit ppc";
2415 return "Mach-O 32-bit unknown";
2420 case MachO::CPU_TYPE_X86_64:
2421 return "Mach-O 64-bit x86-64";
2422 case MachO::CPU_TYPE_ARM64:
2423 return "Mach-O arm64";
2424 case MachO::CPU_TYPE_POWERPC64:
2425 return "Mach-O 64-bit ppc64";
2427 return "Mach-O 64-bit unknown";
2431 Triple::ArchType MachOObjectFile::getArch(uint32_t CPUType) {
2433 case MachO::CPU_TYPE_I386:
2435 case MachO::CPU_TYPE_X86_64:
2436 return Triple::x86_64;
2437 case MachO::CPU_TYPE_ARM:
2439 case MachO::CPU_TYPE_ARM64:
2440 return Triple::aarch64;
2441 case MachO::CPU_TYPE_POWERPC:
2443 case MachO::CPU_TYPE_POWERPC64:
2444 return Triple::ppc64;
2446 return Triple::UnknownArch;
2450 Triple MachOObjectFile::getArchTriple(uint32_t CPUType, uint32_t CPUSubType,
2451 const char **McpuDefault,
2452 const char **ArchFlag) {
2454 *McpuDefault = nullptr;
2456 *ArchFlag = nullptr;
2459 case MachO::CPU_TYPE_I386:
2460 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2461 case MachO::CPU_SUBTYPE_I386_ALL:
2464 return Triple("i386-apple-darwin");
2468 case MachO::CPU_TYPE_X86_64:
2469 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2470 case MachO::CPU_SUBTYPE_X86_64_ALL:
2472 *ArchFlag = "x86_64";
2473 return Triple("x86_64-apple-darwin");
2474 case MachO::CPU_SUBTYPE_X86_64_H:
2476 *ArchFlag = "x86_64h";
2477 return Triple("x86_64h-apple-darwin");
2481 case MachO::CPU_TYPE_ARM:
2482 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2483 case MachO::CPU_SUBTYPE_ARM_V4T:
2485 *ArchFlag = "armv4t";
2486 return Triple("armv4t-apple-darwin");
2487 case MachO::CPU_SUBTYPE_ARM_V5TEJ:
2489 *ArchFlag = "armv5e";
2490 return Triple("armv5e-apple-darwin");
2491 case MachO::CPU_SUBTYPE_ARM_XSCALE:
2493 *ArchFlag = "xscale";
2494 return Triple("xscale-apple-darwin");
2495 case MachO::CPU_SUBTYPE_ARM_V6:
2497 *ArchFlag = "armv6";
2498 return Triple("armv6-apple-darwin");
2499 case MachO::CPU_SUBTYPE_ARM_V6M:
2501 *McpuDefault = "cortex-m0";
2503 *ArchFlag = "armv6m";
2504 return Triple("armv6m-apple-darwin");
2505 case MachO::CPU_SUBTYPE_ARM_V7:
2507 *ArchFlag = "armv7";
2508 return Triple("armv7-apple-darwin");
2509 case MachO::CPU_SUBTYPE_ARM_V7EM:
2511 *McpuDefault = "cortex-m4";
2513 *ArchFlag = "armv7em";
2514 return Triple("thumbv7em-apple-darwin");
2515 case MachO::CPU_SUBTYPE_ARM_V7K:
2517 *McpuDefault = "cortex-a7";
2519 *ArchFlag = "armv7k";
2520 return Triple("armv7k-apple-darwin");
2521 case MachO::CPU_SUBTYPE_ARM_V7M:
2523 *McpuDefault = "cortex-m3";
2525 *ArchFlag = "armv7m";
2526 return Triple("thumbv7m-apple-darwin");
2527 case MachO::CPU_SUBTYPE_ARM_V7S:
2529 *McpuDefault = "cortex-a7";
2531 *ArchFlag = "armv7s";
2532 return Triple("armv7s-apple-darwin");
2536 case MachO::CPU_TYPE_ARM64:
2537 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2538 case MachO::CPU_SUBTYPE_ARM64_ALL:
2540 *McpuDefault = "cyclone";
2542 *ArchFlag = "arm64";
2543 return Triple("arm64-apple-darwin");
2547 case MachO::CPU_TYPE_POWERPC:
2548 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2549 case MachO::CPU_SUBTYPE_POWERPC_ALL:
2552 return Triple("ppc-apple-darwin");
2556 case MachO::CPU_TYPE_POWERPC64:
2557 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2558 case MachO::CPU_SUBTYPE_POWERPC_ALL:
2560 *ArchFlag = "ppc64";
2561 return Triple("ppc64-apple-darwin");
2570 Triple MachOObjectFile::getHostArch() {
2571 return Triple(sys::getDefaultTargetTriple());
2574 bool MachOObjectFile::isValidArch(StringRef ArchFlag) {
2575 return StringSwitch<bool>(ArchFlag)
2577 .Case("x86_64", true)
2578 .Case("x86_64h", true)
2579 .Case("armv4t", true)
2581 .Case("armv5e", true)
2582 .Case("armv6", true)
2583 .Case("armv6m", true)
2584 .Case("armv7", true)
2585 .Case("armv7em", true)
2586 .Case("armv7k", true)
2587 .Case("armv7m", true)
2588 .Case("armv7s", true)
2589 .Case("arm64", true)
2591 .Case("ppc64", true)
2595 Triple::ArchType MachOObjectFile::getArch() const {
2596 return getArch(getCPUType(*this));
2599 Triple MachOObjectFile::getArchTriple(const char **McpuDefault) const {
2600 return getArchTriple(Header.cputype, Header.cpusubtype, McpuDefault);
2603 relocation_iterator MachOObjectFile::section_rel_begin(unsigned Index) const {
2606 return section_rel_begin(DRI);
2609 relocation_iterator MachOObjectFile::section_rel_end(unsigned Index) const {
2612 return section_rel_end(DRI);
2615 dice_iterator MachOObjectFile::begin_dices() const {
2617 if (!DataInCodeLoadCmd)
2618 return dice_iterator(DiceRef(DRI, this));
2620 MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
2621 DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, DicLC.dataoff));
2622 return dice_iterator(DiceRef(DRI, this));
2625 dice_iterator MachOObjectFile::end_dices() const {
2627 if (!DataInCodeLoadCmd)
2628 return dice_iterator(DiceRef(DRI, this));
2630 MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
2631 unsigned Offset = DicLC.dataoff + DicLC.datasize;
2632 DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2633 return dice_iterator(DiceRef(DRI, this));
2636 ExportEntry::ExportEntry(Error *E, const MachOObjectFile *O,
2637 ArrayRef<uint8_t> T) : E(E), O(O), Trie(T) {}
2639 void ExportEntry::moveToFirst() {
2640 ErrorAsOutParameter ErrAsOutParam(E);
2644 pushDownUntilBottom();
2647 void ExportEntry::moveToEnd() {
2652 bool ExportEntry::operator==(const ExportEntry &Other) const {
2653 // Common case, one at end, other iterating from begin.
2654 if (Done || Other.Done)
2655 return (Done == Other.Done);
2656 // Not equal if different stack sizes.
2657 if (Stack.size() != Other.Stack.size())
2659 // Not equal if different cumulative strings.
2660 if (!CumulativeString.equals(Other.CumulativeString))
2662 // Equal if all nodes in both stacks match.
2663 for (unsigned i=0; i < Stack.size(); ++i) {
2664 if (Stack[i].Start != Other.Stack[i].Start)
2670 uint64_t ExportEntry::readULEB128(const uint8_t *&Ptr, const char **error) {
2672 uint64_t Result = decodeULEB128(Ptr, &Count, Trie.end(), error);
2674 if (Ptr > Trie.end())
2679 StringRef ExportEntry::name() const {
2680 return CumulativeString;
2683 uint64_t ExportEntry::flags() const {
2684 return Stack.back().Flags;
2687 uint64_t ExportEntry::address() const {
2688 return Stack.back().Address;
2691 uint64_t ExportEntry::other() const {
2692 return Stack.back().Other;
2695 StringRef ExportEntry::otherName() const {
2696 const char* ImportName = Stack.back().ImportName;
2698 return StringRef(ImportName);
2702 uint32_t ExportEntry::nodeOffset() const {
2703 return Stack.back().Start - Trie.begin();
2706 ExportEntry::NodeState::NodeState(const uint8_t *Ptr)
2707 : Start(Ptr), Current(Ptr) {}
2709 void ExportEntry::pushNode(uint64_t offset) {
2710 ErrorAsOutParameter ErrAsOutParam(E);
2711 const uint8_t *Ptr = Trie.begin() + offset;
2712 NodeState State(Ptr);
2714 uint64_t ExportInfoSize = readULEB128(State.Current, &error);
2716 *E = malformedError("export info size " + Twine(error) +
2717 " in export trie data at node: 0x" +
2718 Twine::utohexstr(offset));
2722 State.IsExportNode = (ExportInfoSize != 0);
2723 const uint8_t* Children = State.Current + ExportInfoSize;
2724 if (Children > Trie.end()) {
2725 *E = malformedError(
2726 "export info size: 0x" + Twine::utohexstr(ExportInfoSize) +
2727 " in export trie data at node: 0x" + Twine::utohexstr(offset) +
2728 " too big and extends past end of trie data");
2732 if (State.IsExportNode) {
2733 const uint8_t *ExportStart = State.Current;
2734 State.Flags = readULEB128(State.Current, &error);
2736 *E = malformedError("flags " + Twine(error) +
2737 " in export trie data at node: 0x" +
2738 Twine::utohexstr(offset));
2742 uint64_t Kind = State.Flags & MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK;
2743 if (State.Flags != 0 &&
2744 (Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_REGULAR &&
2745 Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE &&
2746 Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL)) {
2747 *E = malformedError(
2748 "unsupported exported symbol kind: " + Twine((int)Kind) +
2749 " in flags: 0x" + Twine::utohexstr(State.Flags) +
2750 " in export trie data at node: 0x" + Twine::utohexstr(offset));
2754 if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT) {
2756 State.Other = readULEB128(State.Current, &error); // dylib ordinal
2758 *E = malformedError("dylib ordinal of re-export " + Twine(error) +
2759 " in export trie data at node: 0x" +
2760 Twine::utohexstr(offset));
2765 if (State.Other > O->getLibraryCount()) {
2766 *E = malformedError(
2767 "bad library ordinal: " + Twine((int)State.Other) + " (max " +
2768 Twine((int)O->getLibraryCount()) +
2769 ") in export trie data at node: 0x" + Twine::utohexstr(offset));
2774 State.ImportName = reinterpret_cast<const char*>(State.Current);
2775 if (*State.ImportName == '\0') {
2778 const uint8_t *End = State.Current + 1;
2779 if (End >= Trie.end()) {
2780 *E = malformedError("import name of re-export in export trie data at "
2782 Twine::utohexstr(offset) +
2783 " starts past end of trie data");
2787 while(*End != '\0' && End < Trie.end())
2790 *E = malformedError("import name of re-export in export trie data at "
2792 Twine::utohexstr(offset) +
2793 " extends past end of trie data");
2797 State.Current = End + 1;
2800 State.Address = readULEB128(State.Current, &error);
2802 *E = malformedError("address " + Twine(error) +
2803 " in export trie data at node: 0x" +
2804 Twine::utohexstr(offset));
2808 if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER) {
2809 State.Other = readULEB128(State.Current, &error);
2811 *E = malformedError("resolver of stub and resolver " + Twine(error) +
2812 " in export trie data at node: 0x" +
2813 Twine::utohexstr(offset));
2819 if(ExportStart + ExportInfoSize != State.Current) {
2820 *E = malformedError(
2821 "inconsistant export info size: 0x" +
2822 Twine::utohexstr(ExportInfoSize) + " where actual size was: 0x" +
2823 Twine::utohexstr(State.Current - ExportStart) +
2824 " in export trie data at node: 0x" + Twine::utohexstr(offset));
2829 State.ChildCount = *Children;
2830 if (State.ChildCount != 0 && Children + 1 >= Trie.end()) {
2831 *E = malformedError("byte for count of childern in export trie data at "
2833 Twine::utohexstr(offset) +
2834 " extends past end of trie data");
2838 State.Current = Children + 1;
2839 State.NextChildIndex = 0;
2840 State.ParentStringLength = CumulativeString.size();
2841 Stack.push_back(State);
2844 void ExportEntry::pushDownUntilBottom() {
2845 ErrorAsOutParameter ErrAsOutParam(E);
2847 while (Stack.back().NextChildIndex < Stack.back().ChildCount) {
2848 NodeState &Top = Stack.back();
2849 CumulativeString.resize(Top.ParentStringLength);
2850 for (;*Top.Current != 0 && Top.Current < Trie.end(); Top.Current++) {
2851 char C = *Top.Current;
2852 CumulativeString.push_back(C);
2854 if (Top.Current >= Trie.end()) {
2855 *E = malformedError("edge sub-string in export trie data at node: 0x" +
2856 Twine::utohexstr(Top.Start - Trie.begin()) +
2857 " for child #" + Twine((int)Top.NextChildIndex) +
2858 " extends past end of trie data");
2863 uint64_t childNodeIndex = readULEB128(Top.Current, &error);
2865 *E = malformedError("child node offset " + Twine(error) +
2866 " in export trie data at node: 0x" +
2867 Twine::utohexstr(Top.Start - Trie.begin()));
2871 for (const NodeState &node : nodes()) {
2872 if (node.Start == Trie.begin() + childNodeIndex){
2873 *E = malformedError("loop in childern in export trie data at node: 0x" +
2874 Twine::utohexstr(Top.Start - Trie.begin()) +
2875 " back to node: 0x" +
2876 Twine::utohexstr(childNodeIndex));
2881 Top.NextChildIndex += 1;
2882 pushNode(childNodeIndex);
2886 if (!Stack.back().IsExportNode) {
2887 *E = malformedError("node is not an export node in export trie data at "
2889 Twine::utohexstr(Stack.back().Start - Trie.begin()));
2895 // We have a trie data structure and need a way to walk it that is compatible
2896 // with the C++ iterator model. The solution is a non-recursive depth first
2897 // traversal where the iterator contains a stack of parent nodes along with a
2898 // string that is the accumulation of all edge strings along the parent chain
2901 // There is one "export" node for each exported symbol. But because some
2902 // symbols may be a prefix of another symbol (e.g. _dup and _dup2), an export
2903 // node may have child nodes too.
2905 // The algorithm for moveNext() is to keep moving down the leftmost unvisited
2906 // child until hitting a node with no children (which is an export node or
2907 // else the trie is malformed). On the way down, each node is pushed on the
2908 // stack ivar. If there is no more ways down, it pops up one and tries to go
2909 // down a sibling path until a childless node is reached.
2910 void ExportEntry::moveNext() {
2911 assert(!Stack.empty() && "ExportEntry::moveNext() with empty node stack");
2912 if (!Stack.back().IsExportNode) {
2913 *E = malformedError("node is not an export node in export trie data at "
2915 Twine::utohexstr(Stack.back().Start - Trie.begin()));
2921 while (!Stack.empty()) {
2922 NodeState &Top = Stack.back();
2923 if (Top.NextChildIndex < Top.ChildCount) {
2924 pushDownUntilBottom();
2925 // Now at the next export node.
2928 if (Top.IsExportNode) {
2929 // This node has no children but is itself an export node.
2930 CumulativeString.resize(Top.ParentStringLength);
2939 iterator_range<export_iterator>
2940 MachOObjectFile::exports(Error &E, ArrayRef<uint8_t> Trie,
2941 const MachOObjectFile *O) {
2942 ExportEntry Start(&E, O, Trie);
2946 Start.moveToFirst();
2948 ExportEntry Finish(&E, O, Trie);
2951 return make_range(export_iterator(Start), export_iterator(Finish));
2954 iterator_range<export_iterator> MachOObjectFile::exports(Error &Err) const {
2955 return exports(Err, getDyldInfoExportsTrie(), this);
2958 MachORebaseEntry::MachORebaseEntry(Error *E, const MachOObjectFile *O,
2959 ArrayRef<uint8_t> Bytes, bool is64Bit)
2960 : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()),
2961 PointerSize(is64Bit ? 8 : 4) {}
2963 void MachORebaseEntry::moveToFirst() {
2964 Ptr = Opcodes.begin();
2968 void MachORebaseEntry::moveToEnd() {
2969 Ptr = Opcodes.end();
2970 RemainingLoopCount = 0;
2974 void MachORebaseEntry::moveNext() {
2975 ErrorAsOutParameter ErrAsOutParam(E);
2976 // If in the middle of some loop, move to next rebasing in loop.
2977 SegmentOffset += AdvanceAmount;
2978 if (RemainingLoopCount) {
2979 --RemainingLoopCount;
2982 // REBASE_OPCODE_DONE is only used for padding if we are not aligned to
2983 // pointer size. Therefore it is possible to reach the end without ever having
2984 // seen REBASE_OPCODE_DONE.
2985 if (Ptr == Opcodes.end()) {
2991 // Parse next opcode and set up next loop.
2992 const uint8_t *OpcodeStart = Ptr;
2993 uint8_t Byte = *Ptr++;
2994 uint8_t ImmValue = Byte & MachO::REBASE_IMMEDIATE_MASK;
2995 uint8_t Opcode = Byte & MachO::REBASE_OPCODE_MASK;
2996 uint32_t Count, Skip;
2997 const char *error = nullptr;
2999 case MachO::REBASE_OPCODE_DONE:
3003 DEBUG_WITH_TYPE("mach-o-rebase", dbgs() << "REBASE_OPCODE_DONE\n");
3005 case MachO::REBASE_OPCODE_SET_TYPE_IMM:
3006 RebaseType = ImmValue;
3007 if (RebaseType > MachO::REBASE_TYPE_TEXT_PCREL32) {
3008 *E = malformedError("for REBASE_OPCODE_SET_TYPE_IMM bad bind type: " +
3009 Twine((int)RebaseType) + " for opcode at: 0x" +
3010 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3016 dbgs() << "REBASE_OPCODE_SET_TYPE_IMM: "
3017 << "RebaseType=" << (int) RebaseType << "\n");
3019 case MachO::REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
3020 SegmentIndex = ImmValue;
3021 SegmentOffset = readULEB128(&error);
3023 *E = malformedError("for REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3024 Twine(error) + " for opcode at: 0x" +
3025 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3029 error = O->RebaseEntryCheckSegAndOffset(SegmentIndex, SegmentOffset,
3032 *E = malformedError("for REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3033 Twine(error) + " for opcode at: 0x" +
3034 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3040 dbgs() << "REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
3041 << "SegmentIndex=" << SegmentIndex << ", "
3042 << format("SegmentOffset=0x%06X", SegmentOffset)
3045 case MachO::REBASE_OPCODE_ADD_ADDR_ULEB:
3046 SegmentOffset += readULEB128(&error);
3048 *E = malformedError("for REBASE_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3049 " for opcode at: 0x" +
3050 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3054 error = O->RebaseEntryCheckSegAndOffset(SegmentIndex, SegmentOffset,
3057 *E = malformedError("for REBASE_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3058 " for opcode at: 0x" +
3059 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3063 DEBUG_WITH_TYPE("mach-o-rebase",
3064 dbgs() << "REBASE_OPCODE_ADD_ADDR_ULEB: "
3065 << format("SegmentOffset=0x%06X",
3066 SegmentOffset) << "\n");
3068 case MachO::REBASE_OPCODE_ADD_ADDR_IMM_SCALED:
3069 error = O->RebaseEntryCheckSegAndOffset(SegmentIndex, SegmentOffset,
3072 *E = malformedError("for REBASE_OPCODE_ADD_ADDR_IMM_SCALED " +
3073 Twine(error) + " for opcode at: 0x" +
3074 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3078 SegmentOffset += ImmValue * PointerSize;
3079 error = O->RebaseEntryCheckSegAndOffset(SegmentIndex, SegmentOffset,
3083 malformedError("for REBASE_OPCODE_ADD_ADDR_IMM_SCALED "
3084 " (after adding immediate times the pointer size) " +
3085 Twine(error) + " for opcode at: 0x" +
3086 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3090 DEBUG_WITH_TYPE("mach-o-rebase",
3091 dbgs() << "REBASE_OPCODE_ADD_ADDR_IMM_SCALED: "
3092 << format("SegmentOffset=0x%06X",
3093 SegmentOffset) << "\n");
3095 case MachO::REBASE_OPCODE_DO_REBASE_IMM_TIMES:
3096 error = O->RebaseEntryCheckSegAndOffset(SegmentIndex, SegmentOffset,
3099 *E = malformedError("for REBASE_OPCODE_DO_REBASE_IMM_TIMES " +
3100 Twine(error) + " for opcode at: 0x" +
3101 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3105 AdvanceAmount = PointerSize;
3109 RemainingLoopCount = ImmValue - 1;
3111 RemainingLoopCount = 0;
3112 error = O->RebaseEntryCheckCountAndSkip(Count, Skip, PointerSize,
3113 SegmentIndex, SegmentOffset);
3115 *E = malformedError("for REBASE_OPCODE_DO_REBASE_IMM_TIMES " +
3116 Twine(error) + " for opcode at: 0x" +
3117 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3123 dbgs() << "REBASE_OPCODE_DO_REBASE_IMM_TIMES: "
3124 << format("SegmentOffset=0x%06X", SegmentOffset)
3125 << ", AdvanceAmount=" << AdvanceAmount
3126 << ", RemainingLoopCount=" << RemainingLoopCount
3129 case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES:
3130 error = O->RebaseEntryCheckSegAndOffset(SegmentIndex, SegmentOffset,
3133 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES " +
3134 Twine(error) + " for opcode at: 0x" +
3135 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3139 AdvanceAmount = PointerSize;
3141 Count = readULEB128(&error);
3143 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES " +
3144 Twine(error) + " for opcode at: 0x" +
3145 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3150 RemainingLoopCount = Count - 1;
3152 RemainingLoopCount = 0;
3153 error = O->RebaseEntryCheckCountAndSkip(Count, Skip, PointerSize,
3154 SegmentIndex, SegmentOffset);
3156 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES " +
3157 Twine(error) + " for opcode at: 0x" +
3158 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3164 dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES: "
3165 << format("SegmentOffset=0x%06X", SegmentOffset)
3166 << ", AdvanceAmount=" << AdvanceAmount
3167 << ", RemainingLoopCount=" << RemainingLoopCount
3170 case MachO::REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB:
3171 error = O->RebaseEntryCheckSegAndOffset(SegmentIndex, SegmentOffset,
3174 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB " +
3175 Twine(error) + " for opcode at: 0x" +
3176 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3180 Skip = readULEB128(&error);
3182 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB " +
3183 Twine(error) + " for opcode at: 0x" +
3184 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3188 AdvanceAmount = Skip + PointerSize;
3190 RemainingLoopCount = 0;
3191 error = O->RebaseEntryCheckCountAndSkip(Count, Skip, PointerSize,
3192 SegmentIndex, SegmentOffset);
3194 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB " +
3195 Twine(error) + " for opcode at: 0x" +
3196 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3202 dbgs() << "REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: "
3203 << format("SegmentOffset=0x%06X", SegmentOffset)
3204 << ", AdvanceAmount=" << AdvanceAmount
3205 << ", RemainingLoopCount=" << RemainingLoopCount
3208 case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB:
3209 error = O->RebaseEntryCheckSegAndOffset(SegmentIndex, SegmentOffset,
3212 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3214 Twine(error) + " for opcode at: 0x" +
3215 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3219 Count = readULEB128(&error);
3221 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3223 Twine(error) + " for opcode at: 0x" +
3224 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3229 RemainingLoopCount = Count - 1;
3231 RemainingLoopCount = 0;
3232 Skip = readULEB128(&error);
3234 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3236 Twine(error) + " for opcode at: 0x" +
3237 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3241 AdvanceAmount = Skip + PointerSize;
3243 error = O->RebaseEntryCheckCountAndSkip(Count, Skip, PointerSize,
3244 SegmentIndex, SegmentOffset);
3246 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3248 Twine(error) + " for opcode at: 0x" +
3249 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3255 dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: "
3256 << format("SegmentOffset=0x%06X", SegmentOffset)
3257 << ", AdvanceAmount=" << AdvanceAmount
3258 << ", RemainingLoopCount=" << RemainingLoopCount
3262 *E = malformedError("bad rebase info (bad opcode value 0x" +
3263 Twine::utohexstr(Opcode) + " for opcode at: 0x" +
3264 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3271 uint64_t MachORebaseEntry::readULEB128(const char **error) {
3273 uint64_t Result = decodeULEB128(Ptr, &Count, Opcodes.end(), error);
3275 if (Ptr > Opcodes.end())
3276 Ptr = Opcodes.end();
3280 int32_t MachORebaseEntry::segmentIndex() const { return SegmentIndex; }
3282 uint64_t MachORebaseEntry::segmentOffset() const { return SegmentOffset; }
3284 StringRef MachORebaseEntry::typeName() const {
3285 switch (RebaseType) {
3286 case MachO::REBASE_TYPE_POINTER:
3288 case MachO::REBASE_TYPE_TEXT_ABSOLUTE32:
3289 return "text abs32";
3290 case MachO::REBASE_TYPE_TEXT_PCREL32:
3291 return "text rel32";
3296 // For use with the SegIndex of a checked Mach-O Rebase entry
3297 // to get the segment name.
3298 StringRef MachORebaseEntry::segmentName() const {
3299 return O->BindRebaseSegmentName(SegmentIndex);
3302 // For use with a SegIndex,SegOffset pair from a checked Mach-O Rebase entry
3303 // to get the section name.
3304 StringRef MachORebaseEntry::sectionName() const {
3305 return O->BindRebaseSectionName(SegmentIndex, SegmentOffset);
3308 // For use with a SegIndex,SegOffset pair from a checked Mach-O Rebase entry
3309 // to get the address.
3310 uint64_t MachORebaseEntry::address() const {
3311 return O->BindRebaseAddress(SegmentIndex, SegmentOffset);
3314 bool MachORebaseEntry::operator==(const MachORebaseEntry &Other) const {
3315 #ifdef EXPENSIVE_CHECKS
3316 assert(Opcodes == Other.Opcodes && "compare iterators of different files");
3318 assert(Opcodes.data() == Other.Opcodes.data() && "compare iterators of different files");
3320 return (Ptr == Other.Ptr) &&
3321 (RemainingLoopCount == Other.RemainingLoopCount) &&
3322 (Done == Other.Done);
3325 iterator_range<rebase_iterator>
3326 MachOObjectFile::rebaseTable(Error &Err, MachOObjectFile *O,
3327 ArrayRef<uint8_t> Opcodes, bool is64) {
3328 if (O->BindRebaseSectionTable == nullptr)
3329 O->BindRebaseSectionTable = llvm::make_unique<BindRebaseSegInfo>(O);
3330 MachORebaseEntry Start(&Err, O, Opcodes, is64);
3331 Start.moveToFirst();
3333 MachORebaseEntry Finish(&Err, O, Opcodes, is64);
3336 return make_range(rebase_iterator(Start), rebase_iterator(Finish));
3339 iterator_range<rebase_iterator> MachOObjectFile::rebaseTable(Error &Err) {
3340 return rebaseTable(Err, this, getDyldInfoRebaseOpcodes(), is64Bit());
3343 MachOBindEntry::MachOBindEntry(Error *E, const MachOObjectFile *O,
3344 ArrayRef<uint8_t> Bytes, bool is64Bit, Kind BK)
3345 : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()),
3346 PointerSize(is64Bit ? 8 : 4), TableKind(BK) {}
3348 void MachOBindEntry::moveToFirst() {
3349 Ptr = Opcodes.begin();
3353 void MachOBindEntry::moveToEnd() {
3354 Ptr = Opcodes.end();
3355 RemainingLoopCount = 0;
3359 void MachOBindEntry::moveNext() {
3360 ErrorAsOutParameter ErrAsOutParam(E);
3361 // If in the middle of some loop, move to next binding in loop.
3362 SegmentOffset += AdvanceAmount;
3363 if (RemainingLoopCount) {
3364 --RemainingLoopCount;
3367 // BIND_OPCODE_DONE is only used for padding if we are not aligned to
3368 // pointer size. Therefore it is possible to reach the end without ever having
3369 // seen BIND_OPCODE_DONE.
3370 if (Ptr == Opcodes.end()) {
3376 // Parse next opcode and set up next loop.
3377 const uint8_t *OpcodeStart = Ptr;
3378 uint8_t Byte = *Ptr++;
3379 uint8_t ImmValue = Byte & MachO::BIND_IMMEDIATE_MASK;
3380 uint8_t Opcode = Byte & MachO::BIND_OPCODE_MASK;
3381 int8_t SignExtended;
3382 const uint8_t *SymStart;
3383 uint32_t Count, Skip;
3384 const char *error = nullptr;
3386 case MachO::BIND_OPCODE_DONE:
3387 if (TableKind == Kind::Lazy) {
3388 // Lazying bindings have a DONE opcode between entries. Need to ignore
3389 // it to advance to next entry. But need not if this is last entry.
3390 bool NotLastEntry = false;
3391 for (const uint8_t *P = Ptr; P < Opcodes.end(); ++P) {
3393 NotLastEntry = true;
3401 DEBUG_WITH_TYPE("mach-o-bind", dbgs() << "BIND_OPCODE_DONE\n");
3403 case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
3404 if (TableKind == Kind::Weak) {
3405 *E = malformedError("BIND_OPCODE_SET_DYLIB_ORDINAL_IMM not allowed in "
3406 "weak bind table for opcode at: 0x" +
3407 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3412 LibraryOrdinalSet = true;
3413 if (ImmValue > O->getLibraryCount()) {
3414 *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB bad "
3415 "library ordinal: " +
3416 Twine((int)ImmValue) + " (max " +
3417 Twine((int)O->getLibraryCount()) +
3418 ") for opcode at: 0x" +
3419 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3425 dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: "
3426 << "Ordinal=" << Ordinal << "\n");
3428 case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
3429 if (TableKind == Kind::Weak) {
3430 *E = malformedError("BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB not allowed in "
3431 "weak bind table for opcode at: 0x" +
3432 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3436 Ordinal = readULEB128(&error);
3437 LibraryOrdinalSet = true;
3439 *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB " +
3440 Twine(error) + " for opcode at: 0x" +
3441 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3445 if (Ordinal > (int)O->getLibraryCount()) {
3446 *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB bad "
3447 "library ordinal: " +
3448 Twine((int)Ordinal) + " (max " +
3449 Twine((int)O->getLibraryCount()) +
3450 ") for opcode at: 0x" +
3451 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3457 dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: "
3458 << "Ordinal=" << Ordinal << "\n");
3460 case MachO::BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:
3461 if (TableKind == Kind::Weak) {
3462 *E = malformedError("BIND_OPCODE_SET_DYLIB_SPECIAL_IMM not allowed in "
3463 "weak bind table for opcode at: 0x" +
3464 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3469 SignExtended = MachO::BIND_OPCODE_MASK | ImmValue;
3470 Ordinal = SignExtended;
3471 if (Ordinal < MachO::BIND_SPECIAL_DYLIB_FLAT_LOOKUP) {
3472 *E = malformedError("for BIND_OPCODE_SET_DYLIB_SPECIAL_IMM unknown "
3473 "special ordinal: " +
3474 Twine((int)Ordinal) + " for opcode at: 0x" +
3475 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3481 LibraryOrdinalSet = true;
3484 dbgs() << "BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: "
3485 << "Ordinal=" << Ordinal << "\n");
3487 case MachO::BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
3490 while (*Ptr && (Ptr < Opcodes.end())) {
3493 if (Ptr == Opcodes.end()) {
3494 *E = malformedError(
3495 "for BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM "
3496 "symbol name extends past opcodes for opcode at: 0x" +
3497 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3501 SymbolName = StringRef(reinterpret_cast<const char*>(SymStart),
3506 dbgs() << "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: "
3507 << "SymbolName=" << SymbolName << "\n");
3508 if (TableKind == Kind::Weak) {
3509 if (ImmValue & MachO::BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION)
3513 case MachO::BIND_OPCODE_SET_TYPE_IMM:
3514 BindType = ImmValue;
3515 if (ImmValue > MachO::BIND_TYPE_TEXT_PCREL32) {
3516 *E = malformedError("for BIND_OPCODE_SET_TYPE_IMM bad bind type: " +
3517 Twine((int)ImmValue) + " for opcode at: 0x" +
3518 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3524 dbgs() << "BIND_OPCODE_SET_TYPE_IMM: "
3525 << "BindType=" << (int)BindType << "\n");
3527 case MachO::BIND_OPCODE_SET_ADDEND_SLEB:
3528 Addend = readSLEB128(&error);
3530 *E = malformedError("for BIND_OPCODE_SET_ADDEND_SLEB " + Twine(error) +
3531 " for opcode at: 0x" +
3532 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3538 dbgs() << "BIND_OPCODE_SET_ADDEND_SLEB: "
3539 << "Addend=" << Addend << "\n");
3541 case MachO::BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
3542 SegmentIndex = ImmValue;
3543 SegmentOffset = readULEB128(&error);
3545 *E = malformedError("for BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3546 Twine(error) + " for opcode at: 0x" +
3547 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3551 error = O->BindEntryCheckSegAndOffset(SegmentIndex, SegmentOffset, true);
3553 *E = malformedError("for BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3554 Twine(error) + " for opcode at: 0x" +
3555 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3561 dbgs() << "BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
3562 << "SegmentIndex=" << SegmentIndex << ", "
3563 << format("SegmentOffset=0x%06X", SegmentOffset)
3566 case MachO::BIND_OPCODE_ADD_ADDR_ULEB:
3567 SegmentOffset += readULEB128(&error);
3569 *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3570 " for opcode at: 0x" +
3571 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3575 error = O->BindEntryCheckSegAndOffset(SegmentIndex, SegmentOffset, true);
3577 *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3578 " for opcode at: 0x" +
3579 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3583 DEBUG_WITH_TYPE("mach-o-bind",
3584 dbgs() << "BIND_OPCODE_ADD_ADDR_ULEB: "
3585 << format("SegmentOffset=0x%06X",
3586 SegmentOffset) << "\n");
3588 case MachO::BIND_OPCODE_DO_BIND:
3589 AdvanceAmount = PointerSize;
3590 RemainingLoopCount = 0;
3591 error = O->BindEntryCheckSegAndOffset(SegmentIndex, SegmentOffset, true);
3593 *E = malformedError("for BIND_OPCODE_DO_BIND " + Twine(error) +
3594 " for opcode at: 0x" +
3595 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3599 if (SymbolName == StringRef()) {
3600 *E = malformedError(
3601 "for BIND_OPCODE_DO_BIND missing preceding "
3602 "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for opcode at: 0x" +
3603 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3607 if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3609 malformedError("for BIND_OPCODE_DO_BIND missing preceding "
3610 "BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode at: 0x" +
3611 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3615 DEBUG_WITH_TYPE("mach-o-bind",
3616 dbgs() << "BIND_OPCODE_DO_BIND: "
3617 << format("SegmentOffset=0x%06X",
3618 SegmentOffset) << "\n");
3620 case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
3621 if (TableKind == Kind::Lazy) {
3622 *E = malformedError("BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB not allowed in "
3623 "lazy bind table for opcode at: 0x" +
3624 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3628 error = O->BindEntryCheckSegAndOffset(SegmentIndex, SegmentOffset, true);
3630 *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB " +
3631 Twine(error) + " for opcode at: 0x" +
3632 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3636 if (SymbolName == StringRef()) {
3637 *E = malformedError(
3638 "for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB missing "
3639 "preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for opcode "
3641 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3645 if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3646 *E = malformedError(
3647 "for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB missing "
3648 "preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode at: 0x" +
3649 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3653 AdvanceAmount = readULEB128(&error) + PointerSize;
3655 *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB " +
3656 Twine(error) + " for opcode at: 0x" +
3657 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3661 // Note, this is not really an error until the next bind but make no sense
3662 // for a BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB to not be followed by another
3664 error = O->BindEntryCheckSegAndOffset(SegmentIndex, SegmentOffset +
3665 AdvanceAmount, false);
3667 *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB (after adding "
3669 Twine(error) + " for opcode at: 0x" +
3670 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3674 RemainingLoopCount = 0;
3677 dbgs() << "BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: "
3678 << format("SegmentOffset=0x%06X", SegmentOffset)
3679 << ", AdvanceAmount=" << AdvanceAmount
3680 << ", RemainingLoopCount=" << RemainingLoopCount
3683 case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
3684 if (TableKind == Kind::Lazy) {
3685 *E = malformedError("BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED not "
3686 "allowed in lazy bind table for opcode at: 0x" +
3687 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3691 error = O->BindEntryCheckSegAndOffset(SegmentIndex, SegmentOffset, true);
3693 *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED " +
3694 Twine(error) + " for opcode at: 0x" +
3695 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3699 if (SymbolName == StringRef()) {
3700 *E = malformedError(
3701 "for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED "
3702 "missing preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for "
3704 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3708 if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3709 *E = malformedError(
3710 "for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED "
3711 "missing preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode "
3713 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3717 AdvanceAmount = ImmValue * PointerSize + PointerSize;
3718 RemainingLoopCount = 0;
3719 error = O->BindEntryCheckSegAndOffset(SegmentIndex, SegmentOffset +
3720 AdvanceAmount, false);
3723 malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED "
3724 " (after adding immediate times the pointer size) " +
3725 Twine(error) + " for opcode at: 0x" +
3726 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3730 DEBUG_WITH_TYPE("mach-o-bind",
3732 << "BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: "
3733 << format("SegmentOffset=0x%06X", SegmentOffset) << "\n");
3735 case MachO::BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
3736 if (TableKind == Kind::Lazy) {
3737 *E = malformedError("BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB not "
3738 "allowed in lazy bind table for opcode at: 0x" +
3739 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3743 Count = readULEB128(&error);
3745 RemainingLoopCount = Count - 1;
3747 RemainingLoopCount = 0;
3749 *E = malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3751 Twine(error) + " for opcode at: 0x" +
3752 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3756 Skip = readULEB128(&error);
3757 AdvanceAmount = Skip + PointerSize;
3759 *E = malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3761 Twine(error) + " for opcode at: 0x" +
3762 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3766 error = O->BindEntryCheckSegAndOffset(SegmentIndex, SegmentOffset, true);
3769 malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB " +
3770 Twine(error) + " for opcode at: 0x" +
3771 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3775 if (SymbolName == StringRef()) {
3776 *E = malformedError(
3777 "for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3778 "missing preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for "
3780 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3784 if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3785 *E = malformedError(
3786 "for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3787 "missing preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode "
3789 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3793 error = O->BindEntryCheckCountAndSkip(Count, Skip, PointerSize,
3794 SegmentIndex, SegmentOffset);
3797 malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB " +
3798 Twine(error) + " for opcode at: 0x" +
3799 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3805 dbgs() << "BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: "
3806 << format("SegmentOffset=0x%06X", SegmentOffset)
3807 << ", AdvanceAmount=" << AdvanceAmount
3808 << ", RemainingLoopCount=" << RemainingLoopCount
3812 *E = malformedError("bad bind info (bad opcode value 0x" +
3813 Twine::utohexstr(Opcode) + " for opcode at: 0x" +
3814 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3821 uint64_t MachOBindEntry::readULEB128(const char **error) {
3823 uint64_t Result = decodeULEB128(Ptr, &Count, Opcodes.end(), error);
3825 if (Ptr > Opcodes.end())
3826 Ptr = Opcodes.end();
3830 int64_t MachOBindEntry::readSLEB128(const char **error) {
3832 int64_t Result = decodeSLEB128(Ptr, &Count, Opcodes.end(), error);
3834 if (Ptr > Opcodes.end())
3835 Ptr = Opcodes.end();
3839 int32_t MachOBindEntry::segmentIndex() const { return SegmentIndex; }
3841 uint64_t MachOBindEntry::segmentOffset() const { return SegmentOffset; }
3843 StringRef MachOBindEntry::typeName() const {
3845 case MachO::BIND_TYPE_POINTER:
3847 case MachO::BIND_TYPE_TEXT_ABSOLUTE32:
3848 return "text abs32";
3849 case MachO::BIND_TYPE_TEXT_PCREL32:
3850 return "text rel32";
3855 StringRef MachOBindEntry::symbolName() const { return SymbolName; }
3857 int64_t MachOBindEntry::addend() const { return Addend; }
3859 uint32_t MachOBindEntry::flags() const { return Flags; }
3861 int MachOBindEntry::ordinal() const { return Ordinal; }
3863 // For use with the SegIndex of a checked Mach-O Bind entry
3864 // to get the segment name.
3865 StringRef MachOBindEntry::segmentName() const {
3866 return O->BindRebaseSegmentName(SegmentIndex);
3869 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind entry
3870 // to get the section name.
3871 StringRef MachOBindEntry::sectionName() const {
3872 return O->BindRebaseSectionName(SegmentIndex, SegmentOffset);
3875 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind entry
3876 // to get the address.
3877 uint64_t MachOBindEntry::address() const {
3878 return O->BindRebaseAddress(SegmentIndex, SegmentOffset);
3881 bool MachOBindEntry::operator==(const MachOBindEntry &Other) const {
3882 #ifdef EXPENSIVE_CHECKS
3883 assert(Opcodes == Other.Opcodes && "compare iterators of different files");
3885 assert(Opcodes.data() == Other.Opcodes.data() && "compare iterators of different files");
3887 return (Ptr == Other.Ptr) &&
3888 (RemainingLoopCount == Other.RemainingLoopCount) &&
3889 (Done == Other.Done);
3892 // Build table of sections so SegIndex/SegOffset pairs can be translated.
3893 BindRebaseSegInfo::BindRebaseSegInfo(const object::MachOObjectFile *Obj) {
3894 uint32_t CurSegIndex = Obj->hasPageZeroSegment() ? 1 : 0;
3895 StringRef CurSegName;
3896 uint64_t CurSegAddress;
3897 for (const SectionRef &Section : Obj->sections()) {
3899 Section.getName(Info.SectionName);
3900 Info.Address = Section.getAddress();
3901 Info.Size = Section.getSize();
3903 Obj->getSectionFinalSegmentName(Section.getRawDataRefImpl());
3904 if (!Info.SegmentName.equals(CurSegName)) {
3906 CurSegName = Info.SegmentName;
3907 CurSegAddress = Info.Address;
3909 Info.SegmentIndex = CurSegIndex - 1;
3910 Info.OffsetInSegment = Info.Address - CurSegAddress;
3911 Info.SegmentStartAddress = CurSegAddress;
3912 Sections.push_back(Info);
3914 MaxSegIndex = CurSegIndex;
3917 // For use with a SegIndex,SegOffset pair in MachOBindEntry::moveNext() to
3918 // validate a MachOBindEntry or MachORebaseEntry.
3919 const char * BindRebaseSegInfo::checkSegAndOffset(int32_t SegIndex,
3923 return "missing preceding *_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB";
3924 if (SegIndex >= MaxSegIndex)
3925 return "bad segIndex (too large)";
3926 for (const SectionInfo &SI : Sections) {
3927 if (SI.SegmentIndex != SegIndex)
3929 if (SI.OffsetInSegment > SegOffset)
3931 if (SegOffset > (SI.OffsetInSegment + SI.Size))
3933 if (endInvalid && SegOffset >= (SI.OffsetInSegment + SI.Size))
3937 return "bad segOffset, too large";
3940 // For use in MachOBindEntry::moveNext() to validate a MachOBindEntry for
3941 // the BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB opcode and for use in
3942 // MachORebaseEntry::moveNext() to validate a MachORebaseEntry for
3943 // REBASE_OPCODE_DO_*_TIMES* opcodes. The SegIndex and SegOffset must have
3944 // been already checked.
3945 const char * BindRebaseSegInfo::checkCountAndSkip(uint32_t Count, uint32_t Skip,
3946 uint8_t PointerSize,
3948 uint64_t SegOffset) {
3949 const SectionInfo &SI = findSection(SegIndex, SegOffset);
3950 uint64_t addr = SI.SegmentStartAddress + SegOffset;
3951 if (addr >= SI.Address + SI.Size)
3952 return "bad segOffset, too large";
3955 i = (Skip + PointerSize) * (Count - 1);
3956 else if (Count == 1)
3957 i = Skip + PointerSize;
3958 if (addr + i >= SI.Address + SI.Size) {
3959 // For rebase opcodes they can step from one section to another.
3960 uint64_t TrailingSegOffset = (addr + i) - SI.SegmentStartAddress;
3961 const char *error = checkSegAndOffset(SegIndex, TrailingSegOffset, false);
3963 return "bad count and skip, too large";
3968 // For use with the SegIndex of a checked Mach-O Bind or Rebase entry
3969 // to get the segment name.
3970 StringRef BindRebaseSegInfo::segmentName(int32_t SegIndex) {
3971 for (const SectionInfo &SI : Sections) {
3972 if (SI.SegmentIndex == SegIndex)
3973 return SI.SegmentName;
3975 llvm_unreachable("invalid SegIndex");
3978 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
3979 // to get the SectionInfo.
3980 const BindRebaseSegInfo::SectionInfo &BindRebaseSegInfo::findSection(
3981 int32_t SegIndex, uint64_t SegOffset) {
3982 for (const SectionInfo &SI : Sections) {
3983 if (SI.SegmentIndex != SegIndex)
3985 if (SI.OffsetInSegment > SegOffset)
3987 if (SegOffset >= (SI.OffsetInSegment + SI.Size))
3991 llvm_unreachable("SegIndex and SegOffset not in any section");
3994 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
3995 // entry to get the section name.
3996 StringRef BindRebaseSegInfo::sectionName(int32_t SegIndex,
3997 uint64_t SegOffset) {
3998 return findSection(SegIndex, SegOffset).SectionName;
4001 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
4002 // entry to get the address.
4003 uint64_t BindRebaseSegInfo::address(uint32_t SegIndex, uint64_t OffsetInSeg) {
4004 const SectionInfo &SI = findSection(SegIndex, OffsetInSeg);
4005 return SI.SegmentStartAddress + OffsetInSeg;
4008 iterator_range<bind_iterator>
4009 MachOObjectFile::bindTable(Error &Err, MachOObjectFile *O,
4010 ArrayRef<uint8_t> Opcodes, bool is64,
4011 MachOBindEntry::Kind BKind) {
4012 if (O->BindRebaseSectionTable == nullptr)
4013 O->BindRebaseSectionTable = llvm::make_unique<BindRebaseSegInfo>(O);
4014 MachOBindEntry Start(&Err, O, Opcodes, is64, BKind);
4015 Start.moveToFirst();
4017 MachOBindEntry Finish(&Err, O, Opcodes, is64, BKind);
4020 return make_range(bind_iterator(Start), bind_iterator(Finish));
4023 iterator_range<bind_iterator> MachOObjectFile::bindTable(Error &Err) {
4024 return bindTable(Err, this, getDyldInfoBindOpcodes(), is64Bit(),
4025 MachOBindEntry::Kind::Regular);
4028 iterator_range<bind_iterator> MachOObjectFile::lazyBindTable(Error &Err) {
4029 return bindTable(Err, this, getDyldInfoLazyBindOpcodes(), is64Bit(),
4030 MachOBindEntry::Kind::Lazy);
4033 iterator_range<bind_iterator> MachOObjectFile::weakBindTable(Error &Err) {
4034 return bindTable(Err, this, getDyldInfoWeakBindOpcodes(), is64Bit(),
4035 MachOBindEntry::Kind::Weak);
4038 MachOObjectFile::load_command_iterator
4039 MachOObjectFile::begin_load_commands() const {
4040 return LoadCommands.begin();
4043 MachOObjectFile::load_command_iterator
4044 MachOObjectFile::end_load_commands() const {
4045 return LoadCommands.end();
4048 iterator_range<MachOObjectFile::load_command_iterator>
4049 MachOObjectFile::load_commands() const {
4050 return make_range(begin_load_commands(), end_load_commands());
4054 MachOObjectFile::getSectionFinalSegmentName(DataRefImpl Sec) const {
4055 ArrayRef<char> Raw = getSectionRawFinalSegmentName(Sec);
4056 return parseSegmentOrSectionName(Raw.data());
4060 MachOObjectFile::getSectionRawName(DataRefImpl Sec) const {
4061 assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
4062 const section_base *Base =
4063 reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
4064 return makeArrayRef(Base->sectname);
4068 MachOObjectFile::getSectionRawFinalSegmentName(DataRefImpl Sec) const {
4069 assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
4070 const section_base *Base =
4071 reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
4072 return makeArrayRef(Base->segname);
4076 MachOObjectFile::isRelocationScattered(const MachO::any_relocation_info &RE)
4078 if (getCPUType(*this) == MachO::CPU_TYPE_X86_64)
4080 return getPlainRelocationAddress(RE) & MachO::R_SCATTERED;
4083 unsigned MachOObjectFile::getPlainRelocationSymbolNum(
4084 const MachO::any_relocation_info &RE) const {
4085 if (isLittleEndian())
4086 return RE.r_word1 & 0xffffff;
4087 return RE.r_word1 >> 8;
4090 bool MachOObjectFile::getPlainRelocationExternal(
4091 const MachO::any_relocation_info &RE) const {
4092 if (isLittleEndian())
4093 return (RE.r_word1 >> 27) & 1;
4094 return (RE.r_word1 >> 4) & 1;
4097 bool MachOObjectFile::getScatteredRelocationScattered(
4098 const MachO::any_relocation_info &RE) const {
4099 return RE.r_word0 >> 31;
4102 uint32_t MachOObjectFile::getScatteredRelocationValue(
4103 const MachO::any_relocation_info &RE) const {
4107 uint32_t MachOObjectFile::getScatteredRelocationType(
4108 const MachO::any_relocation_info &RE) const {
4109 return (RE.r_word0 >> 24) & 0xf;
4112 unsigned MachOObjectFile::getAnyRelocationAddress(
4113 const MachO::any_relocation_info &RE) const {
4114 if (isRelocationScattered(RE))
4115 return getScatteredRelocationAddress(RE);
4116 return getPlainRelocationAddress(RE);
4119 unsigned MachOObjectFile::getAnyRelocationPCRel(
4120 const MachO::any_relocation_info &RE) const {
4121 if (isRelocationScattered(RE))
4122 return getScatteredRelocationPCRel(RE);
4123 return getPlainRelocationPCRel(*this, RE);
4126 unsigned MachOObjectFile::getAnyRelocationLength(
4127 const MachO::any_relocation_info &RE) const {
4128 if (isRelocationScattered(RE))
4129 return getScatteredRelocationLength(RE);
4130 return getPlainRelocationLength(*this, RE);
4134 MachOObjectFile::getAnyRelocationType(
4135 const MachO::any_relocation_info &RE) const {
4136 if (isRelocationScattered(RE))
4137 return getScatteredRelocationType(RE);
4138 return getPlainRelocationType(*this, RE);
4142 MachOObjectFile::getAnyRelocationSection(
4143 const MachO::any_relocation_info &RE) const {
4144 if (isRelocationScattered(RE) || getPlainRelocationExternal(RE))
4145 return *section_end();
4146 unsigned SecNum = getPlainRelocationSymbolNum(RE);
4147 if (SecNum == MachO::R_ABS || SecNum > Sections.size())
4148 return *section_end();
4150 DRI.d.a = SecNum - 1;
4151 return SectionRef(DRI, this);
4154 MachO::section MachOObjectFile::getSection(DataRefImpl DRI) const {
4155 assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
4156 return getStruct<MachO::section>(*this, Sections[DRI.d.a]);
4159 MachO::section_64 MachOObjectFile::getSection64(DataRefImpl DRI) const {
4160 assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
4161 return getStruct<MachO::section_64>(*this, Sections[DRI.d.a]);
4164 MachO::section MachOObjectFile::getSection(const LoadCommandInfo &L,
4165 unsigned Index) const {
4166 const char *Sec = getSectionPtr(*this, L, Index);
4167 return getStruct<MachO::section>(*this, Sec);
4170 MachO::section_64 MachOObjectFile::getSection64(const LoadCommandInfo &L,
4171 unsigned Index) const {
4172 const char *Sec = getSectionPtr(*this, L, Index);
4173 return getStruct<MachO::section_64>(*this, Sec);
4177 MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI) const {
4178 const char *P = reinterpret_cast<const char *>(DRI.p);
4179 return getStruct<MachO::nlist>(*this, P);
4183 MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI) const {
4184 const char *P = reinterpret_cast<const char *>(DRI.p);
4185 return getStruct<MachO::nlist_64>(*this, P);
4188 MachO::linkedit_data_command
4189 MachOObjectFile::getLinkeditDataLoadCommand(const LoadCommandInfo &L) const {
4190 return getStruct<MachO::linkedit_data_command>(*this, L.Ptr);
4193 MachO::segment_command
4194 MachOObjectFile::getSegmentLoadCommand(const LoadCommandInfo &L) const {
4195 return getStruct<MachO::segment_command>(*this, L.Ptr);
4198 MachO::segment_command_64
4199 MachOObjectFile::getSegment64LoadCommand(const LoadCommandInfo &L) const {
4200 return getStruct<MachO::segment_command_64>(*this, L.Ptr);
4203 MachO::linker_option_command
4204 MachOObjectFile::getLinkerOptionLoadCommand(const LoadCommandInfo &L) const {
4205 return getStruct<MachO::linker_option_command>(*this, L.Ptr);
4208 MachO::version_min_command
4209 MachOObjectFile::getVersionMinLoadCommand(const LoadCommandInfo &L) const {
4210 return getStruct<MachO::version_min_command>(*this, L.Ptr);
4214 MachOObjectFile::getNoteLoadCommand(const LoadCommandInfo &L) const {
4215 return getStruct<MachO::note_command>(*this, L.Ptr);
4218 MachO::build_version_command
4219 MachOObjectFile::getBuildVersionLoadCommand(const LoadCommandInfo &L) const {
4220 return getStruct<MachO::build_version_command>(*this, L.Ptr);
4223 MachO::build_tool_version
4224 MachOObjectFile::getBuildToolVersion(unsigned index) const {
4225 return getStruct<MachO::build_tool_version>(*this, BuildTools[index]);
4228 MachO::dylib_command
4229 MachOObjectFile::getDylibIDLoadCommand(const LoadCommandInfo &L) const {
4230 return getStruct<MachO::dylib_command>(*this, L.Ptr);
4233 MachO::dyld_info_command
4234 MachOObjectFile::getDyldInfoLoadCommand(const LoadCommandInfo &L) const {
4235 return getStruct<MachO::dyld_info_command>(*this, L.Ptr);
4238 MachO::dylinker_command
4239 MachOObjectFile::getDylinkerCommand(const LoadCommandInfo &L) const {
4240 return getStruct<MachO::dylinker_command>(*this, L.Ptr);
4244 MachOObjectFile::getUuidCommand(const LoadCommandInfo &L) const {
4245 return getStruct<MachO::uuid_command>(*this, L.Ptr);
4248 MachO::rpath_command
4249 MachOObjectFile::getRpathCommand(const LoadCommandInfo &L) const {
4250 return getStruct<MachO::rpath_command>(*this, L.Ptr);
4253 MachO::source_version_command
4254 MachOObjectFile::getSourceVersionCommand(const LoadCommandInfo &L) const {
4255 return getStruct<MachO::source_version_command>(*this, L.Ptr);
4258 MachO::entry_point_command
4259 MachOObjectFile::getEntryPointCommand(const LoadCommandInfo &L) const {
4260 return getStruct<MachO::entry_point_command>(*this, L.Ptr);
4263 MachO::encryption_info_command
4264 MachOObjectFile::getEncryptionInfoCommand(const LoadCommandInfo &L) const {
4265 return getStruct<MachO::encryption_info_command>(*this, L.Ptr);
4268 MachO::encryption_info_command_64
4269 MachOObjectFile::getEncryptionInfoCommand64(const LoadCommandInfo &L) const {
4270 return getStruct<MachO::encryption_info_command_64>(*this, L.Ptr);
4273 MachO::sub_framework_command
4274 MachOObjectFile::getSubFrameworkCommand(const LoadCommandInfo &L) const {
4275 return getStruct<MachO::sub_framework_command>(*this, L.Ptr);
4278 MachO::sub_umbrella_command
4279 MachOObjectFile::getSubUmbrellaCommand(const LoadCommandInfo &L) const {
4280 return getStruct<MachO::sub_umbrella_command>(*this, L.Ptr);
4283 MachO::sub_library_command
4284 MachOObjectFile::getSubLibraryCommand(const LoadCommandInfo &L) const {
4285 return getStruct<MachO::sub_library_command>(*this, L.Ptr);
4288 MachO::sub_client_command
4289 MachOObjectFile::getSubClientCommand(const LoadCommandInfo &L) const {
4290 return getStruct<MachO::sub_client_command>(*this, L.Ptr);
4293 MachO::routines_command
4294 MachOObjectFile::getRoutinesCommand(const LoadCommandInfo &L) const {
4295 return getStruct<MachO::routines_command>(*this, L.Ptr);
4298 MachO::routines_command_64
4299 MachOObjectFile::getRoutinesCommand64(const LoadCommandInfo &L) const {
4300 return getStruct<MachO::routines_command_64>(*this, L.Ptr);
4303 MachO::thread_command
4304 MachOObjectFile::getThreadCommand(const LoadCommandInfo &L) const {
4305 return getStruct<MachO::thread_command>(*this, L.Ptr);
4308 MachO::any_relocation_info
4309 MachOObjectFile::getRelocation(DataRefImpl Rel) const {
4311 if (getHeader().filetype == MachO::MH_OBJECT) {
4315 MachO::section_64 Sect = getSection64(Sec);
4316 Offset = Sect.reloff;
4318 MachO::section Sect = getSection(Sec);
4319 Offset = Sect.reloff;
4322 MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
4324 Offset = DysymtabLoadCmd.extreloff; // Offset to the external relocations
4326 Offset = DysymtabLoadCmd.locreloff; // Offset to the local relocations
4329 auto P = reinterpret_cast<const MachO::any_relocation_info *>(
4330 getPtr(*this, Offset)) + Rel.d.b;
4331 return getStruct<MachO::any_relocation_info>(
4332 *this, reinterpret_cast<const char *>(P));
4335 MachO::data_in_code_entry
4336 MachOObjectFile::getDice(DataRefImpl Rel) const {
4337 const char *P = reinterpret_cast<const char *>(Rel.p);
4338 return getStruct<MachO::data_in_code_entry>(*this, P);
4341 const MachO::mach_header &MachOObjectFile::getHeader() const {
4345 const MachO::mach_header_64 &MachOObjectFile::getHeader64() const {
4350 uint32_t MachOObjectFile::getIndirectSymbolTableEntry(
4351 const MachO::dysymtab_command &DLC,
4352 unsigned Index) const {
4353 uint64_t Offset = DLC.indirectsymoff + Index * sizeof(uint32_t);
4354 return getStruct<uint32_t>(*this, getPtr(*this, Offset));
4357 MachO::data_in_code_entry
4358 MachOObjectFile::getDataInCodeTableEntry(uint32_t DataOffset,
4359 unsigned Index) const {
4360 uint64_t Offset = DataOffset + Index * sizeof(MachO::data_in_code_entry);
4361 return getStruct<MachO::data_in_code_entry>(*this, getPtr(*this, Offset));
4364 MachO::symtab_command MachOObjectFile::getSymtabLoadCommand() const {
4366 return getStruct<MachO::symtab_command>(*this, SymtabLoadCmd);
4368 // If there is no SymtabLoadCmd return a load command with zero'ed fields.
4369 MachO::symtab_command Cmd;
4370 Cmd.cmd = MachO::LC_SYMTAB;
4371 Cmd.cmdsize = sizeof(MachO::symtab_command);
4379 MachO::dysymtab_command MachOObjectFile::getDysymtabLoadCommand() const {
4380 if (DysymtabLoadCmd)
4381 return getStruct<MachO::dysymtab_command>(*this, DysymtabLoadCmd);
4383 // If there is no DysymtabLoadCmd return a load command with zero'ed fields.
4384 MachO::dysymtab_command Cmd;
4385 Cmd.cmd = MachO::LC_DYSYMTAB;
4386 Cmd.cmdsize = sizeof(MachO::dysymtab_command);
4397 Cmd.extrefsymoff = 0;
4398 Cmd.nextrefsyms = 0;
4399 Cmd.indirectsymoff = 0;
4400 Cmd.nindirectsyms = 0;
4408 MachO::linkedit_data_command
4409 MachOObjectFile::getDataInCodeLoadCommand() const {
4410 if (DataInCodeLoadCmd)
4411 return getStruct<MachO::linkedit_data_command>(*this, DataInCodeLoadCmd);
4413 // If there is no DataInCodeLoadCmd return a load command with zero'ed fields.
4414 MachO::linkedit_data_command Cmd;
4415 Cmd.cmd = MachO::LC_DATA_IN_CODE;
4416 Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
4422 MachO::linkedit_data_command
4423 MachOObjectFile::getLinkOptHintsLoadCommand() const {
4424 if (LinkOptHintsLoadCmd)
4425 return getStruct<MachO::linkedit_data_command>(*this, LinkOptHintsLoadCmd);
4427 // If there is no LinkOptHintsLoadCmd return a load command with zero'ed
4429 MachO::linkedit_data_command Cmd;
4430 Cmd.cmd = MachO::LC_LINKER_OPTIMIZATION_HINT;
4431 Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
4437 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoRebaseOpcodes() const {
4438 if (!DyldInfoLoadCmd)
4441 MachO::dyld_info_command DyldInfo =
4442 getStruct<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4443 const uint8_t *Ptr =
4444 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.rebase_off));
4445 return makeArrayRef(Ptr, DyldInfo.rebase_size);
4448 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoBindOpcodes() const {
4449 if (!DyldInfoLoadCmd)
4452 MachO::dyld_info_command DyldInfo =
4453 getStruct<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4454 const uint8_t *Ptr =
4455 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.bind_off));
4456 return makeArrayRef(Ptr, DyldInfo.bind_size);
4459 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoWeakBindOpcodes() const {
4460 if (!DyldInfoLoadCmd)
4463 MachO::dyld_info_command DyldInfo =
4464 getStruct<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4465 const uint8_t *Ptr =
4466 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.weak_bind_off));
4467 return makeArrayRef(Ptr, DyldInfo.weak_bind_size);
4470 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoLazyBindOpcodes() const {
4471 if (!DyldInfoLoadCmd)
4474 MachO::dyld_info_command DyldInfo =
4475 getStruct<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4476 const uint8_t *Ptr =
4477 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.lazy_bind_off));
4478 return makeArrayRef(Ptr, DyldInfo.lazy_bind_size);
4481 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoExportsTrie() const {
4482 if (!DyldInfoLoadCmd)
4485 MachO::dyld_info_command DyldInfo =
4486 getStruct<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4487 const uint8_t *Ptr =
4488 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.export_off));
4489 return makeArrayRef(Ptr, DyldInfo.export_size);
4492 ArrayRef<uint8_t> MachOObjectFile::getUuid() const {
4495 // Returning a pointer is fine as uuid doesn't need endian swapping.
4496 const char *Ptr = UuidLoadCmd + offsetof(MachO::uuid_command, uuid);
4497 return makeArrayRef(reinterpret_cast<const uint8_t *>(Ptr), 16);
4500 StringRef MachOObjectFile::getStringTableData() const {
4501 MachO::symtab_command S = getSymtabLoadCommand();
4502 return getData().substr(S.stroff, S.strsize);
4505 bool MachOObjectFile::is64Bit() const {
4506 return getType() == getMachOType(false, true) ||
4507 getType() == getMachOType(true, true);
4510 void MachOObjectFile::ReadULEB128s(uint64_t Index,
4511 SmallVectorImpl<uint64_t> &Out) const {
4512 DataExtractor extractor(ObjectFile::getData(), true, 0);
4514 uint32_t offset = Index;
4516 while (uint64_t delta = extractor.getULEB128(&offset)) {
4518 Out.push_back(data);
4522 bool MachOObjectFile::isRelocatableObject() const {
4523 return getHeader().filetype == MachO::MH_OBJECT;
4526 Expected<std::unique_ptr<MachOObjectFile>>
4527 ObjectFile::createMachOObjectFile(MemoryBufferRef Buffer,
4528 uint32_t UniversalCputype,
4529 uint32_t UniversalIndex) {
4530 StringRef Magic = Buffer.getBuffer().slice(0, 4);
4531 if (Magic == "\xFE\xED\xFA\xCE")
4532 return MachOObjectFile::create(Buffer, false, false,
4533 UniversalCputype, UniversalIndex);
4534 if (Magic == "\xCE\xFA\xED\xFE")
4535 return MachOObjectFile::create(Buffer, true, false,
4536 UniversalCputype, UniversalIndex);
4537 if (Magic == "\xFE\xED\xFA\xCF")
4538 return MachOObjectFile::create(Buffer, false, true,
4539 UniversalCputype, UniversalIndex);
4540 if (Magic == "\xCF\xFA\xED\xFE")
4541 return MachOObjectFile::create(Buffer, true, true,
4542 UniversalCputype, UniversalIndex);
4543 return make_error<GenericBinaryError>("Unrecognized MachO magic number",
4544 object_error::invalid_file_type);
4547 StringRef MachOObjectFile::mapDebugSectionName(StringRef Name) const {
4548 return StringSwitch<StringRef>(Name)
4549 .Case("debug_str_offs", "debug_str_offsets")