1 //===- MachOObjectFile.cpp - Mach-O object file binding -------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the MachOObjectFile class, which binds the MachOObject
10 // class to the generic ObjectFile wrapper.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/ADT/ArrayRef.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/SmallVector.h"
17 #include "llvm/ADT/StringRef.h"
18 #include "llvm/ADT/StringSwitch.h"
19 #include "llvm/ADT/Triple.h"
20 #include "llvm/ADT/Twine.h"
21 #include "llvm/ADT/bit.h"
22 #include "llvm/BinaryFormat/MachO.h"
23 #include "llvm/BinaryFormat/Swift.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/Errc.h"
31 #include "llvm/Support/Error.h"
32 #include "llvm/Support/ErrorHandling.h"
33 #include "llvm/Support/FileSystem.h"
34 #include "llvm/Support/Format.h"
35 #include "llvm/Support/Host.h"
36 #include "llvm/Support/LEB128.h"
37 #include "llvm/Support/MemoryBufferRef.h"
38 #include "llvm/Support/Path.h"
39 #include "llvm/Support/SwapByteOrder.h"
40 #include "llvm/Support/raw_ostream.h"
41 #include <algorithm>
42 #include <cassert>
43 #include <cstddef>
44 #include <cstdint>
45 #include <cstring>
46 #include <limits>
47 #include <list>
48 #include <memory>
49 #include <system_error>
50 
51 using namespace llvm;
52 using namespace object;
53 
54 namespace {
55 
56   struct section_base {
57     char sectname[16];
58     char segname[16];
59   };
60 
61 } // end anonymous namespace
62 
malformedError(const Twine & Msg)63 static Error malformedError(const Twine &Msg) {
64   return make_error<GenericBinaryError>("truncated or malformed object (" +
65                                             Msg + ")",
66                                         object_error::parse_failed);
67 }
68 
69 // FIXME: Replace all uses of this function with getStructOrErr.
70 template <typename T>
getStruct(const MachOObjectFile & O,const char * P)71 static T getStruct(const MachOObjectFile &O, const char *P) {
72   // Don't read before the beginning or past the end of the file
73   if (P < O.getData().begin() || P + sizeof(T) > O.getData().end())
74     report_fatal_error("Malformed MachO file.");
75 
76   T Cmd;
77   memcpy(&Cmd, P, sizeof(T));
78   if (O.isLittleEndian() != sys::IsLittleEndianHost)
79     MachO::swapStruct(Cmd);
80   return Cmd;
81 }
82 
83 template <typename T>
getStructOrErr(const MachOObjectFile & O,const char * P)84 static Expected<T> getStructOrErr(const MachOObjectFile &O, const char *P) {
85   // Don't read before the beginning or past the end of the file
86   if (P < O.getData().begin() || P + sizeof(T) > O.getData().end())
87     return malformedError("Structure read out-of-range");
88 
89   T Cmd;
90   memcpy(&Cmd, P, sizeof(T));
91   if (O.isLittleEndian() != sys::IsLittleEndianHost)
92     MachO::swapStruct(Cmd);
93   return Cmd;
94 }
95 
96 static const char *
getSectionPtr(const MachOObjectFile & O,MachOObjectFile::LoadCommandInfo L,unsigned Sec)97 getSectionPtr(const MachOObjectFile &O, MachOObjectFile::LoadCommandInfo L,
98               unsigned Sec) {
99   uintptr_t CommandAddr = reinterpret_cast<uintptr_t>(L.Ptr);
100 
101   bool Is64 = O.is64Bit();
102   unsigned SegmentLoadSize = Is64 ? sizeof(MachO::segment_command_64) :
103                                     sizeof(MachO::segment_command);
104   unsigned SectionSize = Is64 ? sizeof(MachO::section_64) :
105                                 sizeof(MachO::section);
106 
107   uintptr_t SectionAddr = CommandAddr + SegmentLoadSize + Sec * SectionSize;
108   return reinterpret_cast<const char*>(SectionAddr);
109 }
110 
getPtr(const MachOObjectFile & O,size_t Offset)111 static const char *getPtr(const MachOObjectFile &O, size_t Offset) {
112   assert(Offset <= O.getData().size());
113   return O.getData().data() + Offset;
114 }
115 
116 static MachO::nlist_base
getSymbolTableEntryBase(const MachOObjectFile & O,DataRefImpl DRI)117 getSymbolTableEntryBase(const MachOObjectFile &O, DataRefImpl DRI) {
118   const char *P = reinterpret_cast<const char *>(DRI.p);
119   return getStruct<MachO::nlist_base>(O, P);
120 }
121 
parseSegmentOrSectionName(const char * P)122 static StringRef parseSegmentOrSectionName(const char *P) {
123   if (P[15] == 0)
124     // Null terminated.
125     return P;
126   // Not null terminated, so this is a 16 char string.
127   return StringRef(P, 16);
128 }
129 
getCPUType(const MachOObjectFile & O)130 static unsigned getCPUType(const MachOObjectFile &O) {
131   return O.getHeader().cputype;
132 }
133 
getCPUSubType(const MachOObjectFile & O)134 static unsigned getCPUSubType(const MachOObjectFile &O) {
135   return O.getHeader().cpusubtype;
136 }
137 
138 static uint32_t
getPlainRelocationAddress(const MachO::any_relocation_info & RE)139 getPlainRelocationAddress(const MachO::any_relocation_info &RE) {
140   return RE.r_word0;
141 }
142 
143 static unsigned
getScatteredRelocationAddress(const MachO::any_relocation_info & RE)144 getScatteredRelocationAddress(const MachO::any_relocation_info &RE) {
145   return RE.r_word0 & 0xffffff;
146 }
147 
getPlainRelocationPCRel(const MachOObjectFile & O,const MachO::any_relocation_info & RE)148 static bool getPlainRelocationPCRel(const MachOObjectFile &O,
149                                     const MachO::any_relocation_info &RE) {
150   if (O.isLittleEndian())
151     return (RE.r_word1 >> 24) & 1;
152   return (RE.r_word1 >> 7) & 1;
153 }
154 
155 static bool
getScatteredRelocationPCRel(const MachO::any_relocation_info & RE)156 getScatteredRelocationPCRel(const MachO::any_relocation_info &RE) {
157   return (RE.r_word0 >> 30) & 1;
158 }
159 
getPlainRelocationLength(const MachOObjectFile & O,const MachO::any_relocation_info & RE)160 static unsigned getPlainRelocationLength(const MachOObjectFile &O,
161                                          const MachO::any_relocation_info &RE) {
162   if (O.isLittleEndian())
163     return (RE.r_word1 >> 25) & 3;
164   return (RE.r_word1 >> 5) & 3;
165 }
166 
167 static unsigned
getScatteredRelocationLength(const MachO::any_relocation_info & RE)168 getScatteredRelocationLength(const MachO::any_relocation_info &RE) {
169   return (RE.r_word0 >> 28) & 3;
170 }
171 
getPlainRelocationType(const MachOObjectFile & O,const MachO::any_relocation_info & RE)172 static unsigned getPlainRelocationType(const MachOObjectFile &O,
173                                        const MachO::any_relocation_info &RE) {
174   if (O.isLittleEndian())
175     return RE.r_word1 >> 28;
176   return RE.r_word1 & 0xf;
177 }
178 
getSectionFlags(const MachOObjectFile & O,DataRefImpl Sec)179 static uint32_t getSectionFlags(const MachOObjectFile &O,
180                                 DataRefImpl Sec) {
181   if (O.is64Bit()) {
182     MachO::section_64 Sect = O.getSection64(Sec);
183     return Sect.flags;
184   }
185   MachO::section Sect = O.getSection(Sec);
186   return Sect.flags;
187 }
188 
189 static Expected<MachOObjectFile::LoadCommandInfo>
getLoadCommandInfo(const MachOObjectFile & Obj,const char * Ptr,uint32_t LoadCommandIndex)190 getLoadCommandInfo(const MachOObjectFile &Obj, const char *Ptr,
191                    uint32_t LoadCommandIndex) {
192   if (auto CmdOrErr = getStructOrErr<MachO::load_command>(Obj, Ptr)) {
193     if (CmdOrErr->cmdsize + Ptr > Obj.getData().end())
194       return malformedError("load command " + Twine(LoadCommandIndex) +
195                             " extends past end of file");
196     if (CmdOrErr->cmdsize < 8)
197       return malformedError("load command " + Twine(LoadCommandIndex) +
198                             " with size less than 8 bytes");
199     return MachOObjectFile::LoadCommandInfo({Ptr, *CmdOrErr});
200   } else
201     return CmdOrErr.takeError();
202 }
203 
204 static Expected<MachOObjectFile::LoadCommandInfo>
getFirstLoadCommandInfo(const MachOObjectFile & Obj)205 getFirstLoadCommandInfo(const MachOObjectFile &Obj) {
206   unsigned HeaderSize = Obj.is64Bit() ? sizeof(MachO::mach_header_64)
207                                       : sizeof(MachO::mach_header);
208   if (sizeof(MachO::load_command) > Obj.getHeader().sizeofcmds)
209     return malformedError("load command 0 extends past the end all load "
210                           "commands in the file");
211   return getLoadCommandInfo(Obj, getPtr(Obj, HeaderSize), 0);
212 }
213 
214 static Expected<MachOObjectFile::LoadCommandInfo>
getNextLoadCommandInfo(const MachOObjectFile & Obj,uint32_t LoadCommandIndex,const MachOObjectFile::LoadCommandInfo & L)215 getNextLoadCommandInfo(const MachOObjectFile &Obj, uint32_t LoadCommandIndex,
216                        const MachOObjectFile::LoadCommandInfo &L) {
217   unsigned HeaderSize = Obj.is64Bit() ? sizeof(MachO::mach_header_64)
218                                       : sizeof(MachO::mach_header);
219   if (L.Ptr + L.C.cmdsize + sizeof(MachO::load_command) >
220       Obj.getData().data() + HeaderSize + Obj.getHeader().sizeofcmds)
221     return malformedError("load command " + Twine(LoadCommandIndex + 1) +
222                           " extends past the end all load commands in the file");
223   return getLoadCommandInfo(Obj, L.Ptr + L.C.cmdsize, LoadCommandIndex + 1);
224 }
225 
226 template <typename T>
parseHeader(const MachOObjectFile & Obj,T & Header,Error & Err)227 static void parseHeader(const MachOObjectFile &Obj, T &Header,
228                         Error &Err) {
229   if (sizeof(T) > Obj.getData().size()) {
230     Err = malformedError("the mach header extends past the end of the "
231                          "file");
232     return;
233   }
234   if (auto HeaderOrErr = getStructOrErr<T>(Obj, getPtr(Obj, 0)))
235     Header = *HeaderOrErr;
236   else
237     Err = HeaderOrErr.takeError();
238 }
239 
240 // This is used to check for overlapping of Mach-O elements.
241 struct MachOElement {
242   uint64_t Offset;
243   uint64_t Size;
244   const char *Name;
245 };
246 
checkOverlappingElement(std::list<MachOElement> & Elements,uint64_t Offset,uint64_t Size,const char * Name)247 static Error checkOverlappingElement(std::list<MachOElement> &Elements,
248                                      uint64_t Offset, uint64_t Size,
249                                      const char *Name) {
250   if (Size == 0)
251     return Error::success();
252 
253   for (auto it = Elements.begin(); it != Elements.end(); ++it) {
254     const auto &E = *it;
255     if ((Offset >= E.Offset && Offset < E.Offset + E.Size) ||
256         (Offset + Size > E.Offset && Offset + Size < E.Offset + E.Size) ||
257         (Offset <= E.Offset && Offset + Size >= E.Offset + E.Size))
258       return malformedError(Twine(Name) + " at offset " + Twine(Offset) +
259                             " with a size of " + Twine(Size) + ", overlaps " +
260                             E.Name + " at offset " + Twine(E.Offset) + " with "
261                             "a size of " + Twine(E.Size));
262     auto nt = it;
263     nt++;
264     if (nt != Elements.end()) {
265       const auto &N = *nt;
266       if (Offset + Size <= N.Offset) {
267         Elements.insert(nt, {Offset, Size, Name});
268         return Error::success();
269       }
270     }
271   }
272   Elements.push_back({Offset, Size, Name});
273   return Error::success();
274 }
275 
276 // Parses LC_SEGMENT or LC_SEGMENT_64 load command, adds addresses of all
277 // sections to \param Sections, and optionally sets
278 // \param IsPageZeroSegment to true.
279 template <typename Segment, typename Section>
parseSegmentLoadCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,SmallVectorImpl<const char * > & Sections,bool & IsPageZeroSegment,uint32_t LoadCommandIndex,const char * CmdName,uint64_t SizeOfHeaders,std::list<MachOElement> & Elements)280 static Error parseSegmentLoadCommand(
281     const MachOObjectFile &Obj, const MachOObjectFile::LoadCommandInfo &Load,
282     SmallVectorImpl<const char *> &Sections, bool &IsPageZeroSegment,
283     uint32_t LoadCommandIndex, const char *CmdName, uint64_t SizeOfHeaders,
284     std::list<MachOElement> &Elements) {
285   const unsigned SegmentLoadSize = sizeof(Segment);
286   if (Load.C.cmdsize < SegmentLoadSize)
287     return malformedError("load command " + Twine(LoadCommandIndex) +
288                           " " + CmdName + " cmdsize too small");
289   if (auto SegOrErr = getStructOrErr<Segment>(Obj, Load.Ptr)) {
290     Segment S = SegOrErr.get();
291     const unsigned SectionSize = sizeof(Section);
292     uint64_t FileSize = Obj.getData().size();
293     if (S.nsects > std::numeric_limits<uint32_t>::max() / SectionSize ||
294         S.nsects * SectionSize > Load.C.cmdsize - SegmentLoadSize)
295       return malformedError("load command " + Twine(LoadCommandIndex) +
296                             " inconsistent cmdsize in " + CmdName +
297                             " for the number of sections");
298     for (unsigned J = 0; J < S.nsects; ++J) {
299       const char *Sec = getSectionPtr(Obj, Load, J);
300       Sections.push_back(Sec);
301       auto SectionOrErr = getStructOrErr<Section>(Obj, Sec);
302       if (!SectionOrErr)
303         return SectionOrErr.takeError();
304       Section s = SectionOrErr.get();
305       if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
306           Obj.getHeader().filetype != MachO::MH_DSYM &&
307           s.flags != MachO::S_ZEROFILL &&
308           s.flags != MachO::S_THREAD_LOCAL_ZEROFILL &&
309           s.offset > FileSize)
310         return malformedError("offset field of section " + Twine(J) + " in " +
311                               CmdName + " command " + Twine(LoadCommandIndex) +
312                               " extends past the end of the file");
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 && S.fileoff == 0 &&
317           s.offset < SizeOfHeaders && s.size != 0)
318         return malformedError("offset field of section " + Twine(J) + " in " +
319                               CmdName + " command " + Twine(LoadCommandIndex) +
320                               " not past the headers of the file");
321       uint64_t BigSize = s.offset;
322       BigSize += s.size;
323       if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
324           Obj.getHeader().filetype != MachO::MH_DSYM &&
325           s.flags != MachO::S_ZEROFILL &&
326           s.flags != MachO::S_THREAD_LOCAL_ZEROFILL &&
327           BigSize > FileSize)
328         return malformedError("offset field plus size field of section " +
329                               Twine(J) + " in " + CmdName + " command " +
330                               Twine(LoadCommandIndex) +
331                               " extends past the end of the file");
332       if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
333           Obj.getHeader().filetype != MachO::MH_DSYM &&
334           s.flags != MachO::S_ZEROFILL &&
335           s.flags != MachO::S_THREAD_LOCAL_ZEROFILL &&
336           s.size > S.filesize)
337         return malformedError("size field of section " +
338                               Twine(J) + " in " + CmdName + " command " +
339                               Twine(LoadCommandIndex) +
340                               " greater than the segment");
341       if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
342           Obj.getHeader().filetype != MachO::MH_DSYM && s.size != 0 &&
343           s.addr < S.vmaddr)
344         return malformedError("addr field of section " + Twine(J) + " in " +
345                               CmdName + " command " + Twine(LoadCommandIndex) +
346                               " less than the segment's vmaddr");
347       BigSize = s.addr;
348       BigSize += s.size;
349       uint64_t BigEnd = S.vmaddr;
350       BigEnd += S.vmsize;
351       if (S.vmsize != 0 && s.size != 0 && BigSize > BigEnd)
352         return malformedError("addr field plus size of section " + Twine(J) +
353                               " in " + CmdName + " command " +
354                               Twine(LoadCommandIndex) +
355                               " greater than than "
356                               "the segment's vmaddr plus vmsize");
357       if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
358           Obj.getHeader().filetype != MachO::MH_DSYM &&
359           s.flags != MachO::S_ZEROFILL &&
360           s.flags != MachO::S_THREAD_LOCAL_ZEROFILL)
361         if (Error Err = checkOverlappingElement(Elements, s.offset, s.size,
362                                                 "section contents"))
363           return Err;
364       if (s.reloff > FileSize)
365         return malformedError("reloff field of section " + Twine(J) + " in " +
366                               CmdName + " command " + Twine(LoadCommandIndex) +
367                               " extends past the end of the file");
368       BigSize = s.nreloc;
369       BigSize *= sizeof(struct MachO::relocation_info);
370       BigSize += s.reloff;
371       if (BigSize > FileSize)
372         return malformedError("reloff field plus nreloc field times sizeof("
373                               "struct relocation_info) of section " +
374                               Twine(J) + " in " + CmdName + " command " +
375                               Twine(LoadCommandIndex) +
376                               " extends past the end of the file");
377       if (Error Err = checkOverlappingElement(Elements, s.reloff, s.nreloc *
378                                               sizeof(struct
379                                               MachO::relocation_info),
380                                               "section relocation entries"))
381         return Err;
382     }
383     if (S.fileoff > FileSize)
384       return malformedError("load command " + Twine(LoadCommandIndex) +
385                             " fileoff field in " + CmdName +
386                             " extends past the end of the file");
387     uint64_t BigSize = S.fileoff;
388     BigSize += S.filesize;
389     if (BigSize > FileSize)
390       return malformedError("load command " + Twine(LoadCommandIndex) +
391                             " fileoff field plus filesize field in " +
392                             CmdName + " extends past the end of the file");
393     if (S.vmsize != 0 && S.filesize > S.vmsize)
394       return malformedError("load command " + Twine(LoadCommandIndex) +
395                             " filesize field in " + CmdName +
396                             " greater than vmsize field");
397     IsPageZeroSegment |= StringRef("__PAGEZERO").equals(S.segname);
398   } else
399     return SegOrErr.takeError();
400 
401   return Error::success();
402 }
403 
checkSymtabCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char ** SymtabLoadCmd,std::list<MachOElement> & Elements)404 static Error checkSymtabCommand(const MachOObjectFile &Obj,
405                                 const MachOObjectFile::LoadCommandInfo &Load,
406                                 uint32_t LoadCommandIndex,
407                                 const char **SymtabLoadCmd,
408                                 std::list<MachOElement> &Elements) {
409   if (Load.C.cmdsize < sizeof(MachO::symtab_command))
410     return malformedError("load command " + Twine(LoadCommandIndex) +
411                           " LC_SYMTAB cmdsize too small");
412   if (*SymtabLoadCmd != nullptr)
413     return malformedError("more than one LC_SYMTAB command");
414   auto SymtabOrErr = getStructOrErr<MachO::symtab_command>(Obj, Load.Ptr);
415   if (!SymtabOrErr)
416     return SymtabOrErr.takeError();
417   MachO::symtab_command Symtab = SymtabOrErr.get();
418   if (Symtab.cmdsize != sizeof(MachO::symtab_command))
419     return malformedError("LC_SYMTAB command " + Twine(LoadCommandIndex) +
420                           " has incorrect cmdsize");
421   uint64_t FileSize = Obj.getData().size();
422   if (Symtab.symoff > FileSize)
423     return malformedError("symoff field of LC_SYMTAB command " +
424                           Twine(LoadCommandIndex) + " extends past the end "
425                           "of the file");
426   uint64_t SymtabSize = Symtab.nsyms;
427   const char *struct_nlist_name;
428   if (Obj.is64Bit()) {
429     SymtabSize *= sizeof(MachO::nlist_64);
430     struct_nlist_name = "struct nlist_64";
431   } else {
432     SymtabSize *= sizeof(MachO::nlist);
433     struct_nlist_name = "struct nlist";
434   }
435   uint64_t BigSize = SymtabSize;
436   BigSize += Symtab.symoff;
437   if (BigSize > FileSize)
438     return malformedError("symoff field plus nsyms field times sizeof(" +
439                           Twine(struct_nlist_name) + ") of LC_SYMTAB command " +
440                           Twine(LoadCommandIndex) + " extends past the end "
441                           "of the file");
442   if (Error Err = checkOverlappingElement(Elements, Symtab.symoff, SymtabSize,
443                                           "symbol table"))
444     return Err;
445   if (Symtab.stroff > FileSize)
446     return malformedError("stroff field of LC_SYMTAB command " +
447                           Twine(LoadCommandIndex) + " extends past the end "
448                           "of the file");
449   BigSize = Symtab.stroff;
450   BigSize += Symtab.strsize;
451   if (BigSize > FileSize)
452     return malformedError("stroff field plus strsize field of LC_SYMTAB "
453                           "command " + Twine(LoadCommandIndex) + " extends "
454                           "past the end of the file");
455   if (Error Err = checkOverlappingElement(Elements, Symtab.stroff,
456                                           Symtab.strsize, "string table"))
457     return Err;
458   *SymtabLoadCmd = Load.Ptr;
459   return Error::success();
460 }
461 
checkDysymtabCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char ** DysymtabLoadCmd,std::list<MachOElement> & Elements)462 static Error checkDysymtabCommand(const MachOObjectFile &Obj,
463                                   const MachOObjectFile::LoadCommandInfo &Load,
464                                   uint32_t LoadCommandIndex,
465                                   const char **DysymtabLoadCmd,
466                                   std::list<MachOElement> &Elements) {
467   if (Load.C.cmdsize < sizeof(MachO::dysymtab_command))
468     return malformedError("load command " + Twine(LoadCommandIndex) +
469                           " LC_DYSYMTAB cmdsize too small");
470   if (*DysymtabLoadCmd != nullptr)
471     return malformedError("more than one LC_DYSYMTAB command");
472   auto DysymtabOrErr =
473     getStructOrErr<MachO::dysymtab_command>(Obj, Load.Ptr);
474   if (!DysymtabOrErr)
475     return DysymtabOrErr.takeError();
476   MachO::dysymtab_command Dysymtab = DysymtabOrErr.get();
477   if (Dysymtab.cmdsize != sizeof(MachO::dysymtab_command))
478     return malformedError("LC_DYSYMTAB command " + Twine(LoadCommandIndex) +
479                           " has incorrect cmdsize");
480   uint64_t FileSize = Obj.getData().size();
481   if (Dysymtab.tocoff > FileSize)
482     return malformedError("tocoff field of LC_DYSYMTAB command " +
483                           Twine(LoadCommandIndex) + " extends past the end of "
484                           "the file");
485   uint64_t BigSize = Dysymtab.ntoc;
486   BigSize *= sizeof(MachO::dylib_table_of_contents);
487   BigSize += Dysymtab.tocoff;
488   if (BigSize > FileSize)
489     return malformedError("tocoff field plus ntoc field times sizeof(struct "
490                           "dylib_table_of_contents) of LC_DYSYMTAB command " +
491                           Twine(LoadCommandIndex) + " extends past the end of "
492                           "the file");
493   if (Error Err = checkOverlappingElement(Elements, Dysymtab.tocoff,
494                                           Dysymtab.ntoc * sizeof(struct
495                                           MachO::dylib_table_of_contents),
496                                           "table of contents"))
497     return Err;
498   if (Dysymtab.modtaboff > FileSize)
499     return malformedError("modtaboff field of LC_DYSYMTAB command " +
500                           Twine(LoadCommandIndex) + " extends past the end of "
501                           "the file");
502   BigSize = Dysymtab.nmodtab;
503   const char *struct_dylib_module_name;
504   uint64_t sizeof_modtab;
505   if (Obj.is64Bit()) {
506     sizeof_modtab = sizeof(MachO::dylib_module_64);
507     struct_dylib_module_name = "struct dylib_module_64";
508   } else {
509     sizeof_modtab = sizeof(MachO::dylib_module);
510     struct_dylib_module_name = "struct dylib_module";
511   }
512   BigSize *= sizeof_modtab;
513   BigSize += Dysymtab.modtaboff;
514   if (BigSize > FileSize)
515     return malformedError("modtaboff field plus nmodtab field times sizeof(" +
516                           Twine(struct_dylib_module_name) + ") of LC_DYSYMTAB "
517                           "command " + Twine(LoadCommandIndex) + " extends "
518                           "past the end of the file");
519   if (Error Err = checkOverlappingElement(Elements, Dysymtab.modtaboff,
520                                           Dysymtab.nmodtab * sizeof_modtab,
521                                           "module table"))
522     return Err;
523   if (Dysymtab.extrefsymoff > FileSize)
524     return malformedError("extrefsymoff field of LC_DYSYMTAB command " +
525                           Twine(LoadCommandIndex) + " extends past the end of "
526                           "the file");
527   BigSize = Dysymtab.nextrefsyms;
528   BigSize *= sizeof(MachO::dylib_reference);
529   BigSize += Dysymtab.extrefsymoff;
530   if (BigSize > FileSize)
531     return malformedError("extrefsymoff field plus nextrefsyms field times "
532                           "sizeof(struct dylib_reference) of LC_DYSYMTAB "
533                           "command " + Twine(LoadCommandIndex) + " extends "
534                           "past the end of the file");
535   if (Error Err = checkOverlappingElement(Elements, Dysymtab.extrefsymoff,
536                                           Dysymtab.nextrefsyms *
537                                               sizeof(MachO::dylib_reference),
538                                           "reference table"))
539     return Err;
540   if (Dysymtab.indirectsymoff > FileSize)
541     return malformedError("indirectsymoff field of LC_DYSYMTAB command " +
542                           Twine(LoadCommandIndex) + " extends past the end of "
543                           "the file");
544   BigSize = Dysymtab.nindirectsyms;
545   BigSize *= sizeof(uint32_t);
546   BigSize += Dysymtab.indirectsymoff;
547   if (BigSize > FileSize)
548     return malformedError("indirectsymoff field plus nindirectsyms field times "
549                           "sizeof(uint32_t) of LC_DYSYMTAB command " +
550                           Twine(LoadCommandIndex) + " extends past the end of "
551                           "the file");
552   if (Error Err = checkOverlappingElement(Elements, Dysymtab.indirectsymoff,
553                                           Dysymtab.nindirectsyms *
554                                           sizeof(uint32_t),
555                                           "indirect table"))
556     return Err;
557   if (Dysymtab.extreloff > FileSize)
558     return malformedError("extreloff field of LC_DYSYMTAB command " +
559                           Twine(LoadCommandIndex) + " extends past the end of "
560                           "the file");
561   BigSize = Dysymtab.nextrel;
562   BigSize *= sizeof(MachO::relocation_info);
563   BigSize += Dysymtab.extreloff;
564   if (BigSize > FileSize)
565     return malformedError("extreloff field plus nextrel field times sizeof"
566                           "(struct relocation_info) of LC_DYSYMTAB command " +
567                           Twine(LoadCommandIndex) + " extends past the end of "
568                           "the file");
569   if (Error Err = checkOverlappingElement(Elements, Dysymtab.extreloff,
570                                           Dysymtab.nextrel *
571                                               sizeof(MachO::relocation_info),
572                                           "external relocation table"))
573     return Err;
574   if (Dysymtab.locreloff > FileSize)
575     return malformedError("locreloff field of LC_DYSYMTAB command " +
576                           Twine(LoadCommandIndex) + " extends past the end of "
577                           "the file");
578   BigSize = Dysymtab.nlocrel;
579   BigSize *= sizeof(MachO::relocation_info);
580   BigSize += Dysymtab.locreloff;
581   if (BigSize > FileSize)
582     return malformedError("locreloff field plus nlocrel field times sizeof"
583                           "(struct relocation_info) of LC_DYSYMTAB command " +
584                           Twine(LoadCommandIndex) + " extends past the end of "
585                           "the file");
586   if (Error Err = checkOverlappingElement(Elements, Dysymtab.locreloff,
587                                           Dysymtab.nlocrel *
588                                               sizeof(MachO::relocation_info),
589                                           "local relocation table"))
590     return Err;
591   *DysymtabLoadCmd = Load.Ptr;
592   return Error::success();
593 }
594 
checkLinkeditDataCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char ** LoadCmd,const char * CmdName,std::list<MachOElement> & Elements,const char * ElementName)595 static Error checkLinkeditDataCommand(const MachOObjectFile &Obj,
596                                  const MachOObjectFile::LoadCommandInfo &Load,
597                                  uint32_t LoadCommandIndex,
598                                  const char **LoadCmd, const char *CmdName,
599                                  std::list<MachOElement> &Elements,
600                                  const char *ElementName) {
601   if (Load.C.cmdsize < sizeof(MachO::linkedit_data_command))
602     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
603                           CmdName + " cmdsize too small");
604   if (*LoadCmd != nullptr)
605     return malformedError("more than one " + Twine(CmdName) + " command");
606   auto LinkDataOrError =
607     getStructOrErr<MachO::linkedit_data_command>(Obj, Load.Ptr);
608   if (!LinkDataOrError)
609     return LinkDataOrError.takeError();
610   MachO::linkedit_data_command LinkData = LinkDataOrError.get();
611   if (LinkData.cmdsize != sizeof(MachO::linkedit_data_command))
612     return malformedError(Twine(CmdName) + " command " +
613                           Twine(LoadCommandIndex) + " has incorrect cmdsize");
614   uint64_t FileSize = Obj.getData().size();
615   if (LinkData.dataoff > FileSize)
616     return malformedError("dataoff field of " + Twine(CmdName) + " command " +
617                           Twine(LoadCommandIndex) + " extends past the end of "
618                           "the file");
619   uint64_t BigSize = LinkData.dataoff;
620   BigSize += LinkData.datasize;
621   if (BigSize > FileSize)
622     return malformedError("dataoff field plus datasize field of " +
623                           Twine(CmdName) + " command " +
624                           Twine(LoadCommandIndex) + " extends past the end of "
625                           "the file");
626   if (Error Err = checkOverlappingElement(Elements, LinkData.dataoff,
627                                           LinkData.datasize, ElementName))
628     return Err;
629   *LoadCmd = Load.Ptr;
630   return Error::success();
631 }
632 
checkDyldInfoCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char ** LoadCmd,const char * CmdName,std::list<MachOElement> & Elements)633 static Error checkDyldInfoCommand(const MachOObjectFile &Obj,
634                                   const MachOObjectFile::LoadCommandInfo &Load,
635                                   uint32_t LoadCommandIndex,
636                                   const char **LoadCmd, const char *CmdName,
637                                   std::list<MachOElement> &Elements) {
638   if (Load.C.cmdsize < sizeof(MachO::dyld_info_command))
639     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
640                           CmdName + " cmdsize too small");
641   if (*LoadCmd != nullptr)
642     return malformedError("more than one LC_DYLD_INFO and or LC_DYLD_INFO_ONLY "
643                           "command");
644   auto DyldInfoOrErr =
645     getStructOrErr<MachO::dyld_info_command>(Obj, Load.Ptr);
646   if (!DyldInfoOrErr)
647     return DyldInfoOrErr.takeError();
648   MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
649   if (DyldInfo.cmdsize != sizeof(MachO::dyld_info_command))
650     return malformedError(Twine(CmdName) + " command " +
651                           Twine(LoadCommandIndex) + " has incorrect cmdsize");
652   uint64_t FileSize = Obj.getData().size();
653   if (DyldInfo.rebase_off > FileSize)
654     return malformedError("rebase_off field of " + Twine(CmdName) +
655                           " command " + Twine(LoadCommandIndex) + " extends "
656                           "past the end of the file");
657   uint64_t BigSize = DyldInfo.rebase_off;
658   BigSize += DyldInfo.rebase_size;
659   if (BigSize > FileSize)
660     return malformedError("rebase_off field plus rebase_size field of " +
661                           Twine(CmdName) + " command " +
662                           Twine(LoadCommandIndex) + " extends past the end of "
663                           "the file");
664   if (Error Err = checkOverlappingElement(Elements, DyldInfo.rebase_off,
665                                           DyldInfo.rebase_size,
666                                           "dyld rebase info"))
667     return Err;
668   if (DyldInfo.bind_off > FileSize)
669     return malformedError("bind_off field of " + Twine(CmdName) +
670                           " command " + Twine(LoadCommandIndex) + " extends "
671                           "past the end of the file");
672   BigSize = DyldInfo.bind_off;
673   BigSize += DyldInfo.bind_size;
674   if (BigSize > FileSize)
675     return malformedError("bind_off field plus bind_size field of " +
676                           Twine(CmdName) + " command " +
677                           Twine(LoadCommandIndex) + " extends past the end of "
678                           "the file");
679   if (Error Err = checkOverlappingElement(Elements, DyldInfo.bind_off,
680                                           DyldInfo.bind_size,
681                                           "dyld bind info"))
682     return Err;
683   if (DyldInfo.weak_bind_off > FileSize)
684     return malformedError("weak_bind_off field of " + Twine(CmdName) +
685                           " command " + Twine(LoadCommandIndex) + " extends "
686                           "past the end of the file");
687   BigSize = DyldInfo.weak_bind_off;
688   BigSize += DyldInfo.weak_bind_size;
689   if (BigSize > FileSize)
690     return malformedError("weak_bind_off field plus weak_bind_size field of " +
691                           Twine(CmdName) + " command " +
692                           Twine(LoadCommandIndex) + " extends past the end of "
693                           "the file");
694   if (Error Err = checkOverlappingElement(Elements, DyldInfo.weak_bind_off,
695                                           DyldInfo.weak_bind_size,
696                                           "dyld weak bind info"))
697     return Err;
698   if (DyldInfo.lazy_bind_off > FileSize)
699     return malformedError("lazy_bind_off field of " + Twine(CmdName) +
700                           " command " + Twine(LoadCommandIndex) + " extends "
701                           "past the end of the file");
702   BigSize = DyldInfo.lazy_bind_off;
703   BigSize += DyldInfo.lazy_bind_size;
704   if (BigSize > FileSize)
705     return malformedError("lazy_bind_off field plus lazy_bind_size field of " +
706                           Twine(CmdName) + " command " +
707                           Twine(LoadCommandIndex) + " extends past the end of "
708                           "the file");
709   if (Error Err = checkOverlappingElement(Elements, DyldInfo.lazy_bind_off,
710                                           DyldInfo.lazy_bind_size,
711                                           "dyld lazy bind info"))
712     return Err;
713   if (DyldInfo.export_off > FileSize)
714     return malformedError("export_off field of " + Twine(CmdName) +
715                           " command " + Twine(LoadCommandIndex) + " extends "
716                           "past the end of the file");
717   BigSize = DyldInfo.export_off;
718   BigSize += DyldInfo.export_size;
719   if (BigSize > FileSize)
720     return malformedError("export_off field plus export_size field of " +
721                           Twine(CmdName) + " command " +
722                           Twine(LoadCommandIndex) + " extends past the end of "
723                           "the file");
724   if (Error Err = checkOverlappingElement(Elements, DyldInfo.export_off,
725                                           DyldInfo.export_size,
726                                           "dyld export info"))
727     return Err;
728   *LoadCmd = Load.Ptr;
729   return Error::success();
730 }
731 
checkDylibCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char * CmdName)732 static Error checkDylibCommand(const MachOObjectFile &Obj,
733                                const MachOObjectFile::LoadCommandInfo &Load,
734                                uint32_t LoadCommandIndex, const char *CmdName) {
735   if (Load.C.cmdsize < sizeof(MachO::dylib_command))
736     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
737                           CmdName + " cmdsize too small");
738   auto CommandOrErr = getStructOrErr<MachO::dylib_command>(Obj, Load.Ptr);
739   if (!CommandOrErr)
740     return CommandOrErr.takeError();
741   MachO::dylib_command D = CommandOrErr.get();
742   if (D.dylib.name < sizeof(MachO::dylib_command))
743     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
744                           CmdName + " name.offset field too small, not past "
745                           "the end of the dylib_command struct");
746   if (D.dylib.name >= D.cmdsize)
747     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
748                           CmdName + " name.offset field extends past the end "
749                           "of the load command");
750   // Make sure there is a null between the starting offset of the name and
751   // the end of the load command.
752   uint32_t i;
753   const char *P = (const char *)Load.Ptr;
754   for (i = D.dylib.name; i < D.cmdsize; i++)
755     if (P[i] == '\0')
756       break;
757   if (i >= D.cmdsize)
758     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
759                           CmdName + " library name extends past the end of the "
760                           "load command");
761   return Error::success();
762 }
763 
checkDylibIdCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char ** LoadCmd)764 static Error checkDylibIdCommand(const MachOObjectFile &Obj,
765                                  const MachOObjectFile::LoadCommandInfo &Load,
766                                  uint32_t LoadCommandIndex,
767                                  const char **LoadCmd) {
768   if (Error Err = checkDylibCommand(Obj, Load, LoadCommandIndex,
769                                      "LC_ID_DYLIB"))
770     return Err;
771   if (*LoadCmd != nullptr)
772     return malformedError("more than one LC_ID_DYLIB command");
773   if (Obj.getHeader().filetype != MachO::MH_DYLIB &&
774       Obj.getHeader().filetype != MachO::MH_DYLIB_STUB)
775     return malformedError("LC_ID_DYLIB load command in non-dynamic library "
776                           "file type");
777   *LoadCmd = Load.Ptr;
778   return Error::success();
779 }
780 
checkDyldCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char * CmdName)781 static Error checkDyldCommand(const MachOObjectFile &Obj,
782                               const MachOObjectFile::LoadCommandInfo &Load,
783                               uint32_t LoadCommandIndex, const char *CmdName) {
784   if (Load.C.cmdsize < sizeof(MachO::dylinker_command))
785     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
786                           CmdName + " cmdsize too small");
787   auto CommandOrErr = getStructOrErr<MachO::dylinker_command>(Obj, Load.Ptr);
788   if (!CommandOrErr)
789     return CommandOrErr.takeError();
790   MachO::dylinker_command D = CommandOrErr.get();
791   if (D.name < sizeof(MachO::dylinker_command))
792     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
793                           CmdName + " name.offset field too small, not past "
794                           "the end of the dylinker_command struct");
795   if (D.name >= D.cmdsize)
796     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
797                           CmdName + " name.offset field extends past the end "
798                           "of the load command");
799   // Make sure there is a null between the starting offset of the name and
800   // the end of the load command.
801   uint32_t i;
802   const char *P = (const char *)Load.Ptr;
803   for (i = D.name; i < D.cmdsize; i++)
804     if (P[i] == '\0')
805       break;
806   if (i >= D.cmdsize)
807     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
808                           CmdName + " dyld name extends past the end of the "
809                           "load command");
810   return Error::success();
811 }
812 
checkVersCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char ** LoadCmd,const char * CmdName)813 static Error checkVersCommand(const MachOObjectFile &Obj,
814                               const MachOObjectFile::LoadCommandInfo &Load,
815                               uint32_t LoadCommandIndex,
816                               const char **LoadCmd, const char *CmdName) {
817   if (Load.C.cmdsize != sizeof(MachO::version_min_command))
818     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
819                           CmdName + " has incorrect cmdsize");
820   if (*LoadCmd != nullptr)
821     return malformedError("more than one LC_VERSION_MIN_MACOSX, "
822                           "LC_VERSION_MIN_IPHONEOS, LC_VERSION_MIN_TVOS or "
823                           "LC_VERSION_MIN_WATCHOS command");
824   *LoadCmd = Load.Ptr;
825   return Error::success();
826 }
827 
checkNoteCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,std::list<MachOElement> & Elements)828 static Error checkNoteCommand(const MachOObjectFile &Obj,
829                               const MachOObjectFile::LoadCommandInfo &Load,
830                               uint32_t LoadCommandIndex,
831                               std::list<MachOElement> &Elements) {
832   if (Load.C.cmdsize != sizeof(MachO::note_command))
833     return malformedError("load command " + Twine(LoadCommandIndex) +
834                           " LC_NOTE has incorrect cmdsize");
835   auto NoteCmdOrErr = getStructOrErr<MachO::note_command>(Obj, Load.Ptr);
836   if (!NoteCmdOrErr)
837     return NoteCmdOrErr.takeError();
838   MachO::note_command Nt = NoteCmdOrErr.get();
839   uint64_t FileSize = Obj.getData().size();
840   if (Nt.offset > FileSize)
841     return malformedError("offset field of LC_NOTE command " +
842                           Twine(LoadCommandIndex) + " extends "
843                           "past the end of the file");
844   uint64_t BigSize = Nt.offset;
845   BigSize += Nt.size;
846   if (BigSize > FileSize)
847     return malformedError("size field plus offset field of LC_NOTE command " +
848                           Twine(LoadCommandIndex) + " extends past the end of "
849                           "the file");
850   if (Error Err = checkOverlappingElement(Elements, Nt.offset, Nt.size,
851                                           "LC_NOTE data"))
852     return Err;
853   return Error::success();
854 }
855 
856 static Error
parseBuildVersionCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,SmallVectorImpl<const char * > & BuildTools,uint32_t LoadCommandIndex)857 parseBuildVersionCommand(const MachOObjectFile &Obj,
858                          const MachOObjectFile::LoadCommandInfo &Load,
859                          SmallVectorImpl<const char*> &BuildTools,
860                          uint32_t LoadCommandIndex) {
861   auto BVCOrErr =
862     getStructOrErr<MachO::build_version_command>(Obj, Load.Ptr);
863   if (!BVCOrErr)
864     return BVCOrErr.takeError();
865   MachO::build_version_command BVC = BVCOrErr.get();
866   if (Load.C.cmdsize !=
867       sizeof(MachO::build_version_command) +
868           BVC.ntools * sizeof(MachO::build_tool_version))
869     return malformedError("load command " + Twine(LoadCommandIndex) +
870                           " LC_BUILD_VERSION_COMMAND has incorrect cmdsize");
871 
872   auto Start = Load.Ptr + sizeof(MachO::build_version_command);
873   BuildTools.resize(BVC.ntools);
874   for (unsigned i = 0; i < BVC.ntools; ++i)
875     BuildTools[i] = Start + i * sizeof(MachO::build_tool_version);
876 
877   return Error::success();
878 }
879 
checkRpathCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex)880 static Error checkRpathCommand(const MachOObjectFile &Obj,
881                                const MachOObjectFile::LoadCommandInfo &Load,
882                                uint32_t LoadCommandIndex) {
883   if (Load.C.cmdsize < sizeof(MachO::rpath_command))
884     return malformedError("load command " + Twine(LoadCommandIndex) +
885                           " LC_RPATH cmdsize too small");
886   auto ROrErr = getStructOrErr<MachO::rpath_command>(Obj, Load.Ptr);
887   if (!ROrErr)
888     return ROrErr.takeError();
889   MachO::rpath_command R = ROrErr.get();
890   if (R.path < sizeof(MachO::rpath_command))
891     return malformedError("load command " + Twine(LoadCommandIndex) +
892                           " LC_RPATH path.offset field too small, not past "
893                           "the end of the rpath_command struct");
894   if (R.path >= R.cmdsize)
895     return malformedError("load command " + Twine(LoadCommandIndex) +
896                           " LC_RPATH path.offset field extends past the end "
897                           "of the load command");
898   // Make sure there is a null between the starting offset of the path and
899   // the end of the load command.
900   uint32_t i;
901   const char *P = (const char *)Load.Ptr;
902   for (i = R.path; i < R.cmdsize; i++)
903     if (P[i] == '\0')
904       break;
905   if (i >= R.cmdsize)
906     return malformedError("load command " + Twine(LoadCommandIndex) +
907                           " LC_RPATH library name extends past the end of the "
908                           "load command");
909   return Error::success();
910 }
911 
checkEncryptCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,uint64_t cryptoff,uint64_t cryptsize,const char ** LoadCmd,const char * CmdName)912 static Error checkEncryptCommand(const MachOObjectFile &Obj,
913                                  const MachOObjectFile::LoadCommandInfo &Load,
914                                  uint32_t LoadCommandIndex,
915                                  uint64_t cryptoff, uint64_t cryptsize,
916                                  const char **LoadCmd, const char *CmdName) {
917   if (*LoadCmd != nullptr)
918     return malformedError("more than one LC_ENCRYPTION_INFO and or "
919                           "LC_ENCRYPTION_INFO_64 command");
920   uint64_t FileSize = Obj.getData().size();
921   if (cryptoff > FileSize)
922     return malformedError("cryptoff field of " + Twine(CmdName) +
923                           " command " + Twine(LoadCommandIndex) + " extends "
924                           "past the end of the file");
925   uint64_t BigSize = cryptoff;
926   BigSize += cryptsize;
927   if (BigSize > FileSize)
928     return malformedError("cryptoff field plus cryptsize field of " +
929                           Twine(CmdName) + " command " +
930                           Twine(LoadCommandIndex) + " extends past the end of "
931                           "the file");
932   *LoadCmd = Load.Ptr;
933   return Error::success();
934 }
935 
checkLinkerOptCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex)936 static Error checkLinkerOptCommand(const MachOObjectFile &Obj,
937                                    const MachOObjectFile::LoadCommandInfo &Load,
938                                    uint32_t LoadCommandIndex) {
939   if (Load.C.cmdsize < sizeof(MachO::linker_option_command))
940     return malformedError("load command " + Twine(LoadCommandIndex) +
941                           " LC_LINKER_OPTION cmdsize too small");
942   auto LinkOptionOrErr =
943     getStructOrErr<MachO::linker_option_command>(Obj, Load.Ptr);
944   if (!LinkOptionOrErr)
945     return LinkOptionOrErr.takeError();
946   MachO::linker_option_command L = LinkOptionOrErr.get();
947   // Make sure the count of strings is correct.
948   const char *string = (const char *)Load.Ptr +
949                        sizeof(struct MachO::linker_option_command);
950   uint32_t left = L.cmdsize - sizeof(struct MachO::linker_option_command);
951   uint32_t i = 0;
952   while (left > 0) {
953     while (*string == '\0' && left > 0) {
954       string++;
955       left--;
956     }
957     if (left > 0) {
958       i++;
959       uint32_t NullPos = StringRef(string, left).find('\0');
960       if (0xffffffff == NullPos)
961         return malformedError("load command " + Twine(LoadCommandIndex) +
962                               " LC_LINKER_OPTION string #" + Twine(i) +
963                               " is not NULL terminated");
964       uint32_t len = std::min(NullPos, left) + 1;
965       string += len;
966       left -= len;
967     }
968   }
969   if (L.count != i)
970     return malformedError("load command " + Twine(LoadCommandIndex) +
971                           " LC_LINKER_OPTION string count " + Twine(L.count) +
972                           " does not match number of strings");
973   return Error::success();
974 }
975 
checkSubCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char * CmdName,size_t SizeOfCmd,const char * CmdStructName,uint32_t PathOffset,const char * PathFieldName)976 static Error checkSubCommand(const MachOObjectFile &Obj,
977                              const MachOObjectFile::LoadCommandInfo &Load,
978                              uint32_t LoadCommandIndex, const char *CmdName,
979                              size_t SizeOfCmd, const char *CmdStructName,
980                              uint32_t PathOffset, const char *PathFieldName) {
981   if (PathOffset < SizeOfCmd)
982     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
983                           CmdName + " " + PathFieldName + ".offset field too "
984                           "small, not past the end of the " + CmdStructName);
985   if (PathOffset >= Load.C.cmdsize)
986     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
987                           CmdName + " " + PathFieldName + ".offset field "
988                           "extends past the end of the load command");
989   // Make sure there is a null between the starting offset of the path and
990   // the end of the load command.
991   uint32_t i;
992   const char *P = (const char *)Load.Ptr;
993   for (i = PathOffset; i < Load.C.cmdsize; i++)
994     if (P[i] == '\0')
995       break;
996   if (i >= Load.C.cmdsize)
997     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
998                           CmdName + " " + PathFieldName + " name extends past "
999                           "the end of the load command");
1000   return Error::success();
1001 }
1002 
checkThreadCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char * CmdName)1003 static Error checkThreadCommand(const MachOObjectFile &Obj,
1004                                 const MachOObjectFile::LoadCommandInfo &Load,
1005                                 uint32_t LoadCommandIndex,
1006                                 const char *CmdName) {
1007   if (Load.C.cmdsize < sizeof(MachO::thread_command))
1008     return malformedError("load command " + Twine(LoadCommandIndex) +
1009                           CmdName + " cmdsize too small");
1010   auto ThreadCommandOrErr =
1011     getStructOrErr<MachO::thread_command>(Obj, Load.Ptr);
1012   if (!ThreadCommandOrErr)
1013     return ThreadCommandOrErr.takeError();
1014   MachO::thread_command T = ThreadCommandOrErr.get();
1015   const char *state = Load.Ptr + sizeof(MachO::thread_command);
1016   const char *end = Load.Ptr + T.cmdsize;
1017   uint32_t nflavor = 0;
1018   uint32_t cputype = getCPUType(Obj);
1019   while (state < end) {
1020     if(state + sizeof(uint32_t) > end)
1021       return malformedError("load command " + Twine(LoadCommandIndex) +
1022                             "flavor in " + CmdName + " extends past end of "
1023                             "command");
1024     uint32_t flavor;
1025     memcpy(&flavor, state, sizeof(uint32_t));
1026     if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
1027       sys::swapByteOrder(flavor);
1028     state += sizeof(uint32_t);
1029 
1030     if(state + sizeof(uint32_t) > end)
1031       return malformedError("load command " + Twine(LoadCommandIndex) +
1032                             " count in " + CmdName + " extends past end of "
1033                             "command");
1034     uint32_t count;
1035     memcpy(&count, state, sizeof(uint32_t));
1036     if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
1037       sys::swapByteOrder(count);
1038     state += sizeof(uint32_t);
1039 
1040     if (cputype == MachO::CPU_TYPE_I386) {
1041       if (flavor == MachO::x86_THREAD_STATE32) {
1042         if (count != MachO::x86_THREAD_STATE32_COUNT)
1043           return malformedError("load command " + Twine(LoadCommandIndex) +
1044                                 " count not x86_THREAD_STATE32_COUNT for "
1045                                 "flavor number " + Twine(nflavor) + " which is "
1046                                 "a x86_THREAD_STATE32 flavor in " + CmdName +
1047                                 " command");
1048         if (state + sizeof(MachO::x86_thread_state32_t) > end)
1049           return malformedError("load command " + Twine(LoadCommandIndex) +
1050                                 " x86_THREAD_STATE32 extends past end of "
1051                                 "command in " + CmdName + " command");
1052         state += sizeof(MachO::x86_thread_state32_t);
1053       } else {
1054         return malformedError("load command " + Twine(LoadCommandIndex) +
1055                               " unknown flavor (" + Twine(flavor) + ") for "
1056                               "flavor number " + Twine(nflavor) + " in " +
1057                               CmdName + " command");
1058       }
1059     } else if (cputype == MachO::CPU_TYPE_X86_64) {
1060       if (flavor == MachO::x86_THREAD_STATE) {
1061         if (count != MachO::x86_THREAD_STATE_COUNT)
1062           return malformedError("load command " + Twine(LoadCommandIndex) +
1063                                 " count not x86_THREAD_STATE_COUNT for "
1064                                 "flavor number " + Twine(nflavor) + " which is "
1065                                 "a x86_THREAD_STATE flavor in " + CmdName +
1066                                 " command");
1067         if (state + sizeof(MachO::x86_thread_state_t) > end)
1068           return malformedError("load command " + Twine(LoadCommandIndex) +
1069                                 " x86_THREAD_STATE extends past end of "
1070                                 "command in " + CmdName + " command");
1071         state += sizeof(MachO::x86_thread_state_t);
1072       } else if (flavor == MachO::x86_FLOAT_STATE) {
1073         if (count != MachO::x86_FLOAT_STATE_COUNT)
1074           return malformedError("load command " + Twine(LoadCommandIndex) +
1075                                 " count not x86_FLOAT_STATE_COUNT for "
1076                                 "flavor number " + Twine(nflavor) + " which is "
1077                                 "a x86_FLOAT_STATE flavor in " + CmdName +
1078                                 " command");
1079         if (state + sizeof(MachO::x86_float_state_t) > end)
1080           return malformedError("load command " + Twine(LoadCommandIndex) +
1081                                 " x86_FLOAT_STATE extends past end of "
1082                                 "command in " + CmdName + " command");
1083         state += sizeof(MachO::x86_float_state_t);
1084       } else if (flavor == MachO::x86_EXCEPTION_STATE) {
1085         if (count != MachO::x86_EXCEPTION_STATE_COUNT)
1086           return malformedError("load command " + Twine(LoadCommandIndex) +
1087                                 " count not x86_EXCEPTION_STATE_COUNT for "
1088                                 "flavor number " + Twine(nflavor) + " which is "
1089                                 "a x86_EXCEPTION_STATE flavor in " + CmdName +
1090                                 " command");
1091         if (state + sizeof(MachO::x86_exception_state_t) > end)
1092           return malformedError("load command " + Twine(LoadCommandIndex) +
1093                                 " x86_EXCEPTION_STATE extends past end of "
1094                                 "command in " + CmdName + " command");
1095         state += sizeof(MachO::x86_exception_state_t);
1096       } else if (flavor == MachO::x86_THREAD_STATE64) {
1097         if (count != MachO::x86_THREAD_STATE64_COUNT)
1098           return malformedError("load command " + Twine(LoadCommandIndex) +
1099                                 " count not x86_THREAD_STATE64_COUNT for "
1100                                 "flavor number " + Twine(nflavor) + " which is "
1101                                 "a x86_THREAD_STATE64 flavor in " + CmdName +
1102                                 " command");
1103         if (state + sizeof(MachO::x86_thread_state64_t) > end)
1104           return malformedError("load command " + Twine(LoadCommandIndex) +
1105                                 " x86_THREAD_STATE64 extends past end of "
1106                                 "command in " + CmdName + " command");
1107         state += sizeof(MachO::x86_thread_state64_t);
1108       } else if (flavor == MachO::x86_EXCEPTION_STATE64) {
1109         if (count != MachO::x86_EXCEPTION_STATE64_COUNT)
1110           return malformedError("load command " + Twine(LoadCommandIndex) +
1111                                 " count not x86_EXCEPTION_STATE64_COUNT for "
1112                                 "flavor number " + Twine(nflavor) + " which is "
1113                                 "a x86_EXCEPTION_STATE64 flavor in " + CmdName +
1114                                 " command");
1115         if (state + sizeof(MachO::x86_exception_state64_t) > end)
1116           return malformedError("load command " + Twine(LoadCommandIndex) +
1117                                 " x86_EXCEPTION_STATE64 extends past end of "
1118                                 "command in " + CmdName + " command");
1119         state += sizeof(MachO::x86_exception_state64_t);
1120       } else {
1121         return malformedError("load command " + Twine(LoadCommandIndex) +
1122                               " unknown flavor (" + Twine(flavor) + ") for "
1123                               "flavor number " + Twine(nflavor) + " in " +
1124                               CmdName + " command");
1125       }
1126     } else if (cputype == MachO::CPU_TYPE_ARM) {
1127       if (flavor == MachO::ARM_THREAD_STATE) {
1128         if (count != MachO::ARM_THREAD_STATE_COUNT)
1129           return malformedError("load command " + Twine(LoadCommandIndex) +
1130                                 " count not ARM_THREAD_STATE_COUNT for "
1131                                 "flavor number " + Twine(nflavor) + " which is "
1132                                 "a ARM_THREAD_STATE flavor in " + CmdName +
1133                                 " command");
1134         if (state + sizeof(MachO::arm_thread_state32_t) > end)
1135           return malformedError("load command " + Twine(LoadCommandIndex) +
1136                                 " ARM_THREAD_STATE extends past end of "
1137                                 "command in " + CmdName + " command");
1138         state += sizeof(MachO::arm_thread_state32_t);
1139       } else {
1140         return malformedError("load command " + Twine(LoadCommandIndex) +
1141                               " unknown flavor (" + Twine(flavor) + ") for "
1142                               "flavor number " + Twine(nflavor) + " in " +
1143                               CmdName + " command");
1144       }
1145     } else if (cputype == MachO::CPU_TYPE_ARM64 ||
1146                cputype == MachO::CPU_TYPE_ARM64_32) {
1147       if (flavor == MachO::ARM_THREAD_STATE64) {
1148         if (count != MachO::ARM_THREAD_STATE64_COUNT)
1149           return malformedError("load command " + Twine(LoadCommandIndex) +
1150                                 " count not ARM_THREAD_STATE64_COUNT for "
1151                                 "flavor number " + Twine(nflavor) + " which is "
1152                                 "a ARM_THREAD_STATE64 flavor in " + CmdName +
1153                                 " command");
1154         if (state + sizeof(MachO::arm_thread_state64_t) > end)
1155           return malformedError("load command " + Twine(LoadCommandIndex) +
1156                                 " ARM_THREAD_STATE64 extends past end of "
1157                                 "command in " + CmdName + " command");
1158         state += sizeof(MachO::arm_thread_state64_t);
1159       } else {
1160         return malformedError("load command " + Twine(LoadCommandIndex) +
1161                               " unknown flavor (" + Twine(flavor) + ") for "
1162                               "flavor number " + Twine(nflavor) + " in " +
1163                               CmdName + " command");
1164       }
1165     } else if (cputype == MachO::CPU_TYPE_POWERPC) {
1166       if (flavor == MachO::PPC_THREAD_STATE) {
1167         if (count != MachO::PPC_THREAD_STATE_COUNT)
1168           return malformedError("load command " + Twine(LoadCommandIndex) +
1169                                 " count not PPC_THREAD_STATE_COUNT for "
1170                                 "flavor number " + Twine(nflavor) + " which is "
1171                                 "a PPC_THREAD_STATE flavor in " + CmdName +
1172                                 " command");
1173         if (state + sizeof(MachO::ppc_thread_state32_t) > end)
1174           return malformedError("load command " + Twine(LoadCommandIndex) +
1175                                 " PPC_THREAD_STATE extends past end of "
1176                                 "command in " + CmdName + " command");
1177         state += sizeof(MachO::ppc_thread_state32_t);
1178       } else {
1179         return malformedError("load command " + Twine(LoadCommandIndex) +
1180                               " unknown flavor (" + Twine(flavor) + ") for "
1181                               "flavor number " + Twine(nflavor) + " in " +
1182                               CmdName + " command");
1183       }
1184     } else {
1185       return malformedError("unknown cputype (" + Twine(cputype) + ") load "
1186                             "command " + Twine(LoadCommandIndex) + " for " +
1187                             CmdName + " command can't be checked");
1188     }
1189     nflavor++;
1190   }
1191   return Error::success();
1192 }
1193 
checkTwoLevelHintsCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char ** LoadCmd,std::list<MachOElement> & Elements)1194 static Error checkTwoLevelHintsCommand(const MachOObjectFile &Obj,
1195                                        const MachOObjectFile::LoadCommandInfo
1196                                          &Load,
1197                                        uint32_t LoadCommandIndex,
1198                                        const char **LoadCmd,
1199                                        std::list<MachOElement> &Elements) {
1200   if (Load.C.cmdsize != sizeof(MachO::twolevel_hints_command))
1201     return malformedError("load command " + Twine(LoadCommandIndex) +
1202                           " LC_TWOLEVEL_HINTS has incorrect cmdsize");
1203   if (*LoadCmd != nullptr)
1204     return malformedError("more than one LC_TWOLEVEL_HINTS command");
1205   auto HintsOrErr = getStructOrErr<MachO::twolevel_hints_command>(Obj, Load.Ptr);
1206   if(!HintsOrErr)
1207     return HintsOrErr.takeError();
1208   MachO::twolevel_hints_command Hints = HintsOrErr.get();
1209   uint64_t FileSize = Obj.getData().size();
1210   if (Hints.offset > FileSize)
1211     return malformedError("offset field of LC_TWOLEVEL_HINTS command " +
1212                           Twine(LoadCommandIndex) + " extends past the end of "
1213                           "the file");
1214   uint64_t BigSize = Hints.nhints;
1215   BigSize *= sizeof(MachO::twolevel_hint);
1216   BigSize += Hints.offset;
1217   if (BigSize > FileSize)
1218     return malformedError("offset field plus nhints times sizeof(struct "
1219                           "twolevel_hint) field of LC_TWOLEVEL_HINTS command " +
1220                           Twine(LoadCommandIndex) + " extends past the end of "
1221                           "the file");
1222   if (Error Err = checkOverlappingElement(Elements, Hints.offset, Hints.nhints *
1223                                           sizeof(MachO::twolevel_hint),
1224                                           "two level hints"))
1225     return Err;
1226   *LoadCmd = Load.Ptr;
1227   return Error::success();
1228 }
1229 
1230 // Returns true if the libObject code does not support the load command and its
1231 // contents.  The cmd value it is treated as an unknown load command but with
1232 // an error message that says the cmd value is obsolete.
isLoadCommandObsolete(uint32_t cmd)1233 static bool isLoadCommandObsolete(uint32_t cmd) {
1234   if (cmd == MachO::LC_SYMSEG ||
1235       cmd == MachO::LC_LOADFVMLIB ||
1236       cmd == MachO::LC_IDFVMLIB ||
1237       cmd == MachO::LC_IDENT ||
1238       cmd == MachO::LC_FVMFILE ||
1239       cmd == MachO::LC_PREPAGE ||
1240       cmd == MachO::LC_PREBOUND_DYLIB ||
1241       cmd == MachO::LC_TWOLEVEL_HINTS ||
1242       cmd == MachO::LC_PREBIND_CKSUM)
1243     return true;
1244   return false;
1245 }
1246 
1247 Expected<std::unique_ptr<MachOObjectFile>>
create(MemoryBufferRef Object,bool IsLittleEndian,bool Is64Bits,uint32_t UniversalCputype,uint32_t UniversalIndex)1248 MachOObjectFile::create(MemoryBufferRef Object, bool IsLittleEndian,
1249                         bool Is64Bits, uint32_t UniversalCputype,
1250                         uint32_t UniversalIndex) {
1251   Error Err = Error::success();
1252   std::unique_ptr<MachOObjectFile> Obj(
1253       new MachOObjectFile(std::move(Object), IsLittleEndian,
1254                           Is64Bits, Err, UniversalCputype,
1255                           UniversalIndex));
1256   if (Err)
1257     return std::move(Err);
1258   return std::move(Obj);
1259 }
1260 
MachOObjectFile(MemoryBufferRef Object,bool IsLittleEndian,bool Is64bits,Error & Err,uint32_t UniversalCputype,uint32_t UniversalIndex)1261 MachOObjectFile::MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian,
1262                                  bool Is64bits, Error &Err,
1263                                  uint32_t UniversalCputype,
1264                                  uint32_t UniversalIndex)
1265     : ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object) {
1266   ErrorAsOutParameter ErrAsOutParam(&Err);
1267   uint64_t SizeOfHeaders;
1268   uint32_t cputype;
1269   if (is64Bit()) {
1270     parseHeader(*this, Header64, Err);
1271     SizeOfHeaders = sizeof(MachO::mach_header_64);
1272     cputype = Header64.cputype;
1273   } else {
1274     parseHeader(*this, Header, Err);
1275     SizeOfHeaders = sizeof(MachO::mach_header);
1276     cputype = Header.cputype;
1277   }
1278   if (Err)
1279     return;
1280   SizeOfHeaders += getHeader().sizeofcmds;
1281   if (getData().data() + SizeOfHeaders > getData().end()) {
1282     Err = malformedError("load commands extend past the end of the file");
1283     return;
1284   }
1285   if (UniversalCputype != 0 && cputype != UniversalCputype) {
1286     Err = malformedError("universal header architecture: " +
1287                          Twine(UniversalIndex) + "'s cputype does not match "
1288                          "object file's mach header");
1289     return;
1290   }
1291   std::list<MachOElement> Elements;
1292   Elements.push_back({0, SizeOfHeaders, "Mach-O headers"});
1293 
1294   uint32_t LoadCommandCount = getHeader().ncmds;
1295   LoadCommandInfo Load;
1296   if (LoadCommandCount != 0) {
1297     if (auto LoadOrErr = getFirstLoadCommandInfo(*this))
1298       Load = *LoadOrErr;
1299     else {
1300       Err = LoadOrErr.takeError();
1301       return;
1302     }
1303   }
1304 
1305   const char *DyldIdLoadCmd = nullptr;
1306   const char *SplitInfoLoadCmd = nullptr;
1307   const char *CodeSignDrsLoadCmd = nullptr;
1308   const char *CodeSignLoadCmd = nullptr;
1309   const char *VersLoadCmd = nullptr;
1310   const char *SourceLoadCmd = nullptr;
1311   const char *EntryPointLoadCmd = nullptr;
1312   const char *EncryptLoadCmd = nullptr;
1313   const char *RoutinesLoadCmd = nullptr;
1314   const char *UnixThreadLoadCmd = nullptr;
1315   const char *TwoLevelHintsLoadCmd = nullptr;
1316   for (unsigned I = 0; I < LoadCommandCount; ++I) {
1317     if (is64Bit()) {
1318       if (Load.C.cmdsize % 8 != 0) {
1319         // We have a hack here to allow 64-bit Mach-O core files to have
1320         // LC_THREAD commands that are only a multiple of 4 and not 8 to be
1321         // allowed since the macOS kernel produces them.
1322         if (getHeader().filetype != MachO::MH_CORE ||
1323             Load.C.cmd != MachO::LC_THREAD || Load.C.cmdsize % 4) {
1324           Err = malformedError("load command " + Twine(I) + " cmdsize not a "
1325                                "multiple of 8");
1326           return;
1327         }
1328       }
1329     } else {
1330       if (Load.C.cmdsize % 4 != 0) {
1331         Err = malformedError("load command " + Twine(I) + " cmdsize not a "
1332                              "multiple of 4");
1333         return;
1334       }
1335     }
1336     LoadCommands.push_back(Load);
1337     if (Load.C.cmd == MachO::LC_SYMTAB) {
1338       if ((Err = checkSymtabCommand(*this, Load, I, &SymtabLoadCmd, Elements)))
1339         return;
1340     } else if (Load.C.cmd == MachO::LC_DYSYMTAB) {
1341       if ((Err = checkDysymtabCommand(*this, Load, I, &DysymtabLoadCmd,
1342                                       Elements)))
1343         return;
1344     } else if (Load.C.cmd == MachO::LC_DATA_IN_CODE) {
1345       if ((Err = checkLinkeditDataCommand(*this, Load, I, &DataInCodeLoadCmd,
1346                                           "LC_DATA_IN_CODE", Elements,
1347                                           "data in code info")))
1348         return;
1349     } else if (Load.C.cmd == MachO::LC_LINKER_OPTIMIZATION_HINT) {
1350       if ((Err = checkLinkeditDataCommand(*this, Load, I, &LinkOptHintsLoadCmd,
1351                                           "LC_LINKER_OPTIMIZATION_HINT",
1352                                           Elements, "linker optimization "
1353                                           "hints")))
1354         return;
1355     } else if (Load.C.cmd == MachO::LC_FUNCTION_STARTS) {
1356       if ((Err = checkLinkeditDataCommand(*this, Load, I, &FuncStartsLoadCmd,
1357                                           "LC_FUNCTION_STARTS", Elements,
1358                                           "function starts data")))
1359         return;
1360     } else if (Load.C.cmd == MachO::LC_SEGMENT_SPLIT_INFO) {
1361       if ((Err = checkLinkeditDataCommand(*this, Load, I, &SplitInfoLoadCmd,
1362                                           "LC_SEGMENT_SPLIT_INFO", Elements,
1363                                           "split info data")))
1364         return;
1365     } else if (Load.C.cmd == MachO::LC_DYLIB_CODE_SIGN_DRS) {
1366       if ((Err = checkLinkeditDataCommand(*this, Load, I, &CodeSignDrsLoadCmd,
1367                                           "LC_DYLIB_CODE_SIGN_DRS", Elements,
1368                                           "code signing RDs data")))
1369         return;
1370     } else if (Load.C.cmd == MachO::LC_CODE_SIGNATURE) {
1371       if ((Err = checkLinkeditDataCommand(*this, Load, I, &CodeSignLoadCmd,
1372                                           "LC_CODE_SIGNATURE", Elements,
1373                                           "code signature data")))
1374         return;
1375     } else if (Load.C.cmd == MachO::LC_DYLD_INFO) {
1376       if ((Err = checkDyldInfoCommand(*this, Load, I, &DyldInfoLoadCmd,
1377                                       "LC_DYLD_INFO", Elements)))
1378         return;
1379     } else if (Load.C.cmd == MachO::LC_DYLD_INFO_ONLY) {
1380       if ((Err = checkDyldInfoCommand(*this, Load, I, &DyldInfoLoadCmd,
1381                                       "LC_DYLD_INFO_ONLY", Elements)))
1382         return;
1383     } else if (Load.C.cmd == MachO::LC_DYLD_CHAINED_FIXUPS) {
1384       if ((Err = checkLinkeditDataCommand(
1385                *this, Load, I, &DyldChainedFixupsLoadCmd,
1386                "LC_DYLD_CHAINED_FIXUPS", Elements, "chained fixups")))
1387         return;
1388     } else if (Load.C.cmd == MachO::LC_DYLD_EXPORTS_TRIE) {
1389       if ((Err = checkLinkeditDataCommand(
1390                *this, Load, I, &DyldExportsTrieLoadCmd, "LC_DYLD_EXPORTS_TRIE",
1391                Elements, "exports trie")))
1392         return;
1393     } else if (Load.C.cmd == MachO::LC_UUID) {
1394       if (Load.C.cmdsize != sizeof(MachO::uuid_command)) {
1395         Err = malformedError("LC_UUID command " + Twine(I) + " has incorrect "
1396                              "cmdsize");
1397         return;
1398       }
1399       if (UuidLoadCmd) {
1400         Err = malformedError("more than one LC_UUID command");
1401         return;
1402       }
1403       UuidLoadCmd = Load.Ptr;
1404     } else if (Load.C.cmd == MachO::LC_SEGMENT_64) {
1405       if ((Err = parseSegmentLoadCommand<MachO::segment_command_64,
1406                                          MachO::section_64>(
1407                    *this, Load, Sections, HasPageZeroSegment, I,
1408                    "LC_SEGMENT_64", SizeOfHeaders, Elements)))
1409         return;
1410     } else if (Load.C.cmd == MachO::LC_SEGMENT) {
1411       if ((Err = parseSegmentLoadCommand<MachO::segment_command,
1412                                          MachO::section>(
1413                    *this, Load, Sections, HasPageZeroSegment, I,
1414                    "LC_SEGMENT", SizeOfHeaders, Elements)))
1415         return;
1416     } else if (Load.C.cmd == MachO::LC_ID_DYLIB) {
1417       if ((Err = checkDylibIdCommand(*this, Load, I, &DyldIdLoadCmd)))
1418         return;
1419     } else if (Load.C.cmd == MachO::LC_LOAD_DYLIB) {
1420       if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_DYLIB")))
1421         return;
1422       Libraries.push_back(Load.Ptr);
1423     } else if (Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB) {
1424       if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_WEAK_DYLIB")))
1425         return;
1426       Libraries.push_back(Load.Ptr);
1427     } else if (Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB) {
1428       if ((Err = checkDylibCommand(*this, Load, I, "LC_LAZY_LOAD_DYLIB")))
1429         return;
1430       Libraries.push_back(Load.Ptr);
1431     } else if (Load.C.cmd == MachO::LC_REEXPORT_DYLIB) {
1432       if ((Err = checkDylibCommand(*this, Load, I, "LC_REEXPORT_DYLIB")))
1433         return;
1434       Libraries.push_back(Load.Ptr);
1435     } else if (Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) {
1436       if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_UPWARD_DYLIB")))
1437         return;
1438       Libraries.push_back(Load.Ptr);
1439     } else if (Load.C.cmd == MachO::LC_ID_DYLINKER) {
1440       if ((Err = checkDyldCommand(*this, Load, I, "LC_ID_DYLINKER")))
1441         return;
1442     } else if (Load.C.cmd == MachO::LC_LOAD_DYLINKER) {
1443       if ((Err = checkDyldCommand(*this, Load, I, "LC_LOAD_DYLINKER")))
1444         return;
1445     } else if (Load.C.cmd == MachO::LC_DYLD_ENVIRONMENT) {
1446       if ((Err = checkDyldCommand(*this, Load, I, "LC_DYLD_ENVIRONMENT")))
1447         return;
1448     } else if (Load.C.cmd == MachO::LC_VERSION_MIN_MACOSX) {
1449       if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1450                                   "LC_VERSION_MIN_MACOSX")))
1451         return;
1452     } else if (Load.C.cmd == MachO::LC_VERSION_MIN_IPHONEOS) {
1453       if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1454                                   "LC_VERSION_MIN_IPHONEOS")))
1455         return;
1456     } else if (Load.C.cmd == MachO::LC_VERSION_MIN_TVOS) {
1457       if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1458                                   "LC_VERSION_MIN_TVOS")))
1459         return;
1460     } else if (Load.C.cmd == MachO::LC_VERSION_MIN_WATCHOS) {
1461       if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1462                                   "LC_VERSION_MIN_WATCHOS")))
1463         return;
1464     } else if (Load.C.cmd == MachO::LC_NOTE) {
1465       if ((Err = checkNoteCommand(*this, Load, I, Elements)))
1466         return;
1467     } else if (Load.C.cmd == MachO::LC_BUILD_VERSION) {
1468       if ((Err = parseBuildVersionCommand(*this, Load, BuildTools, I)))
1469         return;
1470     } else if (Load.C.cmd == MachO::LC_RPATH) {
1471       if ((Err = checkRpathCommand(*this, Load, I)))
1472         return;
1473     } else if (Load.C.cmd == MachO::LC_SOURCE_VERSION) {
1474       if (Load.C.cmdsize != sizeof(MachO::source_version_command)) {
1475         Err = malformedError("LC_SOURCE_VERSION command " + Twine(I) +
1476                              " has incorrect cmdsize");
1477         return;
1478       }
1479       if (SourceLoadCmd) {
1480         Err = malformedError("more than one LC_SOURCE_VERSION command");
1481         return;
1482       }
1483       SourceLoadCmd = Load.Ptr;
1484     } else if (Load.C.cmd == MachO::LC_MAIN) {
1485       if (Load.C.cmdsize != sizeof(MachO::entry_point_command)) {
1486         Err = malformedError("LC_MAIN command " + Twine(I) +
1487                              " has incorrect cmdsize");
1488         return;
1489       }
1490       if (EntryPointLoadCmd) {
1491         Err = malformedError("more than one LC_MAIN command");
1492         return;
1493       }
1494       EntryPointLoadCmd = Load.Ptr;
1495     } else if (Load.C.cmd == MachO::LC_ENCRYPTION_INFO) {
1496       if (Load.C.cmdsize != sizeof(MachO::encryption_info_command)) {
1497         Err = malformedError("LC_ENCRYPTION_INFO command " + Twine(I) +
1498                              " has incorrect cmdsize");
1499         return;
1500       }
1501       MachO::encryption_info_command E =
1502         getStruct<MachO::encryption_info_command>(*this, Load.Ptr);
1503       if ((Err = checkEncryptCommand(*this, Load, I, E.cryptoff, E.cryptsize,
1504                                      &EncryptLoadCmd, "LC_ENCRYPTION_INFO")))
1505         return;
1506     } else if (Load.C.cmd == MachO::LC_ENCRYPTION_INFO_64) {
1507       if (Load.C.cmdsize != sizeof(MachO::encryption_info_command_64)) {
1508         Err = malformedError("LC_ENCRYPTION_INFO_64 command " + Twine(I) +
1509                              " has incorrect cmdsize");
1510         return;
1511       }
1512       MachO::encryption_info_command_64 E =
1513         getStruct<MachO::encryption_info_command_64>(*this, Load.Ptr);
1514       if ((Err = checkEncryptCommand(*this, Load, I, E.cryptoff, E.cryptsize,
1515                                      &EncryptLoadCmd, "LC_ENCRYPTION_INFO_64")))
1516         return;
1517     } else if (Load.C.cmd == MachO::LC_LINKER_OPTION) {
1518       if ((Err = checkLinkerOptCommand(*this, Load, I)))
1519         return;
1520     } else if (Load.C.cmd == MachO::LC_SUB_FRAMEWORK) {
1521       if (Load.C.cmdsize < sizeof(MachO::sub_framework_command)) {
1522         Err =  malformedError("load command " + Twine(I) +
1523                               " LC_SUB_FRAMEWORK cmdsize too small");
1524         return;
1525       }
1526       MachO::sub_framework_command S =
1527         getStruct<MachO::sub_framework_command>(*this, Load.Ptr);
1528       if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_FRAMEWORK",
1529                                  sizeof(MachO::sub_framework_command),
1530                                  "sub_framework_command", S.umbrella,
1531                                  "umbrella")))
1532         return;
1533     } else if (Load.C.cmd == MachO::LC_SUB_UMBRELLA) {
1534       if (Load.C.cmdsize < sizeof(MachO::sub_umbrella_command)) {
1535         Err =  malformedError("load command " + Twine(I) +
1536                               " LC_SUB_UMBRELLA cmdsize too small");
1537         return;
1538       }
1539       MachO::sub_umbrella_command S =
1540         getStruct<MachO::sub_umbrella_command>(*this, Load.Ptr);
1541       if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_UMBRELLA",
1542                                  sizeof(MachO::sub_umbrella_command),
1543                                  "sub_umbrella_command", S.sub_umbrella,
1544                                  "sub_umbrella")))
1545         return;
1546     } else if (Load.C.cmd == MachO::LC_SUB_LIBRARY) {
1547       if (Load.C.cmdsize < sizeof(MachO::sub_library_command)) {
1548         Err =  malformedError("load command " + Twine(I) +
1549                               " LC_SUB_LIBRARY cmdsize too small");
1550         return;
1551       }
1552       MachO::sub_library_command S =
1553         getStruct<MachO::sub_library_command>(*this, Load.Ptr);
1554       if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_LIBRARY",
1555                                  sizeof(MachO::sub_library_command),
1556                                  "sub_library_command", S.sub_library,
1557                                  "sub_library")))
1558         return;
1559     } else if (Load.C.cmd == MachO::LC_SUB_CLIENT) {
1560       if (Load.C.cmdsize < sizeof(MachO::sub_client_command)) {
1561         Err =  malformedError("load command " + Twine(I) +
1562                               " LC_SUB_CLIENT cmdsize too small");
1563         return;
1564       }
1565       MachO::sub_client_command S =
1566         getStruct<MachO::sub_client_command>(*this, Load.Ptr);
1567       if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_CLIENT",
1568                                  sizeof(MachO::sub_client_command),
1569                                  "sub_client_command", S.client, "client")))
1570         return;
1571     } else if (Load.C.cmd == MachO::LC_ROUTINES) {
1572       if (Load.C.cmdsize != sizeof(MachO::routines_command)) {
1573         Err = malformedError("LC_ROUTINES command " + Twine(I) +
1574                              " has incorrect cmdsize");
1575         return;
1576       }
1577       if (RoutinesLoadCmd) {
1578         Err = malformedError("more than one LC_ROUTINES and or LC_ROUTINES_64 "
1579                              "command");
1580         return;
1581       }
1582       RoutinesLoadCmd = Load.Ptr;
1583     } else if (Load.C.cmd == MachO::LC_ROUTINES_64) {
1584       if (Load.C.cmdsize != sizeof(MachO::routines_command_64)) {
1585         Err = malformedError("LC_ROUTINES_64 command " + Twine(I) +
1586                              " has incorrect cmdsize");
1587         return;
1588       }
1589       if (RoutinesLoadCmd) {
1590         Err = malformedError("more than one LC_ROUTINES_64 and or LC_ROUTINES "
1591                              "command");
1592         return;
1593       }
1594       RoutinesLoadCmd = Load.Ptr;
1595     } else if (Load.C.cmd == MachO::LC_UNIXTHREAD) {
1596       if ((Err = checkThreadCommand(*this, Load, I, "LC_UNIXTHREAD")))
1597         return;
1598       if (UnixThreadLoadCmd) {
1599         Err = malformedError("more than one LC_UNIXTHREAD command");
1600         return;
1601       }
1602       UnixThreadLoadCmd = Load.Ptr;
1603     } else if (Load.C.cmd == MachO::LC_THREAD) {
1604       if ((Err = checkThreadCommand(*this, Load, I, "LC_THREAD")))
1605         return;
1606     // Note: LC_TWOLEVEL_HINTS is really obsolete and is not supported.
1607     } else if (Load.C.cmd == MachO::LC_TWOLEVEL_HINTS) {
1608       if ((Err = checkTwoLevelHintsCommand(*this, Load, I,
1609                                            &TwoLevelHintsLoadCmd, Elements)))
1610         return;
1611     } else if (Load.C.cmd == MachO::LC_IDENT) {
1612       // Note: LC_IDENT is ignored.
1613       continue;
1614     } else if (isLoadCommandObsolete(Load.C.cmd)) {
1615       Err = malformedError("load command " + Twine(I) + " for cmd value of: " +
1616                            Twine(Load.C.cmd) + " is obsolete and not "
1617                            "supported");
1618       return;
1619     }
1620     // TODO: generate a error for unknown load commands by default.  But still
1621     // need work out an approach to allow or not allow unknown values like this
1622     // as an option for some uses like lldb.
1623     if (I < LoadCommandCount - 1) {
1624       if (auto LoadOrErr = getNextLoadCommandInfo(*this, I, Load))
1625         Load = *LoadOrErr;
1626       else {
1627         Err = LoadOrErr.takeError();
1628         return;
1629       }
1630     }
1631   }
1632   if (!SymtabLoadCmd) {
1633     if (DysymtabLoadCmd) {
1634       Err = malformedError("contains LC_DYSYMTAB load command without a "
1635                            "LC_SYMTAB load command");
1636       return;
1637     }
1638   } else if (DysymtabLoadCmd) {
1639     MachO::symtab_command Symtab =
1640       getStruct<MachO::symtab_command>(*this, SymtabLoadCmd);
1641     MachO::dysymtab_command Dysymtab =
1642       getStruct<MachO::dysymtab_command>(*this, DysymtabLoadCmd);
1643     if (Dysymtab.nlocalsym != 0 && Dysymtab.ilocalsym > Symtab.nsyms) {
1644       Err = malformedError("ilocalsym in LC_DYSYMTAB load command "
1645                            "extends past the end of the symbol table");
1646       return;
1647     }
1648     uint64_t BigSize = Dysymtab.ilocalsym;
1649     BigSize += Dysymtab.nlocalsym;
1650     if (Dysymtab.nlocalsym != 0 && BigSize > Symtab.nsyms) {
1651       Err = malformedError("ilocalsym plus nlocalsym in LC_DYSYMTAB load "
1652                            "command extends past the end of the symbol table");
1653       return;
1654     }
1655     if (Dysymtab.nextdefsym != 0 && Dysymtab.iextdefsym > Symtab.nsyms) {
1656       Err = malformedError("iextdefsym in LC_DYSYMTAB load command "
1657                            "extends past the end of the symbol table");
1658       return;
1659     }
1660     BigSize = Dysymtab.iextdefsym;
1661     BigSize += Dysymtab.nextdefsym;
1662     if (Dysymtab.nextdefsym != 0 && BigSize > Symtab.nsyms) {
1663       Err = malformedError("iextdefsym plus nextdefsym in LC_DYSYMTAB "
1664                            "load command extends past the end of the symbol "
1665                            "table");
1666       return;
1667     }
1668     if (Dysymtab.nundefsym != 0 && Dysymtab.iundefsym > Symtab.nsyms) {
1669       Err = malformedError("iundefsym in LC_DYSYMTAB load command "
1670                            "extends past the end of the symbol table");
1671       return;
1672     }
1673     BigSize = Dysymtab.iundefsym;
1674     BigSize += Dysymtab.nundefsym;
1675     if (Dysymtab.nundefsym != 0 && BigSize > Symtab.nsyms) {
1676       Err = malformedError("iundefsym plus nundefsym in LC_DYSYMTAB load "
1677                            " command extends past the end of the symbol table");
1678       return;
1679     }
1680   }
1681   if ((getHeader().filetype == MachO::MH_DYLIB ||
1682        getHeader().filetype == MachO::MH_DYLIB_STUB) &&
1683        DyldIdLoadCmd == nullptr) {
1684     Err = malformedError("no LC_ID_DYLIB load command in dynamic library "
1685                          "filetype");
1686     return;
1687   }
1688   assert(LoadCommands.size() == LoadCommandCount);
1689 
1690   Err = Error::success();
1691 }
1692 
checkSymbolTable() const1693 Error MachOObjectFile::checkSymbolTable() const {
1694   uint32_t Flags = 0;
1695   if (is64Bit()) {
1696     MachO::mach_header_64 H_64 = MachOObjectFile::getHeader64();
1697     Flags = H_64.flags;
1698   } else {
1699     MachO::mach_header H = MachOObjectFile::getHeader();
1700     Flags = H.flags;
1701   }
1702   uint8_t NType = 0;
1703   uint8_t NSect = 0;
1704   uint16_t NDesc = 0;
1705   uint32_t NStrx = 0;
1706   uint64_t NValue = 0;
1707   uint32_t SymbolIndex = 0;
1708   MachO::symtab_command S = getSymtabLoadCommand();
1709   for (const SymbolRef &Symbol : symbols()) {
1710     DataRefImpl SymDRI = Symbol.getRawDataRefImpl();
1711     if (is64Bit()) {
1712       MachO::nlist_64 STE_64 = getSymbol64TableEntry(SymDRI);
1713       NType = STE_64.n_type;
1714       NSect = STE_64.n_sect;
1715       NDesc = STE_64.n_desc;
1716       NStrx = STE_64.n_strx;
1717       NValue = STE_64.n_value;
1718     } else {
1719       MachO::nlist STE = getSymbolTableEntry(SymDRI);
1720       NType = STE.n_type;
1721       NSect = STE.n_sect;
1722       NDesc = STE.n_desc;
1723       NStrx = STE.n_strx;
1724       NValue = STE.n_value;
1725     }
1726     if ((NType & MachO::N_STAB) == 0) {
1727       if ((NType & MachO::N_TYPE) == MachO::N_SECT) {
1728         if (NSect == 0 || NSect > Sections.size())
1729           return malformedError("bad section index: " + Twine((int)NSect) +
1730                                 " for symbol at index " + Twine(SymbolIndex));
1731       }
1732       if ((NType & MachO::N_TYPE) == MachO::N_INDR) {
1733         if (NValue >= S.strsize)
1734           return malformedError("bad n_value: " + Twine((int)NValue) + " past "
1735                                 "the end of string table, for N_INDR symbol at "
1736                                 "index " + Twine(SymbolIndex));
1737       }
1738       if ((Flags & MachO::MH_TWOLEVEL) == MachO::MH_TWOLEVEL &&
1739           (((NType & MachO::N_TYPE) == MachO::N_UNDF && NValue == 0) ||
1740            (NType & MachO::N_TYPE) == MachO::N_PBUD)) {
1741             uint32_t LibraryOrdinal = MachO::GET_LIBRARY_ORDINAL(NDesc);
1742             if (LibraryOrdinal != 0 &&
1743                 LibraryOrdinal != MachO::EXECUTABLE_ORDINAL &&
1744                 LibraryOrdinal != MachO::DYNAMIC_LOOKUP_ORDINAL &&
1745                 LibraryOrdinal - 1 >= Libraries.size() ) {
1746               return malformedError("bad library ordinal: " + Twine(LibraryOrdinal) +
1747                                     " for symbol at index " + Twine(SymbolIndex));
1748             }
1749           }
1750     }
1751     if (NStrx >= S.strsize)
1752       return malformedError("bad string table index: " + Twine((int)NStrx) +
1753                             " past the end of string table, for symbol at "
1754                             "index " + Twine(SymbolIndex));
1755     SymbolIndex++;
1756   }
1757   return Error::success();
1758 }
1759 
moveSymbolNext(DataRefImpl & Symb) const1760 void MachOObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
1761   unsigned SymbolTableEntrySize = is64Bit() ?
1762     sizeof(MachO::nlist_64) :
1763     sizeof(MachO::nlist);
1764   Symb.p += SymbolTableEntrySize;
1765 }
1766 
getSymbolName(DataRefImpl Symb) const1767 Expected<StringRef> MachOObjectFile::getSymbolName(DataRefImpl Symb) const {
1768   StringRef StringTable = getStringTableData();
1769   MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1770   if (Entry.n_strx == 0)
1771     // A n_strx value of 0 indicates that no name is associated with a
1772     // particular symbol table entry.
1773     return StringRef();
1774   const char *Start = &StringTable.data()[Entry.n_strx];
1775   if (Start < getData().begin() || Start >= getData().end()) {
1776     return malformedError("bad string index: " + Twine(Entry.n_strx) +
1777                           " for symbol at index " + Twine(getSymbolIndex(Symb)));
1778   }
1779   return StringRef(Start);
1780 }
1781 
getSectionType(SectionRef Sec) const1782 unsigned MachOObjectFile::getSectionType(SectionRef Sec) const {
1783   DataRefImpl DRI = Sec.getRawDataRefImpl();
1784   uint32_t Flags = getSectionFlags(*this, DRI);
1785   return Flags & MachO::SECTION_TYPE;
1786 }
1787 
getNValue(DataRefImpl Sym) const1788 uint64_t MachOObjectFile::getNValue(DataRefImpl Sym) const {
1789   if (is64Bit()) {
1790     MachO::nlist_64 Entry = getSymbol64TableEntry(Sym);
1791     return Entry.n_value;
1792   }
1793   MachO::nlist Entry = getSymbolTableEntry(Sym);
1794   return Entry.n_value;
1795 }
1796 
1797 // getIndirectName() returns the name of the alias'ed symbol who's string table
1798 // index is in the n_value field.
getIndirectName(DataRefImpl Symb,StringRef & Res) const1799 std::error_code MachOObjectFile::getIndirectName(DataRefImpl Symb,
1800                                                  StringRef &Res) const {
1801   StringRef StringTable = getStringTableData();
1802   MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1803   if ((Entry.n_type & MachO::N_TYPE) != MachO::N_INDR)
1804     return object_error::parse_failed;
1805   uint64_t NValue = getNValue(Symb);
1806   if (NValue >= StringTable.size())
1807     return object_error::parse_failed;
1808   const char *Start = &StringTable.data()[NValue];
1809   Res = StringRef(Start);
1810   return std::error_code();
1811 }
1812 
getSymbolValueImpl(DataRefImpl Sym) const1813 uint64_t MachOObjectFile::getSymbolValueImpl(DataRefImpl Sym) const {
1814   return getNValue(Sym);
1815 }
1816 
getSymbolAddress(DataRefImpl Sym) const1817 Expected<uint64_t> MachOObjectFile::getSymbolAddress(DataRefImpl Sym) const {
1818   return getSymbolValue(Sym);
1819 }
1820 
getSymbolAlignment(DataRefImpl DRI) const1821 uint32_t MachOObjectFile::getSymbolAlignment(DataRefImpl DRI) const {
1822   uint32_t Flags = cantFail(getSymbolFlags(DRI));
1823   if (Flags & SymbolRef::SF_Common) {
1824     MachO::nlist_base Entry = getSymbolTableEntryBase(*this, DRI);
1825     return 1 << MachO::GET_COMM_ALIGN(Entry.n_desc);
1826   }
1827   return 0;
1828 }
1829 
getCommonSymbolSizeImpl(DataRefImpl DRI) const1830 uint64_t MachOObjectFile::getCommonSymbolSizeImpl(DataRefImpl DRI) const {
1831   return getNValue(DRI);
1832 }
1833 
1834 Expected<SymbolRef::Type>
getSymbolType(DataRefImpl Symb) const1835 MachOObjectFile::getSymbolType(DataRefImpl Symb) const {
1836   MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1837   uint8_t n_type = Entry.n_type;
1838 
1839   // If this is a STAB debugging symbol, we can do nothing more.
1840   if (n_type & MachO::N_STAB)
1841     return SymbolRef::ST_Debug;
1842 
1843   switch (n_type & MachO::N_TYPE) {
1844     case MachO::N_UNDF :
1845       return SymbolRef::ST_Unknown;
1846     case MachO::N_SECT :
1847       Expected<section_iterator> SecOrError = getSymbolSection(Symb);
1848       if (!SecOrError)
1849         return SecOrError.takeError();
1850       section_iterator Sec = *SecOrError;
1851       if (Sec == section_end())
1852         return SymbolRef::ST_Other;
1853       if (Sec->isData() || Sec->isBSS())
1854         return SymbolRef::ST_Data;
1855       return SymbolRef::ST_Function;
1856   }
1857   return SymbolRef::ST_Other;
1858 }
1859 
getSymbolFlags(DataRefImpl DRI) const1860 Expected<uint32_t> MachOObjectFile::getSymbolFlags(DataRefImpl DRI) const {
1861   MachO::nlist_base Entry = getSymbolTableEntryBase(*this, DRI);
1862 
1863   uint8_t MachOType = Entry.n_type;
1864   uint16_t MachOFlags = Entry.n_desc;
1865 
1866   uint32_t Result = SymbolRef::SF_None;
1867 
1868   if ((MachOType & MachO::N_TYPE) == MachO::N_INDR)
1869     Result |= SymbolRef::SF_Indirect;
1870 
1871   if (MachOType & MachO::N_STAB)
1872     Result |= SymbolRef::SF_FormatSpecific;
1873 
1874   if (MachOType & MachO::N_EXT) {
1875     Result |= SymbolRef::SF_Global;
1876     if ((MachOType & MachO::N_TYPE) == MachO::N_UNDF) {
1877       if (getNValue(DRI))
1878         Result |= SymbolRef::SF_Common;
1879       else
1880         Result |= SymbolRef::SF_Undefined;
1881     }
1882 
1883     if (MachOType & MachO::N_PEXT)
1884       Result |= SymbolRef::SF_Hidden;
1885     else
1886       Result |= SymbolRef::SF_Exported;
1887 
1888   } else if (MachOType & MachO::N_PEXT)
1889     Result |= SymbolRef::SF_Hidden;
1890 
1891   if (MachOFlags & (MachO::N_WEAK_REF | MachO::N_WEAK_DEF))
1892     Result |= SymbolRef::SF_Weak;
1893 
1894   if (MachOFlags & (MachO::N_ARM_THUMB_DEF))
1895     Result |= SymbolRef::SF_Thumb;
1896 
1897   if ((MachOType & MachO::N_TYPE) == MachO::N_ABS)
1898     Result |= SymbolRef::SF_Absolute;
1899 
1900   return Result;
1901 }
1902 
1903 Expected<section_iterator>
getSymbolSection(DataRefImpl Symb) const1904 MachOObjectFile::getSymbolSection(DataRefImpl Symb) const {
1905   MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1906   uint8_t index = Entry.n_sect;
1907 
1908   if (index == 0)
1909     return section_end();
1910   DataRefImpl DRI;
1911   DRI.d.a = index - 1;
1912   if (DRI.d.a >= Sections.size()){
1913     return malformedError("bad section index: " + Twine((int)index) +
1914                           " for symbol at index " + Twine(getSymbolIndex(Symb)));
1915   }
1916   return section_iterator(SectionRef(DRI, this));
1917 }
1918 
getSymbolSectionID(SymbolRef Sym) const1919 unsigned MachOObjectFile::getSymbolSectionID(SymbolRef Sym) const {
1920   MachO::nlist_base Entry =
1921       getSymbolTableEntryBase(*this, Sym.getRawDataRefImpl());
1922   return Entry.n_sect - 1;
1923 }
1924 
moveSectionNext(DataRefImpl & Sec) const1925 void MachOObjectFile::moveSectionNext(DataRefImpl &Sec) const {
1926   Sec.d.a++;
1927 }
1928 
getSectionName(DataRefImpl Sec) const1929 Expected<StringRef> MachOObjectFile::getSectionName(DataRefImpl Sec) const {
1930   ArrayRef<char> Raw = getSectionRawName(Sec);
1931   return parseSegmentOrSectionName(Raw.data());
1932 }
1933 
getSectionAddress(DataRefImpl Sec) const1934 uint64_t MachOObjectFile::getSectionAddress(DataRefImpl Sec) const {
1935   if (is64Bit())
1936     return getSection64(Sec).addr;
1937   return getSection(Sec).addr;
1938 }
1939 
getSectionIndex(DataRefImpl Sec) const1940 uint64_t MachOObjectFile::getSectionIndex(DataRefImpl Sec) const {
1941   return Sec.d.a;
1942 }
1943 
getSectionSize(DataRefImpl Sec) const1944 uint64_t MachOObjectFile::getSectionSize(DataRefImpl Sec) const {
1945   // In the case if a malformed Mach-O file where the section offset is past
1946   // the end of the file or some part of the section size is past the end of
1947   // the file return a size of zero or a size that covers the rest of the file
1948   // but does not extend past the end of the file.
1949   uint32_t SectOffset, SectType;
1950   uint64_t SectSize;
1951 
1952   if (is64Bit()) {
1953     MachO::section_64 Sect = getSection64(Sec);
1954     SectOffset = Sect.offset;
1955     SectSize = Sect.size;
1956     SectType = Sect.flags & MachO::SECTION_TYPE;
1957   } else {
1958     MachO::section Sect = getSection(Sec);
1959     SectOffset = Sect.offset;
1960     SectSize = Sect.size;
1961     SectType = Sect.flags & MachO::SECTION_TYPE;
1962   }
1963   if (SectType == MachO::S_ZEROFILL || SectType == MachO::S_GB_ZEROFILL)
1964     return SectSize;
1965   uint64_t FileSize = getData().size();
1966   if (SectOffset > FileSize)
1967     return 0;
1968   if (FileSize - SectOffset < SectSize)
1969     return FileSize - SectOffset;
1970   return SectSize;
1971 }
1972 
getSectionContents(uint32_t Offset,uint64_t Size) const1973 ArrayRef<uint8_t> MachOObjectFile::getSectionContents(uint32_t Offset,
1974                                                       uint64_t Size) const {
1975   return arrayRefFromStringRef(getData().substr(Offset, Size));
1976 }
1977 
1978 Expected<ArrayRef<uint8_t>>
getSectionContents(DataRefImpl Sec) const1979 MachOObjectFile::getSectionContents(DataRefImpl Sec) const {
1980   uint32_t Offset;
1981   uint64_t Size;
1982 
1983   if (is64Bit()) {
1984     MachO::section_64 Sect = getSection64(Sec);
1985     Offset = Sect.offset;
1986     Size = Sect.size;
1987   } else {
1988     MachO::section Sect = getSection(Sec);
1989     Offset = Sect.offset;
1990     Size = Sect.size;
1991   }
1992 
1993   return getSectionContents(Offset, Size);
1994 }
1995 
getSectionAlignment(DataRefImpl Sec) const1996 uint64_t MachOObjectFile::getSectionAlignment(DataRefImpl Sec) const {
1997   uint32_t Align;
1998   if (is64Bit()) {
1999     MachO::section_64 Sect = getSection64(Sec);
2000     Align = Sect.align;
2001   } else {
2002     MachO::section Sect = getSection(Sec);
2003     Align = Sect.align;
2004   }
2005 
2006   return uint64_t(1) << Align;
2007 }
2008 
getSection(unsigned SectionIndex) const2009 Expected<SectionRef> MachOObjectFile::getSection(unsigned SectionIndex) const {
2010   if (SectionIndex < 1 || SectionIndex > Sections.size())
2011     return malformedError("bad section index: " + Twine((int)SectionIndex));
2012 
2013   DataRefImpl DRI;
2014   DRI.d.a = SectionIndex - 1;
2015   return SectionRef(DRI, this);
2016 }
2017 
getSection(StringRef SectionName) const2018 Expected<SectionRef> MachOObjectFile::getSection(StringRef SectionName) const {
2019   for (const SectionRef &Section : sections()) {
2020     auto NameOrErr = Section.getName();
2021     if (!NameOrErr)
2022       return NameOrErr.takeError();
2023     if (*NameOrErr == SectionName)
2024       return Section;
2025   }
2026   return errorCodeToError(object_error::parse_failed);
2027 }
2028 
isSectionCompressed(DataRefImpl Sec) const2029 bool MachOObjectFile::isSectionCompressed(DataRefImpl Sec) const {
2030   return false;
2031 }
2032 
isSectionText(DataRefImpl Sec) const2033 bool MachOObjectFile::isSectionText(DataRefImpl Sec) const {
2034   uint32_t Flags = getSectionFlags(*this, Sec);
2035   return Flags & MachO::S_ATTR_PURE_INSTRUCTIONS;
2036 }
2037 
isSectionData(DataRefImpl Sec) const2038 bool MachOObjectFile::isSectionData(DataRefImpl Sec) const {
2039   uint32_t Flags = getSectionFlags(*this, Sec);
2040   unsigned SectionType = Flags & MachO::SECTION_TYPE;
2041   return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
2042          !(SectionType == MachO::S_ZEROFILL ||
2043            SectionType == MachO::S_GB_ZEROFILL);
2044 }
2045 
isSectionBSS(DataRefImpl Sec) const2046 bool MachOObjectFile::isSectionBSS(DataRefImpl Sec) const {
2047   uint32_t Flags = getSectionFlags(*this, Sec);
2048   unsigned SectionType = Flags & MachO::SECTION_TYPE;
2049   return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
2050          (SectionType == MachO::S_ZEROFILL ||
2051           SectionType == MachO::S_GB_ZEROFILL);
2052 }
2053 
isDebugSection(DataRefImpl Sec) const2054 bool MachOObjectFile::isDebugSection(DataRefImpl Sec) const {
2055   Expected<StringRef> SectionNameOrErr = getSectionName(Sec);
2056   if (!SectionNameOrErr) {
2057     // TODO: Report the error message properly.
2058     consumeError(SectionNameOrErr.takeError());
2059     return false;
2060   }
2061   StringRef SectionName = SectionNameOrErr.get();
2062   return SectionName.startswith("__debug") ||
2063          SectionName.startswith("__zdebug") ||
2064          SectionName.startswith("__apple") || SectionName == "__gdb_index" ||
2065          SectionName == "__swift_ast";
2066 }
2067 
2068 namespace {
2069 template <typename LoadCommandType>
getSegmentContents(const MachOObjectFile & Obj,MachOObjectFile::LoadCommandInfo LoadCmd,StringRef SegmentName)2070 ArrayRef<uint8_t> getSegmentContents(const MachOObjectFile &Obj,
2071                                      MachOObjectFile::LoadCommandInfo LoadCmd,
2072                                      StringRef SegmentName) {
2073   auto SegmentOrErr = getStructOrErr<LoadCommandType>(Obj, LoadCmd.Ptr);
2074   if (!SegmentOrErr) {
2075     consumeError(SegmentOrErr.takeError());
2076     return {};
2077   }
2078   auto &Segment = SegmentOrErr.get();
2079   if (StringRef(Segment.segname, 16).startswith(SegmentName))
2080     return arrayRefFromStringRef(Obj.getData().slice(
2081         Segment.fileoff, Segment.fileoff + Segment.filesize));
2082   return {};
2083 }
2084 
2085 template <typename LoadCommandType>
getSegmentContents(const MachOObjectFile & Obj,MachOObjectFile::LoadCommandInfo LoadCmd)2086 ArrayRef<uint8_t> getSegmentContents(const MachOObjectFile &Obj,
2087                                      MachOObjectFile::LoadCommandInfo LoadCmd) {
2088   auto SegmentOrErr = getStructOrErr<LoadCommandType>(Obj, LoadCmd.Ptr);
2089   if (!SegmentOrErr) {
2090     consumeError(SegmentOrErr.takeError());
2091     return {};
2092   }
2093   auto &Segment = SegmentOrErr.get();
2094   return arrayRefFromStringRef(
2095       Obj.getData().slice(Segment.fileoff, Segment.fileoff + Segment.filesize));
2096 }
2097 } // namespace
2098 
2099 ArrayRef<uint8_t>
getSegmentContents(StringRef SegmentName) const2100 MachOObjectFile::getSegmentContents(StringRef SegmentName) const {
2101   for (auto LoadCmd : load_commands()) {
2102     ArrayRef<uint8_t> Contents;
2103     switch (LoadCmd.C.cmd) {
2104     case MachO::LC_SEGMENT:
2105       Contents = ::getSegmentContents<MachO::segment_command>(*this, LoadCmd,
2106                                                               SegmentName);
2107       break;
2108     case MachO::LC_SEGMENT_64:
2109       Contents = ::getSegmentContents<MachO::segment_command_64>(*this, LoadCmd,
2110                                                                  SegmentName);
2111       break;
2112     default:
2113       continue;
2114     }
2115     if (!Contents.empty())
2116       return Contents;
2117   }
2118   return {};
2119 }
2120 
2121 ArrayRef<uint8_t>
getSegmentContents(size_t SegmentIndex) const2122 MachOObjectFile::getSegmentContents(size_t SegmentIndex) const {
2123   size_t Idx = 0;
2124   for (auto LoadCmd : load_commands()) {
2125     switch (LoadCmd.C.cmd) {
2126     case MachO::LC_SEGMENT:
2127       if (Idx == SegmentIndex)
2128         return ::getSegmentContents<MachO::segment_command>(*this, LoadCmd);
2129       ++Idx;
2130       break;
2131     case MachO::LC_SEGMENT_64:
2132       if (Idx == SegmentIndex)
2133         return ::getSegmentContents<MachO::segment_command_64>(*this, LoadCmd);
2134       ++Idx;
2135       break;
2136     default:
2137       continue;
2138     }
2139   }
2140   return {};
2141 }
2142 
getSectionID(SectionRef Sec) const2143 unsigned MachOObjectFile::getSectionID(SectionRef Sec) const {
2144   return Sec.getRawDataRefImpl().d.a;
2145 }
2146 
isSectionVirtual(DataRefImpl Sec) const2147 bool MachOObjectFile::isSectionVirtual(DataRefImpl Sec) const {
2148   uint32_t Flags = getSectionFlags(*this, Sec);
2149   unsigned SectionType = Flags & MachO::SECTION_TYPE;
2150   return SectionType == MachO::S_ZEROFILL ||
2151          SectionType == MachO::S_GB_ZEROFILL;
2152 }
2153 
isSectionBitcode(DataRefImpl Sec) const2154 bool MachOObjectFile::isSectionBitcode(DataRefImpl Sec) const {
2155   StringRef SegmentName = getSectionFinalSegmentName(Sec);
2156   if (Expected<StringRef> NameOrErr = getSectionName(Sec))
2157     return (SegmentName == "__LLVM" && *NameOrErr == "__bitcode");
2158   return false;
2159 }
2160 
isSectionStripped(DataRefImpl Sec) const2161 bool MachOObjectFile::isSectionStripped(DataRefImpl Sec) const {
2162   if (is64Bit())
2163     return getSection64(Sec).offset == 0;
2164   return getSection(Sec).offset == 0;
2165 }
2166 
section_rel_begin(DataRefImpl Sec) const2167 relocation_iterator MachOObjectFile::section_rel_begin(DataRefImpl Sec) const {
2168   DataRefImpl Ret;
2169   Ret.d.a = Sec.d.a;
2170   Ret.d.b = 0;
2171   return relocation_iterator(RelocationRef(Ret, this));
2172 }
2173 
2174 relocation_iterator
section_rel_end(DataRefImpl Sec) const2175 MachOObjectFile::section_rel_end(DataRefImpl Sec) const {
2176   uint32_t Num;
2177   if (is64Bit()) {
2178     MachO::section_64 Sect = getSection64(Sec);
2179     Num = Sect.nreloc;
2180   } else {
2181     MachO::section Sect = getSection(Sec);
2182     Num = Sect.nreloc;
2183   }
2184 
2185   DataRefImpl Ret;
2186   Ret.d.a = Sec.d.a;
2187   Ret.d.b = Num;
2188   return relocation_iterator(RelocationRef(Ret, this));
2189 }
2190 
extrel_begin() const2191 relocation_iterator MachOObjectFile::extrel_begin() const {
2192   DataRefImpl Ret;
2193   // for DYSYMTAB symbols, Ret.d.a == 0 for external relocations
2194   Ret.d.a = 0; // Would normally be a section index.
2195   Ret.d.b = 0; // Index into the external relocations
2196   return relocation_iterator(RelocationRef(Ret, this));
2197 }
2198 
extrel_end() const2199 relocation_iterator MachOObjectFile::extrel_end() const {
2200   MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
2201   DataRefImpl Ret;
2202   // for DYSYMTAB symbols, Ret.d.a == 0 for external relocations
2203   Ret.d.a = 0; // Would normally be a section index.
2204   Ret.d.b = DysymtabLoadCmd.nextrel; // Index into the external relocations
2205   return relocation_iterator(RelocationRef(Ret, this));
2206 }
2207 
locrel_begin() const2208 relocation_iterator MachOObjectFile::locrel_begin() const {
2209   DataRefImpl Ret;
2210   // for DYSYMTAB symbols, Ret.d.a == 1 for local relocations
2211   Ret.d.a = 1; // Would normally be a section index.
2212   Ret.d.b = 0; // Index into the local relocations
2213   return relocation_iterator(RelocationRef(Ret, this));
2214 }
2215 
locrel_end() const2216 relocation_iterator MachOObjectFile::locrel_end() const {
2217   MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
2218   DataRefImpl Ret;
2219   // for DYSYMTAB symbols, Ret.d.a == 1 for local relocations
2220   Ret.d.a = 1; // Would normally be a section index.
2221   Ret.d.b = DysymtabLoadCmd.nlocrel; // Index into the local relocations
2222   return relocation_iterator(RelocationRef(Ret, this));
2223 }
2224 
moveRelocationNext(DataRefImpl & Rel) const2225 void MachOObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
2226   ++Rel.d.b;
2227 }
2228 
getRelocationOffset(DataRefImpl Rel) const2229 uint64_t MachOObjectFile::getRelocationOffset(DataRefImpl Rel) const {
2230   assert((getHeader().filetype == MachO::MH_OBJECT ||
2231           getHeader().filetype == MachO::MH_KEXT_BUNDLE) &&
2232          "Only implemented for MH_OBJECT && MH_KEXT_BUNDLE");
2233   MachO::any_relocation_info RE = getRelocation(Rel);
2234   return getAnyRelocationAddress(RE);
2235 }
2236 
2237 symbol_iterator
getRelocationSymbol(DataRefImpl Rel) const2238 MachOObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
2239   MachO::any_relocation_info RE = getRelocation(Rel);
2240   if (isRelocationScattered(RE))
2241     return symbol_end();
2242 
2243   uint32_t SymbolIdx = getPlainRelocationSymbolNum(RE);
2244   bool isExtern = getPlainRelocationExternal(RE);
2245   if (!isExtern)
2246     return symbol_end();
2247 
2248   MachO::symtab_command S = getSymtabLoadCommand();
2249   unsigned SymbolTableEntrySize = is64Bit() ?
2250     sizeof(MachO::nlist_64) :
2251     sizeof(MachO::nlist);
2252   uint64_t Offset = S.symoff + SymbolIdx * SymbolTableEntrySize;
2253   DataRefImpl Sym;
2254   Sym.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2255   return symbol_iterator(SymbolRef(Sym, this));
2256 }
2257 
2258 section_iterator
getRelocationSection(DataRefImpl Rel) const2259 MachOObjectFile::getRelocationSection(DataRefImpl Rel) const {
2260   return section_iterator(getAnyRelocationSection(getRelocation(Rel)));
2261 }
2262 
getRelocationType(DataRefImpl Rel) const2263 uint64_t MachOObjectFile::getRelocationType(DataRefImpl Rel) const {
2264   MachO::any_relocation_info RE = getRelocation(Rel);
2265   return getAnyRelocationType(RE);
2266 }
2267 
getRelocationTypeName(DataRefImpl Rel,SmallVectorImpl<char> & Result) const2268 void MachOObjectFile::getRelocationTypeName(
2269     DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
2270   StringRef res;
2271   uint64_t RType = getRelocationType(Rel);
2272 
2273   unsigned Arch = this->getArch();
2274 
2275   switch (Arch) {
2276     case Triple::x86: {
2277       static const char *const Table[] =  {
2278         "GENERIC_RELOC_VANILLA",
2279         "GENERIC_RELOC_PAIR",
2280         "GENERIC_RELOC_SECTDIFF",
2281         "GENERIC_RELOC_PB_LA_PTR",
2282         "GENERIC_RELOC_LOCAL_SECTDIFF",
2283         "GENERIC_RELOC_TLV" };
2284 
2285       if (RType > 5)
2286         res = "Unknown";
2287       else
2288         res = Table[RType];
2289       break;
2290     }
2291     case Triple::x86_64: {
2292       static const char *const Table[] =  {
2293         "X86_64_RELOC_UNSIGNED",
2294         "X86_64_RELOC_SIGNED",
2295         "X86_64_RELOC_BRANCH",
2296         "X86_64_RELOC_GOT_LOAD",
2297         "X86_64_RELOC_GOT",
2298         "X86_64_RELOC_SUBTRACTOR",
2299         "X86_64_RELOC_SIGNED_1",
2300         "X86_64_RELOC_SIGNED_2",
2301         "X86_64_RELOC_SIGNED_4",
2302         "X86_64_RELOC_TLV" };
2303 
2304       if (RType > 9)
2305         res = "Unknown";
2306       else
2307         res = Table[RType];
2308       break;
2309     }
2310     case Triple::arm: {
2311       static const char *const Table[] =  {
2312         "ARM_RELOC_VANILLA",
2313         "ARM_RELOC_PAIR",
2314         "ARM_RELOC_SECTDIFF",
2315         "ARM_RELOC_LOCAL_SECTDIFF",
2316         "ARM_RELOC_PB_LA_PTR",
2317         "ARM_RELOC_BR24",
2318         "ARM_THUMB_RELOC_BR22",
2319         "ARM_THUMB_32BIT_BRANCH",
2320         "ARM_RELOC_HALF",
2321         "ARM_RELOC_HALF_SECTDIFF" };
2322 
2323       if (RType > 9)
2324         res = "Unknown";
2325       else
2326         res = Table[RType];
2327       break;
2328     }
2329     case Triple::aarch64:
2330     case Triple::aarch64_32: {
2331       static const char *const Table[] = {
2332         "ARM64_RELOC_UNSIGNED",           "ARM64_RELOC_SUBTRACTOR",
2333         "ARM64_RELOC_BRANCH26",           "ARM64_RELOC_PAGE21",
2334         "ARM64_RELOC_PAGEOFF12",          "ARM64_RELOC_GOT_LOAD_PAGE21",
2335         "ARM64_RELOC_GOT_LOAD_PAGEOFF12", "ARM64_RELOC_POINTER_TO_GOT",
2336         "ARM64_RELOC_TLVP_LOAD_PAGE21",   "ARM64_RELOC_TLVP_LOAD_PAGEOFF12",
2337         "ARM64_RELOC_ADDEND"
2338       };
2339 
2340       if (RType >= std::size(Table))
2341         res = "Unknown";
2342       else
2343         res = Table[RType];
2344       break;
2345     }
2346     case Triple::ppc: {
2347       static const char *const Table[] =  {
2348         "PPC_RELOC_VANILLA",
2349         "PPC_RELOC_PAIR",
2350         "PPC_RELOC_BR14",
2351         "PPC_RELOC_BR24",
2352         "PPC_RELOC_HI16",
2353         "PPC_RELOC_LO16",
2354         "PPC_RELOC_HA16",
2355         "PPC_RELOC_LO14",
2356         "PPC_RELOC_SECTDIFF",
2357         "PPC_RELOC_PB_LA_PTR",
2358         "PPC_RELOC_HI16_SECTDIFF",
2359         "PPC_RELOC_LO16_SECTDIFF",
2360         "PPC_RELOC_HA16_SECTDIFF",
2361         "PPC_RELOC_JBSR",
2362         "PPC_RELOC_LO14_SECTDIFF",
2363         "PPC_RELOC_LOCAL_SECTDIFF" };
2364 
2365       if (RType > 15)
2366         res = "Unknown";
2367       else
2368         res = Table[RType];
2369       break;
2370     }
2371     case Triple::UnknownArch:
2372       res = "Unknown";
2373       break;
2374   }
2375   Result.append(res.begin(), res.end());
2376 }
2377 
getRelocationLength(DataRefImpl Rel) const2378 uint8_t MachOObjectFile::getRelocationLength(DataRefImpl Rel) const {
2379   MachO::any_relocation_info RE = getRelocation(Rel);
2380   return getAnyRelocationLength(RE);
2381 }
2382 
2383 //
2384 // guessLibraryShortName() is passed a name of a dynamic library and returns a
2385 // guess on what the short name is.  Then name is returned as a substring of the
2386 // StringRef Name passed in.  The name of the dynamic library is recognized as
2387 // a framework if it has one of the two following forms:
2388 //      Foo.framework/Versions/A/Foo
2389 //      Foo.framework/Foo
2390 // Where A and Foo can be any string.  And may contain a trailing suffix
2391 // starting with an underbar.  If the Name is recognized as a framework then
2392 // isFramework is set to true else it is set to false.  If the Name has a
2393 // suffix then Suffix is set to the substring in Name that contains the suffix
2394 // else it is set to a NULL StringRef.
2395 //
2396 // The Name of the dynamic library is recognized as a library name if it has
2397 // one of the two following forms:
2398 //      libFoo.A.dylib
2399 //      libFoo.dylib
2400 //
2401 // The library may have a suffix trailing the name Foo of the form:
2402 //      libFoo_profile.A.dylib
2403 //      libFoo_profile.dylib
2404 // These dyld image suffixes are separated from the short name by a '_'
2405 // character. Because the '_' character is commonly used to separate words in
2406 // filenames guessLibraryShortName() cannot reliably separate a dylib's short
2407 // name from an arbitrary image suffix; imagine if both the short name and the
2408 // suffix contains an '_' character! To better deal with this ambiguity,
2409 // guessLibraryShortName() will recognize only "_debug" and "_profile" as valid
2410 // Suffix values. Calling code needs to be tolerant of guessLibraryShortName()
2411 // guessing incorrectly.
2412 //
2413 // The Name of the dynamic library is also recognized as a library name if it
2414 // has the following form:
2415 //      Foo.qtx
2416 //
2417 // If the Name of the dynamic library is none of the forms above then a NULL
2418 // StringRef is returned.
guessLibraryShortName(StringRef Name,bool & isFramework,StringRef & Suffix)2419 StringRef MachOObjectFile::guessLibraryShortName(StringRef Name,
2420                                                  bool &isFramework,
2421                                                  StringRef &Suffix) {
2422   StringRef Foo, F, DotFramework, V, Dylib, Lib, Dot, Qtx;
2423   size_t a, b, c, d, Idx;
2424 
2425   isFramework = false;
2426   Suffix = StringRef();
2427 
2428   // Pull off the last component and make Foo point to it
2429   a = Name.rfind('/');
2430   if (a == Name.npos || a == 0)
2431     goto guess_library;
2432   Foo = Name.slice(a+1, Name.npos);
2433 
2434   // Look for a suffix starting with a '_'
2435   Idx = Foo.rfind('_');
2436   if (Idx != Foo.npos && Foo.size() >= 2) {
2437     Suffix = Foo.slice(Idx, Foo.npos);
2438     if (Suffix != "_debug" && Suffix != "_profile")
2439       Suffix = StringRef();
2440     else
2441       Foo = Foo.slice(0, Idx);
2442   }
2443 
2444   // First look for the form Foo.framework/Foo
2445   b = Name.rfind('/', a);
2446   if (b == Name.npos)
2447     Idx = 0;
2448   else
2449     Idx = b+1;
2450   F = Name.slice(Idx, Idx + Foo.size());
2451   DotFramework = Name.slice(Idx + Foo.size(),
2452                             Idx + Foo.size() + sizeof(".framework/")-1);
2453   if (F == Foo && DotFramework == ".framework/") {
2454     isFramework = true;
2455     return Foo;
2456   }
2457 
2458   // Next look for the form Foo.framework/Versions/A/Foo
2459   if (b == Name.npos)
2460     goto guess_library;
2461   c =  Name.rfind('/', b);
2462   if (c == Name.npos || c == 0)
2463     goto guess_library;
2464   V = Name.slice(c+1, Name.npos);
2465   if (!V.startswith("Versions/"))
2466     goto guess_library;
2467   d =  Name.rfind('/', c);
2468   if (d == Name.npos)
2469     Idx = 0;
2470   else
2471     Idx = d+1;
2472   F = Name.slice(Idx, Idx + Foo.size());
2473   DotFramework = Name.slice(Idx + Foo.size(),
2474                             Idx + Foo.size() + sizeof(".framework/")-1);
2475   if (F == Foo && DotFramework == ".framework/") {
2476     isFramework = true;
2477     return Foo;
2478   }
2479 
2480 guess_library:
2481   // pull off the suffix after the "." and make a point to it
2482   a = Name.rfind('.');
2483   if (a == Name.npos || a == 0)
2484     return StringRef();
2485   Dylib = Name.slice(a, Name.npos);
2486   if (Dylib != ".dylib")
2487     goto guess_qtx;
2488 
2489   // First pull off the version letter for the form Foo.A.dylib if any.
2490   if (a >= 3) {
2491     Dot = Name.slice(a-2, a-1);
2492     if (Dot == ".")
2493       a = a - 2;
2494   }
2495 
2496   b = Name.rfind('/', a);
2497   if (b == Name.npos)
2498     b = 0;
2499   else
2500     b = b+1;
2501   // ignore any suffix after an underbar like Foo_profile.A.dylib
2502   Idx = Name.rfind('_');
2503   if (Idx != Name.npos && Idx != b) {
2504     Lib = Name.slice(b, Idx);
2505     Suffix = Name.slice(Idx, a);
2506     if (Suffix != "_debug" && Suffix != "_profile") {
2507       Suffix = StringRef();
2508       Lib = Name.slice(b, a);
2509     }
2510   }
2511   else
2512     Lib = Name.slice(b, a);
2513   // There are incorrect library names of the form:
2514   // libATS.A_profile.dylib so check for these.
2515   if (Lib.size() >= 3) {
2516     Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
2517     if (Dot == ".")
2518       Lib = Lib.slice(0, Lib.size()-2);
2519   }
2520   return Lib;
2521 
2522 guess_qtx:
2523   Qtx = Name.slice(a, Name.npos);
2524   if (Qtx != ".qtx")
2525     return StringRef();
2526   b = Name.rfind('/', a);
2527   if (b == Name.npos)
2528     Lib = Name.slice(0, a);
2529   else
2530     Lib = Name.slice(b+1, a);
2531   // There are library names of the form: QT.A.qtx so check for these.
2532   if (Lib.size() >= 3) {
2533     Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
2534     if (Dot == ".")
2535       Lib = Lib.slice(0, Lib.size()-2);
2536   }
2537   return Lib;
2538 }
2539 
2540 // getLibraryShortNameByIndex() is used to get the short name of the library
2541 // for an undefined symbol in a linked Mach-O binary that was linked with the
2542 // normal two-level namespace default (that is MH_TWOLEVEL in the header).
2543 // It is passed the index (0 - based) of the library as translated from
2544 // GET_LIBRARY_ORDINAL (1 - based).
getLibraryShortNameByIndex(unsigned Index,StringRef & Res) const2545 std::error_code MachOObjectFile::getLibraryShortNameByIndex(unsigned Index,
2546                                                          StringRef &Res) const {
2547   if (Index >= Libraries.size())
2548     return object_error::parse_failed;
2549 
2550   // If the cache of LibrariesShortNames is not built up do that first for
2551   // all the Libraries.
2552   if (LibrariesShortNames.size() == 0) {
2553     for (unsigned i = 0; i < Libraries.size(); i++) {
2554       auto CommandOrErr =
2555         getStructOrErr<MachO::dylib_command>(*this, Libraries[i]);
2556       if (!CommandOrErr)
2557         return object_error::parse_failed;
2558       MachO::dylib_command D = CommandOrErr.get();
2559       if (D.dylib.name >= D.cmdsize)
2560         return object_error::parse_failed;
2561       const char *P = (const char *)(Libraries[i]) + D.dylib.name;
2562       StringRef Name = StringRef(P);
2563       if (D.dylib.name+Name.size() >= D.cmdsize)
2564         return object_error::parse_failed;
2565       StringRef Suffix;
2566       bool isFramework;
2567       StringRef shortName = guessLibraryShortName(Name, isFramework, Suffix);
2568       if (shortName.empty())
2569         LibrariesShortNames.push_back(Name);
2570       else
2571         LibrariesShortNames.push_back(shortName);
2572     }
2573   }
2574 
2575   Res = LibrariesShortNames[Index];
2576   return std::error_code();
2577 }
2578 
getLibraryCount() const2579 uint32_t MachOObjectFile::getLibraryCount() const {
2580   return Libraries.size();
2581 }
2582 
2583 section_iterator
getRelocationRelocatedSection(relocation_iterator Rel) const2584 MachOObjectFile::getRelocationRelocatedSection(relocation_iterator Rel) const {
2585   DataRefImpl Sec;
2586   Sec.d.a = Rel->getRawDataRefImpl().d.a;
2587   return section_iterator(SectionRef(Sec, this));
2588 }
2589 
symbol_begin() const2590 basic_symbol_iterator MachOObjectFile::symbol_begin() const {
2591   DataRefImpl DRI;
2592   MachO::symtab_command Symtab = getSymtabLoadCommand();
2593   if (!SymtabLoadCmd || Symtab.nsyms == 0)
2594     return basic_symbol_iterator(SymbolRef(DRI, this));
2595 
2596   return getSymbolByIndex(0);
2597 }
2598 
symbol_end() const2599 basic_symbol_iterator MachOObjectFile::symbol_end() const {
2600   DataRefImpl DRI;
2601   MachO::symtab_command Symtab = getSymtabLoadCommand();
2602   if (!SymtabLoadCmd || Symtab.nsyms == 0)
2603     return basic_symbol_iterator(SymbolRef(DRI, this));
2604 
2605   unsigned SymbolTableEntrySize = is64Bit() ?
2606     sizeof(MachO::nlist_64) :
2607     sizeof(MachO::nlist);
2608   unsigned Offset = Symtab.symoff +
2609     Symtab.nsyms * SymbolTableEntrySize;
2610   DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2611   return basic_symbol_iterator(SymbolRef(DRI, this));
2612 }
2613 
getSymbolByIndex(unsigned Index) const2614 symbol_iterator MachOObjectFile::getSymbolByIndex(unsigned Index) const {
2615   MachO::symtab_command Symtab = getSymtabLoadCommand();
2616   if (!SymtabLoadCmd || Index >= Symtab.nsyms)
2617     report_fatal_error("Requested symbol index is out of range.");
2618   unsigned SymbolTableEntrySize =
2619     is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
2620   DataRefImpl DRI;
2621   DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Symtab.symoff));
2622   DRI.p += Index * SymbolTableEntrySize;
2623   return basic_symbol_iterator(SymbolRef(DRI, this));
2624 }
2625 
getSymbolIndex(DataRefImpl Symb) const2626 uint64_t MachOObjectFile::getSymbolIndex(DataRefImpl Symb) const {
2627   MachO::symtab_command Symtab = getSymtabLoadCommand();
2628   if (!SymtabLoadCmd)
2629     report_fatal_error("getSymbolIndex() called with no symbol table symbol");
2630   unsigned SymbolTableEntrySize =
2631     is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
2632   DataRefImpl DRIstart;
2633   DRIstart.p = reinterpret_cast<uintptr_t>(getPtr(*this, Symtab.symoff));
2634   uint64_t Index = (Symb.p - DRIstart.p) / SymbolTableEntrySize;
2635   return Index;
2636 }
2637 
section_begin() const2638 section_iterator MachOObjectFile::section_begin() const {
2639   DataRefImpl DRI;
2640   return section_iterator(SectionRef(DRI, this));
2641 }
2642 
section_end() const2643 section_iterator MachOObjectFile::section_end() const {
2644   DataRefImpl DRI;
2645   DRI.d.a = Sections.size();
2646   return section_iterator(SectionRef(DRI, this));
2647 }
2648 
getBytesInAddress() const2649 uint8_t MachOObjectFile::getBytesInAddress() const {
2650   return is64Bit() ? 8 : 4;
2651 }
2652 
getFileFormatName() const2653 StringRef MachOObjectFile::getFileFormatName() const {
2654   unsigned CPUType = getCPUType(*this);
2655   if (!is64Bit()) {
2656     switch (CPUType) {
2657     case MachO::CPU_TYPE_I386:
2658       return "Mach-O 32-bit i386";
2659     case MachO::CPU_TYPE_ARM:
2660       return "Mach-O arm";
2661     case MachO::CPU_TYPE_ARM64_32:
2662       return "Mach-O arm64 (ILP32)";
2663     case MachO::CPU_TYPE_POWERPC:
2664       return "Mach-O 32-bit ppc";
2665     default:
2666       return "Mach-O 32-bit unknown";
2667     }
2668   }
2669 
2670   switch (CPUType) {
2671   case MachO::CPU_TYPE_X86_64:
2672     return "Mach-O 64-bit x86-64";
2673   case MachO::CPU_TYPE_ARM64:
2674     return "Mach-O arm64";
2675   case MachO::CPU_TYPE_POWERPC64:
2676     return "Mach-O 64-bit ppc64";
2677   default:
2678     return "Mach-O 64-bit unknown";
2679   }
2680 }
2681 
getArch(uint32_t CPUType,uint32_t CPUSubType)2682 Triple::ArchType MachOObjectFile::getArch(uint32_t CPUType, uint32_t CPUSubType) {
2683   switch (CPUType) {
2684   case MachO::CPU_TYPE_I386:
2685     return Triple::x86;
2686   case MachO::CPU_TYPE_X86_64:
2687     return Triple::x86_64;
2688   case MachO::CPU_TYPE_ARM:
2689     return Triple::arm;
2690   case MachO::CPU_TYPE_ARM64:
2691     return Triple::aarch64;
2692   case MachO::CPU_TYPE_ARM64_32:
2693     return Triple::aarch64_32;
2694   case MachO::CPU_TYPE_POWERPC:
2695     return Triple::ppc;
2696   case MachO::CPU_TYPE_POWERPC64:
2697     return Triple::ppc64;
2698   default:
2699     return Triple::UnknownArch;
2700   }
2701 }
2702 
getArchTriple(uint32_t CPUType,uint32_t CPUSubType,const char ** McpuDefault,const char ** ArchFlag)2703 Triple MachOObjectFile::getArchTriple(uint32_t CPUType, uint32_t CPUSubType,
2704                                       const char **McpuDefault,
2705                                       const char **ArchFlag) {
2706   if (McpuDefault)
2707     *McpuDefault = nullptr;
2708   if (ArchFlag)
2709     *ArchFlag = nullptr;
2710 
2711   switch (CPUType) {
2712   case MachO::CPU_TYPE_I386:
2713     switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2714     case MachO::CPU_SUBTYPE_I386_ALL:
2715       if (ArchFlag)
2716         *ArchFlag = "i386";
2717       return Triple("i386-apple-darwin");
2718     default:
2719       return Triple();
2720     }
2721   case MachO::CPU_TYPE_X86_64:
2722     switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2723     case MachO::CPU_SUBTYPE_X86_64_ALL:
2724       if (ArchFlag)
2725         *ArchFlag = "x86_64";
2726       return Triple("x86_64-apple-darwin");
2727     case MachO::CPU_SUBTYPE_X86_64_H:
2728       if (ArchFlag)
2729         *ArchFlag = "x86_64h";
2730       return Triple("x86_64h-apple-darwin");
2731     default:
2732       return Triple();
2733     }
2734   case MachO::CPU_TYPE_ARM:
2735     switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2736     case MachO::CPU_SUBTYPE_ARM_V4T:
2737       if (ArchFlag)
2738         *ArchFlag = "armv4t";
2739       return Triple("armv4t-apple-darwin");
2740     case MachO::CPU_SUBTYPE_ARM_V5TEJ:
2741       if (ArchFlag)
2742         *ArchFlag = "armv5e";
2743       return Triple("armv5e-apple-darwin");
2744     case MachO::CPU_SUBTYPE_ARM_XSCALE:
2745       if (ArchFlag)
2746         *ArchFlag = "xscale";
2747       return Triple("xscale-apple-darwin");
2748     case MachO::CPU_SUBTYPE_ARM_V6:
2749       if (ArchFlag)
2750         *ArchFlag = "armv6";
2751       return Triple("armv6-apple-darwin");
2752     case MachO::CPU_SUBTYPE_ARM_V6M:
2753       if (McpuDefault)
2754         *McpuDefault = "cortex-m0";
2755       if (ArchFlag)
2756         *ArchFlag = "armv6m";
2757       return Triple("armv6m-apple-darwin");
2758     case MachO::CPU_SUBTYPE_ARM_V7:
2759       if (ArchFlag)
2760         *ArchFlag = "armv7";
2761       return Triple("armv7-apple-darwin");
2762     case MachO::CPU_SUBTYPE_ARM_V7EM:
2763       if (McpuDefault)
2764         *McpuDefault = "cortex-m4";
2765       if (ArchFlag)
2766         *ArchFlag = "armv7em";
2767       return Triple("thumbv7em-apple-darwin");
2768     case MachO::CPU_SUBTYPE_ARM_V7K:
2769       if (McpuDefault)
2770         *McpuDefault = "cortex-a7";
2771       if (ArchFlag)
2772         *ArchFlag = "armv7k";
2773       return Triple("armv7k-apple-darwin");
2774     case MachO::CPU_SUBTYPE_ARM_V7M:
2775       if (McpuDefault)
2776         *McpuDefault = "cortex-m3";
2777       if (ArchFlag)
2778         *ArchFlag = "armv7m";
2779       return Triple("thumbv7m-apple-darwin");
2780     case MachO::CPU_SUBTYPE_ARM_V7S:
2781       if (McpuDefault)
2782         *McpuDefault = "cortex-a7";
2783       if (ArchFlag)
2784         *ArchFlag = "armv7s";
2785       return Triple("armv7s-apple-darwin");
2786     default:
2787       return Triple();
2788     }
2789   case MachO::CPU_TYPE_ARM64:
2790     switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2791     case MachO::CPU_SUBTYPE_ARM64_ALL:
2792       if (McpuDefault)
2793         *McpuDefault = "cyclone";
2794       if (ArchFlag)
2795         *ArchFlag = "arm64";
2796       return Triple("arm64-apple-darwin");
2797     case MachO::CPU_SUBTYPE_ARM64E:
2798       if (McpuDefault)
2799         *McpuDefault = "apple-a12";
2800       if (ArchFlag)
2801         *ArchFlag = "arm64e";
2802       return Triple("arm64e-apple-darwin");
2803     default:
2804       return Triple();
2805     }
2806   case MachO::CPU_TYPE_ARM64_32:
2807     switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2808     case MachO::CPU_SUBTYPE_ARM64_32_V8:
2809       if (McpuDefault)
2810         *McpuDefault = "cyclone";
2811       if (ArchFlag)
2812         *ArchFlag = "arm64_32";
2813       return Triple("arm64_32-apple-darwin");
2814     default:
2815       return Triple();
2816     }
2817   case MachO::CPU_TYPE_POWERPC:
2818     switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2819     case MachO::CPU_SUBTYPE_POWERPC_ALL:
2820       if (ArchFlag)
2821         *ArchFlag = "ppc";
2822       return Triple("ppc-apple-darwin");
2823     default:
2824       return Triple();
2825     }
2826   case MachO::CPU_TYPE_POWERPC64:
2827     switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2828     case MachO::CPU_SUBTYPE_POWERPC_ALL:
2829       if (ArchFlag)
2830         *ArchFlag = "ppc64";
2831       return Triple("ppc64-apple-darwin");
2832     default:
2833       return Triple();
2834     }
2835   default:
2836     return Triple();
2837   }
2838 }
2839 
getHostArch()2840 Triple MachOObjectFile::getHostArch() {
2841   return Triple(sys::getDefaultTargetTriple());
2842 }
2843 
isValidArch(StringRef ArchFlag)2844 bool MachOObjectFile::isValidArch(StringRef ArchFlag) {
2845   auto validArchs = getValidArchs();
2846   return llvm::is_contained(validArchs, ArchFlag);
2847 }
2848 
getValidArchs()2849 ArrayRef<StringRef> MachOObjectFile::getValidArchs() {
2850   static const std::array<StringRef, 18> ValidArchs = {{
2851       "i386",
2852       "x86_64",
2853       "x86_64h",
2854       "armv4t",
2855       "arm",
2856       "armv5e",
2857       "armv6",
2858       "armv6m",
2859       "armv7",
2860       "armv7em",
2861       "armv7k",
2862       "armv7m",
2863       "armv7s",
2864       "arm64",
2865       "arm64e",
2866       "arm64_32",
2867       "ppc",
2868       "ppc64",
2869   }};
2870 
2871   return ValidArchs;
2872 }
2873 
getArch() const2874 Triple::ArchType MachOObjectFile::getArch() const {
2875   return getArch(getCPUType(*this), getCPUSubType(*this));
2876 }
2877 
getArchTriple(const char ** McpuDefault) const2878 Triple MachOObjectFile::getArchTriple(const char **McpuDefault) const {
2879   return getArchTriple(Header.cputype, Header.cpusubtype, McpuDefault);
2880 }
2881 
section_rel_begin(unsigned Index) const2882 relocation_iterator MachOObjectFile::section_rel_begin(unsigned Index) const {
2883   DataRefImpl DRI;
2884   DRI.d.a = Index;
2885   return section_rel_begin(DRI);
2886 }
2887 
section_rel_end(unsigned Index) const2888 relocation_iterator MachOObjectFile::section_rel_end(unsigned Index) const {
2889   DataRefImpl DRI;
2890   DRI.d.a = Index;
2891   return section_rel_end(DRI);
2892 }
2893 
begin_dices() const2894 dice_iterator MachOObjectFile::begin_dices() const {
2895   DataRefImpl DRI;
2896   if (!DataInCodeLoadCmd)
2897     return dice_iterator(DiceRef(DRI, this));
2898 
2899   MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
2900   DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, DicLC.dataoff));
2901   return dice_iterator(DiceRef(DRI, this));
2902 }
2903 
end_dices() const2904 dice_iterator MachOObjectFile::end_dices() const {
2905   DataRefImpl DRI;
2906   if (!DataInCodeLoadCmd)
2907     return dice_iterator(DiceRef(DRI, this));
2908 
2909   MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
2910   unsigned Offset = DicLC.dataoff + DicLC.datasize;
2911   DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2912   return dice_iterator(DiceRef(DRI, this));
2913 }
2914 
ExportEntry(Error * E,const MachOObjectFile * O,ArrayRef<uint8_t> T)2915 ExportEntry::ExportEntry(Error *E, const MachOObjectFile *O,
2916                          ArrayRef<uint8_t> T) : E(E), O(O), Trie(T) {}
2917 
moveToFirst()2918 void ExportEntry::moveToFirst() {
2919   ErrorAsOutParameter ErrAsOutParam(E);
2920   pushNode(0);
2921   if (*E)
2922     return;
2923   pushDownUntilBottom();
2924 }
2925 
moveToEnd()2926 void ExportEntry::moveToEnd() {
2927   Stack.clear();
2928   Done = true;
2929 }
2930 
operator ==(const ExportEntry & Other) const2931 bool ExportEntry::operator==(const ExportEntry &Other) const {
2932   // Common case, one at end, other iterating from begin.
2933   if (Done || Other.Done)
2934     return (Done == Other.Done);
2935   // Not equal if different stack sizes.
2936   if (Stack.size() != Other.Stack.size())
2937     return false;
2938   // Not equal if different cumulative strings.
2939   if (!CumulativeString.equals(Other.CumulativeString))
2940     return false;
2941   // Equal if all nodes in both stacks match.
2942   for (unsigned i=0; i < Stack.size(); ++i) {
2943     if (Stack[i].Start != Other.Stack[i].Start)
2944       return false;
2945   }
2946   return true;
2947 }
2948 
readULEB128(const uint8_t * & Ptr,const char ** error)2949 uint64_t ExportEntry::readULEB128(const uint8_t *&Ptr, const char **error) {
2950   unsigned Count;
2951   uint64_t Result = decodeULEB128(Ptr, &Count, Trie.end(), error);
2952   Ptr += Count;
2953   if (Ptr > Trie.end())
2954     Ptr = Trie.end();
2955   return Result;
2956 }
2957 
name() const2958 StringRef ExportEntry::name() const {
2959   return CumulativeString;
2960 }
2961 
flags() const2962 uint64_t ExportEntry::flags() const {
2963   return Stack.back().Flags;
2964 }
2965 
address() const2966 uint64_t ExportEntry::address() const {
2967   return Stack.back().Address;
2968 }
2969 
other() const2970 uint64_t ExportEntry::other() const {
2971   return Stack.back().Other;
2972 }
2973 
otherName() const2974 StringRef ExportEntry::otherName() const {
2975   const char* ImportName = Stack.back().ImportName;
2976   if (ImportName)
2977     return StringRef(ImportName);
2978   return StringRef();
2979 }
2980 
nodeOffset() const2981 uint32_t ExportEntry::nodeOffset() const {
2982   return Stack.back().Start - Trie.begin();
2983 }
2984 
NodeState(const uint8_t * Ptr)2985 ExportEntry::NodeState::NodeState(const uint8_t *Ptr)
2986     : Start(Ptr), Current(Ptr) {}
2987 
pushNode(uint64_t offset)2988 void ExportEntry::pushNode(uint64_t offset) {
2989   ErrorAsOutParameter ErrAsOutParam(E);
2990   const uint8_t *Ptr = Trie.begin() + offset;
2991   NodeState State(Ptr);
2992   const char *error;
2993   uint64_t ExportInfoSize = readULEB128(State.Current, &error);
2994   if (error) {
2995     *E = malformedError("export info size " + Twine(error) +
2996                         " in export trie data at node: 0x" +
2997                         Twine::utohexstr(offset));
2998     moveToEnd();
2999     return;
3000   }
3001   State.IsExportNode = (ExportInfoSize != 0);
3002   const uint8_t* Children = State.Current + ExportInfoSize;
3003   if (Children > Trie.end()) {
3004     *E = malformedError(
3005         "export info size: 0x" + Twine::utohexstr(ExportInfoSize) +
3006         " in export trie data at node: 0x" + Twine::utohexstr(offset) +
3007         " too big and extends past end of trie data");
3008     moveToEnd();
3009     return;
3010   }
3011   if (State.IsExportNode) {
3012     const uint8_t *ExportStart = State.Current;
3013     State.Flags = readULEB128(State.Current, &error);
3014     if (error) {
3015       *E = malformedError("flags " + Twine(error) +
3016                           " in export trie data at node: 0x" +
3017                           Twine::utohexstr(offset));
3018       moveToEnd();
3019       return;
3020     }
3021     uint64_t Kind = State.Flags & MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK;
3022     if (State.Flags != 0 &&
3023         (Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_REGULAR &&
3024          Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE &&
3025          Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL)) {
3026       *E = malformedError(
3027           "unsupported exported symbol kind: " + Twine((int)Kind) +
3028           " in flags: 0x" + Twine::utohexstr(State.Flags) +
3029           " in export trie data at node: 0x" + Twine::utohexstr(offset));
3030       moveToEnd();
3031       return;
3032     }
3033     if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT) {
3034       State.Address = 0;
3035       State.Other = readULEB128(State.Current, &error); // dylib ordinal
3036       if (error) {
3037         *E = malformedError("dylib ordinal of re-export " + Twine(error) +
3038                             " in export trie data at node: 0x" +
3039                             Twine::utohexstr(offset));
3040         moveToEnd();
3041         return;
3042       }
3043       if (O != nullptr) {
3044         // Only positive numbers represent library ordinals. Zero and negative
3045         // numbers have special meaning (see BindSpecialDylib).
3046         if ((int64_t)State.Other > 0 && State.Other > O->getLibraryCount()) {
3047           *E = malformedError(
3048               "bad library ordinal: " + Twine((int)State.Other) + " (max " +
3049               Twine((int)O->getLibraryCount()) +
3050               ") in export trie data at node: 0x" + Twine::utohexstr(offset));
3051           moveToEnd();
3052           return;
3053         }
3054       }
3055       State.ImportName = reinterpret_cast<const char*>(State.Current);
3056       if (*State.ImportName == '\0') {
3057         State.Current++;
3058       } else {
3059         const uint8_t *End = State.Current + 1;
3060         if (End >= Trie.end()) {
3061           *E = malformedError("import name of re-export in export trie data at "
3062                               "node: 0x" +
3063                               Twine::utohexstr(offset) +
3064                               " starts past end of trie data");
3065           moveToEnd();
3066           return;
3067         }
3068         while(*End != '\0' && End < Trie.end())
3069           End++;
3070         if (*End != '\0') {
3071           *E = malformedError("import name of re-export in export trie data at "
3072                               "node: 0x" +
3073                               Twine::utohexstr(offset) +
3074                               " extends past end of trie data");
3075           moveToEnd();
3076           return;
3077         }
3078         State.Current = End + 1;
3079       }
3080     } else {
3081       State.Address = readULEB128(State.Current, &error);
3082       if (error) {
3083         *E = malformedError("address " + Twine(error) +
3084                             " in export trie data at node: 0x" +
3085                             Twine::utohexstr(offset));
3086         moveToEnd();
3087         return;
3088       }
3089       if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER) {
3090         State.Other = readULEB128(State.Current, &error);
3091         if (error) {
3092           *E = malformedError("resolver of stub and resolver " + Twine(error) +
3093                               " in export trie data at node: 0x" +
3094                               Twine::utohexstr(offset));
3095           moveToEnd();
3096           return;
3097         }
3098       }
3099     }
3100     if(ExportStart + ExportInfoSize != State.Current) {
3101       *E = malformedError(
3102           "inconsistent export info size: 0x" +
3103           Twine::utohexstr(ExportInfoSize) + " where actual size was: 0x" +
3104           Twine::utohexstr(State.Current - ExportStart) +
3105           " in export trie data at node: 0x" + Twine::utohexstr(offset));
3106       moveToEnd();
3107       return;
3108     }
3109   }
3110   State.ChildCount = *Children;
3111   if (State.ChildCount != 0 && Children + 1 >= Trie.end()) {
3112     *E = malformedError("byte for count of childern in export trie data at "
3113                         "node: 0x" +
3114                         Twine::utohexstr(offset) +
3115                         " extends past end of trie data");
3116     moveToEnd();
3117     return;
3118   }
3119   State.Current = Children + 1;
3120   State.NextChildIndex = 0;
3121   State.ParentStringLength = CumulativeString.size();
3122   Stack.push_back(State);
3123 }
3124 
pushDownUntilBottom()3125 void ExportEntry::pushDownUntilBottom() {
3126   ErrorAsOutParameter ErrAsOutParam(E);
3127   const char *error;
3128   while (Stack.back().NextChildIndex < Stack.back().ChildCount) {
3129     NodeState &Top = Stack.back();
3130     CumulativeString.resize(Top.ParentStringLength);
3131     for (;*Top.Current != 0 && Top.Current < Trie.end(); Top.Current++) {
3132       char C = *Top.Current;
3133       CumulativeString.push_back(C);
3134     }
3135     if (Top.Current >= Trie.end()) {
3136       *E = malformedError("edge sub-string in export trie data at node: 0x" +
3137                           Twine::utohexstr(Top.Start - Trie.begin()) +
3138                           " for child #" + Twine((int)Top.NextChildIndex) +
3139                           " extends past end of trie data");
3140       moveToEnd();
3141       return;
3142     }
3143     Top.Current += 1;
3144     uint64_t childNodeIndex = readULEB128(Top.Current, &error);
3145     if (error) {
3146       *E = malformedError("child node offset " + Twine(error) +
3147                           " in export trie data at node: 0x" +
3148                           Twine::utohexstr(Top.Start - Trie.begin()));
3149       moveToEnd();
3150       return;
3151     }
3152     for (const NodeState &node : nodes()) {
3153       if (node.Start == Trie.begin() + childNodeIndex){
3154         *E = malformedError("loop in childern in export trie data at node: 0x" +
3155                             Twine::utohexstr(Top.Start - Trie.begin()) +
3156                             " back to node: 0x" +
3157                             Twine::utohexstr(childNodeIndex));
3158         moveToEnd();
3159         return;
3160       }
3161     }
3162     Top.NextChildIndex += 1;
3163     pushNode(childNodeIndex);
3164     if (*E)
3165       return;
3166   }
3167   if (!Stack.back().IsExportNode) {
3168     *E = malformedError("node is not an export node in export trie data at "
3169                         "node: 0x" +
3170                         Twine::utohexstr(Stack.back().Start - Trie.begin()));
3171     moveToEnd();
3172     return;
3173   }
3174 }
3175 
3176 // We have a trie data structure and need a way to walk it that is compatible
3177 // with the C++ iterator model. The solution is a non-recursive depth first
3178 // traversal where the iterator contains a stack of parent nodes along with a
3179 // string that is the accumulation of all edge strings along the parent chain
3180 // to this point.
3181 //
3182 // There is one "export" node for each exported symbol.  But because some
3183 // symbols may be a prefix of another symbol (e.g. _dup and _dup2), an export
3184 // node may have child nodes too.
3185 //
3186 // The algorithm for moveNext() is to keep moving down the leftmost unvisited
3187 // child until hitting a node with no children (which is an export node or
3188 // else the trie is malformed). On the way down, each node is pushed on the
3189 // stack ivar.  If there is no more ways down, it pops up one and tries to go
3190 // down a sibling path until a childless node is reached.
moveNext()3191 void ExportEntry::moveNext() {
3192   assert(!Stack.empty() && "ExportEntry::moveNext() with empty node stack");
3193   if (!Stack.back().IsExportNode) {
3194     *E = malformedError("node is not an export node in export trie data at "
3195                         "node: 0x" +
3196                         Twine::utohexstr(Stack.back().Start - Trie.begin()));
3197     moveToEnd();
3198     return;
3199   }
3200 
3201   Stack.pop_back();
3202   while (!Stack.empty()) {
3203     NodeState &Top = Stack.back();
3204     if (Top.NextChildIndex < Top.ChildCount) {
3205       pushDownUntilBottom();
3206       // Now at the next export node.
3207       return;
3208     } else {
3209       if (Top.IsExportNode) {
3210         // This node has no children but is itself an export node.
3211         CumulativeString.resize(Top.ParentStringLength);
3212         return;
3213       }
3214       Stack.pop_back();
3215     }
3216   }
3217   Done = true;
3218 }
3219 
3220 iterator_range<export_iterator>
exports(Error & E,ArrayRef<uint8_t> Trie,const MachOObjectFile * O)3221 MachOObjectFile::exports(Error &E, ArrayRef<uint8_t> Trie,
3222                          const MachOObjectFile *O) {
3223   ExportEntry Start(&E, O, Trie);
3224   if (Trie.empty())
3225     Start.moveToEnd();
3226   else
3227     Start.moveToFirst();
3228 
3229   ExportEntry Finish(&E, O, Trie);
3230   Finish.moveToEnd();
3231 
3232   return make_range(export_iterator(Start), export_iterator(Finish));
3233 }
3234 
exports(Error & Err) const3235 iterator_range<export_iterator> MachOObjectFile::exports(Error &Err) const {
3236   ArrayRef<uint8_t> Trie;
3237   if (DyldInfoLoadCmd)
3238     Trie = getDyldInfoExportsTrie();
3239   else if (DyldExportsTrieLoadCmd)
3240     Trie = getDyldExportsTrie();
3241 
3242   return exports(Err, Trie, this);
3243 }
3244 
MachOAbstractFixupEntry(Error * E,const MachOObjectFile * O)3245 MachOAbstractFixupEntry::MachOAbstractFixupEntry(Error *E,
3246                                                  const MachOObjectFile *O)
3247     : E(E), O(O) {
3248   // Cache the vmaddress of __TEXT
3249   for (const auto &Command : O->load_commands()) {
3250     if (Command.C.cmd == MachO::LC_SEGMENT) {
3251       MachO::segment_command SLC = O->getSegmentLoadCommand(Command);
3252       if (StringRef(SLC.segname) == StringRef("__TEXT")) {
3253         TextAddress = SLC.vmaddr;
3254         break;
3255       }
3256     } else if (Command.C.cmd == MachO::LC_SEGMENT_64) {
3257       MachO::segment_command_64 SLC_64 = O->getSegment64LoadCommand(Command);
3258       if (StringRef(SLC_64.segname) == StringRef("__TEXT")) {
3259         TextAddress = SLC_64.vmaddr;
3260         break;
3261       }
3262     }
3263   }
3264 }
3265 
segmentIndex() const3266 int32_t MachOAbstractFixupEntry::segmentIndex() const { return SegmentIndex; }
3267 
segmentOffset() const3268 uint64_t MachOAbstractFixupEntry::segmentOffset() const {
3269   return SegmentOffset;
3270 }
3271 
segmentAddress() const3272 uint64_t MachOAbstractFixupEntry::segmentAddress() const {
3273   return O->BindRebaseAddress(SegmentIndex, 0);
3274 }
3275 
segmentName() const3276 StringRef MachOAbstractFixupEntry::segmentName() const {
3277   return O->BindRebaseSegmentName(SegmentIndex);
3278 }
3279 
sectionName() const3280 StringRef MachOAbstractFixupEntry::sectionName() const {
3281   return O->BindRebaseSectionName(SegmentIndex, SegmentOffset);
3282 }
3283 
address() const3284 uint64_t MachOAbstractFixupEntry::address() const {
3285   return O->BindRebaseAddress(SegmentIndex, SegmentOffset);
3286 }
3287 
symbolName() const3288 StringRef MachOAbstractFixupEntry::symbolName() const { return SymbolName; }
3289 
addend() const3290 int64_t MachOAbstractFixupEntry::addend() const { return Addend; }
3291 
flags() const3292 uint32_t MachOAbstractFixupEntry::flags() const { return Flags; }
3293 
ordinal() const3294 int MachOAbstractFixupEntry::ordinal() const { return Ordinal; }
3295 
typeName() const3296 StringRef MachOAbstractFixupEntry::typeName() const { return "unknown"; }
3297 
moveToFirst()3298 void MachOAbstractFixupEntry::moveToFirst() {
3299   SegmentOffset = 0;
3300   SegmentIndex = -1;
3301   Ordinal = 0;
3302   Flags = 0;
3303   Addend = 0;
3304   Done = false;
3305 }
3306 
moveToEnd()3307 void MachOAbstractFixupEntry::moveToEnd() { Done = true; }
3308 
moveNext()3309 void MachOAbstractFixupEntry::moveNext() {}
3310 
MachOChainedFixupEntry(Error * E,const MachOObjectFile * O,bool Parse)3311 MachOChainedFixupEntry::MachOChainedFixupEntry(Error *E,
3312                                                const MachOObjectFile *O,
3313                                                bool Parse)
3314     : MachOAbstractFixupEntry(E, O) {
3315   ErrorAsOutParameter e(E);
3316   if (!Parse)
3317     return;
3318 
3319   if (auto FixupTargetsOrErr = O->getDyldChainedFixupTargets()) {
3320     FixupTargets = *FixupTargetsOrErr;
3321   } else {
3322     *E = FixupTargetsOrErr.takeError();
3323     return;
3324   }
3325 
3326   if (auto SegmentsOrErr = O->getChainedFixupsSegments()) {
3327     Segments = std::move(SegmentsOrErr->second);
3328   } else {
3329     *E = SegmentsOrErr.takeError();
3330     return;
3331   }
3332 }
3333 
findNextPageWithFixups()3334 void MachOChainedFixupEntry::findNextPageWithFixups() {
3335   auto FindInSegment = [this]() {
3336     const ChainedFixupsSegment &SegInfo = Segments[InfoSegIndex];
3337     while (PageIndex < SegInfo.PageStarts.size() &&
3338            SegInfo.PageStarts[PageIndex] == MachO::DYLD_CHAINED_PTR_START_NONE)
3339       ++PageIndex;
3340     return PageIndex < SegInfo.PageStarts.size();
3341   };
3342 
3343   while (InfoSegIndex < Segments.size()) {
3344     if (FindInSegment()) {
3345       PageOffset = Segments[InfoSegIndex].PageStarts[PageIndex];
3346       SegmentData = O->getSegmentContents(Segments[InfoSegIndex].SegIdx);
3347       return;
3348     }
3349 
3350     InfoSegIndex++;
3351     PageIndex = 0;
3352   }
3353 }
3354 
moveToFirst()3355 void MachOChainedFixupEntry::moveToFirst() {
3356   MachOAbstractFixupEntry::moveToFirst();
3357   if (Segments.empty()) {
3358     Done = true;
3359     return;
3360   }
3361 
3362   InfoSegIndex = 0;
3363   PageIndex = 0;
3364 
3365   findNextPageWithFixups();
3366   moveNext();
3367 }
3368 
moveToEnd()3369 void MachOChainedFixupEntry::moveToEnd() {
3370   MachOAbstractFixupEntry::moveToEnd();
3371 }
3372 
moveNext()3373 void MachOChainedFixupEntry::moveNext() {
3374   ErrorAsOutParameter ErrAsOutParam(E);
3375 
3376   if (InfoSegIndex == Segments.size()) {
3377     Done = true;
3378     return;
3379   }
3380 
3381   const ChainedFixupsSegment &SegInfo = Segments[InfoSegIndex];
3382   SegmentIndex = SegInfo.SegIdx;
3383   SegmentOffset = SegInfo.Header.page_size * PageIndex + PageOffset;
3384 
3385   // FIXME: Handle other pointer formats.
3386   uint16_t PointerFormat = SegInfo.Header.pointer_format;
3387   if (PointerFormat != MachO::DYLD_CHAINED_PTR_64 &&
3388       PointerFormat != MachO::DYLD_CHAINED_PTR_64_OFFSET) {
3389     *E = createError("segment " + Twine(SegmentIndex) +
3390                      " has unsupported chained fixup pointer_format " +
3391                      Twine(PointerFormat));
3392     moveToEnd();
3393     return;
3394   }
3395 
3396   Ordinal = 0;
3397   Flags = 0;
3398   Addend = 0;
3399   PointerValue = 0;
3400   SymbolName = {};
3401 
3402   if (SegmentOffset + sizeof(RawValue) > SegmentData.size()) {
3403     *E = malformedError("fixup in segment " + Twine(SegmentIndex) +
3404                         " at offset " + Twine(SegmentOffset) +
3405                         " extends past segment's end");
3406     moveToEnd();
3407     return;
3408   }
3409 
3410   static_assert(sizeof(RawValue) == sizeof(MachO::dyld_chained_import_addend));
3411   memcpy(&RawValue, SegmentData.data() + SegmentOffset, sizeof(RawValue));
3412   if (O->isLittleEndian() != sys::IsLittleEndianHost)
3413     sys::swapByteOrder(RawValue);
3414 
3415   // The bit extraction below assumes little-endian fixup entries.
3416   assert(O->isLittleEndian() && "big-endian object should have been rejected "
3417                                 "by getDyldChainedFixupTargets()");
3418   auto Field = [this](uint8_t Right, uint8_t Count) {
3419     return (RawValue >> Right) & ((1ULL << Count) - 1);
3420   };
3421 
3422   // The `bind` field (most significant bit) of the encoded fixup determines
3423   // whether it is dyld_chained_ptr_64_bind or dyld_chained_ptr_64_rebase.
3424   bool IsBind = Field(63, 1);
3425   Kind = IsBind ? FixupKind::Bind : FixupKind::Rebase;
3426   uint32_t Next = Field(51, 12);
3427   if (IsBind) {
3428     uint32_t ImportOrdinal = Field(0, 24);
3429     uint8_t InlineAddend = Field(24, 8);
3430 
3431     if (ImportOrdinal >= FixupTargets.size()) {
3432       *E = malformedError("fixup in segment " + Twine(SegmentIndex) +
3433                           " at offset " + Twine(SegmentOffset) +
3434                           "  has out-of range import ordinal " +
3435                           Twine(ImportOrdinal));
3436       moveToEnd();
3437       return;
3438     }
3439 
3440     ChainedFixupTarget &Target = FixupTargets[ImportOrdinal];
3441     Ordinal = Target.libOrdinal();
3442     Addend = InlineAddend ? InlineAddend : Target.addend();
3443     Flags = Target.weakImport() ? MachO::BIND_SYMBOL_FLAGS_WEAK_IMPORT : 0;
3444     SymbolName = Target.symbolName();
3445   } else {
3446     uint64_t Target = Field(0, 36);
3447     uint64_t High8 = Field(36, 8);
3448 
3449     PointerValue = Target | (High8 << 56);
3450     if (PointerFormat == MachO::DYLD_CHAINED_PTR_64_OFFSET)
3451       PointerValue += textAddress();
3452   }
3453 
3454   // The stride is 4 bytes for DYLD_CHAINED_PTR_64(_OFFSET).
3455   if (Next != 0) {
3456     PageOffset += 4 * Next;
3457   } else {
3458     ++PageIndex;
3459     findNextPageWithFixups();
3460   }
3461 }
3462 
operator ==(const MachOChainedFixupEntry & Other) const3463 bool MachOChainedFixupEntry::operator==(
3464     const MachOChainedFixupEntry &Other) const {
3465   if (Done && Other.Done)
3466     return true;
3467   if (Done != Other.Done)
3468     return false;
3469   return InfoSegIndex == Other.InfoSegIndex && PageIndex == Other.PageIndex &&
3470          PageOffset == Other.PageOffset;
3471 }
3472 
MachORebaseEntry(Error * E,const MachOObjectFile * O,ArrayRef<uint8_t> Bytes,bool is64Bit)3473 MachORebaseEntry::MachORebaseEntry(Error *E, const MachOObjectFile *O,
3474                                    ArrayRef<uint8_t> Bytes, bool is64Bit)
3475     : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()),
3476       PointerSize(is64Bit ? 8 : 4) {}
3477 
moveToFirst()3478 void MachORebaseEntry::moveToFirst() {
3479   Ptr = Opcodes.begin();
3480   moveNext();
3481 }
3482 
moveToEnd()3483 void MachORebaseEntry::moveToEnd() {
3484   Ptr = Opcodes.end();
3485   RemainingLoopCount = 0;
3486   Done = true;
3487 }
3488 
moveNext()3489 void MachORebaseEntry::moveNext() {
3490   ErrorAsOutParameter ErrAsOutParam(E);
3491   // If in the middle of some loop, move to next rebasing in loop.
3492   SegmentOffset += AdvanceAmount;
3493   if (RemainingLoopCount) {
3494     --RemainingLoopCount;
3495     return;
3496   }
3497   // REBASE_OPCODE_DONE is only used for padding if we are not aligned to
3498   // pointer size. Therefore it is possible to reach the end without ever having
3499   // seen REBASE_OPCODE_DONE.
3500   if (Ptr == Opcodes.end()) {
3501     Done = true;
3502     return;
3503   }
3504   bool More = true;
3505   while (More) {
3506     // Parse next opcode and set up next loop.
3507     const uint8_t *OpcodeStart = Ptr;
3508     uint8_t Byte = *Ptr++;
3509     uint8_t ImmValue = Byte & MachO::REBASE_IMMEDIATE_MASK;
3510     uint8_t Opcode = Byte & MachO::REBASE_OPCODE_MASK;
3511     uint32_t Count, Skip;
3512     const char *error = nullptr;
3513     switch (Opcode) {
3514     case MachO::REBASE_OPCODE_DONE:
3515       More = false;
3516       Done = true;
3517       moveToEnd();
3518       DEBUG_WITH_TYPE("mach-o-rebase", dbgs() << "REBASE_OPCODE_DONE\n");
3519       break;
3520     case MachO::REBASE_OPCODE_SET_TYPE_IMM:
3521       RebaseType = ImmValue;
3522       if (RebaseType > MachO::REBASE_TYPE_TEXT_PCREL32) {
3523         *E = malformedError("for REBASE_OPCODE_SET_TYPE_IMM bad bind type: " +
3524                             Twine((int)RebaseType) + " for opcode at: 0x" +
3525                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3526         moveToEnd();
3527         return;
3528       }
3529       DEBUG_WITH_TYPE(
3530           "mach-o-rebase",
3531           dbgs() << "REBASE_OPCODE_SET_TYPE_IMM: "
3532                  << "RebaseType=" << (int) RebaseType << "\n");
3533       break;
3534     case MachO::REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
3535       SegmentIndex = ImmValue;
3536       SegmentOffset = readULEB128(&error);
3537       if (error) {
3538         *E = malformedError("for REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3539                             Twine(error) + " for opcode at: 0x" +
3540                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3541         moveToEnd();
3542         return;
3543       }
3544       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3545                                                PointerSize);
3546       if (error) {
3547         *E = malformedError("for REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3548                             Twine(error) + " for opcode at: 0x" +
3549                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3550         moveToEnd();
3551         return;
3552       }
3553       DEBUG_WITH_TYPE(
3554           "mach-o-rebase",
3555           dbgs() << "REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
3556                  << "SegmentIndex=" << SegmentIndex << ", "
3557                  << format("SegmentOffset=0x%06X", SegmentOffset)
3558                  << "\n");
3559       break;
3560     case MachO::REBASE_OPCODE_ADD_ADDR_ULEB:
3561       SegmentOffset += readULEB128(&error);
3562       if (error) {
3563         *E = malformedError("for REBASE_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3564                             " for opcode at: 0x" +
3565                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3566         moveToEnd();
3567         return;
3568       }
3569       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3570                                                PointerSize);
3571       if (error) {
3572         *E = malformedError("for REBASE_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3573                             " for opcode at: 0x" +
3574                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3575         moveToEnd();
3576         return;
3577       }
3578       DEBUG_WITH_TYPE("mach-o-rebase",
3579                       dbgs() << "REBASE_OPCODE_ADD_ADDR_ULEB: "
3580                              << format("SegmentOffset=0x%06X",
3581                                        SegmentOffset) << "\n");
3582       break;
3583     case MachO::REBASE_OPCODE_ADD_ADDR_IMM_SCALED:
3584       SegmentOffset += ImmValue * PointerSize;
3585       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3586                                                PointerSize);
3587       if (error) {
3588         *E = malformedError("for REBASE_OPCODE_ADD_ADDR_IMM_SCALED " +
3589                             Twine(error) + " for opcode at: 0x" +
3590                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3591         moveToEnd();
3592         return;
3593       }
3594       DEBUG_WITH_TYPE("mach-o-rebase",
3595                       dbgs() << "REBASE_OPCODE_ADD_ADDR_IMM_SCALED: "
3596                              << format("SegmentOffset=0x%06X",
3597                                        SegmentOffset) << "\n");
3598       break;
3599     case MachO::REBASE_OPCODE_DO_REBASE_IMM_TIMES:
3600       AdvanceAmount = PointerSize;
3601       Skip = 0;
3602       Count = ImmValue;
3603       if (ImmValue != 0)
3604         RemainingLoopCount = ImmValue - 1;
3605       else
3606         RemainingLoopCount = 0;
3607       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3608                                                PointerSize, Count, Skip);
3609       if (error) {
3610         *E = malformedError("for REBASE_OPCODE_DO_REBASE_IMM_TIMES " +
3611                             Twine(error) + " for opcode at: 0x" +
3612                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3613         moveToEnd();
3614         return;
3615       }
3616       DEBUG_WITH_TYPE(
3617           "mach-o-rebase",
3618           dbgs() << "REBASE_OPCODE_DO_REBASE_IMM_TIMES: "
3619                  << format("SegmentOffset=0x%06X", SegmentOffset)
3620                  << ", AdvanceAmount=" << AdvanceAmount
3621                  << ", RemainingLoopCount=" << RemainingLoopCount
3622                  << "\n");
3623       return;
3624     case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES:
3625       AdvanceAmount = PointerSize;
3626       Skip = 0;
3627       Count = readULEB128(&error);
3628       if (error) {
3629         *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES " +
3630                             Twine(error) + " for opcode at: 0x" +
3631                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3632         moveToEnd();
3633         return;
3634       }
3635       if (Count != 0)
3636         RemainingLoopCount = Count - 1;
3637       else
3638         RemainingLoopCount = 0;
3639       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3640                                                PointerSize, Count, Skip);
3641       if (error) {
3642         *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES " +
3643                             Twine(error) + " for opcode at: 0x" +
3644                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3645         moveToEnd();
3646         return;
3647       }
3648       DEBUG_WITH_TYPE(
3649           "mach-o-rebase",
3650           dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES: "
3651                  << format("SegmentOffset=0x%06X", SegmentOffset)
3652                  << ", AdvanceAmount=" << AdvanceAmount
3653                  << ", RemainingLoopCount=" << RemainingLoopCount
3654                  << "\n");
3655       return;
3656     case MachO::REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB:
3657       Skip = readULEB128(&error);
3658       if (error) {
3659         *E = malformedError("for REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB " +
3660                             Twine(error) + " for opcode at: 0x" +
3661                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3662         moveToEnd();
3663         return;
3664       }
3665       AdvanceAmount = Skip + PointerSize;
3666       Count = 1;
3667       RemainingLoopCount = 0;
3668       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3669                                                PointerSize, Count, Skip);
3670       if (error) {
3671         *E = malformedError("for REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB " +
3672                             Twine(error) + " for opcode at: 0x" +
3673                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3674         moveToEnd();
3675         return;
3676       }
3677       DEBUG_WITH_TYPE(
3678           "mach-o-rebase",
3679           dbgs() << "REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: "
3680                  << format("SegmentOffset=0x%06X", SegmentOffset)
3681                  << ", AdvanceAmount=" << AdvanceAmount
3682                  << ", RemainingLoopCount=" << RemainingLoopCount
3683                  << "\n");
3684       return;
3685     case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB:
3686       Count = readULEB128(&error);
3687       if (error) {
3688         *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3689                             "ULEB " +
3690                             Twine(error) + " for opcode at: 0x" +
3691                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3692         moveToEnd();
3693         return;
3694       }
3695       if (Count != 0)
3696         RemainingLoopCount = Count - 1;
3697       else
3698         RemainingLoopCount = 0;
3699       Skip = readULEB128(&error);
3700       if (error) {
3701         *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3702                             "ULEB " +
3703                             Twine(error) + " for opcode at: 0x" +
3704                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3705         moveToEnd();
3706         return;
3707       }
3708       AdvanceAmount = Skip + PointerSize;
3709 
3710       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3711                                                PointerSize, Count, Skip);
3712       if (error) {
3713         *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3714                             "ULEB " +
3715                             Twine(error) + " for opcode at: 0x" +
3716                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3717         moveToEnd();
3718         return;
3719       }
3720       DEBUG_WITH_TYPE(
3721           "mach-o-rebase",
3722           dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: "
3723                  << format("SegmentOffset=0x%06X", SegmentOffset)
3724                  << ", AdvanceAmount=" << AdvanceAmount
3725                  << ", RemainingLoopCount=" << RemainingLoopCount
3726                  << "\n");
3727       return;
3728     default:
3729       *E = malformedError("bad rebase info (bad opcode value 0x" +
3730                           Twine::utohexstr(Opcode) + " for opcode at: 0x" +
3731                           Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3732       moveToEnd();
3733       return;
3734     }
3735   }
3736 }
3737 
readULEB128(const char ** error)3738 uint64_t MachORebaseEntry::readULEB128(const char **error) {
3739   unsigned Count;
3740   uint64_t Result = decodeULEB128(Ptr, &Count, Opcodes.end(), error);
3741   Ptr += Count;
3742   if (Ptr > Opcodes.end())
3743     Ptr = Opcodes.end();
3744   return Result;
3745 }
3746 
segmentIndex() const3747 int32_t MachORebaseEntry::segmentIndex() const { return SegmentIndex; }
3748 
segmentOffset() const3749 uint64_t MachORebaseEntry::segmentOffset() const { return SegmentOffset; }
3750 
typeName() const3751 StringRef MachORebaseEntry::typeName() const {
3752   switch (RebaseType) {
3753   case MachO::REBASE_TYPE_POINTER:
3754     return "pointer";
3755   case MachO::REBASE_TYPE_TEXT_ABSOLUTE32:
3756     return "text abs32";
3757   case MachO::REBASE_TYPE_TEXT_PCREL32:
3758     return "text rel32";
3759   }
3760   return "unknown";
3761 }
3762 
3763 // For use with the SegIndex of a checked Mach-O Rebase entry
3764 // to get the segment name.
segmentName() const3765 StringRef MachORebaseEntry::segmentName() const {
3766   return O->BindRebaseSegmentName(SegmentIndex);
3767 }
3768 
3769 // For use with a SegIndex,SegOffset pair from a checked Mach-O Rebase entry
3770 // to get the section name.
sectionName() const3771 StringRef MachORebaseEntry::sectionName() const {
3772   return O->BindRebaseSectionName(SegmentIndex, SegmentOffset);
3773 }
3774 
3775 // For use with a SegIndex,SegOffset pair from a checked Mach-O Rebase entry
3776 // to get the address.
address() const3777 uint64_t MachORebaseEntry::address() const {
3778   return O->BindRebaseAddress(SegmentIndex, SegmentOffset);
3779 }
3780 
operator ==(const MachORebaseEntry & Other) const3781 bool MachORebaseEntry::operator==(const MachORebaseEntry &Other) const {
3782 #ifdef EXPENSIVE_CHECKS
3783   assert(Opcodes == Other.Opcodes && "compare iterators of different files");
3784 #else
3785   assert(Opcodes.data() == Other.Opcodes.data() && "compare iterators of different files");
3786 #endif
3787   return (Ptr == Other.Ptr) &&
3788          (RemainingLoopCount == Other.RemainingLoopCount) &&
3789          (Done == Other.Done);
3790 }
3791 
3792 iterator_range<rebase_iterator>
rebaseTable(Error & Err,MachOObjectFile * O,ArrayRef<uint8_t> Opcodes,bool is64)3793 MachOObjectFile::rebaseTable(Error &Err, MachOObjectFile *O,
3794                              ArrayRef<uint8_t> Opcodes, bool is64) {
3795   if (O->BindRebaseSectionTable == nullptr)
3796     O->BindRebaseSectionTable = std::make_unique<BindRebaseSegInfo>(O);
3797   MachORebaseEntry Start(&Err, O, Opcodes, is64);
3798   Start.moveToFirst();
3799 
3800   MachORebaseEntry Finish(&Err, O, Opcodes, is64);
3801   Finish.moveToEnd();
3802 
3803   return make_range(rebase_iterator(Start), rebase_iterator(Finish));
3804 }
3805 
rebaseTable(Error & Err)3806 iterator_range<rebase_iterator> MachOObjectFile::rebaseTable(Error &Err) {
3807   return rebaseTable(Err, this, getDyldInfoRebaseOpcodes(), is64Bit());
3808 }
3809 
MachOBindEntry(Error * E,const MachOObjectFile * O,ArrayRef<uint8_t> Bytes,bool is64Bit,Kind BK)3810 MachOBindEntry::MachOBindEntry(Error *E, const MachOObjectFile *O,
3811                                ArrayRef<uint8_t> Bytes, bool is64Bit, Kind BK)
3812     : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()),
3813       PointerSize(is64Bit ? 8 : 4), TableKind(BK) {}
3814 
moveToFirst()3815 void MachOBindEntry::moveToFirst() {
3816   Ptr = Opcodes.begin();
3817   moveNext();
3818 }
3819 
moveToEnd()3820 void MachOBindEntry::moveToEnd() {
3821   Ptr = Opcodes.end();
3822   RemainingLoopCount = 0;
3823   Done = true;
3824 }
3825 
moveNext()3826 void MachOBindEntry::moveNext() {
3827   ErrorAsOutParameter ErrAsOutParam(E);
3828   // If in the middle of some loop, move to next binding in loop.
3829   SegmentOffset += AdvanceAmount;
3830   if (RemainingLoopCount) {
3831     --RemainingLoopCount;
3832     return;
3833   }
3834   // BIND_OPCODE_DONE is only used for padding if we are not aligned to
3835   // pointer size. Therefore it is possible to reach the end without ever having
3836   // seen BIND_OPCODE_DONE.
3837   if (Ptr == Opcodes.end()) {
3838     Done = true;
3839     return;
3840   }
3841   bool More = true;
3842   while (More) {
3843     // Parse next opcode and set up next loop.
3844     const uint8_t *OpcodeStart = Ptr;
3845     uint8_t Byte = *Ptr++;
3846     uint8_t ImmValue = Byte & MachO::BIND_IMMEDIATE_MASK;
3847     uint8_t Opcode = Byte & MachO::BIND_OPCODE_MASK;
3848     int8_t SignExtended;
3849     const uint8_t *SymStart;
3850     uint32_t Count, Skip;
3851     const char *error = nullptr;
3852     switch (Opcode) {
3853     case MachO::BIND_OPCODE_DONE:
3854       if (TableKind == Kind::Lazy) {
3855         // Lazying bindings have a DONE opcode between entries.  Need to ignore
3856         // it to advance to next entry.  But need not if this is last entry.
3857         bool NotLastEntry = false;
3858         for (const uint8_t *P = Ptr; P < Opcodes.end(); ++P) {
3859           if (*P) {
3860             NotLastEntry = true;
3861           }
3862         }
3863         if (NotLastEntry)
3864           break;
3865       }
3866       More = false;
3867       moveToEnd();
3868       DEBUG_WITH_TYPE("mach-o-bind", dbgs() << "BIND_OPCODE_DONE\n");
3869       break;
3870     case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
3871       if (TableKind == Kind::Weak) {
3872         *E = malformedError("BIND_OPCODE_SET_DYLIB_ORDINAL_IMM not allowed in "
3873                             "weak bind table for opcode at: 0x" +
3874                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3875         moveToEnd();
3876         return;
3877       }
3878       Ordinal = ImmValue;
3879       LibraryOrdinalSet = true;
3880       if (ImmValue > O->getLibraryCount()) {
3881         *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB bad "
3882                             "library ordinal: " +
3883                             Twine((int)ImmValue) + " (max " +
3884                             Twine((int)O->getLibraryCount()) +
3885                             ") for opcode at: 0x" +
3886                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3887         moveToEnd();
3888         return;
3889       }
3890       DEBUG_WITH_TYPE(
3891           "mach-o-bind",
3892           dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: "
3893                  << "Ordinal=" << Ordinal << "\n");
3894       break;
3895     case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
3896       if (TableKind == Kind::Weak) {
3897         *E = malformedError("BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB not allowed in "
3898                             "weak bind table for opcode at: 0x" +
3899                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3900         moveToEnd();
3901         return;
3902       }
3903       Ordinal = readULEB128(&error);
3904       LibraryOrdinalSet = true;
3905       if (error) {
3906         *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB " +
3907                             Twine(error) + " for opcode at: 0x" +
3908                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3909         moveToEnd();
3910         return;
3911       }
3912       if (Ordinal > (int)O->getLibraryCount()) {
3913         *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB bad "
3914                             "library ordinal: " +
3915                             Twine((int)Ordinal) + " (max " +
3916                             Twine((int)O->getLibraryCount()) +
3917                             ") for opcode at: 0x" +
3918                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3919         moveToEnd();
3920         return;
3921       }
3922       DEBUG_WITH_TYPE(
3923           "mach-o-bind",
3924           dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: "
3925                  << "Ordinal=" << Ordinal << "\n");
3926       break;
3927     case MachO::BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:
3928       if (TableKind == Kind::Weak) {
3929         *E = malformedError("BIND_OPCODE_SET_DYLIB_SPECIAL_IMM not allowed in "
3930                             "weak bind table for opcode at: 0x" +
3931                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3932         moveToEnd();
3933         return;
3934       }
3935       if (ImmValue) {
3936         SignExtended = MachO::BIND_OPCODE_MASK | ImmValue;
3937         Ordinal = SignExtended;
3938         if (Ordinal < MachO::BIND_SPECIAL_DYLIB_FLAT_LOOKUP) {
3939           *E = malformedError("for BIND_OPCODE_SET_DYLIB_SPECIAL_IMM unknown "
3940                               "special ordinal: " +
3941                               Twine((int)Ordinal) + " for opcode at: 0x" +
3942                               Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3943           moveToEnd();
3944           return;
3945         }
3946       } else
3947         Ordinal = 0;
3948       LibraryOrdinalSet = true;
3949       DEBUG_WITH_TYPE(
3950           "mach-o-bind",
3951           dbgs() << "BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: "
3952                  << "Ordinal=" << Ordinal << "\n");
3953       break;
3954     case MachO::BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
3955       Flags = ImmValue;
3956       SymStart = Ptr;
3957       while (*Ptr && (Ptr < Opcodes.end())) {
3958         ++Ptr;
3959       }
3960       if (Ptr == Opcodes.end()) {
3961         *E = malformedError(
3962             "for BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM "
3963             "symbol name extends past opcodes for opcode at: 0x" +
3964             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3965         moveToEnd();
3966         return;
3967       }
3968       SymbolName = StringRef(reinterpret_cast<const char*>(SymStart),
3969                              Ptr-SymStart);
3970       ++Ptr;
3971       DEBUG_WITH_TYPE(
3972           "mach-o-bind",
3973           dbgs() << "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: "
3974                  << "SymbolName=" << SymbolName << "\n");
3975       if (TableKind == Kind::Weak) {
3976         if (ImmValue & MachO::BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION)
3977           return;
3978       }
3979       break;
3980     case MachO::BIND_OPCODE_SET_TYPE_IMM:
3981       BindType = ImmValue;
3982       if (ImmValue > MachO::BIND_TYPE_TEXT_PCREL32) {
3983         *E = malformedError("for BIND_OPCODE_SET_TYPE_IMM bad bind type: " +
3984                             Twine((int)ImmValue) + " for opcode at: 0x" +
3985                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3986         moveToEnd();
3987         return;
3988       }
3989       DEBUG_WITH_TYPE(
3990           "mach-o-bind",
3991           dbgs() << "BIND_OPCODE_SET_TYPE_IMM: "
3992                  << "BindType=" << (int)BindType << "\n");
3993       break;
3994     case MachO::BIND_OPCODE_SET_ADDEND_SLEB:
3995       Addend = readSLEB128(&error);
3996       if (error) {
3997         *E = malformedError("for BIND_OPCODE_SET_ADDEND_SLEB " + Twine(error) +
3998                             " for opcode at: 0x" +
3999                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4000         moveToEnd();
4001         return;
4002       }
4003       DEBUG_WITH_TYPE(
4004           "mach-o-bind",
4005           dbgs() << "BIND_OPCODE_SET_ADDEND_SLEB: "
4006                  << "Addend=" << Addend << "\n");
4007       break;
4008     case MachO::BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
4009       SegmentIndex = ImmValue;
4010       SegmentOffset = readULEB128(&error);
4011       if (error) {
4012         *E = malformedError("for BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
4013                             Twine(error) + " for opcode at: 0x" +
4014                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4015         moveToEnd();
4016         return;
4017       }
4018       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
4019                                              PointerSize);
4020       if (error) {
4021         *E = malformedError("for BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
4022                             Twine(error) + " for opcode at: 0x" +
4023                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4024         moveToEnd();
4025         return;
4026       }
4027       DEBUG_WITH_TYPE(
4028           "mach-o-bind",
4029           dbgs() << "BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
4030                  << "SegmentIndex=" << SegmentIndex << ", "
4031                  << format("SegmentOffset=0x%06X", SegmentOffset)
4032                  << "\n");
4033       break;
4034     case MachO::BIND_OPCODE_ADD_ADDR_ULEB:
4035       SegmentOffset += readULEB128(&error);
4036       if (error) {
4037         *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
4038                             " for opcode at: 0x" +
4039                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4040         moveToEnd();
4041         return;
4042       }
4043       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
4044                                              PointerSize);
4045       if (error) {
4046         *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
4047                             " for opcode at: 0x" +
4048                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4049         moveToEnd();
4050         return;
4051       }
4052       DEBUG_WITH_TYPE("mach-o-bind",
4053                       dbgs() << "BIND_OPCODE_ADD_ADDR_ULEB: "
4054                              << format("SegmentOffset=0x%06X",
4055                                        SegmentOffset) << "\n");
4056       break;
4057     case MachO::BIND_OPCODE_DO_BIND:
4058       AdvanceAmount = PointerSize;
4059       RemainingLoopCount = 0;
4060       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
4061                                              PointerSize);
4062       if (error) {
4063         *E = malformedError("for BIND_OPCODE_DO_BIND " + Twine(error) +
4064                             " for opcode at: 0x" +
4065                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4066         moveToEnd();
4067         return;
4068       }
4069       if (SymbolName == StringRef()) {
4070         *E = malformedError(
4071             "for BIND_OPCODE_DO_BIND missing preceding "
4072             "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for opcode at: 0x" +
4073             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4074         moveToEnd();
4075         return;
4076       }
4077       if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
4078         *E =
4079             malformedError("for BIND_OPCODE_DO_BIND missing preceding "
4080                            "BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode at: 0x" +
4081                            Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4082         moveToEnd();
4083         return;
4084       }
4085       DEBUG_WITH_TYPE("mach-o-bind",
4086                       dbgs() << "BIND_OPCODE_DO_BIND: "
4087                              << format("SegmentOffset=0x%06X",
4088                                        SegmentOffset) << "\n");
4089       return;
4090      case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
4091       if (TableKind == Kind::Lazy) {
4092         *E = malformedError("BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB not allowed in "
4093                             "lazy bind table for opcode at: 0x" +
4094                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4095         moveToEnd();
4096         return;
4097       }
4098       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
4099                                              PointerSize);
4100       if (error) {
4101         *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB " +
4102                             Twine(error) + " for opcode at: 0x" +
4103                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4104         moveToEnd();
4105         return;
4106       }
4107       if (SymbolName == StringRef()) {
4108         *E = malformedError(
4109             "for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB missing "
4110             "preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for opcode "
4111             "at: 0x" +
4112             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4113         moveToEnd();
4114         return;
4115       }
4116       if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
4117         *E = malformedError(
4118             "for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB missing "
4119             "preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode at: 0x" +
4120             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4121         moveToEnd();
4122         return;
4123       }
4124       AdvanceAmount = readULEB128(&error) + PointerSize;
4125       if (error) {
4126         *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB " +
4127                             Twine(error) + " for opcode at: 0x" +
4128                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4129         moveToEnd();
4130         return;
4131       }
4132       // Note, this is not really an error until the next bind but make no sense
4133       // for a BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB to not be followed by another
4134       // bind operation.
4135       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset +
4136                                             AdvanceAmount, PointerSize);
4137       if (error) {
4138         *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB (after adding "
4139                             "ULEB) " +
4140                             Twine(error) + " for opcode at: 0x" +
4141                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4142         moveToEnd();
4143         return;
4144       }
4145       RemainingLoopCount = 0;
4146       DEBUG_WITH_TYPE(
4147           "mach-o-bind",
4148           dbgs() << "BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: "
4149                  << format("SegmentOffset=0x%06X", SegmentOffset)
4150                  << ", AdvanceAmount=" << AdvanceAmount
4151                  << ", RemainingLoopCount=" << RemainingLoopCount
4152                  << "\n");
4153       return;
4154     case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
4155       if (TableKind == Kind::Lazy) {
4156         *E = malformedError("BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED not "
4157                             "allowed in lazy bind table for opcode at: 0x" +
4158                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4159         moveToEnd();
4160         return;
4161       }
4162       if (SymbolName == StringRef()) {
4163         *E = malformedError(
4164             "for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED "
4165             "missing preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for "
4166             "opcode at: 0x" +
4167             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4168         moveToEnd();
4169         return;
4170       }
4171       if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
4172         *E = malformedError(
4173             "for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED "
4174             "missing preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode "
4175             "at: 0x" +
4176             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4177         moveToEnd();
4178         return;
4179       }
4180       AdvanceAmount = ImmValue * PointerSize + PointerSize;
4181       RemainingLoopCount = 0;
4182       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset +
4183                                              AdvanceAmount, PointerSize);
4184       if (error) {
4185         *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED " +
4186                             Twine(error) + " for opcode at: 0x" +
4187                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4188         moveToEnd();
4189         return;
4190       }
4191       DEBUG_WITH_TYPE("mach-o-bind",
4192                       dbgs()
4193                       << "BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: "
4194                       << format("SegmentOffset=0x%06X", SegmentOffset) << "\n");
4195       return;
4196     case MachO::BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
4197       if (TableKind == Kind::Lazy) {
4198         *E = malformedError("BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB not "
4199                             "allowed in lazy bind table for opcode at: 0x" +
4200                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4201         moveToEnd();
4202         return;
4203       }
4204       Count = readULEB128(&error);
4205       if (Count != 0)
4206         RemainingLoopCount = Count - 1;
4207       else
4208         RemainingLoopCount = 0;
4209       if (error) {
4210         *E = malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
4211                             " (count value) " +
4212                             Twine(error) + " for opcode at: 0x" +
4213                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4214         moveToEnd();
4215         return;
4216       }
4217       Skip = readULEB128(&error);
4218       AdvanceAmount = Skip + PointerSize;
4219       if (error) {
4220         *E = malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
4221                             " (skip value) " +
4222                             Twine(error) + " for opcode at: 0x" +
4223                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4224         moveToEnd();
4225         return;
4226       }
4227       if (SymbolName == StringRef()) {
4228         *E = malformedError(
4229             "for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
4230             "missing preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for "
4231             "opcode at: 0x" +
4232             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4233         moveToEnd();
4234         return;
4235       }
4236       if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
4237         *E = malformedError(
4238             "for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
4239             "missing preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode "
4240             "at: 0x" +
4241             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4242         moveToEnd();
4243         return;
4244       }
4245       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
4246                                              PointerSize, Count, Skip);
4247       if (error) {
4248         *E =
4249             malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB " +
4250                            Twine(error) + " for opcode at: 0x" +
4251                            Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4252         moveToEnd();
4253         return;
4254       }
4255       DEBUG_WITH_TYPE(
4256           "mach-o-bind",
4257           dbgs() << "BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: "
4258                  << format("SegmentOffset=0x%06X", SegmentOffset)
4259                  << ", AdvanceAmount=" << AdvanceAmount
4260                  << ", RemainingLoopCount=" << RemainingLoopCount
4261                  << "\n");
4262       return;
4263     default:
4264       *E = malformedError("bad bind info (bad opcode value 0x" +
4265                           Twine::utohexstr(Opcode) + " for opcode at: 0x" +
4266                           Twine::utohexstr(OpcodeStart - Opcodes.begin()));
4267       moveToEnd();
4268       return;
4269     }
4270   }
4271 }
4272 
readULEB128(const char ** error)4273 uint64_t MachOBindEntry::readULEB128(const char **error) {
4274   unsigned Count;
4275   uint64_t Result = decodeULEB128(Ptr, &Count, Opcodes.end(), error);
4276   Ptr += Count;
4277   if (Ptr > Opcodes.end())
4278     Ptr = Opcodes.end();
4279   return Result;
4280 }
4281 
readSLEB128(const char ** error)4282 int64_t MachOBindEntry::readSLEB128(const char **error) {
4283   unsigned Count;
4284   int64_t Result = decodeSLEB128(Ptr, &Count, Opcodes.end(), error);
4285   Ptr += Count;
4286   if (Ptr > Opcodes.end())
4287     Ptr = Opcodes.end();
4288   return Result;
4289 }
4290 
segmentIndex() const4291 int32_t MachOBindEntry::segmentIndex() const { return SegmentIndex; }
4292 
segmentOffset() const4293 uint64_t MachOBindEntry::segmentOffset() const { return SegmentOffset; }
4294 
typeName() const4295 StringRef MachOBindEntry::typeName() const {
4296   switch (BindType) {
4297   case MachO::BIND_TYPE_POINTER:
4298     return "pointer";
4299   case MachO::BIND_TYPE_TEXT_ABSOLUTE32:
4300     return "text abs32";
4301   case MachO::BIND_TYPE_TEXT_PCREL32:
4302     return "text rel32";
4303   }
4304   return "unknown";
4305 }
4306 
symbolName() const4307 StringRef MachOBindEntry::symbolName() const { return SymbolName; }
4308 
addend() const4309 int64_t MachOBindEntry::addend() const { return Addend; }
4310 
flags() const4311 uint32_t MachOBindEntry::flags() const { return Flags; }
4312 
ordinal() const4313 int MachOBindEntry::ordinal() const { return Ordinal; }
4314 
4315 // For use with the SegIndex of a checked Mach-O Bind entry
4316 // to get the segment name.
segmentName() const4317 StringRef MachOBindEntry::segmentName() const {
4318   return O->BindRebaseSegmentName(SegmentIndex);
4319 }
4320 
4321 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind entry
4322 // to get the section name.
sectionName() const4323 StringRef MachOBindEntry::sectionName() const {
4324   return O->BindRebaseSectionName(SegmentIndex, SegmentOffset);
4325 }
4326 
4327 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind entry
4328 // to get the address.
address() const4329 uint64_t MachOBindEntry::address() const {
4330   return O->BindRebaseAddress(SegmentIndex, SegmentOffset);
4331 }
4332 
operator ==(const MachOBindEntry & Other) const4333 bool MachOBindEntry::operator==(const MachOBindEntry &Other) const {
4334 #ifdef EXPENSIVE_CHECKS
4335   assert(Opcodes == Other.Opcodes && "compare iterators of different files");
4336 #else
4337   assert(Opcodes.data() == Other.Opcodes.data() && "compare iterators of different files");
4338 #endif
4339   return (Ptr == Other.Ptr) &&
4340          (RemainingLoopCount == Other.RemainingLoopCount) &&
4341          (Done == Other.Done);
4342 }
4343 
4344 // Build table of sections so SegIndex/SegOffset pairs can be translated.
BindRebaseSegInfo(const object::MachOObjectFile * Obj)4345 BindRebaseSegInfo::BindRebaseSegInfo(const object::MachOObjectFile *Obj) {
4346   uint32_t CurSegIndex = Obj->hasPageZeroSegment() ? 1 : 0;
4347   StringRef CurSegName;
4348   uint64_t CurSegAddress;
4349   for (const SectionRef &Section : Obj->sections()) {
4350     SectionInfo Info;
4351     Expected<StringRef> NameOrErr = Section.getName();
4352     if (!NameOrErr)
4353       consumeError(NameOrErr.takeError());
4354     else
4355       Info.SectionName = *NameOrErr;
4356     Info.Address = Section.getAddress();
4357     Info.Size = Section.getSize();
4358     Info.SegmentName =
4359         Obj->getSectionFinalSegmentName(Section.getRawDataRefImpl());
4360     if (!Info.SegmentName.equals(CurSegName)) {
4361       ++CurSegIndex;
4362       CurSegName = Info.SegmentName;
4363       CurSegAddress = Info.Address;
4364     }
4365     Info.SegmentIndex = CurSegIndex - 1;
4366     Info.OffsetInSegment = Info.Address - CurSegAddress;
4367     Info.SegmentStartAddress = CurSegAddress;
4368     Sections.push_back(Info);
4369   }
4370   MaxSegIndex = CurSegIndex;
4371 }
4372 
4373 // For use with a SegIndex, SegOffset, and PointerSize triple in
4374 // MachOBindEntry::moveNext() to validate a MachOBindEntry or MachORebaseEntry.
4375 //
4376 // Given a SegIndex, SegOffset, and PointerSize, verify a valid section exists
4377 // that fully contains a pointer at that location. Multiple fixups in a bind
4378 // (such as with the BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB opcode) can
4379 // be tested via the Count and Skip parameters.
checkSegAndOffsets(int32_t SegIndex,uint64_t SegOffset,uint8_t PointerSize,uint32_t Count,uint32_t Skip)4380 const char * BindRebaseSegInfo::checkSegAndOffsets(int32_t SegIndex,
4381                                                    uint64_t SegOffset,
4382                                                    uint8_t PointerSize,
4383                                                    uint32_t Count,
4384                                                    uint32_t Skip) {
4385   if (SegIndex == -1)
4386     return "missing preceding *_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB";
4387   if (SegIndex >= MaxSegIndex)
4388     return "bad segIndex (too large)";
4389   for (uint32_t i = 0; i < Count; ++i) {
4390     uint32_t Start = SegOffset + i * (PointerSize + Skip);
4391     uint32_t End = Start + PointerSize;
4392     bool Found = false;
4393     for (const SectionInfo &SI : Sections) {
4394       if (SI.SegmentIndex != SegIndex)
4395         continue;
4396       if ((SI.OffsetInSegment<=Start) && (Start<(SI.OffsetInSegment+SI.Size))) {
4397         if (End <= SI.OffsetInSegment + SI.Size) {
4398           Found = true;
4399           break;
4400         }
4401         else
4402           return "bad offset, extends beyond section boundary";
4403       }
4404     }
4405     if (!Found)
4406       return "bad offset, not in section";
4407   }
4408   return nullptr;
4409 }
4410 
4411 // For use with the SegIndex of a checked Mach-O Bind or Rebase entry
4412 // to get the segment name.
segmentName(int32_t SegIndex)4413 StringRef BindRebaseSegInfo::segmentName(int32_t SegIndex) {
4414   for (const SectionInfo &SI : Sections) {
4415     if (SI.SegmentIndex == SegIndex)
4416       return SI.SegmentName;
4417   }
4418   llvm_unreachable("invalid SegIndex");
4419 }
4420 
4421 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
4422 // to get the SectionInfo.
findSection(int32_t SegIndex,uint64_t SegOffset)4423 const BindRebaseSegInfo::SectionInfo &BindRebaseSegInfo::findSection(
4424                                      int32_t SegIndex, uint64_t SegOffset) {
4425   for (const SectionInfo &SI : Sections) {
4426     if (SI.SegmentIndex != SegIndex)
4427       continue;
4428     if (SI.OffsetInSegment > SegOffset)
4429       continue;
4430     if (SegOffset >= (SI.OffsetInSegment + SI.Size))
4431       continue;
4432     return SI;
4433   }
4434   llvm_unreachable("SegIndex and SegOffset not in any section");
4435 }
4436 
4437 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
4438 // entry to get the section name.
sectionName(int32_t SegIndex,uint64_t SegOffset)4439 StringRef BindRebaseSegInfo::sectionName(int32_t SegIndex,
4440                                          uint64_t SegOffset) {
4441   return findSection(SegIndex, SegOffset).SectionName;
4442 }
4443 
4444 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
4445 // entry to get the address.
address(uint32_t SegIndex,uint64_t OffsetInSeg)4446 uint64_t BindRebaseSegInfo::address(uint32_t SegIndex, uint64_t OffsetInSeg) {
4447   const SectionInfo &SI = findSection(SegIndex, OffsetInSeg);
4448   return SI.SegmentStartAddress + OffsetInSeg;
4449 }
4450 
4451 iterator_range<bind_iterator>
bindTable(Error & Err,MachOObjectFile * O,ArrayRef<uint8_t> Opcodes,bool is64,MachOBindEntry::Kind BKind)4452 MachOObjectFile::bindTable(Error &Err, MachOObjectFile *O,
4453                            ArrayRef<uint8_t> Opcodes, bool is64,
4454                            MachOBindEntry::Kind BKind) {
4455   if (O->BindRebaseSectionTable == nullptr)
4456     O->BindRebaseSectionTable = std::make_unique<BindRebaseSegInfo>(O);
4457   MachOBindEntry Start(&Err, O, Opcodes, is64, BKind);
4458   Start.moveToFirst();
4459 
4460   MachOBindEntry Finish(&Err, O, Opcodes, is64, BKind);
4461   Finish.moveToEnd();
4462 
4463   return make_range(bind_iterator(Start), bind_iterator(Finish));
4464 }
4465 
bindTable(Error & Err)4466 iterator_range<bind_iterator> MachOObjectFile::bindTable(Error &Err) {
4467   return bindTable(Err, this, getDyldInfoBindOpcodes(), is64Bit(),
4468                    MachOBindEntry::Kind::Regular);
4469 }
4470 
lazyBindTable(Error & Err)4471 iterator_range<bind_iterator> MachOObjectFile::lazyBindTable(Error &Err) {
4472   return bindTable(Err, this, getDyldInfoLazyBindOpcodes(), is64Bit(),
4473                    MachOBindEntry::Kind::Lazy);
4474 }
4475 
weakBindTable(Error & Err)4476 iterator_range<bind_iterator> MachOObjectFile::weakBindTable(Error &Err) {
4477   return bindTable(Err, this, getDyldInfoWeakBindOpcodes(), is64Bit(),
4478                    MachOBindEntry::Kind::Weak);
4479 }
4480 
fixupTable(Error & Err)4481 iterator_range<fixup_iterator> MachOObjectFile::fixupTable(Error &Err) {
4482   if (BindRebaseSectionTable == nullptr)
4483     BindRebaseSectionTable = std::make_unique<BindRebaseSegInfo>(this);
4484 
4485   MachOChainedFixupEntry Start(&Err, this, true);
4486   Start.moveToFirst();
4487 
4488   MachOChainedFixupEntry Finish(&Err, this, false);
4489   Finish.moveToEnd();
4490 
4491   return make_range(fixup_iterator(Start), fixup_iterator(Finish));
4492 }
4493 
4494 MachOObjectFile::load_command_iterator
begin_load_commands() const4495 MachOObjectFile::begin_load_commands() const {
4496   return LoadCommands.begin();
4497 }
4498 
4499 MachOObjectFile::load_command_iterator
end_load_commands() const4500 MachOObjectFile::end_load_commands() const {
4501   return LoadCommands.end();
4502 }
4503 
4504 iterator_range<MachOObjectFile::load_command_iterator>
load_commands() const4505 MachOObjectFile::load_commands() const {
4506   return make_range(begin_load_commands(), end_load_commands());
4507 }
4508 
4509 StringRef
getSectionFinalSegmentName(DataRefImpl Sec) const4510 MachOObjectFile::getSectionFinalSegmentName(DataRefImpl Sec) const {
4511   ArrayRef<char> Raw = getSectionRawFinalSegmentName(Sec);
4512   return parseSegmentOrSectionName(Raw.data());
4513 }
4514 
4515 ArrayRef<char>
getSectionRawName(DataRefImpl Sec) const4516 MachOObjectFile::getSectionRawName(DataRefImpl Sec) const {
4517   assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
4518   const section_base *Base =
4519     reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
4520   return ArrayRef(Base->sectname);
4521 }
4522 
4523 ArrayRef<char>
getSectionRawFinalSegmentName(DataRefImpl Sec) const4524 MachOObjectFile::getSectionRawFinalSegmentName(DataRefImpl Sec) const {
4525   assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
4526   const section_base *Base =
4527     reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
4528   return ArrayRef(Base->segname);
4529 }
4530 
4531 bool
isRelocationScattered(const MachO::any_relocation_info & RE) const4532 MachOObjectFile::isRelocationScattered(const MachO::any_relocation_info &RE)
4533   const {
4534   if (getCPUType(*this) == MachO::CPU_TYPE_X86_64)
4535     return false;
4536   return getPlainRelocationAddress(RE) & MachO::R_SCATTERED;
4537 }
4538 
getPlainRelocationSymbolNum(const MachO::any_relocation_info & RE) const4539 unsigned MachOObjectFile::getPlainRelocationSymbolNum(
4540     const MachO::any_relocation_info &RE) const {
4541   if (isLittleEndian())
4542     return RE.r_word1 & 0xffffff;
4543   return RE.r_word1 >> 8;
4544 }
4545 
getPlainRelocationExternal(const MachO::any_relocation_info & RE) const4546 bool MachOObjectFile::getPlainRelocationExternal(
4547     const MachO::any_relocation_info &RE) const {
4548   if (isLittleEndian())
4549     return (RE.r_word1 >> 27) & 1;
4550   return (RE.r_word1 >> 4) & 1;
4551 }
4552 
getScatteredRelocationScattered(const MachO::any_relocation_info & RE) const4553 bool MachOObjectFile::getScatteredRelocationScattered(
4554     const MachO::any_relocation_info &RE) const {
4555   return RE.r_word0 >> 31;
4556 }
4557 
getScatteredRelocationValue(const MachO::any_relocation_info & RE) const4558 uint32_t MachOObjectFile::getScatteredRelocationValue(
4559     const MachO::any_relocation_info &RE) const {
4560   return RE.r_word1;
4561 }
4562 
getScatteredRelocationType(const MachO::any_relocation_info & RE) const4563 uint32_t MachOObjectFile::getScatteredRelocationType(
4564     const MachO::any_relocation_info &RE) const {
4565   return (RE.r_word0 >> 24) & 0xf;
4566 }
4567 
getAnyRelocationAddress(const MachO::any_relocation_info & RE) const4568 unsigned MachOObjectFile::getAnyRelocationAddress(
4569     const MachO::any_relocation_info &RE) const {
4570   if (isRelocationScattered(RE))
4571     return getScatteredRelocationAddress(RE);
4572   return getPlainRelocationAddress(RE);
4573 }
4574 
getAnyRelocationPCRel(const MachO::any_relocation_info & RE) const4575 unsigned MachOObjectFile::getAnyRelocationPCRel(
4576     const MachO::any_relocation_info &RE) const {
4577   if (isRelocationScattered(RE))
4578     return getScatteredRelocationPCRel(RE);
4579   return getPlainRelocationPCRel(*this, RE);
4580 }
4581 
getAnyRelocationLength(const MachO::any_relocation_info & RE) const4582 unsigned MachOObjectFile::getAnyRelocationLength(
4583     const MachO::any_relocation_info &RE) const {
4584   if (isRelocationScattered(RE))
4585     return getScatteredRelocationLength(RE);
4586   return getPlainRelocationLength(*this, RE);
4587 }
4588 
4589 unsigned
getAnyRelocationType(const MachO::any_relocation_info & RE) const4590 MachOObjectFile::getAnyRelocationType(
4591                                    const MachO::any_relocation_info &RE) const {
4592   if (isRelocationScattered(RE))
4593     return getScatteredRelocationType(RE);
4594   return getPlainRelocationType(*this, RE);
4595 }
4596 
4597 SectionRef
getAnyRelocationSection(const MachO::any_relocation_info & RE) const4598 MachOObjectFile::getAnyRelocationSection(
4599                                    const MachO::any_relocation_info &RE) const {
4600   if (isRelocationScattered(RE) || getPlainRelocationExternal(RE))
4601     return *section_end();
4602   unsigned SecNum = getPlainRelocationSymbolNum(RE);
4603   if (SecNum == MachO::R_ABS || SecNum > Sections.size())
4604     return *section_end();
4605   DataRefImpl DRI;
4606   DRI.d.a = SecNum - 1;
4607   return SectionRef(DRI, this);
4608 }
4609 
getSection(DataRefImpl DRI) const4610 MachO::section MachOObjectFile::getSection(DataRefImpl DRI) const {
4611   assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
4612   return getStruct<MachO::section>(*this, Sections[DRI.d.a]);
4613 }
4614 
getSection64(DataRefImpl DRI) const4615 MachO::section_64 MachOObjectFile::getSection64(DataRefImpl DRI) const {
4616   assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
4617   return getStruct<MachO::section_64>(*this, Sections[DRI.d.a]);
4618 }
4619 
getSection(const LoadCommandInfo & L,unsigned Index) const4620 MachO::section MachOObjectFile::getSection(const LoadCommandInfo &L,
4621                                            unsigned Index) const {
4622   const char *Sec = getSectionPtr(*this, L, Index);
4623   return getStruct<MachO::section>(*this, Sec);
4624 }
4625 
getSection64(const LoadCommandInfo & L,unsigned Index) const4626 MachO::section_64 MachOObjectFile::getSection64(const LoadCommandInfo &L,
4627                                                 unsigned Index) const {
4628   const char *Sec = getSectionPtr(*this, L, Index);
4629   return getStruct<MachO::section_64>(*this, Sec);
4630 }
4631 
4632 MachO::nlist
getSymbolTableEntry(DataRefImpl DRI) const4633 MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI) const {
4634   const char *P = reinterpret_cast<const char *>(DRI.p);
4635   return getStruct<MachO::nlist>(*this, P);
4636 }
4637 
4638 MachO::nlist_64
getSymbol64TableEntry(DataRefImpl DRI) const4639 MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI) const {
4640   const char *P = reinterpret_cast<const char *>(DRI.p);
4641   return getStruct<MachO::nlist_64>(*this, P);
4642 }
4643 
4644 MachO::linkedit_data_command
getLinkeditDataLoadCommand(const LoadCommandInfo & L) const4645 MachOObjectFile::getLinkeditDataLoadCommand(const LoadCommandInfo &L) const {
4646   return getStruct<MachO::linkedit_data_command>(*this, L.Ptr);
4647 }
4648 
4649 MachO::segment_command
getSegmentLoadCommand(const LoadCommandInfo & L) const4650 MachOObjectFile::getSegmentLoadCommand(const LoadCommandInfo &L) const {
4651   return getStruct<MachO::segment_command>(*this, L.Ptr);
4652 }
4653 
4654 MachO::segment_command_64
getSegment64LoadCommand(const LoadCommandInfo & L) const4655 MachOObjectFile::getSegment64LoadCommand(const LoadCommandInfo &L) const {
4656   return getStruct<MachO::segment_command_64>(*this, L.Ptr);
4657 }
4658 
4659 MachO::linker_option_command
getLinkerOptionLoadCommand(const LoadCommandInfo & L) const4660 MachOObjectFile::getLinkerOptionLoadCommand(const LoadCommandInfo &L) const {
4661   return getStruct<MachO::linker_option_command>(*this, L.Ptr);
4662 }
4663 
4664 MachO::version_min_command
getVersionMinLoadCommand(const LoadCommandInfo & L) const4665 MachOObjectFile::getVersionMinLoadCommand(const LoadCommandInfo &L) const {
4666   return getStruct<MachO::version_min_command>(*this, L.Ptr);
4667 }
4668 
4669 MachO::note_command
getNoteLoadCommand(const LoadCommandInfo & L) const4670 MachOObjectFile::getNoteLoadCommand(const LoadCommandInfo &L) const {
4671   return getStruct<MachO::note_command>(*this, L.Ptr);
4672 }
4673 
4674 MachO::build_version_command
getBuildVersionLoadCommand(const LoadCommandInfo & L) const4675 MachOObjectFile::getBuildVersionLoadCommand(const LoadCommandInfo &L) const {
4676   return getStruct<MachO::build_version_command>(*this, L.Ptr);
4677 }
4678 
4679 MachO::build_tool_version
getBuildToolVersion(unsigned index) const4680 MachOObjectFile::getBuildToolVersion(unsigned index) const {
4681   return getStruct<MachO::build_tool_version>(*this, BuildTools[index]);
4682 }
4683 
4684 MachO::dylib_command
getDylibIDLoadCommand(const LoadCommandInfo & L) const4685 MachOObjectFile::getDylibIDLoadCommand(const LoadCommandInfo &L) const {
4686   return getStruct<MachO::dylib_command>(*this, L.Ptr);
4687 }
4688 
4689 MachO::dyld_info_command
getDyldInfoLoadCommand(const LoadCommandInfo & L) const4690 MachOObjectFile::getDyldInfoLoadCommand(const LoadCommandInfo &L) const {
4691   return getStruct<MachO::dyld_info_command>(*this, L.Ptr);
4692 }
4693 
4694 MachO::dylinker_command
getDylinkerCommand(const LoadCommandInfo & L) const4695 MachOObjectFile::getDylinkerCommand(const LoadCommandInfo &L) const {
4696   return getStruct<MachO::dylinker_command>(*this, L.Ptr);
4697 }
4698 
4699 MachO::uuid_command
getUuidCommand(const LoadCommandInfo & L) const4700 MachOObjectFile::getUuidCommand(const LoadCommandInfo &L) const {
4701   return getStruct<MachO::uuid_command>(*this, L.Ptr);
4702 }
4703 
4704 MachO::rpath_command
getRpathCommand(const LoadCommandInfo & L) const4705 MachOObjectFile::getRpathCommand(const LoadCommandInfo &L) const {
4706   return getStruct<MachO::rpath_command>(*this, L.Ptr);
4707 }
4708 
4709 MachO::source_version_command
getSourceVersionCommand(const LoadCommandInfo & L) const4710 MachOObjectFile::getSourceVersionCommand(const LoadCommandInfo &L) const {
4711   return getStruct<MachO::source_version_command>(*this, L.Ptr);
4712 }
4713 
4714 MachO::entry_point_command
getEntryPointCommand(const LoadCommandInfo & L) const4715 MachOObjectFile::getEntryPointCommand(const LoadCommandInfo &L) const {
4716   return getStruct<MachO::entry_point_command>(*this, L.Ptr);
4717 }
4718 
4719 MachO::encryption_info_command
getEncryptionInfoCommand(const LoadCommandInfo & L) const4720 MachOObjectFile::getEncryptionInfoCommand(const LoadCommandInfo &L) const {
4721   return getStruct<MachO::encryption_info_command>(*this, L.Ptr);
4722 }
4723 
4724 MachO::encryption_info_command_64
getEncryptionInfoCommand64(const LoadCommandInfo & L) const4725 MachOObjectFile::getEncryptionInfoCommand64(const LoadCommandInfo &L) const {
4726   return getStruct<MachO::encryption_info_command_64>(*this, L.Ptr);
4727 }
4728 
4729 MachO::sub_framework_command
getSubFrameworkCommand(const LoadCommandInfo & L) const4730 MachOObjectFile::getSubFrameworkCommand(const LoadCommandInfo &L) const {
4731   return getStruct<MachO::sub_framework_command>(*this, L.Ptr);
4732 }
4733 
4734 MachO::sub_umbrella_command
getSubUmbrellaCommand(const LoadCommandInfo & L) const4735 MachOObjectFile::getSubUmbrellaCommand(const LoadCommandInfo &L) const {
4736   return getStruct<MachO::sub_umbrella_command>(*this, L.Ptr);
4737 }
4738 
4739 MachO::sub_library_command
getSubLibraryCommand(const LoadCommandInfo & L) const4740 MachOObjectFile::getSubLibraryCommand(const LoadCommandInfo &L) const {
4741   return getStruct<MachO::sub_library_command>(*this, L.Ptr);
4742 }
4743 
4744 MachO::sub_client_command
getSubClientCommand(const LoadCommandInfo & L) const4745 MachOObjectFile::getSubClientCommand(const LoadCommandInfo &L) const {
4746   return getStruct<MachO::sub_client_command>(*this, L.Ptr);
4747 }
4748 
4749 MachO::routines_command
getRoutinesCommand(const LoadCommandInfo & L) const4750 MachOObjectFile::getRoutinesCommand(const LoadCommandInfo &L) const {
4751   return getStruct<MachO::routines_command>(*this, L.Ptr);
4752 }
4753 
4754 MachO::routines_command_64
getRoutinesCommand64(const LoadCommandInfo & L) const4755 MachOObjectFile::getRoutinesCommand64(const LoadCommandInfo &L) const {
4756   return getStruct<MachO::routines_command_64>(*this, L.Ptr);
4757 }
4758 
4759 MachO::thread_command
getThreadCommand(const LoadCommandInfo & L) const4760 MachOObjectFile::getThreadCommand(const LoadCommandInfo &L) const {
4761   return getStruct<MachO::thread_command>(*this, L.Ptr);
4762 }
4763 
4764 MachO::any_relocation_info
getRelocation(DataRefImpl Rel) const4765 MachOObjectFile::getRelocation(DataRefImpl Rel) const {
4766   uint32_t Offset;
4767   if (getHeader().filetype == MachO::MH_OBJECT) {
4768     DataRefImpl Sec;
4769     Sec.d.a = Rel.d.a;
4770     if (is64Bit()) {
4771       MachO::section_64 Sect = getSection64(Sec);
4772       Offset = Sect.reloff;
4773     } else {
4774       MachO::section Sect = getSection(Sec);
4775       Offset = Sect.reloff;
4776     }
4777   } else {
4778     MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
4779     if (Rel.d.a == 0)
4780       Offset = DysymtabLoadCmd.extreloff; // Offset to the external relocations
4781     else
4782       Offset = DysymtabLoadCmd.locreloff; // Offset to the local relocations
4783   }
4784 
4785   auto P = reinterpret_cast<const MachO::any_relocation_info *>(
4786       getPtr(*this, Offset)) + Rel.d.b;
4787   return getStruct<MachO::any_relocation_info>(
4788       *this, reinterpret_cast<const char *>(P));
4789 }
4790 
4791 MachO::data_in_code_entry
getDice(DataRefImpl Rel) const4792 MachOObjectFile::getDice(DataRefImpl Rel) const {
4793   const char *P = reinterpret_cast<const char *>(Rel.p);
4794   return getStruct<MachO::data_in_code_entry>(*this, P);
4795 }
4796 
getHeader() const4797 const MachO::mach_header &MachOObjectFile::getHeader() const {
4798   return Header;
4799 }
4800 
getHeader64() const4801 const MachO::mach_header_64 &MachOObjectFile::getHeader64() const {
4802   assert(is64Bit());
4803   return Header64;
4804 }
4805 
getIndirectSymbolTableEntry(const MachO::dysymtab_command & DLC,unsigned Index) const4806 uint32_t MachOObjectFile::getIndirectSymbolTableEntry(
4807                                              const MachO::dysymtab_command &DLC,
4808                                              unsigned Index) const {
4809   uint64_t Offset = DLC.indirectsymoff + Index * sizeof(uint32_t);
4810   return getStruct<uint32_t>(*this, getPtr(*this, Offset));
4811 }
4812 
4813 MachO::data_in_code_entry
getDataInCodeTableEntry(uint32_t DataOffset,unsigned Index) const4814 MachOObjectFile::getDataInCodeTableEntry(uint32_t DataOffset,
4815                                          unsigned Index) const {
4816   uint64_t Offset = DataOffset + Index * sizeof(MachO::data_in_code_entry);
4817   return getStruct<MachO::data_in_code_entry>(*this, getPtr(*this, Offset));
4818 }
4819 
getSymtabLoadCommand() const4820 MachO::symtab_command MachOObjectFile::getSymtabLoadCommand() const {
4821   if (SymtabLoadCmd)
4822     return getStruct<MachO::symtab_command>(*this, SymtabLoadCmd);
4823 
4824   // If there is no SymtabLoadCmd return a load command with zero'ed fields.
4825   MachO::symtab_command Cmd;
4826   Cmd.cmd = MachO::LC_SYMTAB;
4827   Cmd.cmdsize = sizeof(MachO::symtab_command);
4828   Cmd.symoff = 0;
4829   Cmd.nsyms = 0;
4830   Cmd.stroff = 0;
4831   Cmd.strsize = 0;
4832   return Cmd;
4833 }
4834 
getDysymtabLoadCommand() const4835 MachO::dysymtab_command MachOObjectFile::getDysymtabLoadCommand() const {
4836   if (DysymtabLoadCmd)
4837     return getStruct<MachO::dysymtab_command>(*this, DysymtabLoadCmd);
4838 
4839   // If there is no DysymtabLoadCmd return a load command with zero'ed fields.
4840   MachO::dysymtab_command Cmd;
4841   Cmd.cmd = MachO::LC_DYSYMTAB;
4842   Cmd.cmdsize = sizeof(MachO::dysymtab_command);
4843   Cmd.ilocalsym = 0;
4844   Cmd.nlocalsym = 0;
4845   Cmd.iextdefsym = 0;
4846   Cmd.nextdefsym = 0;
4847   Cmd.iundefsym = 0;
4848   Cmd.nundefsym = 0;
4849   Cmd.tocoff = 0;
4850   Cmd.ntoc = 0;
4851   Cmd.modtaboff = 0;
4852   Cmd.nmodtab = 0;
4853   Cmd.extrefsymoff = 0;
4854   Cmd.nextrefsyms = 0;
4855   Cmd.indirectsymoff = 0;
4856   Cmd.nindirectsyms = 0;
4857   Cmd.extreloff = 0;
4858   Cmd.nextrel = 0;
4859   Cmd.locreloff = 0;
4860   Cmd.nlocrel = 0;
4861   return Cmd;
4862 }
4863 
4864 MachO::linkedit_data_command
getDataInCodeLoadCommand() const4865 MachOObjectFile::getDataInCodeLoadCommand() const {
4866   if (DataInCodeLoadCmd)
4867     return getStruct<MachO::linkedit_data_command>(*this, DataInCodeLoadCmd);
4868 
4869   // If there is no DataInCodeLoadCmd return a load command with zero'ed fields.
4870   MachO::linkedit_data_command Cmd;
4871   Cmd.cmd = MachO::LC_DATA_IN_CODE;
4872   Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
4873   Cmd.dataoff = 0;
4874   Cmd.datasize = 0;
4875   return Cmd;
4876 }
4877 
4878 MachO::linkedit_data_command
getLinkOptHintsLoadCommand() const4879 MachOObjectFile::getLinkOptHintsLoadCommand() const {
4880   if (LinkOptHintsLoadCmd)
4881     return getStruct<MachO::linkedit_data_command>(*this, LinkOptHintsLoadCmd);
4882 
4883   // If there is no LinkOptHintsLoadCmd return a load command with zero'ed
4884   // fields.
4885   MachO::linkedit_data_command Cmd;
4886   Cmd.cmd = MachO::LC_LINKER_OPTIMIZATION_HINT;
4887   Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
4888   Cmd.dataoff = 0;
4889   Cmd.datasize = 0;
4890   return Cmd;
4891 }
4892 
getDyldInfoRebaseOpcodes() const4893 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoRebaseOpcodes() const {
4894   if (!DyldInfoLoadCmd)
4895     return std::nullopt;
4896 
4897   auto DyldInfoOrErr =
4898     getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4899   if (!DyldInfoOrErr)
4900     return std::nullopt;
4901   MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4902   const uint8_t *Ptr =
4903       reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.rebase_off));
4904   return ArrayRef(Ptr, DyldInfo.rebase_size);
4905 }
4906 
getDyldInfoBindOpcodes() const4907 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoBindOpcodes() const {
4908   if (!DyldInfoLoadCmd)
4909     return std::nullopt;
4910 
4911   auto DyldInfoOrErr =
4912     getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4913   if (!DyldInfoOrErr)
4914     return std::nullopt;
4915   MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4916   const uint8_t *Ptr =
4917       reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.bind_off));
4918   return ArrayRef(Ptr, DyldInfo.bind_size);
4919 }
4920 
getDyldInfoWeakBindOpcodes() const4921 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoWeakBindOpcodes() const {
4922   if (!DyldInfoLoadCmd)
4923     return std::nullopt;
4924 
4925   auto DyldInfoOrErr =
4926     getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4927   if (!DyldInfoOrErr)
4928     return std::nullopt;
4929   MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4930   const uint8_t *Ptr =
4931       reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.weak_bind_off));
4932   return ArrayRef(Ptr, DyldInfo.weak_bind_size);
4933 }
4934 
getDyldInfoLazyBindOpcodes() const4935 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoLazyBindOpcodes() const {
4936   if (!DyldInfoLoadCmd)
4937     return std::nullopt;
4938 
4939   auto DyldInfoOrErr =
4940       getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4941   if (!DyldInfoOrErr)
4942     return std::nullopt;
4943   MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4944   const uint8_t *Ptr =
4945       reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.lazy_bind_off));
4946   return ArrayRef(Ptr, DyldInfo.lazy_bind_size);
4947 }
4948 
getDyldInfoExportsTrie() const4949 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoExportsTrie() const {
4950   if (!DyldInfoLoadCmd)
4951     return std::nullopt;
4952 
4953   auto DyldInfoOrErr =
4954       getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4955   if (!DyldInfoOrErr)
4956     return std::nullopt;
4957   MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4958   const uint8_t *Ptr =
4959       reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.export_off));
4960   return ArrayRef(Ptr, DyldInfo.export_size);
4961 }
4962 
4963 Expected<std::optional<MachO::linkedit_data_command>>
getChainedFixupsLoadCommand() const4964 MachOObjectFile::getChainedFixupsLoadCommand() const {
4965   // Load the dyld chained fixups load command.
4966   if (!DyldChainedFixupsLoadCmd)
4967     return std::nullopt;
4968   auto DyldChainedFixupsOrErr = getStructOrErr<MachO::linkedit_data_command>(
4969       *this, DyldChainedFixupsLoadCmd);
4970   if (!DyldChainedFixupsOrErr)
4971     return DyldChainedFixupsOrErr.takeError();
4972   const MachO::linkedit_data_command &DyldChainedFixups =
4973       *DyldChainedFixupsOrErr;
4974 
4975   // If the load command is present but the data offset has been zeroed out,
4976   // as is the case for dylib stubs, return std::nullopt (no error).
4977   if (!DyldChainedFixups.dataoff)
4978     return std::nullopt;
4979   return DyldChainedFixups;
4980 }
4981 
4982 Expected<std::optional<MachO::dyld_chained_fixups_header>>
getChainedFixupsHeader() const4983 MachOObjectFile::getChainedFixupsHeader() const {
4984   auto CFOrErr = getChainedFixupsLoadCommand();
4985   if (!CFOrErr)
4986     return CFOrErr.takeError();
4987   if (!CFOrErr->has_value())
4988     return std::nullopt;
4989 
4990   const MachO::linkedit_data_command &DyldChainedFixups = **CFOrErr;
4991 
4992   uint64_t CFHeaderOffset = DyldChainedFixups.dataoff;
4993   uint64_t CFSize = DyldChainedFixups.datasize;
4994 
4995   // Load the dyld chained fixups header.
4996   const char *CFHeaderPtr = getPtr(*this, CFHeaderOffset);
4997   auto CFHeaderOrErr =
4998       getStructOrErr<MachO::dyld_chained_fixups_header>(*this, CFHeaderPtr);
4999   if (!CFHeaderOrErr)
5000     return CFHeaderOrErr.takeError();
5001   MachO::dyld_chained_fixups_header CFHeader = CFHeaderOrErr.get();
5002 
5003   // Reject unknown chained fixup formats.
5004   if (CFHeader.fixups_version != 0)
5005     return malformedError(Twine("bad chained fixups: unknown version: ") +
5006                           Twine(CFHeader.fixups_version));
5007   if (CFHeader.imports_format < 1 || CFHeader.imports_format > 3)
5008     return malformedError(
5009         Twine("bad chained fixups: unknown imports format: ") +
5010         Twine(CFHeader.imports_format));
5011 
5012   // Validate the image format.
5013   //
5014   // Load the image starts.
5015   uint64_t CFImageStartsOffset = (CFHeaderOffset + CFHeader.starts_offset);
5016   if (CFHeader.starts_offset < sizeof(MachO::dyld_chained_fixups_header)) {
5017     return malformedError(Twine("bad chained fixups: image starts offset ") +
5018                           Twine(CFHeader.starts_offset) +
5019                           " overlaps with chained fixups header");
5020   }
5021   uint32_t EndOffset = CFHeaderOffset + CFSize;
5022   if (CFImageStartsOffset + sizeof(MachO::dyld_chained_starts_in_image) >
5023       EndOffset) {
5024     return malformedError(Twine("bad chained fixups: image starts end ") +
5025                           Twine(CFImageStartsOffset +
5026                                 sizeof(MachO::dyld_chained_starts_in_image)) +
5027                           " extends past end " + Twine(EndOffset));
5028   }
5029 
5030   return CFHeader;
5031 }
5032 
5033 Expected<std::pair<size_t, std::vector<ChainedFixupsSegment>>>
getChainedFixupsSegments() const5034 MachOObjectFile::getChainedFixupsSegments() const {
5035   auto CFOrErr = getChainedFixupsLoadCommand();
5036   if (!CFOrErr)
5037     return CFOrErr.takeError();
5038 
5039   std::vector<ChainedFixupsSegment> Segments;
5040   if (!CFOrErr->has_value())
5041     return std::make_pair(0, Segments);
5042 
5043   const MachO::linkedit_data_command &DyldChainedFixups = **CFOrErr;
5044 
5045   auto HeaderOrErr = getChainedFixupsHeader();
5046   if (!HeaderOrErr)
5047     return HeaderOrErr.takeError();
5048   if (!HeaderOrErr->has_value())
5049     return std::make_pair(0, Segments);
5050   const MachO::dyld_chained_fixups_header &Header = **HeaderOrErr;
5051 
5052   const char *Contents = getPtr(*this, DyldChainedFixups.dataoff);
5053 
5054   auto ImageStartsOrErr = getStructOrErr<MachO::dyld_chained_starts_in_image>(
5055       *this, Contents + Header.starts_offset);
5056   if (!ImageStartsOrErr)
5057     return ImageStartsOrErr.takeError();
5058   const MachO::dyld_chained_starts_in_image &ImageStarts = *ImageStartsOrErr;
5059 
5060   const char *SegOffsPtr =
5061       Contents + Header.starts_offset +
5062       offsetof(MachO::dyld_chained_starts_in_image, seg_info_offset);
5063   const char *SegOffsEnd =
5064       SegOffsPtr + ImageStarts.seg_count * sizeof(uint32_t);
5065   if (SegOffsEnd > Contents + DyldChainedFixups.datasize)
5066     return malformedError(
5067         "bad chained fixups: seg_info_offset extends past end");
5068 
5069   const char *LastSegEnd = nullptr;
5070   for (size_t I = 0, N = ImageStarts.seg_count; I < N; ++I) {
5071     auto OffOrErr =
5072         getStructOrErr<uint32_t>(*this, SegOffsPtr + I * sizeof(uint32_t));
5073     if (!OffOrErr)
5074       return OffOrErr.takeError();
5075     // seg_info_offset == 0 means there is no associated starts_in_segment
5076     // entry.
5077     if (!*OffOrErr)
5078       continue;
5079 
5080     auto Fail = [&](Twine Message) {
5081       return malformedError("bad chained fixups: segment info" + Twine(I) +
5082                             " at offset " + Twine(*OffOrErr) + Message);
5083     };
5084 
5085     const char *SegPtr = Contents + Header.starts_offset + *OffOrErr;
5086     if (LastSegEnd && SegPtr < LastSegEnd)
5087       return Fail(" overlaps with previous segment info");
5088 
5089     auto SegOrErr =
5090         getStructOrErr<MachO::dyld_chained_starts_in_segment>(*this, SegPtr);
5091     if (!SegOrErr)
5092       return SegOrErr.takeError();
5093     const MachO::dyld_chained_starts_in_segment &Seg = *SegOrErr;
5094 
5095     LastSegEnd = SegPtr + Seg.size;
5096     if (Seg.pointer_format < 1 || Seg.pointer_format > 12)
5097       return Fail(" has unknown pointer format: " + Twine(Seg.pointer_format));
5098 
5099     const char *PageStart =
5100         SegPtr + offsetof(MachO::dyld_chained_starts_in_segment, page_start);
5101     const char *PageEnd = PageStart + Seg.page_count * sizeof(uint16_t);
5102     if (PageEnd > SegPtr + Seg.size)
5103       return Fail(" : page_starts extend past seg_info size");
5104 
5105     // FIXME: This does not account for multiple offsets on a single page
5106     //        (DYLD_CHAINED_PTR_START_MULTI; 32-bit only).
5107     std::vector<uint16_t> PageStarts;
5108     for (size_t PageIdx = 0; PageIdx < Seg.page_count; ++PageIdx) {
5109       uint16_t Start;
5110       memcpy(&Start, PageStart + PageIdx * sizeof(uint16_t), sizeof(uint16_t));
5111       if (isLittleEndian() != sys::IsLittleEndianHost)
5112         sys::swapByteOrder(Start);
5113       PageStarts.push_back(Start);
5114     }
5115 
5116     Segments.emplace_back(I, *OffOrErr, Seg, std::move(PageStarts));
5117   }
5118 
5119   return std::make_pair(ImageStarts.seg_count, Segments);
5120 }
5121 
5122 // The special library ordinals have a negative value, but they are encoded in
5123 // an unsigned bitfield, so we need to sign extend the value.
getEncodedOrdinal(T Value)5124 template <typename T> static int getEncodedOrdinal(T Value) {
5125   if (Value == static_cast<T>(MachO::BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE) ||
5126       Value == static_cast<T>(MachO::BIND_SPECIAL_DYLIB_FLAT_LOOKUP) ||
5127       Value == static_cast<T>(MachO::BIND_SPECIAL_DYLIB_WEAK_LOOKUP))
5128     return SignExtend32<sizeof(T) * CHAR_BIT>(Value);
5129   return Value;
5130 }
5131 
5132 template <typename T, unsigned N>
getArray(const MachOObjectFile & O,const void * Ptr)5133 static std::array<T, N> getArray(const MachOObjectFile &O, const void *Ptr) {
5134   std::array<T, N> RawValue;
5135   memcpy(RawValue.data(), Ptr, N * sizeof(T));
5136   if (O.isLittleEndian() != sys::IsLittleEndianHost)
5137     for (auto &Element : RawValue)
5138       sys::swapByteOrder(Element);
5139   return RawValue;
5140 }
5141 
5142 Expected<std::vector<ChainedFixupTarget>>
getDyldChainedFixupTargets() const5143 MachOObjectFile::getDyldChainedFixupTargets() const {
5144   auto CFOrErr = getChainedFixupsLoadCommand();
5145   if (!CFOrErr)
5146     return CFOrErr.takeError();
5147 
5148   std::vector<ChainedFixupTarget> Targets;
5149   if (!CFOrErr->has_value())
5150     return Targets;
5151 
5152   const MachO::linkedit_data_command &DyldChainedFixups = **CFOrErr;
5153 
5154   auto CFHeaderOrErr = getChainedFixupsHeader();
5155   if (!CFHeaderOrErr)
5156     return CFHeaderOrErr.takeError();
5157   if (!(*CFHeaderOrErr))
5158     return Targets;
5159   const MachO::dyld_chained_fixups_header &Header = **CFHeaderOrErr;
5160 
5161   size_t ImportSize = 0;
5162   if (Header.imports_format == MachO::DYLD_CHAINED_IMPORT)
5163     ImportSize = sizeof(MachO::dyld_chained_import);
5164   else if (Header.imports_format == MachO::DYLD_CHAINED_IMPORT_ADDEND)
5165     ImportSize = sizeof(MachO::dyld_chained_import_addend);
5166   else if (Header.imports_format == MachO::DYLD_CHAINED_IMPORT_ADDEND64)
5167     ImportSize = sizeof(MachO::dyld_chained_import_addend64);
5168   else
5169     return malformedError("bad chained fixups: unknown imports format: " +
5170                           Twine(Header.imports_format));
5171 
5172   const char *Contents = getPtr(*this, DyldChainedFixups.dataoff);
5173   const char *Imports = Contents + Header.imports_offset;
5174   size_t ImportsEndOffset =
5175       Header.imports_offset + ImportSize * Header.imports_count;
5176   const char *ImportsEnd = Contents + ImportsEndOffset;
5177   const char *Symbols = Contents + Header.symbols_offset;
5178   const char *SymbolsEnd = Contents + DyldChainedFixups.datasize;
5179 
5180   if (ImportsEnd > Symbols)
5181     return malformedError("bad chained fixups: imports end " +
5182                           Twine(ImportsEndOffset) + " extends past end " +
5183                           Twine(DyldChainedFixups.datasize));
5184 
5185   if (ImportsEnd > Symbols)
5186     return malformedError("bad chained fixups: imports end " +
5187                           Twine(ImportsEndOffset) + " overlaps with symbols");
5188 
5189   // We use bit manipulation to extract data from the bitfields. This is correct
5190   // for both LE and BE hosts, but we assume that the object is little-endian.
5191   if (!isLittleEndian())
5192     return createError("parsing big-endian chained fixups is not implemented");
5193   for (const char *ImportPtr = Imports; ImportPtr < ImportsEnd;
5194        ImportPtr += ImportSize) {
5195     int LibOrdinal;
5196     bool WeakImport;
5197     uint32_t NameOffset;
5198     uint64_t Addend;
5199     if (Header.imports_format == MachO::DYLD_CHAINED_IMPORT) {
5200       static_assert(sizeof(uint32_t) == sizeof(MachO::dyld_chained_import));
5201       auto RawValue = getArray<uint32_t, 1>(*this, ImportPtr);
5202 
5203       LibOrdinal = getEncodedOrdinal<uint8_t>(RawValue[0] & 0xFF);
5204       WeakImport = (RawValue[0] >> 8) & 1;
5205       NameOffset = RawValue[0] >> 9;
5206       Addend = 0;
5207     } else if (Header.imports_format == MachO::DYLD_CHAINED_IMPORT_ADDEND) {
5208       static_assert(sizeof(uint64_t) ==
5209                     sizeof(MachO::dyld_chained_import_addend));
5210       auto RawValue = getArray<uint32_t, 2>(*this, ImportPtr);
5211 
5212       LibOrdinal = getEncodedOrdinal<uint8_t>(RawValue[0] & 0xFF);
5213       WeakImport = (RawValue[0] >> 8) & 1;
5214       NameOffset = RawValue[0] >> 9;
5215       Addend = bit_cast<int32_t>(RawValue[1]);
5216     } else if (Header.imports_format == MachO::DYLD_CHAINED_IMPORT_ADDEND64) {
5217       static_assert(2 * sizeof(uint64_t) ==
5218                     sizeof(MachO::dyld_chained_import_addend64));
5219       auto RawValue = getArray<uint64_t, 2>(*this, ImportPtr);
5220 
5221       LibOrdinal = getEncodedOrdinal<uint16_t>(RawValue[0] & 0xFFFF);
5222       NameOffset = (RawValue[0] >> 16) & 1;
5223       WeakImport = RawValue[0] >> 17;
5224       Addend = RawValue[1];
5225     } else {
5226       llvm_unreachable("Import format should have been checked");
5227     }
5228 
5229     const char *Str = Symbols + NameOffset;
5230     if (Str >= SymbolsEnd)
5231       return malformedError("bad chained fixups: symbol offset " +
5232                             Twine(NameOffset) + " extends past end " +
5233                             Twine(DyldChainedFixups.datasize));
5234     Targets.emplace_back(LibOrdinal, NameOffset, Str, Addend, WeakImport);
5235   }
5236 
5237   return std::move(Targets);
5238 }
5239 
getDyldExportsTrie() const5240 ArrayRef<uint8_t> MachOObjectFile::getDyldExportsTrie() const {
5241   if (!DyldExportsTrieLoadCmd)
5242     return std::nullopt;
5243 
5244   auto DyldExportsTrieOrError = getStructOrErr<MachO::linkedit_data_command>(
5245       *this, DyldExportsTrieLoadCmd);
5246   if (!DyldExportsTrieOrError)
5247     return std::nullopt;
5248   MachO::linkedit_data_command DyldExportsTrie = DyldExportsTrieOrError.get();
5249   const uint8_t *Ptr =
5250       reinterpret_cast<const uint8_t *>(getPtr(*this, DyldExportsTrie.dataoff));
5251   return ArrayRef(Ptr, DyldExportsTrie.datasize);
5252 }
5253 
getFunctionStarts() const5254 SmallVector<uint64_t> MachOObjectFile::getFunctionStarts() const {
5255   if (!FuncStartsLoadCmd)
5256     return {};
5257 
5258   auto InfoOrErr =
5259       getStructOrErr<MachO::linkedit_data_command>(*this, FuncStartsLoadCmd);
5260   if (!InfoOrErr)
5261     return {};
5262 
5263   MachO::linkedit_data_command Info = InfoOrErr.get();
5264   SmallVector<uint64_t, 8> FunctionStarts;
5265   this->ReadULEB128s(Info.dataoff, FunctionStarts);
5266   return std::move(FunctionStarts);
5267 }
5268 
getUuid() const5269 ArrayRef<uint8_t> MachOObjectFile::getUuid() const {
5270   if (!UuidLoadCmd)
5271     return std::nullopt;
5272   // Returning a pointer is fine as uuid doesn't need endian swapping.
5273   const char *Ptr = UuidLoadCmd + offsetof(MachO::uuid_command, uuid);
5274   return ArrayRef(reinterpret_cast<const uint8_t *>(Ptr), 16);
5275 }
5276 
getStringTableData() const5277 StringRef MachOObjectFile::getStringTableData() const {
5278   MachO::symtab_command S = getSymtabLoadCommand();
5279   return getData().substr(S.stroff, S.strsize);
5280 }
5281 
is64Bit() const5282 bool MachOObjectFile::is64Bit() const {
5283   return getType() == getMachOType(false, true) ||
5284     getType() == getMachOType(true, true);
5285 }
5286 
ReadULEB128s(uint64_t Index,SmallVectorImpl<uint64_t> & Out) const5287 void MachOObjectFile::ReadULEB128s(uint64_t Index,
5288                                    SmallVectorImpl<uint64_t> &Out) const {
5289   DataExtractor extractor(ObjectFile::getData(), true, 0);
5290 
5291   uint64_t offset = Index;
5292   uint64_t data = 0;
5293   while (uint64_t delta = extractor.getULEB128(&offset)) {
5294     data += delta;
5295     Out.push_back(data);
5296   }
5297 }
5298 
isRelocatableObject() const5299 bool MachOObjectFile::isRelocatableObject() const {
5300   return getHeader().filetype == MachO::MH_OBJECT;
5301 }
5302 
5303 Expected<std::unique_ptr<MachOObjectFile>>
createMachOObjectFile(MemoryBufferRef Buffer,uint32_t UniversalCputype,uint32_t UniversalIndex)5304 ObjectFile::createMachOObjectFile(MemoryBufferRef Buffer,
5305                                   uint32_t UniversalCputype,
5306                                   uint32_t UniversalIndex) {
5307   StringRef Magic = Buffer.getBuffer().slice(0, 4);
5308   if (Magic == "\xFE\xED\xFA\xCE")
5309     return MachOObjectFile::create(Buffer, false, false,
5310                                    UniversalCputype, UniversalIndex);
5311   if (Magic == "\xCE\xFA\xED\xFE")
5312     return MachOObjectFile::create(Buffer, true, false,
5313                                    UniversalCputype, UniversalIndex);
5314   if (Magic == "\xFE\xED\xFA\xCF")
5315     return MachOObjectFile::create(Buffer, false, true,
5316                                    UniversalCputype, UniversalIndex);
5317   if (Magic == "\xCF\xFA\xED\xFE")
5318     return MachOObjectFile::create(Buffer, true, true,
5319                                    UniversalCputype, UniversalIndex);
5320   return make_error<GenericBinaryError>("Unrecognized MachO magic number",
5321                                         object_error::invalid_file_type);
5322 }
5323 
mapDebugSectionName(StringRef Name) const5324 StringRef MachOObjectFile::mapDebugSectionName(StringRef Name) const {
5325   return StringSwitch<StringRef>(Name)
5326       .Case("debug_str_offs", "debug_str_offsets")
5327       .Default(Name);
5328 }
5329 
5330 Expected<std::vector<std::string>>
findDsymObjectMembers(StringRef Path)5331 MachOObjectFile::findDsymObjectMembers(StringRef Path) {
5332   SmallString<256> BundlePath(Path);
5333   // Normalize input path. This is necessary to accept `bundle.dSYM/`.
5334   sys::path::remove_dots(BundlePath);
5335   if (!sys::fs::is_directory(BundlePath) ||
5336       sys::path::extension(BundlePath) != ".dSYM")
5337     return std::vector<std::string>();
5338   sys::path::append(BundlePath, "Contents", "Resources", "DWARF");
5339   bool IsDir;
5340   auto EC = sys::fs::is_directory(BundlePath, IsDir);
5341   if (EC == errc::no_such_file_or_directory || (!EC && !IsDir))
5342     return createStringError(
5343         EC, "%s: expected directory 'Contents/Resources/DWARF' in dSYM bundle",
5344         Path.str().c_str());
5345   if (EC)
5346     return createFileError(BundlePath, errorCodeToError(EC));
5347 
5348   std::vector<std::string> ObjectPaths;
5349   for (sys::fs::directory_iterator Dir(BundlePath, EC), DirEnd;
5350        Dir != DirEnd && !EC; Dir.increment(EC)) {
5351     StringRef ObjectPath = Dir->path();
5352     sys::fs::file_status Status;
5353     if (auto EC = sys::fs::status(ObjectPath, Status))
5354       return createFileError(ObjectPath, errorCodeToError(EC));
5355     switch (Status.type()) {
5356     case sys::fs::file_type::regular_file:
5357     case sys::fs::file_type::symlink_file:
5358     case sys::fs::file_type::type_unknown:
5359       ObjectPaths.push_back(ObjectPath.str());
5360       break;
5361     default: /*ignore*/;
5362     }
5363   }
5364   if (EC)
5365     return createFileError(BundlePath, errorCodeToError(EC));
5366   if (ObjectPaths.empty())
5367     return createStringError(std::error_code(),
5368                              "%s: no objects found in dSYM bundle",
5369                              Path.str().c_str());
5370   return ObjectPaths;
5371 }
5372 
5373 llvm::binaryformat::Swift5ReflectionSectionKind
mapReflectionSectionNameToEnumValue(StringRef SectionName) const5374 MachOObjectFile::mapReflectionSectionNameToEnumValue(
5375     StringRef SectionName) const {
5376 #define HANDLE_SWIFT_SECTION(KIND, MACHO, ELF, COFF)                           \
5377   .Case(MACHO, llvm::binaryformat::Swift5ReflectionSectionKind::KIND)
5378   return StringSwitch<llvm::binaryformat::Swift5ReflectionSectionKind>(
5379              SectionName)
5380 #include "llvm/BinaryFormat/Swift.def"
5381       .Default(llvm::binaryformat::Swift5ReflectionSectionKind::unknown);
5382 #undef HANDLE_SWIFT_SECTION
5383 }
5384 
isMachOPairedReloc(uint64_t RelocType,uint64_t Arch)5385 bool MachOObjectFile::isMachOPairedReloc(uint64_t RelocType, uint64_t Arch) {
5386   switch (Arch) {
5387   case Triple::x86:
5388     return RelocType == MachO::GENERIC_RELOC_SECTDIFF ||
5389            RelocType == MachO::GENERIC_RELOC_LOCAL_SECTDIFF;
5390   case Triple::x86_64:
5391     return RelocType == MachO::X86_64_RELOC_SUBTRACTOR;
5392   case Triple::arm:
5393   case Triple::thumb:
5394     return RelocType == MachO::ARM_RELOC_SECTDIFF ||
5395            RelocType == MachO::ARM_RELOC_LOCAL_SECTDIFF ||
5396            RelocType == MachO::ARM_RELOC_HALF ||
5397            RelocType == MachO::ARM_RELOC_HALF_SECTDIFF;
5398   case Triple::aarch64:
5399     return RelocType == MachO::ARM64_RELOC_SUBTRACTOR;
5400   default:
5401     return false;
5402   }
5403 }
5404