LLVM  13.0.0git
MachOObjectFile.cpp
Go to the documentation of this file.
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/None.h"
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/ADT/SmallVector.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/ADT/StringSwitch.h"
20 #include "llvm/ADT/Triple.h"
21 #include "llvm/ADT/Twine.h"
23 #include "llvm/Object/Error.h"
24 #include "llvm/Object/MachO.h"
25 #include "llvm/Object/ObjectFile.h"
28 #include "llvm/Support/Debug.h"
29 #include "llvm/Support/Error.h"
31 #include "llvm/Support/Format.h"
32 #include "llvm/Support/Host.h"
33 #include "llvm/Support/LEB128.h"
37 #include <algorithm>
38 #include <cassert>
39 #include <cstddef>
40 #include <cstdint>
41 #include <cstring>
42 #include <limits>
43 #include <list>
44 #include <memory>
45 #include <string>
46 #include <system_error>
47 
48 using namespace llvm;
49 using namespace object;
50 
51 namespace {
52 
53  struct section_base {
54  char sectname[16];
55  char segname[16];
56  };
57 
58 } // end anonymous namespace
59 
60 static Error malformedError(const Twine &Msg) {
61  return make_error<GenericBinaryError>("truncated or malformed object (" +
62  Msg + ")",
64 }
65 
66 // FIXME: Replace all uses of this function with getStructOrErr.
67 template <typename T>
68 static T getStruct(const MachOObjectFile &O, const char *P) {
69  // Don't read before the beginning or past the end of the file
70  if (P < O.getData().begin() || P + sizeof(T) > O.getData().end())
71  report_fatal_error("Malformed MachO file.");
72 
73  T Cmd;
74  memcpy(&Cmd, P, sizeof(T));
75  if (O.isLittleEndian() != sys::IsLittleEndianHost)
76  MachO::swapStruct(Cmd);
77  return Cmd;
78 }
79 
80 template <typename T>
81 static Expected<T> getStructOrErr(const MachOObjectFile &O, const char *P) {
82  // Don't read before the beginning or past the end of the file
83  if (P < O.getData().begin() || P + sizeof(T) > O.getData().end())
84  return malformedError("Structure read out-of-range");
85 
86  T Cmd;
87  memcpy(&Cmd, P, sizeof(T));
88  if (O.isLittleEndian() != sys::IsLittleEndianHost)
89  MachO::swapStruct(Cmd);
90  return Cmd;
91 }
92 
93 static const char *
94 getSectionPtr(const MachOObjectFile &O, MachOObjectFile::LoadCommandInfo L,
95  unsigned Sec) {
96  uintptr_t CommandAddr = reinterpret_cast<uintptr_t>(L.Ptr);
97 
98  bool Is64 = O.is64Bit();
99  unsigned SegmentLoadSize = Is64 ? sizeof(MachO::segment_command_64) :
100  sizeof(MachO::segment_command);
101  unsigned SectionSize = Is64 ? sizeof(MachO::section_64) :
102  sizeof(MachO::section);
103 
104  uintptr_t SectionAddr = CommandAddr + SegmentLoadSize + Sec * SectionSize;
105  return reinterpret_cast<const char*>(SectionAddr);
106 }
107 
108 static const char *getPtr(const MachOObjectFile &O, size_t Offset) {
109  assert(Offset <= O.getData().size());
110  return O.getData().data() + Offset;
111 }
112 
113 static MachO::nlist_base
114 getSymbolTableEntryBase(const MachOObjectFile &O, DataRefImpl DRI) {
115  const char *P = reinterpret_cast<const char *>(DRI.p);
116  return getStruct<MachO::nlist_base>(O, P);
117 }
118 
119 static StringRef parseSegmentOrSectionName(const char *P) {
120  if (P[15] == 0)
121  // Null terminated.
122  return P;
123  // Not null terminated, so this is a 16 char string.
124  return StringRef(P, 16);
125 }
126 
127 static unsigned getCPUType(const MachOObjectFile &O) {
128  return O.getHeader().cputype;
129 }
130 
131 static unsigned getCPUSubType(const MachOObjectFile &O) {
132  return O.getHeader().cpusubtype;
133 }
134 
135 static uint32_t
137  return RE.r_word0;
138 }
139 
140 static unsigned
142  return RE.r_word0 & 0xffffff;
143 }
144 
145 static bool getPlainRelocationPCRel(const MachOObjectFile &O,
146  const MachO::any_relocation_info &RE) {
147  if (O.isLittleEndian())
148  return (RE.r_word1 >> 24) & 1;
149  return (RE.r_word1 >> 7) & 1;
150 }
151 
152 static bool
154  return (RE.r_word0 >> 30) & 1;
155 }
156 
157 static unsigned getPlainRelocationLength(const MachOObjectFile &O,
158  const MachO::any_relocation_info &RE) {
159  if (O.isLittleEndian())
160  return (RE.r_word1 >> 25) & 3;
161  return (RE.r_word1 >> 5) & 3;
162 }
163 
164 static unsigned
166  return (RE.r_word0 >> 28) & 3;
167 }
168 
169 static unsigned getPlainRelocationType(const MachOObjectFile &O,
170  const MachO::any_relocation_info &RE) {
171  if (O.isLittleEndian())
172  return RE.r_word1 >> 28;
173  return RE.r_word1 & 0xf;
174 }
175 
176 static uint32_t getSectionFlags(const MachOObjectFile &O,
177  DataRefImpl Sec) {
178  if (O.is64Bit()) {
179  MachO::section_64 Sect = O.getSection64(Sec);
180  return Sect.flags;
181  }
182  MachO::section Sect = O.getSection(Sec);
183  return Sect.flags;
184 }
185 
187 getLoadCommandInfo(const MachOObjectFile &Obj, const char *Ptr,
188  uint32_t LoadCommandIndex) {
189  if (auto CmdOrErr = getStructOrErr<MachO::load_command>(Obj, Ptr)) {
190  if (CmdOrErr->cmdsize + Ptr > Obj.getData().end())
191  return malformedError("load command " + Twine(LoadCommandIndex) +
192  " extends past end of file");
193  if (CmdOrErr->cmdsize < 8)
194  return malformedError("load command " + Twine(LoadCommandIndex) +
195  " with size less than 8 bytes");
196  return MachOObjectFile::LoadCommandInfo({Ptr, *CmdOrErr});
197  } else
198  return CmdOrErr.takeError();
199 }
200 
202 getFirstLoadCommandInfo(const MachOObjectFile &Obj) {
203  unsigned HeaderSize = Obj.is64Bit() ? sizeof(MachO::mach_header_64)
204  : sizeof(MachO::mach_header);
205  if (sizeof(MachO::load_command) > Obj.getHeader().sizeofcmds)
206  return malformedError("load command 0 extends past the end all load "
207  "commands in the file");
208  return getLoadCommandInfo(Obj, getPtr(Obj, HeaderSize), 0);
209 }
210 
212 getNextLoadCommandInfo(const MachOObjectFile &Obj, uint32_t LoadCommandIndex,
213  const MachOObjectFile::LoadCommandInfo &L) {
214  unsigned HeaderSize = Obj.is64Bit() ? sizeof(MachO::mach_header_64)
215  : sizeof(MachO::mach_header);
216  if (L.Ptr + L.C.cmdsize + sizeof(MachO::load_command) >
217  Obj.getData().data() + HeaderSize + Obj.getHeader().sizeofcmds)
218  return malformedError("load command " + Twine(LoadCommandIndex + 1) +
219  " extends past the end all load commands in the file");
220  return getLoadCommandInfo(Obj, L.Ptr + L.C.cmdsize, LoadCommandIndex + 1);
221 }
222 
223 template <typename T>
224 static void parseHeader(const MachOObjectFile &Obj, T &Header,
225  Error &Err) {
226  if (sizeof(T) > Obj.getData().size()) {
227  Err = malformedError("the mach header extends past the end of the "
228  "file");
229  return;
230  }
231  if (auto HeaderOrErr = getStructOrErr<T>(Obj, getPtr(Obj, 0)))
232  Header = *HeaderOrErr;
233  else
234  Err = HeaderOrErr.takeError();
235 }
236 
237 // This is used to check for overlapping of Mach-O elements.
238 struct MachOElement {
239  uint64_t Offset;
240  uint64_t Size;
241  const char *Name;
242 };
243 
244 static Error checkOverlappingElement(std::list<MachOElement> &Elements,
245  uint64_t Offset, uint64_t Size,
246  const char *Name) {
247  if (Size == 0)
248  return Error::success();
249 
250  for (auto it=Elements.begin() ; it != Elements.end(); ++it) {
251  auto E = *it;
252  if ((Offset >= E.Offset && Offset < E.Offset + E.Size) ||
253  (Offset + Size > E.Offset && Offset + Size < E.Offset + E.Size) ||
254  (Offset <= E.Offset && Offset + Size >= E.Offset + E.Size))
255  return malformedError(Twine(Name) + " at offset " + Twine(Offset) +
256  " with a size of " + Twine(Size) + ", overlaps " +
257  E.Name + " at offset " + Twine(E.Offset) + " with "
258  "a size of " + Twine(E.Size));
259  auto nt = it;
260  nt++;
261  if (nt != Elements.end()) {
262  auto N = *nt;
263  if (Offset + Size <= N.Offset) {
264  Elements.insert(nt, {Offset, Size, Name});
265  return Error::success();
266  }
267  }
268  }
269  Elements.push_back({Offset, Size, Name});
270  return Error::success();
271 }
272 
273 // Parses LC_SEGMENT or LC_SEGMENT_64 load command, adds addresses of all
274 // sections to \param Sections, and optionally sets
275 // \param IsPageZeroSegment to true.
276 template <typename Segment, typename Section>
278  const MachOObjectFile &Obj, const MachOObjectFile::LoadCommandInfo &Load,
279  SmallVectorImpl<const char *> &Sections, bool &IsPageZeroSegment,
280  uint32_t LoadCommandIndex, const char *CmdName, uint64_t SizeOfHeaders,
281  std::list<MachOElement> &Elements) {
282  const unsigned SegmentLoadSize = sizeof(Segment);
283  if (Load.C.cmdsize < SegmentLoadSize)
284  return malformedError("load command " + Twine(LoadCommandIndex) +
285  " " + CmdName + " cmdsize too small");
286  if (auto SegOrErr = getStructOrErr<Segment>(Obj, Load.Ptr)) {
287  Segment S = SegOrErr.get();
288  const unsigned SectionSize = sizeof(Section);
289  uint64_t FileSize = Obj.getData().size();
291  S.nsects * SectionSize > Load.C.cmdsize - SegmentLoadSize)
292  return malformedError("load command " + Twine(LoadCommandIndex) +
293  " inconsistent cmdsize in " + CmdName +
294  " for the number of sections");
295  for (unsigned J = 0; J < S.nsects; ++J) {
296  const char *Sec = getSectionPtr(Obj, Load, J);
297  Sections.push_back(Sec);
298  auto SectionOrErr = getStructOrErr<Section>(Obj, Sec);
299  if (!SectionOrErr)
300  return SectionOrErr.takeError();
301  Section s = SectionOrErr.get();
302  if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
303  Obj.getHeader().filetype != MachO::MH_DSYM &&
304  s.flags != MachO::S_ZEROFILL &&
306  s.offset > FileSize)
307  return malformedError("offset field of section " + Twine(J) + " in " +
308  CmdName + " command " + Twine(LoadCommandIndex) +
309  " extends past the end of the file");
310  if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
311  Obj.getHeader().filetype != MachO::MH_DSYM &&
312  s.flags != MachO::S_ZEROFILL &&
313  s.flags != MachO::S_THREAD_LOCAL_ZEROFILL && S.fileoff == 0 &&
314  s.offset < SizeOfHeaders && s.size != 0)
315  return malformedError("offset field of section " + Twine(J) + " in " +
316  CmdName + " command " + Twine(LoadCommandIndex) +
317  " not past the headers of the file");
318  uint64_t BigSize = s.offset;
319  BigSize += s.size;
320  if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
321  Obj.getHeader().filetype != MachO::MH_DSYM &&
322  s.flags != MachO::S_ZEROFILL &&
324  BigSize > FileSize)
325  return malformedError("offset field plus size field of section " +
326  Twine(J) + " in " + CmdName + " command " +
327  Twine(LoadCommandIndex) +
328  " extends past the end of the file");
329  if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
330  Obj.getHeader().filetype != MachO::MH_DSYM &&
331  s.flags != MachO::S_ZEROFILL &&
333  s.size > S.filesize)
334  return malformedError("size field of section " +
335  Twine(J) + " in " + CmdName + " command " +
336  Twine(LoadCommandIndex) +
337  " greater than the segment");
338  if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
339  Obj.getHeader().filetype != MachO::MH_DSYM && s.size != 0 &&
340  s.addr < S.vmaddr)
341  return malformedError("addr field of section " + Twine(J) + " in " +
342  CmdName + " command " + Twine(LoadCommandIndex) +
343  " less than the segment's vmaddr");
344  BigSize = s.addr;
345  BigSize += s.size;
346  uint64_t BigEnd = S.vmaddr;
347  BigEnd += S.vmsize;
348  if (S.vmsize != 0 && s.size != 0 && BigSize > BigEnd)
349  return malformedError("addr field plus size of section " + Twine(J) +
350  " in " + CmdName + " command " +
351  Twine(LoadCommandIndex) +
352  " greater than than "
353  "the segment's vmaddr plus vmsize");
354  if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
355  Obj.getHeader().filetype != MachO::MH_DSYM &&
356  s.flags != MachO::S_ZEROFILL &&
358  if (Error Err = checkOverlappingElement(Elements, s.offset, s.size,
359  "section contents"))
360  return Err;
361  if (s.reloff > FileSize)
362  return malformedError("reloff field of section " + Twine(J) + " in " +
363  CmdName + " command " + Twine(LoadCommandIndex) +
364  " extends past the end of the file");
365  BigSize = s.nreloc;
366  BigSize *= sizeof(struct MachO::relocation_info);
367  BigSize += s.reloff;
368  if (BigSize > FileSize)
369  return malformedError("reloff field plus nreloc field times sizeof("
370  "struct relocation_info) of section " +
371  Twine(J) + " in " + CmdName + " command " +
372  Twine(LoadCommandIndex) +
373  " extends past the end of the file");
374  if (Error Err = checkOverlappingElement(Elements, s.reloff, s.nreloc *
375  sizeof(struct
377  "section relocation entries"))
378  return Err;
379  }
380  if (S.fileoff > FileSize)
381  return malformedError("load command " + Twine(LoadCommandIndex) +
382  " fileoff field in " + CmdName +
383  " extends past the end of the file");
384  uint64_t BigSize = S.fileoff;
385  BigSize += S.filesize;
386  if (BigSize > FileSize)
387  return malformedError("load command " + Twine(LoadCommandIndex) +
388  " fileoff field plus filesize field in " +
389  CmdName + " extends past the end of the file");
390  if (S.vmsize != 0 && S.filesize > S.vmsize)
391  return malformedError("load command " + Twine(LoadCommandIndex) +
392  " filesize field in " + CmdName +
393  " greater than vmsize field");
394  IsPageZeroSegment |= StringRef("__PAGEZERO").equals(S.segname);
395  } else
396  return SegOrErr.takeError();
397 
398  return Error::success();
399 }
400 
401 static Error checkSymtabCommand(const MachOObjectFile &Obj,
402  const MachOObjectFile::LoadCommandInfo &Load,
403  uint32_t LoadCommandIndex,
404  const char **SymtabLoadCmd,
405  std::list<MachOElement> &Elements) {
406  if (Load.C.cmdsize < sizeof(MachO::symtab_command))
407  return malformedError("load command " + Twine(LoadCommandIndex) +
408  " LC_SYMTAB cmdsize too small");
409  if (*SymtabLoadCmd != nullptr)
410  return malformedError("more than one LC_SYMTAB command");
411  auto SymtabOrErr = getStructOrErr<MachO::symtab_command>(Obj, Load.Ptr);
412  if (!SymtabOrErr)
413  return SymtabOrErr.takeError();
414  MachO::symtab_command Symtab = SymtabOrErr.get();
415  if (Symtab.cmdsize != sizeof(MachO::symtab_command))
416  return malformedError("LC_SYMTAB command " + Twine(LoadCommandIndex) +
417  " has incorrect cmdsize");
418  uint64_t FileSize = Obj.getData().size();
419  if (Symtab.symoff > FileSize)
420  return malformedError("symoff field of LC_SYMTAB command " +
421  Twine(LoadCommandIndex) + " extends past the end "
422  "of the file");
423  uint64_t SymtabSize = Symtab.nsyms;
424  const char *struct_nlist_name;
425  if (Obj.is64Bit()) {
426  SymtabSize *= sizeof(MachO::nlist_64);
427  struct_nlist_name = "struct nlist_64";
428  } else {
429  SymtabSize *= sizeof(MachO::nlist);
430  struct_nlist_name = "struct nlist";
431  }
432  uint64_t BigSize = SymtabSize;
433  BigSize += Symtab.symoff;
434  if (BigSize > FileSize)
435  return malformedError("symoff field plus nsyms field times sizeof(" +
436  Twine(struct_nlist_name) + ") of LC_SYMTAB command " +
437  Twine(LoadCommandIndex) + " extends past the end "
438  "of the file");
439  if (Error Err = checkOverlappingElement(Elements, Symtab.symoff, SymtabSize,
440  "symbol table"))
441  return Err;
442  if (Symtab.stroff > FileSize)
443  return malformedError("stroff field of LC_SYMTAB command " +
444  Twine(LoadCommandIndex) + " extends past the end "
445  "of the file");
446  BigSize = Symtab.stroff;
447  BigSize += Symtab.strsize;
448  if (BigSize > FileSize)
449  return malformedError("stroff field plus strsize field of LC_SYMTAB "
450  "command " + Twine(LoadCommandIndex) + " extends "
451  "past the end of the file");
452  if (Error Err = checkOverlappingElement(Elements, Symtab.stroff,
453  Symtab.strsize, "string table"))
454  return Err;
455  *SymtabLoadCmd = Load.Ptr;
456  return Error::success();
457 }
458 
459 static Error checkDysymtabCommand(const MachOObjectFile &Obj,
460  const MachOObjectFile::LoadCommandInfo &Load,
461  uint32_t LoadCommandIndex,
462  const char **DysymtabLoadCmd,
463  std::list<MachOElement> &Elements) {
464  if (Load.C.cmdsize < sizeof(MachO::dysymtab_command))
465  return malformedError("load command " + Twine(LoadCommandIndex) +
466  " LC_DYSYMTAB cmdsize too small");
467  if (*DysymtabLoadCmd != nullptr)
468  return malformedError("more than one LC_DYSYMTAB command");
469  auto DysymtabOrErr =
470  getStructOrErr<MachO::dysymtab_command>(Obj, Load.Ptr);
471  if (!DysymtabOrErr)
472  return DysymtabOrErr.takeError();
473  MachO::dysymtab_command Dysymtab = DysymtabOrErr.get();
474  if (Dysymtab.cmdsize != sizeof(MachO::dysymtab_command))
475  return malformedError("LC_DYSYMTAB command " + Twine(LoadCommandIndex) +
476  " has incorrect cmdsize");
477  uint64_t FileSize = Obj.getData().size();
478  if (Dysymtab.tocoff > FileSize)
479  return malformedError("tocoff field of LC_DYSYMTAB command " +
480  Twine(LoadCommandIndex) + " extends past the end of "
481  "the file");
482  uint64_t BigSize = Dysymtab.ntoc;
483  BigSize *= sizeof(MachO::dylib_table_of_contents);
484  BigSize += Dysymtab.tocoff;
485  if (BigSize > FileSize)
486  return malformedError("tocoff field plus ntoc field times sizeof(struct "
487  "dylib_table_of_contents) of LC_DYSYMTAB command " +
488  Twine(LoadCommandIndex) + " extends past the end of "
489  "the file");
490  if (Error Err = checkOverlappingElement(Elements, Dysymtab.tocoff,
491  Dysymtab.ntoc * sizeof(struct
493  "table of contents"))
494  return Err;
495  if (Dysymtab.modtaboff > FileSize)
496  return malformedError("modtaboff field of LC_DYSYMTAB command " +
497  Twine(LoadCommandIndex) + " extends past the end of "
498  "the file");
499  BigSize = Dysymtab.nmodtab;
500  const char *struct_dylib_module_name;
501  uint64_t sizeof_modtab;
502  if (Obj.is64Bit()) {
503  sizeof_modtab = sizeof(MachO::dylib_module_64);
504  struct_dylib_module_name = "struct dylib_module_64";
505  } else {
506  sizeof_modtab = sizeof(MachO::dylib_module);
507  struct_dylib_module_name = "struct dylib_module";
508  }
509  BigSize *= sizeof_modtab;
510  BigSize += Dysymtab.modtaboff;
511  if (BigSize > FileSize)
512  return malformedError("modtaboff field plus nmodtab field times sizeof(" +
513  Twine(struct_dylib_module_name) + ") of LC_DYSYMTAB "
514  "command " + Twine(LoadCommandIndex) + " extends "
515  "past the end of the file");
516  if (Error Err = checkOverlappingElement(Elements, Dysymtab.modtaboff,
517  Dysymtab.nmodtab * sizeof_modtab,
518  "module table"))
519  return Err;
520  if (Dysymtab.extrefsymoff > FileSize)
521  return malformedError("extrefsymoff field of LC_DYSYMTAB command " +
522  Twine(LoadCommandIndex) + " extends past the end of "
523  "the file");
524  BigSize = Dysymtab.nextrefsyms;
525  BigSize *= sizeof(MachO::dylib_reference);
526  BigSize += Dysymtab.extrefsymoff;
527  if (BigSize > FileSize)
528  return malformedError("extrefsymoff field plus nextrefsyms field times "
529  "sizeof(struct dylib_reference) of LC_DYSYMTAB "
530  "command " + Twine(LoadCommandIndex) + " extends "
531  "past the end of the file");
532  if (Error Err = checkOverlappingElement(Elements, Dysymtab.extrefsymoff,
533  Dysymtab.nextrefsyms *
534  sizeof(MachO::dylib_reference),
535  "reference table"))
536  return Err;
537  if (Dysymtab.indirectsymoff > FileSize)
538  return malformedError("indirectsymoff field of LC_DYSYMTAB command " +
539  Twine(LoadCommandIndex) + " extends past the end of "
540  "the file");
541  BigSize = Dysymtab.nindirectsyms;
542  BigSize *= sizeof(uint32_t);
543  BigSize += Dysymtab.indirectsymoff;
544  if (BigSize > FileSize)
545  return malformedError("indirectsymoff field plus nindirectsyms field times "
546  "sizeof(uint32_t) of LC_DYSYMTAB command " +
547  Twine(LoadCommandIndex) + " extends past the end of "
548  "the file");
549  if (Error Err = checkOverlappingElement(Elements, Dysymtab.indirectsymoff,
550  Dysymtab.nindirectsyms *
551  sizeof(uint32_t),
552  "indirect table"))
553  return Err;
554  if (Dysymtab.extreloff > FileSize)
555  return malformedError("extreloff field of LC_DYSYMTAB command " +
556  Twine(LoadCommandIndex) + " extends past the end of "
557  "the file");
558  BigSize = Dysymtab.nextrel;
559  BigSize *= sizeof(MachO::relocation_info);
560  BigSize += Dysymtab.extreloff;
561  if (BigSize > FileSize)
562  return malformedError("extreloff field plus nextrel field times sizeof"
563  "(struct relocation_info) of LC_DYSYMTAB command " +
564  Twine(LoadCommandIndex) + " extends past the end of "
565  "the file");
566  if (Error Err = checkOverlappingElement(Elements, Dysymtab.extreloff,
567  Dysymtab.nextrel *
568  sizeof(MachO::relocation_info),
569  "external relocation table"))
570  return Err;
571  if (Dysymtab.locreloff > FileSize)
572  return malformedError("locreloff field of LC_DYSYMTAB command " +
573  Twine(LoadCommandIndex) + " extends past the end of "
574  "the file");
575  BigSize = Dysymtab.nlocrel;
576  BigSize *= sizeof(MachO::relocation_info);
577  BigSize += Dysymtab.locreloff;
578  if (BigSize > FileSize)
579  return malformedError("locreloff field plus nlocrel field times sizeof"
580  "(struct relocation_info) of LC_DYSYMTAB command " +
581  Twine(LoadCommandIndex) + " extends past the end of "
582  "the file");
583  if (Error Err = checkOverlappingElement(Elements, Dysymtab.locreloff,
584  Dysymtab.nlocrel *
585  sizeof(MachO::relocation_info),
586  "local relocation table"))
587  return Err;
588  *DysymtabLoadCmd = Load.Ptr;
589  return Error::success();
590 }
591 
592 static Error checkLinkeditDataCommand(const MachOObjectFile &Obj,
593  const MachOObjectFile::LoadCommandInfo &Load,
594  uint32_t LoadCommandIndex,
595  const char **LoadCmd, const char *CmdName,
596  std::list<MachOElement> &Elements,
597  const char *ElementName) {
598  if (Load.C.cmdsize < sizeof(MachO::linkedit_data_command))
599  return malformedError("load command " + Twine(LoadCommandIndex) + " " +
600  CmdName + " cmdsize too small");
601  if (*LoadCmd != nullptr)
602  return malformedError("more than one " + Twine(CmdName) + " command");
603  auto LinkDataOrError =
604  getStructOrErr<MachO::linkedit_data_command>(Obj, Load.Ptr);
605  if (!LinkDataOrError)
606  return LinkDataOrError.takeError();
607  MachO::linkedit_data_command LinkData = LinkDataOrError.get();
608  if (LinkData.cmdsize != sizeof(MachO::linkedit_data_command))
609  return malformedError(Twine(CmdName) + " command " +
610  Twine(LoadCommandIndex) + " has incorrect cmdsize");
611  uint64_t FileSize = Obj.getData().size();
612  if (LinkData.dataoff > FileSize)
613  return malformedError("dataoff field of " + Twine(CmdName) + " command " +
614  Twine(LoadCommandIndex) + " extends past the end of "
615  "the file");
616  uint64_t BigSize = LinkData.dataoff;
617  BigSize += LinkData.datasize;
618  if (BigSize > FileSize)
619  return malformedError("dataoff field plus datasize field of " +
620  Twine(CmdName) + " command " +
621  Twine(LoadCommandIndex) + " extends past the end of "
622  "the file");
623  if (Error Err = checkOverlappingElement(Elements, LinkData.dataoff,
624  LinkData.datasize, ElementName))
625  return Err;
626  *LoadCmd = Load.Ptr;
627  return Error::success();
628 }
629 
630 static Error checkDyldInfoCommand(const MachOObjectFile &Obj,
631  const MachOObjectFile::LoadCommandInfo &Load,
632  uint32_t LoadCommandIndex,
633  const char **LoadCmd, const char *CmdName,
634  std::list<MachOElement> &Elements) {
635  if (Load.C.cmdsize < sizeof(MachO::dyld_info_command))
636  return malformedError("load command " + Twine(LoadCommandIndex) + " " +
637  CmdName + " cmdsize too small");
638  if (*LoadCmd != nullptr)
639  return malformedError("more than one LC_DYLD_INFO and or LC_DYLD_INFO_ONLY "
640  "command");
641  auto DyldInfoOrErr =
642  getStructOrErr<MachO::dyld_info_command>(Obj, Load.Ptr);
643  if (!DyldInfoOrErr)
644  return DyldInfoOrErr.takeError();
645  MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
646  if (DyldInfo.cmdsize != sizeof(MachO::dyld_info_command))
647  return malformedError(Twine(CmdName) + " command " +
648  Twine(LoadCommandIndex) + " has incorrect cmdsize");
649  uint64_t FileSize = Obj.getData().size();
650  if (DyldInfo.rebase_off > FileSize)
651  return malformedError("rebase_off field of " + Twine(CmdName) +
652  " command " + Twine(LoadCommandIndex) + " extends "
653  "past the end of the file");
654  uint64_t BigSize = DyldInfo.rebase_off;
655  BigSize += DyldInfo.rebase_size;
656  if (BigSize > FileSize)
657  return malformedError("rebase_off field plus rebase_size field of " +
658  Twine(CmdName) + " command " +
659  Twine(LoadCommandIndex) + " extends past the end of "
660  "the file");
661  if (Error Err = checkOverlappingElement(Elements, DyldInfo.rebase_off,
662  DyldInfo.rebase_size,
663  "dyld rebase info"))
664  return Err;
665  if (DyldInfo.bind_off > FileSize)
666  return malformedError("bind_off field of " + Twine(CmdName) +
667  " command " + Twine(LoadCommandIndex) + " extends "
668  "past the end of the file");
669  BigSize = DyldInfo.bind_off;
670  BigSize += DyldInfo.bind_size;
671  if (BigSize > FileSize)
672  return malformedError("bind_off field plus bind_size field of " +
673  Twine(CmdName) + " command " +
674  Twine(LoadCommandIndex) + " extends past the end of "
675  "the file");
676  if (Error Err = checkOverlappingElement(Elements, DyldInfo.bind_off,
677  DyldInfo.bind_size,
678  "dyld bind info"))
679  return Err;
680  if (DyldInfo.weak_bind_off > FileSize)
681  return malformedError("weak_bind_off field of " + Twine(CmdName) +
682  " command " + Twine(LoadCommandIndex) + " extends "
683  "past the end of the file");
684  BigSize = DyldInfo.weak_bind_off;
685  BigSize += DyldInfo.weak_bind_size;
686  if (BigSize > FileSize)
687  return malformedError("weak_bind_off field plus weak_bind_size field of " +
688  Twine(CmdName) + " command " +
689  Twine(LoadCommandIndex) + " extends past the end of "
690  "the file");
691  if (Error Err = checkOverlappingElement(Elements, DyldInfo.weak_bind_off,
692  DyldInfo.weak_bind_size,
693  "dyld weak bind info"))
694  return Err;
695  if (DyldInfo.lazy_bind_off > FileSize)
696  return malformedError("lazy_bind_off field of " + Twine(CmdName) +
697  " command " + Twine(LoadCommandIndex) + " extends "
698  "past the end of the file");
699  BigSize = DyldInfo.lazy_bind_off;
700  BigSize += DyldInfo.lazy_bind_size;
701  if (BigSize > FileSize)
702  return malformedError("lazy_bind_off field plus lazy_bind_size field of " +
703  Twine(CmdName) + " command " +
704  Twine(LoadCommandIndex) + " extends past the end of "
705  "the file");
706  if (Error Err = checkOverlappingElement(Elements, DyldInfo.lazy_bind_off,
707  DyldInfo.lazy_bind_size,
708  "dyld lazy bind info"))
709  return Err;
710  if (DyldInfo.export_off > FileSize)
711  return malformedError("export_off field of " + Twine(CmdName) +
712  " command " + Twine(LoadCommandIndex) + " extends "
713  "past the end of the file");
714  BigSize = DyldInfo.export_off;
715  BigSize += DyldInfo.export_size;
716  if (BigSize > FileSize)
717  return malformedError("export_off field plus export_size field of " +
718  Twine(CmdName) + " command " +
719  Twine(LoadCommandIndex) + " extends past the end of "
720  "the file");
721  if (Error Err = checkOverlappingElement(Elements, DyldInfo.export_off,
722  DyldInfo.export_size,
723  "dyld export info"))
724  return Err;
725  *LoadCmd = Load.Ptr;
726  return Error::success();
727 }
728 
729 static Error checkDylibCommand(const MachOObjectFile &Obj,
730  const MachOObjectFile::LoadCommandInfo &Load,
731  uint32_t LoadCommandIndex, const char *CmdName) {
732  if (Load.C.cmdsize < sizeof(MachO::dylib_command))
733  return malformedError("load command " + Twine(LoadCommandIndex) + " " +
734  CmdName + " cmdsize too small");
735  auto CommandOrErr = getStructOrErr<MachO::dylib_command>(Obj, Load.Ptr);
736  if (!CommandOrErr)
737  return CommandOrErr.takeError();
738  MachO::dylib_command D = CommandOrErr.get();
739  if (D.dylib.name < sizeof(MachO::dylib_command))
740  return malformedError("load command " + Twine(LoadCommandIndex) + " " +
741  CmdName + " name.offset field too small, not past "
742  "the end of the dylib_command struct");
743  if (D.dylib.name >= D.cmdsize)
744  return malformedError("load command " + Twine(LoadCommandIndex) + " " +
745  CmdName + " name.offset field extends past the end "
746  "of the load command");
747  // Make sure there is a null between the starting offset of the name and
748  // the end of the load command.
749  uint32_t i;
750  const char *P = (const char *)Load.Ptr;
751  for (i = D.dylib.name; i < D.cmdsize; i++)
752  if (P[i] == '\0')
753  break;
754  if (i >= D.cmdsize)
755  return malformedError("load command " + Twine(LoadCommandIndex) + " " +
756  CmdName + " library name extends past the end of the "
757  "load command");
758  return Error::success();
759 }
760 
761 static Error checkDylibIdCommand(const MachOObjectFile &Obj,
762  const MachOObjectFile::LoadCommandInfo &Load,
763  uint32_t LoadCommandIndex,
764  const char **LoadCmd) {
765  if (Error Err = checkDylibCommand(Obj, Load, LoadCommandIndex,
766  "LC_ID_DYLIB"))
767  return Err;
768  if (*LoadCmd != nullptr)
769  return malformedError("more than one LC_ID_DYLIB command");
770  if (Obj.getHeader().filetype != MachO::MH_DYLIB &&
771  Obj.getHeader().filetype != MachO::MH_DYLIB_STUB)
772  return malformedError("LC_ID_DYLIB load command in non-dynamic library "
773  "file type");
774  *LoadCmd = Load.Ptr;
775  return Error::success();
776 }
777 
778 static Error checkDyldCommand(const MachOObjectFile &Obj,
779  const MachOObjectFile::LoadCommandInfo &Load,
780  uint32_t LoadCommandIndex, const char *CmdName) {
781  if (Load.C.cmdsize < sizeof(MachO::dylinker_command))
782  return malformedError("load command " + Twine(LoadCommandIndex) + " " +
783  CmdName + " cmdsize too small");
784  auto CommandOrErr = getStructOrErr<MachO::dylinker_command>(Obj, Load.Ptr);
785  if (!CommandOrErr)
786  return CommandOrErr.takeError();
787  MachO::dylinker_command D = CommandOrErr.get();
788  if (D.name < sizeof(MachO::dylinker_command))
789  return malformedError("load command " + Twine(LoadCommandIndex) + " " +
790  CmdName + " name.offset field too small, not past "
791  "the end of the dylinker_command struct");
792  if (D.name >= D.cmdsize)
793  return malformedError("load command " + Twine(LoadCommandIndex) + " " +
794  CmdName + " name.offset field extends past the end "
795  "of the load command");
796  // Make sure there is a null between the starting offset of the name and
797  // the end of the load command.
798  uint32_t i;
799  const char *P = (const char *)Load.Ptr;
800  for (i = D.name; i < D.cmdsize; i++)
801  if (P[i] == '\0')
802  break;
803  if (i >= D.cmdsize)
804  return malformedError("load command " + Twine(LoadCommandIndex) + " " +
805  CmdName + " dyld name extends past the end of the "
806  "load command");
807  return Error::success();
808 }
809 
810 static Error checkVersCommand(const MachOObjectFile &Obj,
811  const MachOObjectFile::LoadCommandInfo &Load,
812  uint32_t LoadCommandIndex,
813  const char **LoadCmd, const char *CmdName) {
814  if (Load.C.cmdsize != sizeof(MachO::version_min_command))
815  return malformedError("load command " + Twine(LoadCommandIndex) + " " +
816  CmdName + " has incorrect cmdsize");
817  if (*LoadCmd != nullptr)
818  return malformedError("more than one LC_VERSION_MIN_MACOSX, "
819  "LC_VERSION_MIN_IPHONEOS, LC_VERSION_MIN_TVOS or "
820  "LC_VERSION_MIN_WATCHOS command");
821  *LoadCmd = Load.Ptr;
822  return Error::success();
823 }
824 
825 static Error checkNoteCommand(const MachOObjectFile &Obj,
826  const MachOObjectFile::LoadCommandInfo &Load,
827  uint32_t LoadCommandIndex,
828  std::list<MachOElement> &Elements) {
829  if (Load.C.cmdsize != sizeof(MachO::note_command))
830  return malformedError("load command " + Twine(LoadCommandIndex) +
831  " LC_NOTE has incorrect cmdsize");
832  auto NoteCmdOrErr = getStructOrErr<MachO::note_command>(Obj, Load.Ptr);
833  if (!NoteCmdOrErr)
834  return NoteCmdOrErr.takeError();
835  MachO::note_command Nt = NoteCmdOrErr.get();
836  uint64_t FileSize = Obj.getData().size();
837  if (Nt.offset > FileSize)
838  return malformedError("offset field of LC_NOTE command " +
839  Twine(LoadCommandIndex) + " extends "
840  "past the end of the file");
841  uint64_t BigSize = Nt.offset;
842  BigSize += Nt.size;
843  if (BigSize > FileSize)
844  return malformedError("size field plus offset field of LC_NOTE command " +
845  Twine(LoadCommandIndex) + " extends past the end of "
846  "the file");
847  if (Error Err = checkOverlappingElement(Elements, Nt.offset, Nt.size,
848  "LC_NOTE data"))
849  return Err;
850  return Error::success();
851 }
852 
853 static Error
854 parseBuildVersionCommand(const MachOObjectFile &Obj,
855  const MachOObjectFile::LoadCommandInfo &Load,
856  SmallVectorImpl<const char*> &BuildTools,
857  uint32_t LoadCommandIndex) {
858  auto BVCOrErr =
859  getStructOrErr<MachO::build_version_command>(Obj, Load.Ptr);
860  if (!BVCOrErr)
861  return BVCOrErr.takeError();
862  MachO::build_version_command BVC = BVCOrErr.get();
863  if (Load.C.cmdsize !=
865  BVC.ntools * sizeof(MachO::build_tool_version))
866  return malformedError("load command " + Twine(LoadCommandIndex) +
867  " LC_BUILD_VERSION_COMMAND has incorrect cmdsize");
868 
869  auto Start = Load.Ptr + sizeof(MachO::build_version_command);
870  BuildTools.resize(BVC.ntools);
871  for (unsigned i = 0; i < BVC.ntools; ++i)
872  BuildTools[i] = Start + i * sizeof(MachO::build_tool_version);
873 
874  return Error::success();
875 }
876 
877 static Error checkRpathCommand(const MachOObjectFile &Obj,
878  const MachOObjectFile::LoadCommandInfo &Load,
879  uint32_t LoadCommandIndex) {
880  if (Load.C.cmdsize < sizeof(MachO::rpath_command))
881  return malformedError("load command " + Twine(LoadCommandIndex) +
882  " LC_RPATH cmdsize too small");
883  auto ROrErr = getStructOrErr<MachO::rpath_command>(Obj, Load.Ptr);
884  if (!ROrErr)
885  return ROrErr.takeError();
886  MachO::rpath_command R = ROrErr.get();
887  if (R.path < sizeof(MachO::rpath_command))
888  return malformedError("load command " + Twine(LoadCommandIndex) +
889  " LC_RPATH path.offset field too small, not past "
890  "the end of the rpath_command struct");
891  if (R.path >= R.cmdsize)
892  return malformedError("load command " + Twine(LoadCommandIndex) +
893  " LC_RPATH path.offset field extends past the end "
894  "of the load command");
895  // Make sure there is a null between the starting offset of the path and
896  // the end of the load command.
897  uint32_t i;
898  const char *P = (const char *)Load.Ptr;
899  for (i = R.path; i < R.cmdsize; i++)
900  if (P[i] == '\0')
901  break;
902  if (i >= R.cmdsize)
903  return malformedError("load command " + Twine(LoadCommandIndex) +
904  " LC_RPATH library name extends past the end of the "
905  "load command");
906  return Error::success();
907 }
908 
909 static Error checkEncryptCommand(const MachOObjectFile &Obj,
910  const MachOObjectFile::LoadCommandInfo &Load,
911  uint32_t LoadCommandIndex,
912  uint64_t cryptoff, uint64_t cryptsize,
913  const char **LoadCmd, const char *CmdName) {
914  if (*LoadCmd != nullptr)
915  return malformedError("more than one LC_ENCRYPTION_INFO and or "
916  "LC_ENCRYPTION_INFO_64 command");
917  uint64_t FileSize = Obj.getData().size();
918  if (cryptoff > FileSize)
919  return malformedError("cryptoff field of " + Twine(CmdName) +
920  " command " + Twine(LoadCommandIndex) + " extends "
921  "past the end of the file");
922  uint64_t BigSize = cryptoff;
923  BigSize += cryptsize;
924  if (BigSize > FileSize)
925  return malformedError("cryptoff field plus cryptsize field of " +
926  Twine(CmdName) + " command " +
927  Twine(LoadCommandIndex) + " extends past the end of "
928  "the file");
929  *LoadCmd = Load.Ptr;
930  return Error::success();
931 }
932 
933 static Error checkLinkerOptCommand(const MachOObjectFile &Obj,
934  const MachOObjectFile::LoadCommandInfo &Load,
935  uint32_t LoadCommandIndex) {
936  if (Load.C.cmdsize < sizeof(MachO::linker_option_command))
937  return malformedError("load command " + Twine(LoadCommandIndex) +
938  " LC_LINKER_OPTION cmdsize too small");
939  auto LinkOptionOrErr =
940  getStructOrErr<MachO::linker_option_command>(Obj, Load.Ptr);
941  if (!LinkOptionOrErr)
942  return LinkOptionOrErr.takeError();
943  MachO::linker_option_command L = LinkOptionOrErr.get();
944  // Make sure the count of strings is correct.
945  const char *string = (const char *)Load.Ptr +
946  sizeof(struct MachO::linker_option_command);
947  uint32_t left = L.cmdsize - sizeof(struct MachO::linker_option_command);
948  uint32_t i = 0;
949  while (left > 0) {
950  while (*string == '\0' && left > 0) {
951  string++;
952  left--;
953  }
954  if (left > 0) {
955  i++;
956  uint32_t NullPos = StringRef(string, left).find('\0');
957  if (0xffffffff == NullPos)
958  return malformedError("load command " + Twine(LoadCommandIndex) +
959  " LC_LINKER_OPTION string #" + Twine(i) +
960  " is not NULL terminated");
961  uint32_t len = std::min(NullPos, left) + 1;
962  string += len;
963  left -= len;
964  }
965  }
966  if (L.count != i)
967  return malformedError("load command " + Twine(LoadCommandIndex) +
968  " LC_LINKER_OPTION string count " + Twine(L.count) +
969  " does not match number of strings");
970  return Error::success();
971 }
972 
973 static Error checkSubCommand(const MachOObjectFile &Obj,
974  const MachOObjectFile::LoadCommandInfo &Load,
975  uint32_t LoadCommandIndex, const char *CmdName,
976  size_t SizeOfCmd, const char *CmdStructName,
977  uint32_t PathOffset, const char *PathFieldName) {
978  if (PathOffset < SizeOfCmd)
979  return malformedError("load command " + Twine(LoadCommandIndex) + " " +
980  CmdName + " " + PathFieldName + ".offset field too "
981  "small, not past the end of the " + CmdStructName);
982  if (PathOffset >= Load.C.cmdsize)
983  return malformedError("load command " + Twine(LoadCommandIndex) + " " +
984  CmdName + " " + PathFieldName + ".offset field "
985  "extends past the end of the load command");
986  // Make sure there is a null between the starting offset of the path and
987  // the end of the load command.
988  uint32_t i;
989  const char *P = (const char *)Load.Ptr;
990  for (i = PathOffset; i < Load.C.cmdsize; i++)
991  if (P[i] == '\0')
992  break;
993  if (i >= Load.C.cmdsize)
994  return malformedError("load command " + Twine(LoadCommandIndex) + " " +
995  CmdName + " " + PathFieldName + " name extends past "
996  "the end of the load command");
997  return Error::success();
998 }
999 
1000 static Error checkThreadCommand(const MachOObjectFile &Obj,
1001  const MachOObjectFile::LoadCommandInfo &Load,
1002  uint32_t LoadCommandIndex,
1003  const char *CmdName) {
1004  if (Load.C.cmdsize < sizeof(MachO::thread_command))
1005  return malformedError("load command " + Twine(LoadCommandIndex) +
1006  CmdName + " cmdsize too small");
1007  auto ThreadCommandOrErr =
1008  getStructOrErr<MachO::thread_command>(Obj, Load.Ptr);
1009  if (!ThreadCommandOrErr)
1010  return ThreadCommandOrErr.takeError();
1011  MachO::thread_command T = ThreadCommandOrErr.get();
1012  const char *state = Load.Ptr + sizeof(MachO::thread_command);
1013  const char *end = Load.Ptr + T.cmdsize;
1014  uint32_t nflavor = 0;
1015  uint32_t cputype = getCPUType(Obj);
1016  while (state < end) {
1017  if(state + sizeof(uint32_t) > end)
1018  return malformedError("load command " + Twine(LoadCommandIndex) +
1019  "flavor in " + CmdName + " extends past end of "
1020  "command");
1021  uint32_t flavor;
1022  memcpy(&flavor, state, sizeof(uint32_t));
1023  if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
1024  sys::swapByteOrder(flavor);
1025  state += sizeof(uint32_t);
1026 
1027  if(state + sizeof(uint32_t) > end)
1028  return malformedError("load command " + Twine(LoadCommandIndex) +
1029  " count in " + CmdName + " extends past end of "
1030  "command");
1031  uint32_t count;
1032  memcpy(&count, state, sizeof(uint32_t));
1033  if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
1035  state += sizeof(uint32_t);
1036 
1037  if (cputype == MachO::CPU_TYPE_I386) {
1038  if (flavor == MachO::x86_THREAD_STATE32) {
1040  return malformedError("load command " + Twine(LoadCommandIndex) +
1041  " count not x86_THREAD_STATE32_COUNT for "
1042  "flavor number " + Twine(nflavor) + " which is "
1043  "a x86_THREAD_STATE32 flavor in " + CmdName +
1044  " command");
1045  if (state + sizeof(MachO::x86_thread_state32_t) > end)
1046  return malformedError("load command " + Twine(LoadCommandIndex) +
1047  " x86_THREAD_STATE32 extends past end of "
1048  "command in " + CmdName + " command");
1049  state += sizeof(MachO::x86_thread_state32_t);
1050  } else {
1051  return malformedError("load command " + Twine(LoadCommandIndex) +
1052  " unknown flavor (" + Twine(flavor) + ") for "
1053  "flavor number " + Twine(nflavor) + " in " +
1054  CmdName + " command");
1055  }
1056  } else if (cputype == MachO::CPU_TYPE_X86_64) {
1057  if (flavor == MachO::x86_THREAD_STATE) {
1059  return malformedError("load command " + Twine(LoadCommandIndex) +
1060  " count not x86_THREAD_STATE_COUNT for "
1061  "flavor number " + Twine(nflavor) + " which is "
1062  "a x86_THREAD_STATE flavor in " + CmdName +
1063  " command");
1064  if (state + sizeof(MachO::x86_thread_state_t) > end)
1065  return malformedError("load command " + Twine(LoadCommandIndex) +
1066  " x86_THREAD_STATE extends past end of "
1067  "command in " + CmdName + " command");
1068  state += sizeof(MachO::x86_thread_state_t);
1069  } else if (flavor == MachO::x86_FLOAT_STATE) {
1071  return malformedError("load command " + Twine(LoadCommandIndex) +
1072  " count not x86_FLOAT_STATE_COUNT for "
1073  "flavor number " + Twine(nflavor) + " which is "
1074  "a x86_FLOAT_STATE flavor in " + CmdName +
1075  " command");
1076  if (state + sizeof(MachO::x86_float_state_t) > end)
1077  return malformedError("load command " + Twine(LoadCommandIndex) +
1078  " x86_FLOAT_STATE extends past end of "
1079  "command in " + CmdName + " command");
1080  state += sizeof(MachO::x86_float_state_t);
1081  } else if (flavor == MachO::x86_EXCEPTION_STATE) {
1083  return malformedError("load command " + Twine(LoadCommandIndex) +
1084  " count not x86_EXCEPTION_STATE_COUNT for "
1085  "flavor number " + Twine(nflavor) + " which is "
1086  "a x86_EXCEPTION_STATE flavor in " + CmdName +
1087  " command");
1088  if (state + sizeof(MachO::x86_exception_state_t) > end)
1089  return malformedError("load command " + Twine(LoadCommandIndex) +
1090  " x86_EXCEPTION_STATE extends past end of "
1091  "command in " + CmdName + " command");
1092  state += sizeof(MachO::x86_exception_state_t);
1093  } else if (flavor == MachO::x86_THREAD_STATE64) {
1095  return malformedError("load command " + Twine(LoadCommandIndex) +
1096  " count not x86_THREAD_STATE64_COUNT for "
1097  "flavor number " + Twine(nflavor) + " which is "
1098  "a x86_THREAD_STATE64 flavor in " + CmdName +
1099  " command");
1100  if (state + sizeof(MachO::x86_thread_state64_t) > end)
1101  return malformedError("load command " + Twine(LoadCommandIndex) +
1102  " x86_THREAD_STATE64 extends past end of "
1103  "command in " + CmdName + " command");
1104  state += sizeof(MachO::x86_thread_state64_t);
1105  } else if (flavor == MachO::x86_EXCEPTION_STATE64) {
1107  return malformedError("load command " + Twine(LoadCommandIndex) +
1108  " count not x86_EXCEPTION_STATE64_COUNT for "
1109  "flavor number " + Twine(nflavor) + " which is "
1110  "a x86_EXCEPTION_STATE64 flavor in " + CmdName +
1111  " command");
1112  if (state + sizeof(MachO::x86_exception_state64_t) > end)
1113  return malformedError("load command " + Twine(LoadCommandIndex) +
1114  " x86_EXCEPTION_STATE64 extends past end of "
1115  "command in " + CmdName + " command");
1116  state += sizeof(MachO::x86_exception_state64_t);
1117  } else {
1118  return malformedError("load command " + Twine(LoadCommandIndex) +
1119  " unknown flavor (" + Twine(flavor) + ") for "
1120  "flavor number " + Twine(nflavor) + " in " +
1121  CmdName + " command");
1122  }
1123  } else if (cputype == MachO::CPU_TYPE_ARM) {
1124  if (flavor == MachO::ARM_THREAD_STATE) {
1126  return malformedError("load command " + Twine(LoadCommandIndex) +
1127  " count not ARM_THREAD_STATE_COUNT for "
1128  "flavor number " + Twine(nflavor) + " which is "
1129  "a ARM_THREAD_STATE flavor in " + CmdName +
1130  " command");
1131  if (state + sizeof(MachO::arm_thread_state32_t) > end)
1132  return malformedError("load command " + Twine(LoadCommandIndex) +
1133  " ARM_THREAD_STATE extends past end of "
1134  "command in " + CmdName + " command");
1135  state += sizeof(MachO::arm_thread_state32_t);
1136  } else {
1137  return malformedError("load command " + Twine(LoadCommandIndex) +
1138  " unknown flavor (" + Twine(flavor) + ") for "
1139  "flavor number " + Twine(nflavor) + " in " +
1140  CmdName + " command");
1141  }
1142  } else if (cputype == MachO::CPU_TYPE_ARM64 ||
1143  cputype == MachO::CPU_TYPE_ARM64_32) {
1144  if (flavor == MachO::ARM_THREAD_STATE64) {
1146  return malformedError("load command " + Twine(LoadCommandIndex) +
1147  " count not ARM_THREAD_STATE64_COUNT for "
1148  "flavor number " + Twine(nflavor) + " which is "
1149  "a ARM_THREAD_STATE64 flavor in " + CmdName +
1150  " command");
1151  if (state + sizeof(MachO::arm_thread_state64_t) > end)
1152  return malformedError("load command " + Twine(LoadCommandIndex) +
1153  " ARM_THREAD_STATE64 extends past end of "
1154  "command in " + CmdName + " command");
1155  state += sizeof(MachO::arm_thread_state64_t);
1156  } else {
1157  return malformedError("load command " + Twine(LoadCommandIndex) +
1158  " unknown flavor (" + Twine(flavor) + ") for "
1159  "flavor number " + Twine(nflavor) + " in " +
1160  CmdName + " command");
1161  }
1162  } else if (cputype == MachO::CPU_TYPE_POWERPC) {
1163  if (flavor == MachO::PPC_THREAD_STATE) {
1165  return malformedError("load command " + Twine(LoadCommandIndex) +
1166  " count not PPC_THREAD_STATE_COUNT for "
1167  "flavor number " + Twine(nflavor) + " which is "
1168  "a PPC_THREAD_STATE flavor in " + CmdName +
1169  " command");
1170  if (state + sizeof(MachO::ppc_thread_state32_t) > end)
1171  return malformedError("load command " + Twine(LoadCommandIndex) +
1172  " PPC_THREAD_STATE extends past end of "
1173  "command in " + CmdName + " command");
1174  state += sizeof(MachO::ppc_thread_state32_t);
1175  } else {
1176  return malformedError("load command " + Twine(LoadCommandIndex) +
1177  " unknown flavor (" + Twine(flavor) + ") for "
1178  "flavor number " + Twine(nflavor) + " in " +
1179  CmdName + " command");
1180  }
1181  } else {
1182  return malformedError("unknown cputype (" + Twine(cputype) + ") load "
1183  "command " + Twine(LoadCommandIndex) + " for " +
1184  CmdName + " command can't be checked");
1185  }
1186  nflavor++;
1187  }
1188  return Error::success();
1189 }
1190 
1191 static Error checkTwoLevelHintsCommand(const MachOObjectFile &Obj,
1192  const MachOObjectFile::LoadCommandInfo
1193  &Load,
1194  uint32_t LoadCommandIndex,
1195  const char **LoadCmd,
1196  std::list<MachOElement> &Elements) {
1197  if (Load.C.cmdsize != sizeof(MachO::twolevel_hints_command))
1198  return malformedError("load command " + Twine(LoadCommandIndex) +
1199  " LC_TWOLEVEL_HINTS has incorrect cmdsize");
1200  if (*LoadCmd != nullptr)
1201  return malformedError("more than one LC_TWOLEVEL_HINTS command");
1202  auto HintsOrErr = getStructOrErr<MachO::twolevel_hints_command>(Obj, Load.Ptr);
1203  if(!HintsOrErr)
1204  return HintsOrErr.takeError();
1205  MachO::twolevel_hints_command Hints = HintsOrErr.get();
1206  uint64_t FileSize = Obj.getData().size();
1207  if (Hints.offset > FileSize)
1208  return malformedError("offset field of LC_TWOLEVEL_HINTS command " +
1209  Twine(LoadCommandIndex) + " extends past the end of "
1210  "the file");
1211  uint64_t BigSize = Hints.nhints;
1212  BigSize *= sizeof(MachO::twolevel_hint);
1213  BigSize += Hints.offset;
1214  if (BigSize > FileSize)
1215  return malformedError("offset field plus nhints times sizeof(struct "
1216  "twolevel_hint) field of LC_TWOLEVEL_HINTS command " +
1217  Twine(LoadCommandIndex) + " extends past the end of "
1218  "the file");
1219  if (Error Err = checkOverlappingElement(Elements, Hints.offset, Hints.nhints *
1220  sizeof(MachO::twolevel_hint),
1221  "two level hints"))
1222  return Err;
1223  *LoadCmd = Load.Ptr;
1224  return Error::success();
1225 }
1226 
1227 // Returns true if the libObject code does not support the load command and its
1228 // contents. The cmd value it is treated as an unknown load command but with
1229 // an error message that says the cmd value is obsolete.
1231  if (cmd == MachO::LC_SYMSEG ||
1232  cmd == MachO::LC_LOADFVMLIB ||
1233  cmd == MachO::LC_IDFVMLIB ||
1234  cmd == MachO::LC_IDENT ||
1235  cmd == MachO::LC_FVMFILE ||
1236  cmd == MachO::LC_PREPAGE ||
1237  cmd == MachO::LC_PREBOUND_DYLIB ||
1238  cmd == MachO::LC_TWOLEVEL_HINTS ||
1239  cmd == MachO::LC_PREBIND_CKSUM)
1240  return true;
1241  return false;
1242 }
1243 
1245 MachOObjectFile::create(MemoryBufferRef Object, bool IsLittleEndian,
1246  bool Is64Bits, uint32_t UniversalCputype,
1247  uint32_t UniversalIndex) {
1248  Error Err = Error::success();
1249  std::unique_ptr<MachOObjectFile> Obj(
1250  new MachOObjectFile(std::move(Object), IsLittleEndian,
1251  Is64Bits, Err, UniversalCputype,
1252  UniversalIndex));
1253  if (Err)
1254  return std::move(Err);
1255  return std::move(Obj);
1256 }
1257 
1258 MachOObjectFile::MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian,
1259  bool Is64bits, Error &Err,
1260  uint32_t UniversalCputype,
1261  uint32_t UniversalIndex)
1262  : ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object) {
1263  ErrorAsOutParameter ErrAsOutParam(&Err);
1264  uint64_t SizeOfHeaders;
1265  uint32_t cputype;
1266  if (is64Bit()) {
1267  parseHeader(*this, Header64, Err);
1268  SizeOfHeaders = sizeof(MachO::mach_header_64);
1269  cputype = Header64.cputype;
1270  } else {
1271  parseHeader(*this, Header, Err);
1272  SizeOfHeaders = sizeof(MachO::mach_header);
1273  cputype = Header.cputype;
1274  }
1275  if (Err)
1276  return;
1277  SizeOfHeaders += getHeader().sizeofcmds;
1278  if (getData().data() + SizeOfHeaders > getData().end()) {
1279  Err = malformedError("load commands extend past the end of the file");
1280  return;
1281  }
1282  if (UniversalCputype != 0 && cputype != UniversalCputype) {
1283  Err = malformedError("universal header architecture: " +
1284  Twine(UniversalIndex) + "'s cputype does not match "
1285  "object file's mach header");
1286  return;
1287  }
1288  std::list<MachOElement> Elements;
1289  Elements.push_back({0, SizeOfHeaders, "Mach-O headers"});
1290 
1291  uint32_t LoadCommandCount = getHeader().ncmds;
1292  LoadCommandInfo Load;
1293  if (LoadCommandCount != 0) {
1294  if (auto LoadOrErr = getFirstLoadCommandInfo(*this))
1295  Load = *LoadOrErr;
1296  else {
1297  Err = LoadOrErr.takeError();
1298  return;
1299  }
1300  }
1301 
1302  const char *DyldIdLoadCmd = nullptr;
1303  const char *FuncStartsLoadCmd = nullptr;
1304  const char *SplitInfoLoadCmd = nullptr;
1305  const char *CodeSignDrsLoadCmd = nullptr;
1306  const char *CodeSignLoadCmd = nullptr;
1307  const char *VersLoadCmd = nullptr;
1308  const char *SourceLoadCmd = nullptr;
1309  const char *EntryPointLoadCmd = nullptr;
1310  const char *EncryptLoadCmd = nullptr;
1311  const char *RoutinesLoadCmd = nullptr;
1312  const char *UnixThreadLoadCmd = nullptr;
1313  const char *TwoLevelHintsLoadCmd = nullptr;
1314  for (unsigned I = 0; I < LoadCommandCount; ++I) {
1315  if (is64Bit()) {
1316  if (Load.C.cmdsize % 8 != 0) {
1317  // We have a hack here to allow 64-bit Mach-O core files to have
1318  // LC_THREAD commands that are only a multiple of 4 and not 8 to be
1319  // allowed since the macOS kernel produces them.
1320  if (getHeader().filetype != MachO::MH_CORE ||
1321  Load.C.cmd != MachO::LC_THREAD || Load.C.cmdsize % 4) {
1322  Err = malformedError("load command " + Twine(I) + " cmdsize not a "
1323  "multiple of 8");
1324  return;
1325  }
1326  }
1327  } else {
1328  if (Load.C.cmdsize % 4 != 0) {
1329  Err = malformedError("load command " + Twine(I) + " cmdsize not a "
1330  "multiple of 4");
1331  return;
1332  }
1333  }
1334  LoadCommands.push_back(Load);
1335  if (Load.C.cmd == MachO::LC_SYMTAB) {
1336  if ((Err = checkSymtabCommand(*this, Load, I, &SymtabLoadCmd, Elements)))
1337  return;
1338  } else if (Load.C.cmd == MachO::LC_DYSYMTAB) {
1339  if ((Err = checkDysymtabCommand(*this, Load, I, &DysymtabLoadCmd,
1340  Elements)))
1341  return;
1342  } else if (Load.C.cmd == MachO::LC_DATA_IN_CODE) {
1343  if ((Err = checkLinkeditDataCommand(*this, Load, I, &DataInCodeLoadCmd,
1344  "LC_DATA_IN_CODE", Elements,
1345  "data in code info")))
1346  return;
1347  } else if (Load.C.cmd == MachO::LC_LINKER_OPTIMIZATION_HINT) {
1348  if ((Err = checkLinkeditDataCommand(*this, Load, I, &LinkOptHintsLoadCmd,
1349  "LC_LINKER_OPTIMIZATION_HINT",
1350  Elements, "linker optimization "
1351  "hints")))
1352  return;
1353  } else if (Load.C.cmd == MachO::LC_FUNCTION_STARTS) {
1354  if ((Err = checkLinkeditDataCommand(*this, Load, I, &FuncStartsLoadCmd,
1355  "LC_FUNCTION_STARTS", Elements,
1356  "function starts data")))
1357  return;
1358  } else if (Load.C.cmd == MachO::LC_SEGMENT_SPLIT_INFO) {
1359  if ((Err = checkLinkeditDataCommand(*this, Load, I, &SplitInfoLoadCmd,
1360  "LC_SEGMENT_SPLIT_INFO", Elements,
1361  "split info data")))
1362  return;
1363  } else if (Load.C.cmd == MachO::LC_DYLIB_CODE_SIGN_DRS) {
1364  if ((Err = checkLinkeditDataCommand(*this, Load, I, &CodeSignDrsLoadCmd,
1365  "LC_DYLIB_CODE_SIGN_DRS", Elements,
1366  "code signing RDs data")))
1367  return;
1368  } else if (Load.C.cmd == MachO::LC_CODE_SIGNATURE) {
1369  if ((Err = checkLinkeditDataCommand(*this, Load, I, &CodeSignLoadCmd,
1370  "LC_CODE_SIGNATURE", Elements,
1371  "code signature data")))
1372  return;
1373  } else if (Load.C.cmd == MachO::LC_DYLD_INFO) {
1374  if ((Err = checkDyldInfoCommand(*this, Load, I, &DyldInfoLoadCmd,
1375  "LC_DYLD_INFO", Elements)))
1376  return;
1377  } else if (Load.C.cmd == MachO::LC_DYLD_INFO_ONLY) {
1378  if ((Err = checkDyldInfoCommand(*this, Load, I, &DyldInfoLoadCmd,
1379  "LC_DYLD_INFO_ONLY", Elements)))
1380  return;
1381  } else if (Load.C.cmd == MachO::LC_UUID) {
1382  if (Load.C.cmdsize != sizeof(MachO::uuid_command)) {
1383  Err = malformedError("LC_UUID command " + Twine(I) + " has incorrect "
1384  "cmdsize");
1385  return;
1386  }
1387  if (UuidLoadCmd) {
1388  Err = malformedError("more than one LC_UUID command");
1389  return;
1390  }
1391  UuidLoadCmd = Load.Ptr;
1392  } else if (Load.C.cmd == MachO::LC_SEGMENT_64) {
1395  *this, Load, Sections, HasPageZeroSegment, I,
1396  "LC_SEGMENT_64", SizeOfHeaders, Elements)))
1397  return;
1398  } else if (Load.C.cmd == MachO::LC_SEGMENT) {
1400  MachO::section>(
1401  *this, Load, Sections, HasPageZeroSegment, I,
1402  "LC_SEGMENT", SizeOfHeaders, Elements)))
1403  return;
1404  } else if (Load.C.cmd == MachO::LC_ID_DYLIB) {
1405  if ((Err = checkDylibIdCommand(*this, Load, I, &DyldIdLoadCmd)))
1406  return;
1407  } else if (Load.C.cmd == MachO::LC_LOAD_DYLIB) {
1408  if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_DYLIB")))
1409  return;
1410  Libraries.push_back(Load.Ptr);
1411  } else if (Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB) {
1412  if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_WEAK_DYLIB")))
1413  return;
1414  Libraries.push_back(Load.Ptr);
1415  } else if (Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB) {
1416  if ((Err = checkDylibCommand(*this, Load, I, "LC_LAZY_LOAD_DYLIB")))
1417  return;
1418  Libraries.push_back(Load.Ptr);
1419  } else if (Load.C.cmd == MachO::LC_REEXPORT_DYLIB) {
1420  if ((Err = checkDylibCommand(*this, Load, I, "LC_REEXPORT_DYLIB")))
1421  return;
1422  Libraries.push_back(Load.Ptr);
1423  } else if (Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) {
1424  if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_UPWARD_DYLIB")))
1425  return;
1426  Libraries.push_back(Load.Ptr);
1427  } else if (Load.C.cmd == MachO::LC_ID_DYLINKER) {
1428  if ((Err = checkDyldCommand(*this, Load, I, "LC_ID_DYLINKER")))
1429  return;
1430  } else if (Load.C.cmd == MachO::LC_LOAD_DYLINKER) {
1431  if ((Err = checkDyldCommand(*this, Load, I, "LC_LOAD_DYLINKER")))
1432  return;
1433  } else if (Load.C.cmd == MachO::LC_DYLD_ENVIRONMENT) {
1434  if ((Err = checkDyldCommand(*this, Load, I, "LC_DYLD_ENVIRONMENT")))
1435  return;
1436  } else if (Load.C.cmd == MachO::LC_VERSION_MIN_MACOSX) {
1437  if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1438  "LC_VERSION_MIN_MACOSX")))
1439  return;
1440  } else if (Load.C.cmd == MachO::LC_VERSION_MIN_IPHONEOS) {
1441  if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1442  "LC_VERSION_MIN_IPHONEOS")))
1443  return;
1444  } else if (Load.C.cmd == MachO::LC_VERSION_MIN_TVOS) {
1445  if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1446  "LC_VERSION_MIN_TVOS")))
1447  return;
1448  } else if (Load.C.cmd == MachO::LC_VERSION_MIN_WATCHOS) {
1449  if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1450  "LC_VERSION_MIN_WATCHOS")))
1451  return;
1452  } else if (Load.C.cmd == MachO::LC_NOTE) {
1453  if ((Err = checkNoteCommand(*this, Load, I, Elements)))
1454  return;
1455  } else if (Load.C.cmd == MachO::LC_BUILD_VERSION) {
1456  if ((Err = parseBuildVersionCommand(*this, Load, BuildTools, I)))
1457  return;
1458  } else if (Load.C.cmd == MachO::LC_RPATH) {
1459  if ((Err = checkRpathCommand(*this, Load, I)))
1460  return;
1461  } else if (Load.C.cmd == MachO::LC_SOURCE_VERSION) {
1462  if (Load.C.cmdsize != sizeof(MachO::source_version_command)) {
1463  Err = malformedError("LC_SOURCE_VERSION command " + Twine(I) +
1464  " has incorrect cmdsize");
1465  return;
1466  }
1467  if (SourceLoadCmd) {
1468  Err = malformedError("more than one LC_SOURCE_VERSION command");
1469  return;
1470  }
1471  SourceLoadCmd = Load.Ptr;
1472  } else if (Load.C.cmd == MachO::LC_MAIN) {
1473  if (Load.C.cmdsize != sizeof(MachO::entry_point_command)) {
1474  Err = malformedError("LC_MAIN command " + Twine(I) +
1475  " has incorrect cmdsize");
1476  return;
1477  }
1478  if (EntryPointLoadCmd) {
1479  Err = malformedError("more than one LC_MAIN command");
1480  return;
1481  }
1482  EntryPointLoadCmd = Load.Ptr;
1483  } else if (Load.C.cmd == MachO::LC_ENCRYPTION_INFO) {
1484  if (Load.C.cmdsize != sizeof(MachO::encryption_info_command)) {
1485  Err = malformedError("LC_ENCRYPTION_INFO command " + Twine(I) +
1486  " has incorrect cmdsize");
1487  return;
1488  }
1490  getStruct<MachO::encryption_info_command>(*this, Load.Ptr);
1491  if ((Err = checkEncryptCommand(*this, Load, I, E.cryptoff, E.cryptsize,
1492  &EncryptLoadCmd, "LC_ENCRYPTION_INFO")))
1493  return;
1494  } else if (Load.C.cmd == MachO::LC_ENCRYPTION_INFO_64) {
1495  if (Load.C.cmdsize != sizeof(MachO::encryption_info_command_64)) {
1496  Err = malformedError("LC_ENCRYPTION_INFO_64 command " + Twine(I) +
1497  " has incorrect cmdsize");
1498  return;
1499  }
1501  getStruct<MachO::encryption_info_command_64>(*this, Load.Ptr);
1502  if ((Err = checkEncryptCommand(*this, Load, I, E.cryptoff, E.cryptsize,
1503  &EncryptLoadCmd, "LC_ENCRYPTION_INFO_64")))
1504  return;
1505  } else if (Load.C.cmd == MachO::LC_LINKER_OPTION) {
1506  if ((Err = checkLinkerOptCommand(*this, Load, I)))
1507  return;
1508  } else if (Load.C.cmd == MachO::LC_SUB_FRAMEWORK) {
1509  if (Load.C.cmdsize < sizeof(MachO::sub_framework_command)) {
1510  Err = malformedError("load command " + Twine(I) +
1511  " LC_SUB_FRAMEWORK cmdsize too small");
1512  return;
1513  }
1515  getStruct<MachO::sub_framework_command>(*this, Load.Ptr);
1516  if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_FRAMEWORK",
1518  "sub_framework_command", S.umbrella,
1519  "umbrella")))
1520  return;
1521  } else if (Load.C.cmd == MachO::LC_SUB_UMBRELLA) {
1522  if (Load.C.cmdsize < sizeof(MachO::sub_umbrella_command)) {
1523  Err = malformedError("load command " + Twine(I) +
1524  " LC_SUB_UMBRELLA cmdsize too small");
1525  return;
1526  }
1528  getStruct<MachO::sub_umbrella_command>(*this, Load.Ptr);
1529  if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_UMBRELLA",
1531  "sub_umbrella_command", S.sub_umbrella,
1532  "sub_umbrella")))
1533  return;
1534  } else if (Load.C.cmd == MachO::LC_SUB_LIBRARY) {
1535  if (Load.C.cmdsize < sizeof(MachO::sub_library_command)) {
1536  Err = malformedError("load command " + Twine(I) +
1537  " LC_SUB_LIBRARY cmdsize too small");
1538  return;
1539  }
1541  getStruct<MachO::sub_library_command>(*this, Load.Ptr);
1542  if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_LIBRARY",
1544  "sub_library_command", S.sub_library,
1545  "sub_library")))
1546  return;
1547  } else if (Load.C.cmd == MachO::LC_SUB_CLIENT) {
1548  if (Load.C.cmdsize < sizeof(MachO::sub_client_command)) {
1549  Err = malformedError("load command " + Twine(I) +
1550  " LC_SUB_CLIENT cmdsize too small");
1551  return;
1552  }
1554  getStruct<MachO::sub_client_command>(*this, Load.Ptr);
1555  if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_CLIENT",
1556  sizeof(MachO::sub_client_command),
1557  "sub_client_command", S.client, "client")))
1558  return;
1559  } else if (Load.C.cmd == MachO::LC_ROUTINES) {
1560  if (Load.C.cmdsize != sizeof(MachO::routines_command)) {
1561  Err = malformedError("LC_ROUTINES command " + Twine(I) +
1562  " has incorrect cmdsize");
1563  return;
1564  }
1565  if (RoutinesLoadCmd) {
1566  Err = malformedError("more than one LC_ROUTINES and or LC_ROUTINES_64 "
1567  "command");
1568  return;
1569  }
1570  RoutinesLoadCmd = Load.Ptr;
1571  } else if (Load.C.cmd == MachO::LC_ROUTINES_64) {
1572  if (Load.C.cmdsize != sizeof(MachO::routines_command_64)) {
1573  Err = malformedError("LC_ROUTINES_64 command " + Twine(I) +
1574  " has incorrect cmdsize");
1575  return;
1576  }
1577  if (RoutinesLoadCmd) {
1578  Err = malformedError("more than one LC_ROUTINES_64 and or LC_ROUTINES "
1579  "command");
1580  return;
1581  }
1582  RoutinesLoadCmd = Load.Ptr;
1583  } else if (Load.C.cmd == MachO::LC_UNIXTHREAD) {
1584  if ((Err = checkThreadCommand(*this, Load, I, "LC_UNIXTHREAD")))
1585  return;
1586  if (UnixThreadLoadCmd) {
1587  Err = malformedError("more than one LC_UNIXTHREAD command");
1588  return;
1589  }
1590  UnixThreadLoadCmd = Load.Ptr;
1591  } else if (Load.C.cmd == MachO::LC_THREAD) {
1592  if ((Err = checkThreadCommand(*this, Load, I, "LC_THREAD")))
1593  return;
1594  // Note: LC_TWOLEVEL_HINTS is really obsolete and is not supported.
1595  } else if (Load.C.cmd == MachO::LC_TWOLEVEL_HINTS) {
1596  if ((Err = checkTwoLevelHintsCommand(*this, Load, I,
1597  &TwoLevelHintsLoadCmd, Elements)))
1598  return;
1599  } else if (Load.C.cmd == MachO::LC_IDENT) {
1600  // Note: LC_IDENT is ignored.
1601  continue;
1602  } else if (isLoadCommandObsolete(Load.C.cmd)) {
1603  Err = malformedError("load command " + Twine(I) + " for cmd value of: " +
1604  Twine(Load.C.cmd) + " is obsolete and not "
1605  "supported");
1606  return;
1607  }
1608  // TODO: generate a error for unknown load commands by default. But still
1609  // need work out an approach to allow or not allow unknown values like this
1610  // as an option for some uses like lldb.
1611  if (I < LoadCommandCount - 1) {
1612  if (auto LoadOrErr = getNextLoadCommandInfo(*this, I, Load))
1613  Load = *LoadOrErr;
1614  else {
1615  Err = LoadOrErr.takeError();
1616  return;
1617  }
1618  }
1619  }
1620  if (!SymtabLoadCmd) {
1621  if (DysymtabLoadCmd) {
1622  Err = malformedError("contains LC_DYSYMTAB load command without a "
1623  "LC_SYMTAB load command");
1624  return;
1625  }
1626  } else if (DysymtabLoadCmd) {
1627  MachO::symtab_command Symtab =
1628  getStruct<MachO::symtab_command>(*this, SymtabLoadCmd);
1629  MachO::dysymtab_command Dysymtab =
1630  getStruct<MachO::dysymtab_command>(*this, DysymtabLoadCmd);
1631  if (Dysymtab.nlocalsym != 0 && Dysymtab.ilocalsym > Symtab.nsyms) {
1632  Err = malformedError("ilocalsym in LC_DYSYMTAB load command "
1633  "extends past the end of the symbol table");
1634  return;
1635  }
1636  uint64_t BigSize = Dysymtab.ilocalsym;
1637  BigSize += Dysymtab.nlocalsym;
1638  if (Dysymtab.nlocalsym != 0 && BigSize > Symtab.nsyms) {
1639  Err = malformedError("ilocalsym plus nlocalsym in LC_DYSYMTAB load "
1640  "command extends past the end of the symbol table");
1641  return;
1642  }
1643  if (Dysymtab.nextdefsym != 0 && Dysymtab.iextdefsym > Symtab.nsyms) {
1644  Err = malformedError("iextdefsym in LC_DYSYMTAB load command "
1645  "extends past the end of the symbol table");
1646  return;
1647  }
1648  BigSize = Dysymtab.iextdefsym;
1649  BigSize += Dysymtab.nextdefsym;
1650  if (Dysymtab.nextdefsym != 0 && BigSize > Symtab.nsyms) {
1651  Err = malformedError("iextdefsym plus nextdefsym in LC_DYSYMTAB "
1652  "load command extends past the end of the symbol "
1653  "table");
1654  return;
1655  }
1656  if (Dysymtab.nundefsym != 0 && Dysymtab.iundefsym > Symtab.nsyms) {
1657  Err = malformedError("iundefsym in LC_DYSYMTAB load command "
1658  "extends past the end of the symbol table");
1659  return;
1660  }
1661  BigSize = Dysymtab.iundefsym;
1662  BigSize += Dysymtab.nundefsym;
1663  if (Dysymtab.nundefsym != 0 && BigSize > Symtab.nsyms) {
1664  Err = malformedError("iundefsym plus nundefsym in LC_DYSYMTAB load "
1665  " command extends past the end of the symbol table");
1666  return;
1667  }
1668  }
1669  if ((getHeader().filetype == MachO::MH_DYLIB ||
1670  getHeader().filetype == MachO::MH_DYLIB_STUB) &&
1671  DyldIdLoadCmd == nullptr) {
1672  Err = malformedError("no LC_ID_DYLIB load command in dynamic library "
1673  "filetype");
1674  return;
1675  }
1676  assert(LoadCommands.size() == LoadCommandCount);
1677 
1678  Err = Error::success();
1679 }
1680 
1682  uint32_t Flags = 0;
1683  if (is64Bit()) {
1685  Flags = H_64.flags;
1686  } else {
1688  Flags = H.flags;
1689  }
1690  uint8_t NType = 0;
1691  uint8_t NSect = 0;
1692  uint16_t NDesc = 0;
1693  uint32_t NStrx = 0;
1694  uint64_t NValue = 0;
1695  uint32_t SymbolIndex = 0;
1697  for (const SymbolRef &Symbol : symbols()) {
1698  DataRefImpl SymDRI = Symbol.getRawDataRefImpl();
1699  if (is64Bit()) {
1700  MachO::nlist_64 STE_64 = getSymbol64TableEntry(SymDRI);
1701  NType = STE_64.n_type;
1702  NSect = STE_64.n_sect;
1703  NDesc = STE_64.n_desc;
1704  NStrx = STE_64.n_strx;
1705  NValue = STE_64.n_value;
1706  } else {
1707  MachO::nlist STE = getSymbolTableEntry(SymDRI);
1708  NType = STE.n_type;
1709  NSect = STE.n_sect;
1710  NDesc = STE.n_desc;
1711  NStrx = STE.n_strx;
1712  NValue = STE.n_value;
1713  }
1714  if ((NType & MachO::N_STAB) == 0) {
1715  if ((NType & MachO::N_TYPE) == MachO::N_SECT) {
1716  if (NSect == 0 || NSect > Sections.size())
1717  return malformedError("bad section index: " + Twine((int)NSect) +
1718  " for symbol at index " + Twine(SymbolIndex));
1719  }
1720  if ((NType & MachO::N_TYPE) == MachO::N_INDR) {
1721  if (NValue >= S.strsize)
1722  return malformedError("bad n_value: " + Twine((int)NValue) + " past "
1723  "the end of string table, for N_INDR symbol at "
1724  "index " + Twine(SymbolIndex));
1725  }
1726  if ((Flags & MachO::MH_TWOLEVEL) == MachO::MH_TWOLEVEL &&
1727  (((NType & MachO::N_TYPE) == MachO::N_UNDF && NValue == 0) ||
1728  (NType & MachO::N_TYPE) == MachO::N_PBUD)) {
1729  uint32_t LibraryOrdinal = MachO::GET_LIBRARY_ORDINAL(NDesc);
1730  if (LibraryOrdinal != 0 &&
1731  LibraryOrdinal != MachO::EXECUTABLE_ORDINAL &&
1732  LibraryOrdinal != MachO::DYNAMIC_LOOKUP_ORDINAL &&
1733  LibraryOrdinal - 1 >= Libraries.size() ) {
1734  return malformedError("bad library ordinal: " + Twine(LibraryOrdinal) +
1735  " for symbol at index " + Twine(SymbolIndex));
1736  }
1737  }
1738  }
1739  if (NStrx >= S.strsize)
1740  return malformedError("bad string table index: " + Twine((int)NStrx) +
1741  " past the end of string table, for symbol at "
1742  "index " + Twine(SymbolIndex));
1743  SymbolIndex++;
1744  }
1745  return Error::success();
1746 }
1747 
1749  unsigned SymbolTableEntrySize = is64Bit() ?
1750  sizeof(MachO::nlist_64) :
1751  sizeof(MachO::nlist);
1752  Symb.p += SymbolTableEntrySize;
1753 }
1754 
1756  StringRef StringTable = getStringTableData();
1757  MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1758  if (Entry.n_strx == 0)
1759  // A n_strx value of 0 indicates that no name is associated with a
1760  // particular symbol table entry.
1761  return StringRef();
1762  const char *Start = &StringTable.data()[Entry.n_strx];
1763  if (Start < getData().begin() || Start >= getData().end()) {
1764  return malformedError("bad string index: " + Twine(Entry.n_strx) +
1765  " for symbol at index " + Twine(getSymbolIndex(Symb)));
1766  }
1767  return StringRef(Start);
1768 }
1769 
1771  DataRefImpl DRI = Sec.getRawDataRefImpl();
1772  uint32_t Flags = getSectionFlags(*this, DRI);
1773  return Flags & MachO::SECTION_TYPE;
1774 }
1775 
1777  if (is64Bit()) {
1779  return Entry.n_value;
1780  }
1781  MachO::nlist Entry = getSymbolTableEntry(Sym);
1782  return Entry.n_value;
1783 }
1784 
1785 // getIndirectName() returns the name of the alias'ed symbol who's string table
1786 // index is in the n_value field.
1788  StringRef &Res) const {
1789  StringRef StringTable = getStringTableData();
1790  MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1791  if ((Entry.n_type & MachO::N_TYPE) != MachO::N_INDR)
1793  uint64_t NValue = getNValue(Symb);
1794  if (NValue >= StringTable.size())
1796  const char *Start = &StringTable.data()[NValue];
1797  Res = StringRef(Start);
1798  return std::error_code();
1799 }
1800 
1801 uint64_t MachOObjectFile::getSymbolValueImpl(DataRefImpl Sym) const {
1802  return getNValue(Sym);
1803 }
1804 
1806  return getSymbolValue(Sym);
1807 }
1808 
1810  uint32_t Flags = cantFail(getSymbolFlags(DRI));
1811  if (Flags & SymbolRef::SF_Common) {
1812  MachO::nlist_base Entry = getSymbolTableEntryBase(*this, DRI);
1813  return 1 << MachO::GET_COMM_ALIGN(Entry.n_desc);
1814  }
1815  return 0;
1816 }
1817 
1819  return getNValue(DRI);
1820 }
1821 
1824  MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1825  uint8_t n_type = Entry.n_type;
1826 
1827  // If this is a STAB debugging symbol, we can do nothing more.
1828  if (n_type & MachO::N_STAB)
1829  return SymbolRef::ST_Debug;
1830 
1831  switch (n_type & MachO::N_TYPE) {
1832  case MachO::N_UNDF :
1833  return SymbolRef::ST_Unknown;
1834  case MachO::N_SECT :
1835  Expected<section_iterator> SecOrError = getSymbolSection(Symb);
1836  if (!SecOrError)
1837  return SecOrError.takeError();
1838  section_iterator Sec = *SecOrError;
1839  if (Sec == section_end())
1840  return SymbolRef::ST_Other;
1841  if (Sec->isData() || Sec->isBSS())
1842  return SymbolRef::ST_Data;
1843  return SymbolRef::ST_Function;
1844  }
1845  return SymbolRef::ST_Other;
1846 }
1847 
1849  MachO::nlist_base Entry = getSymbolTableEntryBase(*this, DRI);
1850 
1851  uint8_t MachOType = Entry.n_type;
1852  uint16_t MachOFlags = Entry.n_desc;
1853 
1854  uint32_t Result = SymbolRef::SF_None;
1855 
1856  if ((MachOType & MachO::N_TYPE) == MachO::N_INDR)
1857  Result |= SymbolRef::SF_Indirect;
1858 
1859  if (MachOType & MachO::N_STAB)
1860  Result |= SymbolRef::SF_FormatSpecific;
1861 
1862  if (MachOType & MachO::N_EXT) {
1863  Result |= SymbolRef::SF_Global;
1864  if ((MachOType & MachO::N_TYPE) == MachO::N_UNDF) {
1865  if (getNValue(DRI))
1866  Result |= SymbolRef::SF_Common;
1867  else
1868  Result |= SymbolRef::SF_Undefined;
1869  }
1870 
1871  if (!(MachOType & MachO::N_PEXT))
1872  Result |= SymbolRef::SF_Exported;
1873  }
1874 
1875  if (MachOFlags & (MachO::N_WEAK_REF | MachO::N_WEAK_DEF))
1876  Result |= SymbolRef::SF_Weak;
1877 
1878  if (MachOFlags & (MachO::N_ARM_THUMB_DEF))
1879  Result |= SymbolRef::SF_Thumb;
1880 
1881  if ((MachOType & MachO::N_TYPE) == MachO::N_ABS)
1882  Result |= SymbolRef::SF_Absolute;
1883 
1884  return Result;
1885 }
1886 
1889  MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1890  uint8_t index = Entry.n_sect;
1891 
1892  if (index == 0)
1893  return section_end();
1894  DataRefImpl DRI;
1895  DRI.d.a = index - 1;
1896  if (DRI.d.a >= Sections.size()){
1897  return malformedError("bad section index: " + Twine((int)index) +
1898  " for symbol at index " + Twine(getSymbolIndex(Symb)));
1899  }
1900  return section_iterator(SectionRef(DRI, this));
1901 }
1902 
1904  MachO::nlist_base Entry =
1906  return Entry.n_sect - 1;
1907 }
1908 
1910  Sec.d.a++;
1911 }
1912 
1914  ArrayRef<char> Raw = getSectionRawName(Sec);
1915  return parseSegmentOrSectionName(Raw.data());
1916 }
1917 
1919  if (is64Bit())
1920  return getSection64(Sec).addr;
1921  return getSection(Sec).addr;
1922 }
1923 
1925  return Sec.d.a;
1926 }
1927 
1929  // In the case if a malformed Mach-O file where the section offset is past
1930  // the end of the file or some part of the section size is past the end of
1931  // the file return a size of zero or a size that covers the rest of the file
1932  // but does not extend past the end of the file.
1933  uint32_t SectOffset, SectType;
1934  uint64_t SectSize;
1935 
1936  if (is64Bit()) {
1937  MachO::section_64 Sect = getSection64(Sec);
1938  SectOffset = Sect.offset;
1939  SectSize = Sect.size;
1940  SectType = Sect.flags & MachO::SECTION_TYPE;
1941  } else {
1942  MachO::section Sect = getSection(Sec);
1943  SectOffset = Sect.offset;
1944  SectSize = Sect.size;
1945  SectType = Sect.flags & MachO::SECTION_TYPE;
1946  }
1947  if (SectType == MachO::S_ZEROFILL || SectType == MachO::S_GB_ZEROFILL)
1948  return SectSize;
1949  uint64_t FileSize = getData().size();
1950  if (SectOffset > FileSize)
1951  return 0;
1952  if (FileSize - SectOffset < SectSize)
1953  return FileSize - SectOffset;
1954  return SectSize;
1955 }
1956 
1958  uint64_t Size) const {
1959  return arrayRefFromStringRef(getData().substr(Offset, Size));
1960 }
1961 
1964  uint32_t Offset;
1965  uint64_t Size;
1966 
1967  if (is64Bit()) {
1968  MachO::section_64 Sect = getSection64(Sec);
1969  Offset = Sect.offset;
1970  Size = Sect.size;
1971  } else {
1972  MachO::section Sect = getSection(Sec);
1973  Offset = Sect.offset;
1974  Size = Sect.size;
1975  }
1976 
1977  return getSectionContents(Offset, Size);
1978 }
1979 
1981  uint32_t Align;
1982  if (is64Bit()) {
1983  MachO::section_64 Sect = getSection64(Sec);
1984  Align = Sect.align;
1985  } else {
1986  MachO::section Sect = getSection(Sec);
1987  Align = Sect.align;
1988  }
1989 
1990  return uint64_t(1) << Align;
1991 }
1992 
1994  if (SectionIndex < 1 || SectionIndex > Sections.size())
1995  return malformedError("bad section index: " + Twine((int)SectionIndex));
1996 
1997  DataRefImpl DRI;
1998  DRI.d.a = SectionIndex - 1;
1999  return SectionRef(DRI, this);
2000 }
2001 
2003  for (const SectionRef &Section : sections()) {
2004  auto NameOrErr = Section.getName();
2005  if (!NameOrErr)
2006  return NameOrErr.takeError();
2007  if (*NameOrErr == SectionName)
2008  return Section;
2009  }
2011 }
2012 
2014  return false;
2015 }
2016 
2018  uint32_t Flags = getSectionFlags(*this, Sec);
2019  return Flags & MachO::S_ATTR_PURE_INSTRUCTIONS;
2020 }
2021 
2023  uint32_t Flags = getSectionFlags(*this, Sec);
2024  unsigned SectionType = Flags & MachO::SECTION_TYPE;
2025  return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
2028 }
2029 
2031  uint32_t Flags = getSectionFlags(*this, Sec);
2032  unsigned SectionType = Flags & MachO::SECTION_TYPE;
2033  return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
2036 }
2037 
2039  return SectionName.startswith("__debug") ||
2040  SectionName.startswith("__zdebug") ||
2041  SectionName.startswith("__apple") || SectionName == "__gdb_index" ||
2042  SectionName == "__swift_ast";
2043 }
2044 
2046  return Sec.getRawDataRefImpl().d.a;
2047 }
2048 
2050  uint32_t Flags = getSectionFlags(*this, Sec);
2051  unsigned SectionType = Flags & MachO::SECTION_TYPE;
2052  return SectionType == MachO::S_ZEROFILL ||
2054 }
2055 
2057  StringRef SegmentName = getSectionFinalSegmentName(Sec);
2058  if (Expected<StringRef> NameOrErr = getSectionName(Sec))
2059  return (SegmentName == "__LLVM" && *NameOrErr == "__bitcode");
2060  return false;
2061 }
2062 
2064  if (is64Bit())
2065  return getSection64(Sec).offset == 0;
2066  return getSection(Sec).offset == 0;
2067 }
2068 
2070  DataRefImpl Ret;
2071  Ret.d.a = Sec.d.a;
2072  Ret.d.b = 0;
2073  return relocation_iterator(RelocationRef(Ret, this));
2074 }
2075 
2077 MachOObjectFile::section_rel_end(DataRefImpl Sec) const {
2078  uint32_t Num;
2079  if (is64Bit()) {
2080  MachO::section_64 Sect = getSection64(Sec);
2081  Num = Sect.nreloc;
2082  } else {
2083  MachO::section Sect = getSection(Sec);
2084  Num = Sect.nreloc;
2085  }
2086 
2087  DataRefImpl Ret;
2088  Ret.d.a = Sec.d.a;
2089  Ret.d.b = Num;
2090  return relocation_iterator(RelocationRef(Ret, this));
2091 }
2092 
2094  DataRefImpl Ret;
2095  // for DYSYMTAB symbols, Ret.d.a == 0 for external relocations
2096  Ret.d.a = 0; // Would normally be a section index.
2097  Ret.d.b = 0; // Index into the external relocations
2098  return relocation_iterator(RelocationRef(Ret, this));
2099 }
2100 
2102  MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
2103  DataRefImpl Ret;
2104  // for DYSYMTAB symbols, Ret.d.a == 0 for external relocations
2105  Ret.d.a = 0; // Would normally be a section index.
2106  Ret.d.b = DysymtabLoadCmd.nextrel; // Index into the external relocations
2107  return relocation_iterator(RelocationRef(Ret, this));
2108 }
2109 
2111  DataRefImpl Ret;
2112  // for DYSYMTAB symbols, Ret.d.a == 1 for local relocations
2113  Ret.d.a = 1; // Would normally be a section index.
2114  Ret.d.b = 0; // Index into the local relocations
2115  return relocation_iterator(RelocationRef(Ret, this));
2116 }
2117 
2119  MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
2120  DataRefImpl Ret;
2121  // for DYSYMTAB symbols, Ret.d.a == 1 for local relocations
2122  Ret.d.a = 1; // Would normally be a section index.
2123  Ret.d.b = DysymtabLoadCmd.nlocrel; // Index into the local relocations
2124  return relocation_iterator(RelocationRef(Ret, this));
2125 }
2126 
2128  ++Rel.d.b;
2129 }
2130 
2132  assert((getHeader().filetype == MachO::MH_OBJECT ||
2133  getHeader().filetype == MachO::MH_KEXT_BUNDLE) &&
2134  "Only implemented for MH_OBJECT && MH_KEXT_BUNDLE");
2136  return getAnyRelocationAddress(RE);
2137 }
2138 
2142  if (isRelocationScattered(RE))
2143  return symbol_end();
2144 
2145  uint32_t SymbolIdx = getPlainRelocationSymbolNum(RE);
2146  bool isExtern = getPlainRelocationExternal(RE);
2147  if (!isExtern)
2148  return symbol_end();
2149 
2151  unsigned SymbolTableEntrySize = is64Bit() ?
2152  sizeof(MachO::nlist_64) :
2153  sizeof(MachO::nlist);
2154  uint64_t Offset = S.symoff + SymbolIdx * SymbolTableEntrySize;
2155  DataRefImpl Sym;
2156  Sym.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2157  return symbol_iterator(SymbolRef(Sym, this));
2158 }
2159 
2163 }
2164 
2167  return getAnyRelocationType(RE);
2168 }
2169 
2171  DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
2172  StringRef res;
2173  uint64_t RType = getRelocationType(Rel);
2174 
2175  unsigned Arch = this->getArch();
2176 
2177  switch (Arch) {
2178  case Triple::x86: {
2179  static const char *const Table[] = {
2180  "GENERIC_RELOC_VANILLA",
2181  "GENERIC_RELOC_PAIR",
2182  "GENERIC_RELOC_SECTDIFF",
2183  "GENERIC_RELOC_PB_LA_PTR",
2184  "GENERIC_RELOC_LOCAL_SECTDIFF",
2185  "GENERIC_RELOC_TLV" };
2186 
2187  if (RType > 5)
2188  res = "Unknown";
2189  else
2190  res = Table[RType];
2191  break;
2192  }
2193  case Triple::x86_64: {
2194  static const char *const Table[] = {
2195  "X86_64_RELOC_UNSIGNED",
2196  "X86_64_RELOC_SIGNED",
2197  "X86_64_RELOC_BRANCH",
2198  "X86_64_RELOC_GOT_LOAD",
2199  "X86_64_RELOC_GOT",
2200  "X86_64_RELOC_SUBTRACTOR",
2201  "X86_64_RELOC_SIGNED_1",
2202  "X86_64_RELOC_SIGNED_2",
2203  "X86_64_RELOC_SIGNED_4",
2204  "X86_64_RELOC_TLV" };
2205 
2206  if (RType > 9)
2207  res = "Unknown";
2208  else
2209  res = Table[RType];
2210  break;
2211  }
2212  case Triple::arm: {
2213  static const char *const Table[] = {
2214  "ARM_RELOC_VANILLA",
2215  "ARM_RELOC_PAIR",
2216  "ARM_RELOC_SECTDIFF",
2217  "ARM_RELOC_LOCAL_SECTDIFF",
2218  "ARM_RELOC_PB_LA_PTR",
2219  "ARM_RELOC_BR24",
2220  "ARM_THUMB_RELOC_BR22",
2221  "ARM_THUMB_32BIT_BRANCH",
2222  "ARM_RELOC_HALF",
2223  "ARM_RELOC_HALF_SECTDIFF" };
2224 
2225  if (RType > 9)
2226  res = "Unknown";
2227  else
2228  res = Table[RType];
2229  break;
2230  }
2231  case Triple::aarch64:
2232  case Triple::aarch64_32: {
2233  static const char *const Table[] = {
2234  "ARM64_RELOC_UNSIGNED", "ARM64_RELOC_SUBTRACTOR",
2235  "ARM64_RELOC_BRANCH26", "ARM64_RELOC_PAGE21",
2236  "ARM64_RELOC_PAGEOFF12", "ARM64_RELOC_GOT_LOAD_PAGE21",
2237  "ARM64_RELOC_GOT_LOAD_PAGEOFF12", "ARM64_RELOC_POINTER_TO_GOT",
2238  "ARM64_RELOC_TLVP_LOAD_PAGE21", "ARM64_RELOC_TLVP_LOAD_PAGEOFF12",
2239  "ARM64_RELOC_ADDEND"
2240  };
2241 
2242  if (RType >= array_lengthof(Table))
2243  res = "Unknown";
2244  else
2245  res = Table[RType];
2246  break;
2247  }
2248  case Triple::ppc: {
2249  static const char *const Table[] = {
2250  "PPC_RELOC_VANILLA",
2251  "PPC_RELOC_PAIR",
2252  "PPC_RELOC_BR14",
2253  "PPC_RELOC_BR24",
2254  "PPC_RELOC_HI16",
2255  "PPC_RELOC_LO16",
2256  "PPC_RELOC_HA16",
2257  "PPC_RELOC_LO14",
2258  "PPC_RELOC_SECTDIFF",
2259  "PPC_RELOC_PB_LA_PTR",
2260  "PPC_RELOC_HI16_SECTDIFF",
2261  "PPC_RELOC_LO16_SECTDIFF",
2262  "PPC_RELOC_HA16_SECTDIFF",
2263  "PPC_RELOC_JBSR",
2264  "PPC_RELOC_LO14_SECTDIFF",
2265  "PPC_RELOC_LOCAL_SECTDIFF" };
2266 
2267  if (RType > 15)
2268  res = "Unknown";
2269  else
2270  res = Table[RType];
2271  break;
2272  }
2273  case Triple::UnknownArch:
2274  res = "Unknown";
2275  break;
2276  }
2277  Result.append(res.begin(), res.end());
2278 }
2279 
2282  return getAnyRelocationLength(RE);
2283 }
2284 
2285 //
2286 // guessLibraryShortName() is passed a name of a dynamic library and returns a
2287 // guess on what the short name is. Then name is returned as a substring of the
2288 // StringRef Name passed in. The name of the dynamic library is recognized as
2289 // a framework if it has one of the two following forms:
2290 // Foo.framework/Versions/A/Foo
2291 // Foo.framework/Foo
2292 // Where A and Foo can be any string. And may contain a trailing suffix
2293 // starting with an underbar. If the Name is recognized as a framework then
2294 // isFramework is set to true else it is set to false. If the Name has a
2295 // suffix then Suffix is set to the substring in Name that contains the suffix
2296 // else it is set to a NULL StringRef.
2297 //
2298 // The Name of the dynamic library is recognized as a library name if it has
2299 // one of the two following forms:
2300 // libFoo.A.dylib
2301 // libFoo.dylib
2302 //
2303 // The library may have a suffix trailing the name Foo of the form:
2304 // libFoo_profile.A.dylib
2305 // libFoo_profile.dylib
2306 // These dyld image suffixes are separated from the short name by a '_'
2307 // character. Because the '_' character is commonly used to separate words in
2308 // filenames guessLibraryShortName() cannot reliably separate a dylib's short
2309 // name from an arbitrary image suffix; imagine if both the short name and the
2310 // suffix contains an '_' character! To better deal with this ambiguity,
2311 // guessLibraryShortName() will recognize only "_debug" and "_profile" as valid
2312 // Suffix values. Calling code needs to be tolerant of guessLibraryShortName()
2313 // guessing incorrectly.
2314 //
2315 // The Name of the dynamic library is also recognized as a library name if it
2316 // has the following form:
2317 // Foo.qtx
2318 //
2319 // If the Name of the dynamic library is none of the forms above then a NULL
2320 // StringRef is returned.
2322  bool &isFramework,
2323  StringRef &Suffix) {
2324  StringRef Foo, F, DotFramework, V, Dylib, Lib, Dot, Qtx;
2325  size_t a, b, c, d, Idx;
2326 
2327  isFramework = false;
2328  Suffix = StringRef();
2329 
2330  // Pull off the last component and make Foo point to it
2331  a = Name.rfind('/');
2332  if (a == Name.npos || a == 0)
2333  goto guess_library;
2334  Foo = Name.slice(a+1, Name.npos);
2335 
2336  // Look for a suffix starting with a '_'
2337  Idx = Foo.rfind('_');
2338  if (Idx != Foo.npos && Foo.size() >= 2) {
2339  Suffix = Foo.slice(Idx, Foo.npos);
2340  if (Suffix != "_debug" && Suffix != "_profile")
2341  Suffix = StringRef();
2342  else
2343  Foo = Foo.slice(0, Idx);
2344  }
2345 
2346  // First look for the form Foo.framework/Foo
2347  b = Name.rfind('/', a);
2348  if (b == Name.npos)
2349  Idx = 0;
2350  else
2351  Idx = b+1;
2352  F = Name.slice(Idx, Idx + Foo.size());
2353  DotFramework = Name.slice(Idx + Foo.size(),
2354  Idx + Foo.size() + sizeof(".framework/")-1);
2355  if (F == Foo && DotFramework == ".framework/") {
2356  isFramework = true;
2357  return Foo;
2358  }
2359 
2360  // Next look for the form Foo.framework/Versions/A/Foo
2361  if (b == Name.npos)
2362  goto guess_library;
2363  c = Name.rfind('/', b);
2364  if (c == Name.npos || c == 0)
2365  goto guess_library;
2366  V = Name.slice(c+1, Name.npos);
2367  if (!V.startswith("Versions/"))
2368  goto guess_library;
2369  d = Name.rfind('/', c);
2370  if (d == Name.npos)
2371  Idx = 0;
2372  else
2373  Idx = d+1;
2374  F = Name.slice(Idx, Idx + Foo.size());
2375  DotFramework = Name.slice(Idx + Foo.size(),
2376  Idx + Foo.size() + sizeof(".framework/")-1);
2377  if (F == Foo && DotFramework == ".framework/") {
2378  isFramework = true;
2379  return Foo;
2380  }
2381 
2382 guess_library:
2383  // pull off the suffix after the "." and make a point to it
2384  a = Name.rfind('.');
2385  if (a == Name.npos || a == 0)
2386  return StringRef();
2387  Dylib = Name.slice(a, Name.npos);
2388  if (Dylib != ".dylib")
2389  goto guess_qtx;
2390 
2391  // First pull off the version letter for the form Foo.A.dylib if any.
2392  if (a >= 3) {
2393  Dot = Name.slice(a-2, a-1);
2394  if (Dot == ".")
2395  a = a - 2;
2396  }
2397 
2398  b = Name.rfind('/', a);
2399  if (b == Name.npos)
2400  b = 0;
2401  else
2402  b = b+1;
2403  // ignore any suffix after an underbar like Foo_profile.A.dylib
2404  Idx = Name.rfind('_');
2405  if (Idx != Name.npos && Idx != b) {
2406  Lib = Name.slice(b, Idx);
2407  Suffix = Name.slice(Idx, a);
2408  if (Suffix != "_debug" && Suffix != "_profile") {
2409  Suffix = StringRef();
2410  Lib = Name.slice(b, a);
2411  }
2412  }
2413  else
2414  Lib = Name.slice(b, a);
2415  // There are incorrect library names of the form:
2416  // libATS.A_profile.dylib so check for these.
2417  if (Lib.size() >= 3) {
2418  Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
2419  if (Dot == ".")
2420  Lib = Lib.slice(0, Lib.size()-2);
2421  }
2422  return Lib;
2423 
2424 guess_qtx:
2425  Qtx = Name.slice(a, Name.npos);
2426  if (Qtx != ".qtx")
2427  return StringRef();
2428  b = Name.rfind('/', a);
2429  if (b == Name.npos)
2430  Lib = Name.slice(0, a);
2431  else
2432  Lib = Name.slice(b+1, a);
2433  // There are library names of the form: QT.A.qtx so check for these.
2434  if (Lib.size() >= 3) {
2435  Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
2436  if (Dot == ".")
2437  Lib = Lib.slice(0, Lib.size()-2);
2438  }
2439  return Lib;
2440 }
2441 
2442 // getLibraryShortNameByIndex() is used to get the short name of the library
2443 // for an undefined symbol in a linked Mach-O binary that was linked with the
2444 // normal two-level namespace default (that is MH_TWOLEVEL in the header).
2445 // It is passed the index (0 - based) of the library as translated from
2446 // GET_LIBRARY_ORDINAL (1 - based).
2448  StringRef &Res) const {
2449  if (Index >= Libraries.size())
2451 
2452  // If the cache of LibrariesShortNames is not built up do that first for
2453  // all the Libraries.
2454  if (LibrariesShortNames.size() == 0) {
2455  for (unsigned i = 0; i < Libraries.size(); i++) {
2456  auto CommandOrErr =
2457  getStructOrErr<MachO::dylib_command>(*this, Libraries[i]);
2458  if (!CommandOrErr)
2460  MachO::dylib_command D = CommandOrErr.get();
2461  if (D.dylib.name >= D.cmdsize)
2463  const char *P = (const char *)(Libraries[i]) + D.dylib.name;
2465  if (D.dylib.name+Name.size() >= D.cmdsize)
2467  StringRef Suffix;
2468  bool isFramework;
2469  StringRef shortName = guessLibraryShortName(Name, isFramework, Suffix);
2470  if (shortName.empty())
2471  LibrariesShortNames.push_back(Name);
2472  else
2473  LibrariesShortNames.push_back(shortName);
2474  }
2475  }
2476 
2477  Res = LibrariesShortNames[Index];
2478  return std::error_code();
2479 }
2480 
2482  return Libraries.size();
2483 }
2484 
2487  DataRefImpl Sec;
2488  Sec.d.a = Rel->getRawDataRefImpl().d.a;
2489  return section_iterator(SectionRef(Sec, this));
2490 }
2491 
2493  DataRefImpl DRI;
2495  if (!SymtabLoadCmd || Symtab.nsyms == 0)
2496  return basic_symbol_iterator(SymbolRef(DRI, this));
2497 
2498  return getSymbolByIndex(0);
2499 }
2500 
2502  DataRefImpl DRI;
2504  if (!SymtabLoadCmd || Symtab.nsyms == 0)
2505  return basic_symbol_iterator(SymbolRef(DRI, this));
2506 
2507  unsigned SymbolTableEntrySize = is64Bit() ?
2508  sizeof(MachO::nlist_64) :
2509  sizeof(MachO::nlist);
2510  unsigned Offset = Symtab.symoff +
2511  Symtab.nsyms * SymbolTableEntrySize;
2512  DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2513  return basic_symbol_iterator(SymbolRef(DRI, this));
2514 }
2515 
2518  if (!SymtabLoadCmd || Index >= Symtab.nsyms)
2519  report_fatal_error("Requested symbol index is out of range.");
2520  unsigned SymbolTableEntrySize =
2521  is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
2522  DataRefImpl DRI;
2523  DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Symtab.symoff));
2524  DRI.p += Index * SymbolTableEntrySize;
2525  return basic_symbol_iterator(SymbolRef(DRI, this));
2526 }
2527 
2530  if (!SymtabLoadCmd)
2531  report_fatal_error("getSymbolIndex() called with no symbol table symbol");
2532  unsigned SymbolTableEntrySize =
2533  is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
2534  DataRefImpl DRIstart;
2535  DRIstart.p = reinterpret_cast<uintptr_t>(getPtr(*this, Symtab.symoff));
2536  uint64_t Index = (Symb.p - DRIstart.p) / SymbolTableEntrySize;
2537  return Index;
2538 }
2539 
2541  DataRefImpl DRI;
2542  return section_iterator(SectionRef(DRI, this));
2543 }
2544 
2546  DataRefImpl DRI;
2547  DRI.d.a = Sections.size();
2548  return section_iterator(SectionRef(DRI, this));
2549 }
2550 
2552  return is64Bit() ? 8 : 4;
2553 }
2554 
2556  unsigned CPUType = getCPUType(*this);
2557  if (!is64Bit()) {
2558  switch (CPUType) {
2559  case MachO::CPU_TYPE_I386:
2560  return "Mach-O 32-bit i386";
2561  case MachO::CPU_TYPE_ARM:
2562  return "Mach-O arm";
2564  return "Mach-O arm64 (ILP32)";
2566  return "Mach-O 32-bit ppc";
2567  default:
2568  return "Mach-O 32-bit unknown";
2569  }
2570  }
2571 
2572  switch (CPUType) {
2574  return "Mach-O 64-bit x86-64";
2575  case MachO::CPU_TYPE_ARM64:
2576  return "Mach-O arm64";
2578  return "Mach-O 64-bit ppc64";
2579  default:
2580  return "Mach-O 64-bit unknown";
2581  }
2582 }
2583 
2585  switch (CPUType) {
2586  case MachO::CPU_TYPE_I386:
2587  return Triple::x86;
2589  return Triple::x86_64;
2590  case MachO::CPU_TYPE_ARM:
2591  return Triple::arm;
2592  case MachO::CPU_TYPE_ARM64:
2593  return Triple::aarch64;
2595  return Triple::aarch64_32;
2597  return Triple::ppc;
2599  return Triple::ppc64;
2600  default:
2601  return Triple::UnknownArch;
2602  }
2603 }
2604 
2606  const char **McpuDefault,
2607  const char **ArchFlag) {
2608  if (McpuDefault)
2609  *McpuDefault = nullptr;
2610  if (ArchFlag)
2611  *ArchFlag = nullptr;
2612 
2613  switch (CPUType) {
2614  case MachO::CPU_TYPE_I386:
2615  switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2617  if (ArchFlag)
2618  *ArchFlag = "i386";
2619  return Triple("i386-apple-darwin");
2620  default:
2621  return Triple();
2622  }
2624  switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2626  if (ArchFlag)
2627  *ArchFlag = "x86_64";
2628  return Triple("x86_64-apple-darwin");
2630  if (ArchFlag)
2631  *ArchFlag = "x86_64h";
2632  return Triple("x86_64h-apple-darwin");
2633  default:
2634  return Triple();
2635  }
2636  case MachO::CPU_TYPE_ARM:
2637  switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2639  if (ArchFlag)
2640  *ArchFlag = "armv4t";
2641  return Triple("armv4t-apple-darwin");
2643  if (ArchFlag)
2644  *ArchFlag = "armv5e";
2645  return Triple("armv5e-apple-darwin");
2647  if (ArchFlag)
2648  *ArchFlag = "xscale";
2649  return Triple("xscale-apple-darwin");
2651  if (ArchFlag)
2652  *ArchFlag = "armv6";
2653  return Triple("armv6-apple-darwin");
2655  if (McpuDefault)
2656  *McpuDefault = "cortex-m0";
2657  if (ArchFlag)
2658  *ArchFlag = "armv6m";
2659  return Triple("armv6m-apple-darwin");
2661  if (ArchFlag)
2662  *ArchFlag = "armv7";
2663  return Triple("armv7-apple-darwin");
2665  if (McpuDefault)
2666  *McpuDefault = "cortex-m4";
2667  if (ArchFlag)
2668  *ArchFlag = "armv7em";
2669  return Triple("thumbv7em-apple-darwin");
2671  if (McpuDefault)
2672  *McpuDefault = "cortex-a7";
2673  if (ArchFlag)
2674  *ArchFlag = "armv7k";
2675  return Triple("armv7k-apple-darwin");
2677  if (McpuDefault)
2678  *McpuDefault = "cortex-m3";
2679  if (ArchFlag)
2680  *ArchFlag = "armv7m";
2681  return Triple("thumbv7m-apple-darwin");
2683  if (McpuDefault)
2684  *McpuDefault = "cortex-a7";
2685  if (ArchFlag)
2686  *ArchFlag = "armv7s";
2687  return Triple("armv7s-apple-darwin");
2688  default:
2689  return Triple();
2690  }
2691  case MachO::CPU_TYPE_ARM64:
2692  switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2694  if (McpuDefault)
2695  *McpuDefault = "cyclone";
2696  if (ArchFlag)
2697  *ArchFlag = "arm64";
2698  return Triple("arm64-apple-darwin");
2700  if (McpuDefault)
2701  *McpuDefault = "apple-a12";
2702  if (ArchFlag)
2703  *ArchFlag = "arm64e";
2704  return Triple("arm64e-apple-darwin");
2705  default:
2706  return Triple();
2707  }
2709  switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2711  if (McpuDefault)
2712  *McpuDefault = "cyclone";
2713  if (ArchFlag)
2714  *ArchFlag = "arm64_32";
2715  return Triple("arm64_32-apple-darwin");
2716  default:
2717  return Triple();
2718  }
2720  switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2722  if (ArchFlag)
2723  *ArchFlag = "ppc";
2724  return Triple("ppc-apple-darwin");
2725  default:
2726  return Triple();
2727  }
2729  switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2731  if (ArchFlag)
2732  *ArchFlag = "ppc64";
2733  return Triple("ppc64-apple-darwin");
2734  default:
2735  return Triple();
2736  }
2737  default:
2738  return Triple();
2739  }
2740 }
2741 
2744 }
2745 
2747  auto validArchs = getValidArchs();
2748  return llvm::is_contained(validArchs, ArchFlag);
2749 }
2750 
2752  static const std::array<StringRef, 18> ValidArchs = {{
2753  "i386",
2754  "x86_64",
2755  "x86_64h",
2756  "armv4t",
2757  "arm",
2758  "armv5e",
2759  "armv6",
2760  "armv6m",
2761  "armv7",
2762  "armv7em",
2763  "armv7k",
2764  "armv7m",
2765  "armv7s",
2766  "arm64",
2767  "arm64e",
2768  "arm64_32",
2769  "ppc",
2770  "ppc64",
2771  }};
2772 
2773  return ValidArchs;
2774 }
2775 
2777  return getArch(getCPUType(*this), getCPUSubType(*this));
2778 }
2779 
2780 Triple MachOObjectFile::getArchTriple(const char **McpuDefault) const {
2781  return getArchTriple(Header.cputype, Header.cpusubtype, McpuDefault);
2782 }
2783 
2785  DataRefImpl DRI;
2786  DRI.d.a = Index;
2787  return section_rel_begin(DRI);
2788 }
2789 
2791  DataRefImpl DRI;
2792  DRI.d.a = Index;
2793  return section_rel_end(DRI);
2794 }
2795 
2797  DataRefImpl DRI;
2798  if (!DataInCodeLoadCmd)
2799  return dice_iterator(DiceRef(DRI, this));
2800 
2802  DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, DicLC.dataoff));
2803  return dice_iterator(DiceRef(DRI, this));
2804 }
2805 
2807  DataRefImpl DRI;
2808  if (!DataInCodeLoadCmd)
2809  return dice_iterator(DiceRef(DRI, this));
2810 
2812  unsigned Offset = DicLC.dataoff + DicLC.datasize;
2813  DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2814  return dice_iterator(DiceRef(DRI, this));
2815 }
2816 
2818  ArrayRef<uint8_t> T) : E(E), O(O), Trie(T) {}
2819 
2820 void ExportEntry::moveToFirst() {
2821  ErrorAsOutParameter ErrAsOutParam(E);
2822  pushNode(0);
2823  if (*E)
2824  return;
2825  pushDownUntilBottom();
2826 }
2827 
2828 void ExportEntry::moveToEnd() {
2829  Stack.clear();
2830  Done = true;
2831 }
2832 
2834  // Common case, one at end, other iterating from begin.
2835  if (Done || Other.Done)
2836  return (Done == Other.Done);
2837  // Not equal if different stack sizes.
2838  if (Stack.size() != Other.Stack.size())
2839  return false;
2840  // Not equal if different cumulative strings.
2841  if (!CumulativeString.equals(Other.CumulativeString))
2842  return false;
2843  // Equal if all nodes in both stacks match.
2844  for (unsigned i=0; i < Stack.size(); ++i) {
2845  if (Stack[i].Start != Other.Stack[i].Start)
2846  return false;
2847  }
2848  return true;
2849 }
2850 
2851 uint64_t ExportEntry::readULEB128(const uint8_t *&Ptr, const char **error) {
2852  unsigned Count;
2853  uint64_t Result = decodeULEB128(Ptr, &Count, Trie.end(), error);
2854  Ptr += Count;
2855  if (Ptr > Trie.end())
2856  Ptr = Trie.end();
2857  return Result;
2858 }
2859 
2861  return CumulativeString;
2862 }
2863 
2864 uint64_t ExportEntry::flags() const {
2865  return Stack.back().Flags;
2866 }
2867 
2868 uint64_t ExportEntry::address() const {
2869  return Stack.back().Address;
2870 }
2871 
2872 uint64_t ExportEntry::other() const {
2873  return Stack.back().Other;
2874 }
2875 
2877  const char* ImportName = Stack.back().ImportName;
2878  if (ImportName)
2879  return StringRef(ImportName);
2880  return StringRef();
2881 }
2882 
2884  return Stack.back().Start - Trie.begin();
2885 }
2886 
2887 ExportEntry::NodeState::NodeState(const uint8_t *Ptr)
2888  : Start(Ptr), Current(Ptr) {}
2889 
2890 void ExportEntry::pushNode(uint64_t offset) {
2891  ErrorAsOutParameter ErrAsOutParam(E);
2892  const uint8_t *Ptr = Trie.begin() + offset;
2893  NodeState State(Ptr);
2894  const char *error;
2895  uint64_t ExportInfoSize = readULEB128(State.Current, &error);
2896  if (error) {
2897  *E = malformedError("export info size " + Twine(error) +
2898  " in export trie data at node: 0x" +
2899  Twine::utohexstr(offset));
2900  moveToEnd();
2901  return;
2902  }
2903  State.IsExportNode = (ExportInfoSize != 0);
2904  const uint8_t* Children = State.Current + ExportInfoSize;
2905  if (Children > Trie.end()) {
2906  *E = malformedError(
2907  "export info size: 0x" + Twine::utohexstr(ExportInfoSize) +
2908  " in export trie data at node: 0x" + Twine::utohexstr(offset) +
2909  " too big and extends past end of trie data");
2910  moveToEnd();
2911  return;
2912  }
2913  if (State.IsExportNode) {
2914  const uint8_t *ExportStart = State.Current;
2915  State.Flags = readULEB128(State.Current, &error);
2916  if (error) {
2917  *E = malformedError("flags " + Twine(error) +
2918  " in export trie data at node: 0x" +
2919  Twine::utohexstr(offset));
2920  moveToEnd();
2921  return;
2922  }
2923  uint64_t Kind = State.Flags & MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK;
2924  if (State.Flags != 0 &&
2928  *E = malformedError(
2929  "unsupported exported symbol kind: " + Twine((int)Kind) +
2930  " in flags: 0x" + Twine::utohexstr(State.Flags) +
2931  " in export trie data at node: 0x" + Twine::utohexstr(offset));
2932  moveToEnd();
2933  return;
2934  }
2935  if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT) {
2936  State.Address = 0;
2937  State.Other = readULEB128(State.Current, &error); // dylib ordinal
2938  if (error) {
2939  *E = malformedError("dylib ordinal of re-export " + Twine(error) +
2940  " in export trie data at node: 0x" +
2941  Twine::utohexstr(offset));
2942  moveToEnd();
2943  return;
2944  }
2945  if (O != nullptr) {
2946  if (State.Other > O->getLibraryCount()) {
2947  *E = malformedError(
2948  "bad library ordinal: " + Twine((int)State.Other) + " (max " +
2949  Twine((int)O->getLibraryCount()) +
2950  ") in export trie data at node: 0x" + Twine::utohexstr(offset));
2951  moveToEnd();
2952  return;
2953  }
2954  }
2955  State.ImportName = reinterpret_cast<const char*>(State.Current);
2956  if (*State.ImportName == '\0') {
2957  State.Current++;
2958  } else {
2959  const uint8_t *End = State.Current + 1;
2960  if (End >= Trie.end()) {
2961  *E = malformedError("import name of re-export in export trie data at "
2962  "node: 0x" +
2963  Twine::utohexstr(offset) +
2964  " starts past end of trie data");
2965  moveToEnd();
2966  return;
2967  }
2968  while(*End != '\0' && End < Trie.end())
2969  End++;
2970  if (*End != '\0') {
2971  *E = malformedError("import name of re-export in export trie data at "
2972  "node: 0x" +
2973  Twine::utohexstr(offset) +
2974  " extends past end of trie data");
2975  moveToEnd();
2976  return;
2977  }
2978  State.Current = End + 1;
2979  }
2980  } else {
2981  State.Address = readULEB128(State.Current, &error);
2982  if (error) {
2983  *E = malformedError("address " + Twine(error) +
2984  " in export trie data at node: 0x" +
2985  Twine::utohexstr(offset));
2986  moveToEnd();
2987  return;
2988  }
2990  State.Other = readULEB128(State.Current, &error);
2991  if (error) {
2992  *E = malformedError("resolver of stub and resolver " + Twine(error) +
2993  " in export trie data at node: 0x" +
2994  Twine::utohexstr(offset));
2995  moveToEnd();
2996  return;
2997  }
2998  }
2999  }
3000  if(ExportStart + ExportInfoSize != State.Current) {
3001  *E = malformedError(
3002  "inconsistant export info size: 0x" +
3003  Twine::utohexstr(ExportInfoSize) + " where actual size was: 0x" +
3004  Twine::utohexstr(State.Current - ExportStart) +
3005  " in export trie data at node: 0x" + Twine::utohexstr(offset));
3006  moveToEnd();
3007  return;
3008  }
3009  }
3010  State.ChildCount = *Children;
3011  if (State.ChildCount != 0 && Children + 1 >= Trie.end()) {
3012  *E = malformedError("byte for count of childern in export trie data at "
3013  "node: 0x" +
3014  Twine::utohexstr(offset) +
3015  " extends past end of trie data");
3016  moveToEnd();
3017  return;
3018  }
3019  State.Current = Children + 1;
3020  State.NextChildIndex = 0;
3021  State.ParentStringLength = CumulativeString.size();
3022  Stack.push_back(State);
3023 }
3024 
3025 void ExportEntry::pushDownUntilBottom() {
3026  ErrorAsOutParameter ErrAsOutParam(E);
3027  const char *error;
3028  while (Stack.back().NextChildIndex < Stack.back().ChildCount) {
3029  NodeState &Top = Stack.back();
3030  CumulativeString.resize(Top.ParentStringLength);
3031  for (;*Top.Current != 0 && Top.Current < Trie.end(); Top.Current++) {
3032  char C = *Top.Current;
3033  CumulativeString.push_back(C);
3034  }
3035  if (Top.Current >= Trie.end()) {
3036  *E = malformedError("edge sub-string in export trie data at node: 0x" +
3037  Twine::utohexstr(Top.Start - Trie.begin()) +
3038  " for child #" + Twine((int)Top.NextChildIndex) +
3039  " extends past end of trie data");
3040  moveToEnd();
3041  return;
3042  }
3043  Top.Current += 1;
3044  uint64_t childNodeIndex = readULEB128(Top.Current, &error);
3045  if (error) {
3046  *E = malformedError("child node offset " + Twine(error) +
3047  " in export trie data at node: 0x" +
3048  Twine::utohexstr(Top.Start - Trie.begin()));
3049  moveToEnd();
3050  return;
3051  }
3052  for (const NodeState &node : nodes()) {
3053  if (node.Start == Trie.begin() + childNodeIndex){
3054  *E = malformedError("loop in childern in export trie data at node: 0x" +
3055  Twine::utohexstr(Top.Start - Trie.begin()) +
3056  " back to node: 0x" +
3057  Twine::utohexstr(childNodeIndex));
3058  moveToEnd();
3059  return;
3060  }
3061  }
3062  Top.NextChildIndex += 1;
3063  pushNode(childNodeIndex);
3064  if (*E)
3065  return;
3066  }
3067  if (!Stack.back().IsExportNode) {
3068  *E = malformedError("node is not an export node in export trie data at "
3069  "node: 0x" +
3070  Twine::utohexstr(Stack.back().Start - Trie.begin()));
3071  moveToEnd();
3072  return;
3073  }
3074 }
3075 
3076 // We have a trie data structure and need a way to walk it that is compatible
3077 // with the C++ iterator model. The solution is a non-recursive depth first
3078 // traversal where the iterator contains a stack of parent nodes along with a
3079 // string that is the accumulation of all edge strings along the parent chain
3080 // to this point.
3081 //
3082 // There is one "export" node for each exported symbol. But because some
3083 // symbols may be a prefix of another symbol (e.g. _dup and _dup2), an export
3084 // node may have child nodes too.
3085 //
3086 // The algorithm for moveNext() is to keep moving down the leftmost unvisited
3087 // child until hitting a node with no children (which is an export node or
3088 // else the trie is malformed). On the way down, each node is pushed on the
3089 // stack ivar. If there is no more ways down, it pops up one and tries to go
3090 // down a sibling path until a childless node is reached.
3092  assert(!Stack.empty() && "ExportEntry::moveNext() with empty node stack");
3093  if (!Stack.back().IsExportNode) {
3094  *E = malformedError("node is not an export node in export trie data at "
3095  "node: 0x" +
3096  Twine::utohexstr(Stack.back().Start - Trie.begin()));
3097  moveToEnd();
3098  return;
3099  }
3100 
3101  Stack.pop_back();
3102  while (!Stack.empty()) {
3103  NodeState &Top = Stack.back();
3104  if (Top.NextChildIndex < Top.ChildCount) {
3105  pushDownUntilBottom();
3106  // Now at the next export node.
3107  return;
3108  } else {
3109  if (Top.IsExportNode) {
3110  // This node has no children but is itself an export node.
3111  CumulativeString.resize(Top.ParentStringLength);
3112  return;
3113  }
3114  Stack.pop_back();
3115  }
3116  }
3117  Done = true;
3118 }
3119 
3122  const MachOObjectFile *O) {
3123  ExportEntry Start(&E, O, Trie);
3124  if (Trie.empty())
3125  Start.moveToEnd();
3126  else
3127  Start.moveToFirst();
3128 
3129  ExportEntry Finish(&E, O, Trie);
3130  Finish.moveToEnd();
3131 
3132  return make_range(export_iterator(Start), export_iterator(Finish));
3133 }
3134 
3136  return exports(Err, getDyldInfoExportsTrie(), this);
3137 }
3138 
3140  ArrayRef<uint8_t> Bytes, bool is64Bit)
3141  : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()),
3142  PointerSize(is64Bit ? 8 : 4) {}
3143 
3144 void MachORebaseEntry::moveToFirst() {
3145  Ptr = Opcodes.begin();
3146  moveNext();
3147 }
3148 
3149 void MachORebaseEntry::moveToEnd() {
3150  Ptr = Opcodes.end();
3151  RemainingLoopCount = 0;
3152  Done = true;
3153 }
3154 
3156  ErrorAsOutParameter ErrAsOutParam(E);
3157  // If in the middle of some loop, move to next rebasing in loop.
3158  SegmentOffset += AdvanceAmount;
3159  if (RemainingLoopCount) {
3160  --RemainingLoopCount;
3161  return;
3162  }
3163  // REBASE_OPCODE_DONE is only used for padding if we are not aligned to
3164  // pointer size. Therefore it is possible to reach the end without ever having
3165  // seen REBASE_OPCODE_DONE.
3166  if (Ptr == Opcodes.end()) {
3167  Done = true;
3168  return;
3169  }
3170  bool More = true;
3171  while (More) {
3172  // Parse next opcode and set up next loop.
3173  const uint8_t *OpcodeStart = Ptr;
3174  uint8_t Byte = *Ptr++;
3175  uint8_t ImmValue = Byte & MachO::REBASE_IMMEDIATE_MASK;
3176  uint8_t Opcode = Byte & MachO::REBASE_OPCODE_MASK;
3177  uint32_t Count, Skip;
3178  const char *error = nullptr;
3179  switch (Opcode) {
3181  More = false;
3182  Done = true;
3183  moveToEnd();
3184  DEBUG_WITH_TYPE("mach-o-rebase", dbgs() << "REBASE_OPCODE_DONE\n");
3185  break;
3187  RebaseType = ImmValue;
3189  *E = malformedError("for REBASE_OPCODE_SET_TYPE_IMM bad bind type: " +
3190  Twine((int)RebaseType) + " for opcode at: 0x" +
3191  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3192  moveToEnd();
3193  return;
3194  }
3196  "mach-o-rebase",
3197  dbgs() << "REBASE_OPCODE_SET_TYPE_IMM: "
3198  << "RebaseType=" << (int) RebaseType << "\n");
3199  break;
3201  SegmentIndex = ImmValue;
3203  if (error) {
3204  *E = malformedError("for REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3205  Twine(error) + " for opcode at: 0x" +
3206  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3207  moveToEnd();
3208  return;
3209  }
3210  error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3211  PointerSize);
3212  if (error) {
3213  *E = malformedError("for REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3214  Twine(error) + " for opcode at: 0x" +
3215  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3216  moveToEnd();
3217  return;
3218  }
3220  "mach-o-rebase",
3221  dbgs() << "REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
3222  << "SegmentIndex=" << SegmentIndex << ", "
3223  << format("SegmentOffset=0x%06X", SegmentOffset)
3224  << "\n");
3225  break;
3228  if (error) {
3229  *E = malformedError("for REBASE_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3230  " for opcode at: 0x" +
3231  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3232  moveToEnd();
3233  return;
3234  }
3235  error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3236  PointerSize);
3237  if (error) {
3238  *E = malformedError("for REBASE_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3239  " for opcode at: 0x" +
3240  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3241  moveToEnd();
3242  return;
3243  }
3244  DEBUG_WITH_TYPE("mach-o-rebase",
3245  dbgs() << "REBASE_OPCODE_ADD_ADDR_ULEB: "
3246  << format("SegmentOffset=0x%06X",
3247  SegmentOffset) << "\n");
3248  break;
3250  SegmentOffset += ImmValue * PointerSize;
3251  error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3252  PointerSize);
3253  if (error) {
3254  *E = malformedError("for REBASE_OPCODE_ADD_ADDR_IMM_SCALED " +
3255  Twine(error) + " for opcode at: 0x" +
3256  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3257  moveToEnd();
3258  return;
3259  }
3260  DEBUG_WITH_TYPE("mach-o-rebase",
3261  dbgs() << "REBASE_OPCODE_ADD_ADDR_IMM_SCALED: "
3262  << format("SegmentOffset=0x%06X",
3263  SegmentOffset) << "\n");
3264  break;
3266  AdvanceAmount = PointerSize;
3267  Skip = 0;
3268  Count = ImmValue;
3269  if (ImmValue != 0)
3270  RemainingLoopCount = ImmValue - 1;
3271  else
3272  RemainingLoopCount = 0;
3273  error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3274  PointerSize, Count, Skip);
3275  if (error) {
3276  *E = malformedError("for REBASE_OPCODE_DO_REBASE_IMM_TIMES " +
3277  Twine(error) + " for opcode at: 0x" +
3278  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3279  moveToEnd();
3280  return;
3281  }
3283  "mach-o-rebase",
3284  dbgs() << "REBASE_OPCODE_DO_REBASE_IMM_TIMES: "
3285  << format("SegmentOffset=0x%06X", SegmentOffset)
3286  << ", AdvanceAmount=" << AdvanceAmount
3287  << ", RemainingLoopCount=" << RemainingLoopCount
3288  << "\n");
3289  return;
3291  AdvanceAmount = PointerSize;
3292  Skip = 0;
3293  Count = readULEB128(&error);
3294  if (error) {
3295  *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES " +
3296  Twine(error) + " for opcode at: 0x" +
3297  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3298  moveToEnd();
3299  return;
3300  }
3301  if (Count != 0)
3302  RemainingLoopCount = Count - 1;
3303  else
3304  RemainingLoopCount = 0;
3305  error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3306  PointerSize, Count, Skip);
3307  if (error) {
3308  *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES " +
3309  Twine(error) + " for opcode at: 0x" +
3310  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3311  moveToEnd();
3312  return;
3313  }
3315  "mach-o-rebase",
3316  dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES: "
3317  << format("SegmentOffset=0x%06X", SegmentOffset)
3318  << ", AdvanceAmount=" << AdvanceAmount
3319  << ", RemainingLoopCount=" << RemainingLoopCount
3320  << "\n");
3321  return;
3323  Skip = readULEB128(&error);
3324  if (error) {
3325  *E = malformedError("for REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB " +
3326  Twine(error) + " for opcode at: 0x" +
3327  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3328  moveToEnd();
3329  return;
3330  }
3331  AdvanceAmount = Skip + PointerSize;
3332  Count = 1;
3333  RemainingLoopCount = 0;
3334  error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3335  PointerSize, Count, Skip);
3336  if (error) {
3337  *E = malformedError("for REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB " +
3338  Twine(error) + " for opcode at: 0x" +
3339  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3340  moveToEnd();
3341  return;
3342  }
3344  "mach-o-rebase",
3345  dbgs() << "REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: "
3346  << format("SegmentOffset=0x%06X", SegmentOffset)
3347  << ", AdvanceAmount=" << AdvanceAmount
3348  << ", RemainingLoopCount=" << RemainingLoopCount
3349  << "\n");
3350  return;
3352  Count = readULEB128(&error);
3353  if (error) {
3354  *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3355  "ULEB " +
3356  Twine(error) + " for opcode at: 0x" +
3357  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3358  moveToEnd();
3359  return;
3360  }
3361  if (Count != 0)
3362  RemainingLoopCount = Count - 1;
3363  else
3364  RemainingLoopCount = 0;
3365  Skip = readULEB128(&error);
3366  if (error) {
3367  *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3368  "ULEB " +
3369  Twine(error) + " for opcode at: 0x" +
3370  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3371  moveToEnd();
3372  return;
3373  }
3374  AdvanceAmount = Skip + PointerSize;
3375 
3376  error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3377  PointerSize, Count, Skip);
3378  if (error) {
3379  *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3380  "ULEB " +
3381  Twine(error) + " for opcode at: 0x" +
3382  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3383  moveToEnd();
3384  return;
3385  }
3387  "mach-o-rebase",
3388  dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: "
3389  << format("SegmentOffset=0x%06X", SegmentOffset)
3390  << ", AdvanceAmount=" << AdvanceAmount
3391  << ", RemainingLoopCount=" << RemainingLoopCount
3392  << "\n");
3393  return;
3394  default:
3395  *E = malformedError("bad rebase info (bad opcode value 0x" +
3396  Twine::utohexstr(Opcode) + " for opcode at: 0x" +
3397  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3398  moveToEnd();
3399  return;
3400  }
3401  }
3402 }
3403 
3404 uint64_t MachORebaseEntry::readULEB128(const char **error) {
3405  unsigned Count;
3406  uint64_t Result = decodeULEB128(Ptr, &Count, Opcodes.end(), error);
3407  Ptr += Count;
3408  if (Ptr > Opcodes.end())
3409  Ptr = Opcodes.end();
3410  return Result;
3411 }
3412 
3413 int32_t MachORebaseEntry::segmentIndex() const { return SegmentIndex; }
3414 
3416 
3418  switch (RebaseType) {
3420  return "pointer";
3422  return "text abs32";
3424  return "text rel32";
3425  }
3426  return "unknown";
3427 }
3428 
3429 // For use with the SegIndex of a checked Mach-O Rebase entry
3430 // to get the segment name.
3432  return O->BindRebaseSegmentName(SegmentIndex);
3433 }
3434 
3435 // For use with a SegIndex,SegOffset pair from a checked Mach-O Rebase entry
3436 // to get the section name.
3438  return O->BindRebaseSectionName(SegmentIndex, SegmentOffset);
3439 }
3440 
3441 // For use with a SegIndex,SegOffset pair from a checked Mach-O Rebase entry
3442 // to get the address.
3443 uint64_t MachORebaseEntry::address() const {
3444  return O->BindRebaseAddress(SegmentIndex, SegmentOffset);
3445 }
3446 
3448 #ifdef EXPENSIVE_CHECKS
3449  assert(Opcodes == Other.Opcodes && "compare iterators of different files");
3450 #else
3451  assert(Opcodes.data() == Other.Opcodes.data() && "compare iterators of different files");
3452 #endif
3453  return (Ptr == Other.Ptr) &&
3454  (RemainingLoopCount == Other.RemainingLoopCount) &&
3455  (Done == Other.Done);
3456 }
3457 
3460  ArrayRef<uint8_t> Opcodes, bool is64) {
3461  if (O->BindRebaseSectionTable == nullptr)
3462  O->BindRebaseSectionTable = std::make_unique<BindRebaseSegInfo>(O);
3463  MachORebaseEntry Start(&Err, O, Opcodes, is64);
3464  Start.moveToFirst();
3465 
3466  MachORebaseEntry Finish(&Err, O, Opcodes, is64);
3467  Finish.moveToEnd();
3468 
3469  return make_range(rebase_iterator(Start), rebase_iterator(Finish));
3470 }
3471 
3473  return rebaseTable(Err, this, getDyldInfoRebaseOpcodes(), is64Bit());
3474 }
3475 
3477  ArrayRef<uint8_t> Bytes, bool is64Bit, Kind BK)
3478  : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()),
3479  PointerSize(is64Bit ? 8 : 4), TableKind(BK) {}
3480 
3481 void MachOBindEntry::moveToFirst() {
3482  Ptr = Opcodes.begin();
3483  moveNext();
3484 }
3485 
3486 void MachOBindEntry::moveToEnd() {
3487  Ptr = Opcodes.end();
3488  RemainingLoopCount = 0;
3489  Done = true;
3490 }
3491 
3493  ErrorAsOutParameter ErrAsOutParam(E);
3494  // If in the middle of some loop, move to next binding in loop.
3495  SegmentOffset += AdvanceAmount;
3496  if (RemainingLoopCount) {
3497  --RemainingLoopCount;
3498  return;
3499  }
3500  // BIND_OPCODE_DONE is only used for padding if we are not aligned to
3501  // pointer size. Therefore it is possible to reach the end without ever having
3502  // seen BIND_OPCODE_DONE.
3503  if (Ptr == Opcodes.end()) {
3504  Done = true;
3505  return;
3506  }
3507  bool More = true;
3508  while (More) {
3509  // Parse next opcode and set up next loop.
3510  const uint8_t *OpcodeStart = Ptr;
3511  uint8_t Byte = *Ptr++;
3512  uint8_t ImmValue = Byte & MachO::BIND_IMMEDIATE_MASK;
3513  uint8_t Opcode = Byte & MachO::BIND_OPCODE_MASK;
3514  int8_t SignExtended;
3515  const uint8_t *SymStart;
3516  uint32_t Count, Skip;
3517  const char *error = nullptr;
3518  switch (Opcode) {
3520  if (TableKind == Kind::Lazy) {
3521  // Lazying bindings have a DONE opcode between entries. Need to ignore
3522  // it to advance to next entry. But need not if this is last entry.
3523  bool NotLastEntry = false;
3524  for (const uint8_t *P = Ptr; P < Opcodes.end(); ++P) {
3525  if (*P) {
3526  NotLastEntry = true;
3527  }
3528  }
3529  if (NotLastEntry)
3530  break;
3531  }
3532  More = false;
3533  moveToEnd();
3534  DEBUG_WITH_TYPE("mach-o-bind", dbgs() << "BIND_OPCODE_DONE\n");
3535  break;
3537  if (TableKind == Kind::Weak) {
3538  *E = malformedError("BIND_OPCODE_SET_DYLIB_ORDINAL_IMM not allowed in "
3539  "weak bind table for opcode at: 0x" +
3540  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3541  moveToEnd();
3542  return;
3543  }
3544  Ordinal = ImmValue;
3545  LibraryOrdinalSet = true;
3546  if (ImmValue > O->getLibraryCount()) {
3547  *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB bad "
3548  "library ordinal: " +
3549  Twine((int)ImmValue) + " (max " +
3550  Twine((int)O->getLibraryCount()) +
3551  ") for opcode at: 0x" +
3552  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3553  moveToEnd();
3554  return;
3555  }
3557  "mach-o-bind",
3558  dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: "
3559  << "Ordinal=" << Ordinal << "\n");
3560  break;
3562  if (TableKind == Kind::Weak) {
3563  *E = malformedError("BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB not allowed in "
3564  "weak bind table for opcode at: 0x" +
3565  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3566  moveToEnd();
3567  return;
3568  }
3569  Ordinal = readULEB128(&error);
3570  LibraryOrdinalSet = true;
3571  if (error) {
3572  *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB " +
3573  Twine(error) + " for opcode at: 0x" +
3574  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3575  moveToEnd();
3576  return;
3577  }
3578  if (Ordinal > (int)O->getLibraryCount()) {
3579  *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB bad "
3580  "library ordinal: " +
3581  Twine((int)Ordinal) + " (max " +
3582  Twine((int)O->getLibraryCount()) +
3583  ") for opcode at: 0x" +
3584  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3585  moveToEnd();
3586  return;
3587  }
3589  "mach-o-bind",
3590  dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: "
3591  << "Ordinal=" << Ordinal << "\n");
3592  break;
3594  if (TableKind == Kind::Weak) {
3595  *E = malformedError("BIND_OPCODE_SET_DYLIB_SPECIAL_IMM not allowed in "
3596  "weak bind table for opcode at: 0x" +
3597  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3598  moveToEnd();
3599  return;
3600  }
3601  if (ImmValue) {
3602  SignExtended = MachO::BIND_OPCODE_MASK | ImmValue;
3603  Ordinal = SignExtended;
3604  if (Ordinal < MachO::BIND_SPECIAL_DYLIB_FLAT_LOOKUP) {
3605  *E = malformedError("for BIND_OPCODE_SET_DYLIB_SPECIAL_IMM unknown "
3606  "special ordinal: " +
3607  Twine((int)Ordinal) + " for opcode at: 0x" +
3608  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3609  moveToEnd();
3610  return;
3611  }
3612  } else
3613  Ordinal = 0;
3614  LibraryOrdinalSet = true;
3616  "mach-o-bind",
3617  dbgs() << "BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: "
3618  << "Ordinal=" << Ordinal << "\n");
3619  break;
3621  Flags = ImmValue;
3622  SymStart = Ptr;
3623  while (*Ptr && (Ptr < Opcodes.end())) {
3624  ++Ptr;
3625  }
3626  if (Ptr == Opcodes.end()) {
3627  *E = malformedError(
3628  "for BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM "
3629  "symbol name extends past opcodes for opcode at: 0x" +
3630  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3631  moveToEnd();
3632  return;
3633  }
3634  SymbolName = StringRef(reinterpret_cast<const char*>(SymStart),
3635  Ptr-SymStart);
3636  ++Ptr;
3638  "mach-o-bind",
3639  dbgs() << "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: "
3640  << "SymbolName=" << SymbolName << "\n");
3641  if (TableKind == Kind::Weak) {
3643  return;
3644  }
3645  break;
3647  BindType = ImmValue;
3648  if (ImmValue > MachO::BIND_TYPE_TEXT_PCREL32) {
3649  *E = malformedError("for BIND_OPCODE_SET_TYPE_IMM bad bind type: " +
3650  Twine((int)ImmValue) + " for opcode at: 0x" +
3651  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3652  moveToEnd();
3653  return;
3654  }
3656  "mach-o-bind",
3657  dbgs() << "BIND_OPCODE_SET_TYPE_IMM: "
3658  << "BindType=" << (int)BindType << "\n");
3659  break;
3661  Addend = readSLEB128(&error);
3662  if (error) {
3663  *E = malformedError("for BIND_OPCODE_SET_ADDEND_SLEB " + Twine(error) +
3664  " for opcode at: 0x" +
3665  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3666  moveToEnd();
3667  return;
3668  }
3670  "mach-o-bind",
3671  dbgs() << "BIND_OPCODE_SET_ADDEND_SLEB: "
3672  << "Addend=" << Addend << "\n");
3673  break;
3675  SegmentIndex = ImmValue;
3677  if (error) {
3678  *E = malformedError("for BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3679  Twine(error) + " for opcode at: 0x" +
3680  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3681  moveToEnd();
3682  return;
3683  }
3684  error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3685  PointerSize);
3686  if (error) {
3687  *E = malformedError("for BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3688  Twine(error) + " for opcode at: 0x" +
3689  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3690  moveToEnd();
3691  return;
3692  }
3694  "mach-o-bind",
3695  dbgs() << "BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
3696  << "SegmentIndex=" << SegmentIndex << ", "
3697  << format("SegmentOffset=0x%06X", SegmentOffset)
3698  << "\n");
3699  break;
3702  if (error) {
3703  *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3704  " for opcode at: 0x" +
3705  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3706  moveToEnd();
3707  return;
3708  }
3709  error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3710  PointerSize);
3711  if (error) {
3712  *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3713  " for opcode at: 0x" +
3714  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3715  moveToEnd();
3716  return;
3717  }
3718  DEBUG_WITH_TYPE("mach-o-bind",
3719  dbgs() << "BIND_OPCODE_ADD_ADDR_ULEB: "
3720  << format("SegmentOffset=0x%06X",
3721  SegmentOffset) << "\n");
3722  break;
3724  AdvanceAmount = PointerSize;
3725  RemainingLoopCount = 0;
3726  error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3727  PointerSize);
3728  if (error) {
3729  *E = malformedError("for BIND_OPCODE_DO_BIND " + Twine(error) +
3730  " for opcode at: 0x" +
3731  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3732  moveToEnd();
3733  return;
3734  }
3735  if (SymbolName == StringRef()) {
3736  *E = malformedError(
3737  "for BIND_OPCODE_DO_BIND missing preceding "
3738  "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for opcode at: 0x" +
3739  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3740  moveToEnd();
3741  return;
3742  }
3743  if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3744  *E =
3745  malformedError("for BIND_OPCODE_DO_BIND missing preceding "
3746  "BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode at: 0x" +
3747  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3748  moveToEnd();
3749  return;
3750  }
3751  DEBUG_WITH_TYPE("mach-o-bind",
3752  dbgs() << "BIND_OPCODE_DO_BIND: "
3753  << format("SegmentOffset=0x%06X",
3754  SegmentOffset) << "\n");
3755  return;
3757  if (TableKind == Kind::Lazy) {
3758  *E = malformedError("BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB not allowed in "
3759  "lazy bind table for opcode at: 0x" +
3760  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3761  moveToEnd();
3762  return;
3763  }
3764  error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3765  PointerSize);
3766  if (error) {
3767  *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB " +
3768  Twine(error) + " for opcode at: 0x" +
3769  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3770  moveToEnd();
3771  return;
3772  }
3773  if (SymbolName == StringRef()) {
3774  *E = malformedError(
3775  "for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB missing "
3776  "preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for opcode "
3777  "at: 0x" +
3778  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3779  moveToEnd();
3780  return;
3781  }
3782  if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3783  *E = malformedError(
3784  "for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB missing "
3785  "preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode at: 0x" +
3786  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3787  moveToEnd();
3788  return;
3789  }
3790  AdvanceAmount = readULEB128(&error) + PointerSize;
3791  if (error) {
3792  *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB " +
3793  Twine(error) + " for opcode at: 0x" +
3794  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3795  moveToEnd();
3796  return;
3797  }
3798  // Note, this is not really an error until the next bind but make no sense
3799  // for a BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB to not be followed by another
3800  // bind operation.
3801  error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset +
3802  AdvanceAmount, PointerSize);
3803  if (error) {
3804  *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB (after adding "
3805  "ULEB) " +
3806  Twine(error) + " for opcode at: 0x" +
3807  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3808  moveToEnd();
3809  return;
3810  }
3811  RemainingLoopCount = 0;
3813  "mach-o-bind",
3814  dbgs() << "BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: "
3815  << format("SegmentOffset=0x%06X", SegmentOffset)
3816  << ", AdvanceAmount=" << AdvanceAmount
3817  << ", RemainingLoopCount=" << RemainingLoopCount
3818  << "\n");
3819  return;
3821  if (TableKind == Kind::Lazy) {
3822  *E = malformedError("BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED not "
3823  "allowed in lazy bind table for opcode at: 0x" +
3824  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3825  moveToEnd();
3826  return;
3827  }
3828  if (SymbolName == StringRef()) {
3829  *E = malformedError(
3830  "for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED "
3831  "missing preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for "
3832  "opcode at: 0x" +
3833  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3834  moveToEnd();
3835  return;
3836  }
3837  if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3838  *E = malformedError(
3839  "for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED "
3840  "missing preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode "
3841  "at: 0x" +
3842  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3843  moveToEnd();
3844  return;
3845  }
3846  AdvanceAmount = ImmValue * PointerSize + PointerSize;
3847  RemainingLoopCount = 0;
3848  error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset +
3849  AdvanceAmount, PointerSize);
3850  if (error) {
3851  *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED " +
3852  Twine(error) + " for opcode at: 0x" +
3853  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3854  moveToEnd();
3855  return;
3856  }
3857  DEBUG_WITH_TYPE("mach-o-bind",
3858  dbgs()
3859  << "BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: "
3860  << format("SegmentOffset=0x%06X", SegmentOffset) << "\n");
3861  return;
3863  if (TableKind == Kind::Lazy) {
3864  *E = malformedError("BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB not "
3865  "allowed in lazy bind table for opcode at: 0x" +
3866  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3867  moveToEnd();
3868  return;
3869  }
3870  Count = readULEB128(&error);
3871  if (Count != 0)
3872  RemainingLoopCount = Count - 1;
3873  else
3874  RemainingLoopCount = 0;
3875  if (error) {
3876  *E = malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3877  " (count value) " +
3878  Twine(error) + " for opcode at: 0x" +
3879  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3880  moveToEnd();
3881  return;
3882  }
3883  Skip = readULEB128(&error);
3884  AdvanceAmount = Skip + PointerSize;
3885  if (error) {
3886  *E = malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3887  " (skip value) " +
3888  Twine(error) + " for opcode at: 0x" +
3889  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3890  moveToEnd();
3891  return;
3892  }
3893  if (SymbolName == StringRef()) {
3894  *E = malformedError(
3895  "for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3896  "missing preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for "
3897  "opcode at: 0x" +
3898  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3899  moveToEnd();
3900  return;
3901  }
3902  if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3903  *E = malformedError(
3904  "for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3905  "missing preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode "
3906  "at: 0x" +
3907  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3908  moveToEnd();
3909  return;
3910  }
3911  error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3912  PointerSize, Count, Skip);
3913  if (error) {
3914  *E =
3915  malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB " +
3916  Twine(error) + " for opcode at: 0x" +
3917  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3918  moveToEnd();
3919  return;
3920  }
3922  "mach-o-bind",
3923  dbgs() << "BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: "
3924  << format("SegmentOffset=0x%06X", SegmentOffset)
3925  << ", AdvanceAmount=" << AdvanceAmount
3926  << ", RemainingLoopCount=" << RemainingLoopCount
3927  << "\n");
3928  return;
3929  default:
3930  *E = malformedError("bad bind info (bad opcode value 0x" +
3931  Twine::utohexstr(Opcode) + " for opcode at: 0x" +
3932  Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3933  moveToEnd();
3934  return;
3935  }
3936  }
3937 }
3938 
3939 uint64_t MachOBindEntry::readULEB128(const char **error) {
3940  unsigned Count;
3941  uint64_t Result = decodeULEB128(Ptr, &Count, Opcodes.end(), error);
3942  Ptr += Count;
3943  if (Ptr > Opcodes.end())
3944  Ptr = Opcodes.end();
3945  return Result;
3946 }
3947 
3948 int64_t MachOBindEntry::readSLEB128(const char **error) {
3949  unsigned Count;
3950  int64_t Result = decodeSLEB128(Ptr, &Count, Opcodes.end(), error);
3951  Ptr += Count;
3952  if (Ptr > Opcodes.end())
3953  Ptr = Opcodes.end();
3954  return Result;
3955 }
3956 
3957 int32_t MachOBindEntry::segmentIndex() const { return SegmentIndex; }
3958 
3959 uint64_t MachOBindEntry::segmentOffset() const { return SegmentOffset; }
3960 
3962  switch (BindType) {
3964  return "pointer";
3966  return "text abs32";
3968  return "text rel32";
3969  }
3970  return "unknown";
3971 }
3972 
3974 
3975 int64_t MachOBindEntry::addend() const { return Addend; }
3976 
3977 uint32_t MachOBindEntry::flags() const { return Flags; }
3978 
3979 int MachOBindEntry::ordinal() const { return Ordinal; }
3980 
3981 // For use with the SegIndex of a checked Mach-O Bind entry
3982 // to get the segment name.
3984  return O->BindRebaseSegmentName(SegmentIndex);
3985 }
3986 
3987 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind entry
3988 // to get the section name.
3990  return O->BindRebaseSectionName(SegmentIndex, SegmentOffset);
3991 }
3992 
3993 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind entry
3994 // to get the address.
3995 uint64_t MachOBindEntry::address() const {
3996  return O->BindRebaseAddress(SegmentIndex, SegmentOffset);
3997 }
3998 
4000 #ifdef EXPENSIVE_CHECKS
4001  assert(Opcodes == Other.Opcodes && "compare iterators of different files");
4002 #else
4003  assert(Opcodes.data() == Other.Opcodes.data() && "compare iterators of different files");
4004 #endif
4005  return (Ptr == Other.Ptr) &&
4006  (RemainingLoopCount == Other.RemainingLoopCount) &&
4007  (Done == Other.Done);
4008 }
4009 
4010 // Build table of sections so SegIndex/SegOffset pairs can be translated.
4012  uint32_t CurSegIndex = Obj->hasPageZeroSegment() ? 1 : 0;
4013  StringRef CurSegName;
4014  uint64_t CurSegAddress;
4015  for (const SectionRef &Section : Obj->sections()) {
4016  SectionInfo Info;
4017  Expected<StringRef> NameOrErr = Section.getName();
4018  if (!NameOrErr)
4019  consumeError(NameOrErr.takeError());
4020  else
4021  Info.SectionName = *NameOrErr;
4022  Info.Address = Section.getAddress();
4023  Info.Size = Section.getSize();
4024  Info.SegmentName =
4025  Obj->getSectionFinalSegmentName(Section.getRawDataRefImpl());
4026  if (!Info.SegmentName.equals(CurSegName)) {
4027  ++CurSegIndex;
4028  CurSegName = Info.SegmentName;
4029  CurSegAddress = Info.Address;
4030  }
4031  Info.SegmentIndex = CurSegIndex - 1;
4032  Info.OffsetInSegment = Info.Address - CurSegAddress;
4033  Info.SegmentStartAddress = CurSegAddress;
4034  Sections.push_back(Info);
4035  }
4036  MaxSegIndex = CurSegIndex;
4037 }
4038 
4039 // For use with a SegIndex, SegOffset, and PointerSize triple in
4040 // MachOBindEntry::moveNext() to validate a MachOBindEntry or MachORebaseEntry.
4041 //
4042 // Given a SegIndex, SegOffset, and PointerSize, verify a valid section exists
4043 // that fully contains a pointer at that location. Multiple fixups in a bind
4044 // (such as with the BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB opcode) can
4045 // be tested via the Count and Skip parameters.
4046 const char * BindRebaseSegInfo::checkSegAndOffsets(int32_t SegIndex,
4047  uint64_t SegOffset,
4048  uint8_t PointerSize,
4049  uint32_t Count,
4050  uint32_t Skip) {
4051  if (SegIndex == -1)
4052  return "missing preceding *_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB";
4053  if (SegIndex >= MaxSegIndex)
4054  return "bad segIndex (too large)";
4055  for (uint32_t i = 0; i < Count; ++i) {
4056  uint32_t Start = SegOffset + i * (PointerSize + Skip);
4057  uint32_t End = Start + PointerSize;
4058  bool Found = false;
4059  for (const SectionInfo &SI : Sections) {
4060  if (SI.SegmentIndex != SegIndex)
4061  continue;
4062  if ((SI.OffsetInSegment<=Start) && (Start<(SI.OffsetInSegment+SI.Size))) {
4063  if (End <= SI.OffsetInSegment + SI.Size) {
4064  Found = true;
4065  break;
4066  }
4067  else
4068  return "bad offset, extends beyond section boundary";
4069  }
4070  }
4071  if (!Found)
4072  return "bad offset, not in section";
4073  }
4074  return nullptr;
4075 }
4076 
4077 // For use with the SegIndex of a checked Mach-O Bind or Rebase entry
4078 // to get the segment name.
4080  for (const SectionInfo &SI : Sections) {
4081  if (SI.SegmentIndex == SegIndex)
4082  return SI.SegmentName;
4083  }
4084  llvm_unreachable("invalid SegIndex");
4085 }
4086 
4087 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
4088 // to get the SectionInfo.
4089 const BindRebaseSegInfo::SectionInfo &BindRebaseSegInfo::findSection(
4090  int32_t SegIndex, uint64_t SegOffset) {
4091  for (const SectionInfo &SI : Sections) {
4092  if (SI.SegmentIndex != SegIndex)
4093  continue;
4094  if (SI.OffsetInSegment > SegOffset)
4095  continue;
4096  if (SegOffset >= (SI.OffsetInSegment + SI.Size))
4097  continue;
4098  return SI;
4099  }
4100  llvm_unreachable("SegIndex and SegOffset not in any section");
4101 }
4102 
4103 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
4104 // entry to get the section name.
4106  uint64_t SegOffset) {
4107  return findSection(SegIndex, SegOffset).SectionName;
4108 }
4109 
4110 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
4111 // entry to get the address.
4112 uint64_t BindRebaseSegInfo::address(uint32_t SegIndex, uint64_t OffsetInSeg) {
4113  const SectionInfo &SI = findSection(SegIndex, OffsetInSeg);
4114  return SI.SegmentStartAddress + OffsetInSeg;
4115 }
4116 
4119  ArrayRef<uint8_t> Opcodes, bool is64,
4120  MachOBindEntry::Kind BKind) {
4121  if (O->BindRebaseSectionTable == nullptr)
4122  O->BindRebaseSectionTable = std::make_unique<BindRebaseSegInfo>(O);
4123  MachOBindEntry Start(&Err, O, Opcodes, is64, BKind);
4124  Start.moveToFirst();
4125 
4126  MachOBindEntry Finish(&Err, O, Opcodes, is64, BKind);
4127  Finish.moveToEnd();
4128 
4129  return make_range(bind_iterator(Start), bind_iterator(Finish));
4130 }
4131 
4133  return bindTable(Err, this, getDyldInfoBindOpcodes(), is64Bit(),
4135 }
4136 
4138  return bindTable(Err, this, getDyldInfoLazyBindOpcodes(), is64Bit(),
4140 }
4141 
4143  return bindTable(Err, this, getDyldInfoWeakBindOpcodes(), is64Bit(),
4145 }
4146 
4149  return LoadCommands.begin();
4150 }
4151 
4154  return LoadCommands.end();
4155 }
4156 
4160 }
4161 
4162 StringRef
4165  return parseSegmentOrSectionName(Raw.data());
4166 }
4167 
4170  assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
4171  const section_base *Base =
4172  reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
4173  return makeArrayRef(Base->sectname);
4174 }
4175 
4178  assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
4179  const section_base *Base =
4180  reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
4181  return makeArrayRef(Base->segname);
4182 }
4183 
4184 bool
4186  const {
4187  if (getCPUType(*this) == MachO::CPU_TYPE_X86_64)
4188  return false;
4190 }
4191 
4193  const MachO::any_relocation_info &RE) const {
4194  if (isLittleEndian())
4195  return RE.r_word1 & 0xffffff;
4196  return RE.r_word1 >> 8;
4197 }
4198 
4200  const MachO::any_relocation_info &RE) const {
4201  if (isLittleEndian())
4202  return (RE.r_word1 >> 27) & 1;
4203  return (RE.r_word1 >> 4) & 1;
4204 }
4205 
4207  const MachO::any_relocation_info &RE) const {
4208  return RE.r_word0 >> 31;
4209 }
4210 
4212  const MachO::any_relocation_info &RE) const {
4213  return RE.r_word1;
4214 }
4215 
4217  const MachO::any_relocation_info &RE) const {
4218  return (RE.r_word0 >> 24) & 0xf;
4219 }
4220 
4222  const MachO::any_relocation_info &RE) const {
4223  if (isRelocationScattered(RE))
4224  return getScatteredRelocationAddress(RE);
4225  return getPlainRelocationAddress(RE);
4226 }
4227 
4229  const MachO::any_relocation_info &RE) const {
4230  if (isRelocationScattered(RE))
4231  return getScatteredRelocationPCRel(RE);
4232  return getPlainRelocationPCRel(*this, RE);
4233 }
4234 
4236  const MachO::any_relocation_info &RE) const {
4237  if (isRelocationScattered(RE))
4238  return getScatteredRelocationLength(RE);
4239  return getPlainRelocationLength(*this, RE);
4240 }
4241 
4242 unsigned
4244  const MachO::any_relocation_info &RE) const {
4245  if (isRelocationScattered(RE))
4246  return getScatteredRelocationType(RE);
4247  return getPlainRelocationType(*this, RE);
4248 }
4249 
4250 SectionRef
4252  const MachO::any_relocation_info &RE) const {
4254  return *section_end();
4255  unsigned SecNum = getPlainRelocationSymbolNum(RE);
4256  if (SecNum == MachO::R_ABS || SecNum > Sections.size())
4257  return *section_end();
4258  DataRefImpl DRI;
4259  DRI.d.a = SecNum - 1;
4260  return SectionRef(DRI, this);
4261 }
4262 
4264  assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
4265  return getStruct<MachO::section>(*this, Sections[DRI.d.a]);
4266 }
4267 
4269  assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
4270  return getStruct<MachO::section_64>(*this, Sections[DRI.d.a]);
4271 }
4272 
4274  unsigned Index) const {
4275  const char *Sec = getSectionPtr(*this, L, Index);
4276  return getStruct<MachO::section>(*this, Sec);
4277 }
4278 
4280  unsigned Index) const {
4281  const char *Sec = getSectionPtr(*this, L, Index);
4282  return getStruct<MachO::section_64>(*this, Sec);
4283 }
4284 
4287  const char *P = reinterpret_cast<const char *>(DRI.p);
4288  return getStruct<MachO::nlist>(*this, P);
4289 }
4290 
4293  const char *P = reinterpret_cast<const char *>(DRI.p);
4294  return getStruct<MachO::nlist_64>(*this, P);
4295 }
4296 
4299  return getStruct<MachO::linkedit_data_command>(*this, L.Ptr);
4300 }
4301 
4304  return getStruct<MachO::segment_command>(*this, L.Ptr);
4305 }
4306 
4309  return getStruct<MachO::segment_command_64>(*this, L.Ptr);
4310 }
4311 
4314  return getStruct<MachO::linker_option_command>(*this, L.Ptr);
4315 }
4316 
4319  return getStruct<MachO::version_min_command>(*this, L.Ptr);
4320 }
4321 
4324  return getStruct<MachO::note_command>(*this, L.Ptr);
4325 }
4326 
4329  return getStruct<MachO::build_version_command>(*this, L.Ptr);
4330 }
4331 
4334  return getStruct<MachO::build_tool_version>(*this, BuildTools[index]);
4335 }
4336 
4339  return getStruct<MachO::dylib_command>(*this, L.Ptr);
4340 }
4341 
4344  return getStruct<MachO::dyld_info_command>(*this, L.Ptr);
4345 }
4346 
4349  return getStruct<MachO::dylinker_command>(*this, L.Ptr);
4350 }
4351 
4354  return getStruct<MachO::uuid_command>(*this, L.Ptr);
4355 }
4356 
4359  return getStruct<MachO::rpath_command>(*this, L.Ptr);
4360 }
4361 
4364  return getStruct<MachO::source_version_command>(*this, L.Ptr);
4365 }
4366 
4369  return getStruct<MachO::entry_point_command>(*this, L.Ptr);
4370 }
4371 
4374  return getStruct<MachO::encryption_info_command>(*this, L.Ptr);
4375 }
4376 
4379  return getStruct<MachO::encryption_info_command_64>(*this, L.Ptr);
4380 }
4381 
4384  return getStruct<MachO::sub_framework_command>(*this, L.Ptr);
4385 }
4386 
4389  return getStruct<MachO::sub_umbrella_command>(*this, L.Ptr);
4390 }
4391 
4394  return getStruct<MachO::sub_library_command>(*this, L.Ptr);
4395 }
4396 
4399  return getStruct<MachO::sub_client_command>(*this, L.Ptr);
4400 }
4401 
4404  return getStruct<MachO::routines_command>(*this, L.Ptr);
4405 }
4406 
4409  return getStruct<MachO::routines_command_64>(*this, L.Ptr);
4410 }
4411 
4414  return getStruct<MachO::thread_command>(*this, L.Ptr);
4415 }
4416 
4419  uint32_t Offset;
4420  if (getHeader().filetype == MachO::MH_OBJECT) {
4421  DataRefImpl Sec;
4422  Sec.d.a = Rel.d.a;
4423  if (is64Bit()) {
4424  MachO::section_64 Sect = getSection64(Sec);
4425  Offset = Sect.reloff;
4426  } else {
4427  MachO::section Sect = getSection(Sec);
4428  Offset = Sect.reloff;
4429  }
4430  } else {
4431  MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
4432  if (Rel.d.a == 0)
4433  Offset = DysymtabLoadCmd.extreloff; // Offset to the external relocations
4434  else
4435  Offset = DysymtabLoadCmd.locreloff; // Offset to the local relocations
4436  }
4437 
4438  auto P = reinterpret_cast<const MachO::any_relocation_info *>(
4439  getPtr(*this, Offset)) + Rel.d.b;
4440  return getStruct<MachO::any_relocation_info>(
4441  *this, reinterpret_cast<const char *>(P));
4442 }
4443 
4446  const char *P = reinterpret_cast<const char *>(Rel.p);
4447  return getStruct<MachO::data_in_code_entry>(*this, P);
4448 }
4449 
4451  return Header;
4452 }
4453 
4455  assert(is64Bit());
4456  return Header64;
4457 }
4458 
4461  unsigned Index) const {
4462  uint64_t Offset = DLC.indirectsymoff + Index * sizeof(uint32_t);
4463  return getStruct<uint32_t>(*this, getPtr(*this, Offset));
4464 }
4465 
4468  unsigned Index) const {
4469  uint64_t Offset = DataOffset + Index * sizeof(MachO::data_in_code_entry);
4470  return getStruct<MachO::data_in_code_entry>(*this, getPtr(*this, Offset));
4471 }
4472 
4474  if (SymtabLoadCmd)
4475  return getStruct<MachO::symtab_command>(*this, SymtabLoadCmd);
4476 
4477  // If there is no SymtabLoadCmd return a load command with zero'ed fields.
4479  Cmd.cmd = MachO::LC_SYMTAB;
4480  Cmd.cmdsize = sizeof(MachO::symtab_command);
4481  Cmd.symoff = 0;
4482  Cmd.nsyms = 0;
4483  Cmd.stroff = 0;
4484  Cmd.strsize = 0;
4485  return Cmd;
4486 }
4487 
4489  if (DysymtabLoadCmd)
4490  return getStruct<MachO::dysymtab_command>(*this, DysymtabLoadCmd);
4491 
4492  // If there is no DysymtabLoadCmd return a load command with zero'ed fields.
4494  Cmd.cmd = MachO::LC_DYSYMTAB;
4495  Cmd.cmdsize = sizeof(MachO::dysymtab_command);
4496  Cmd.ilocalsym = 0;
4497  Cmd.nlocalsym = 0;
4498  Cmd.iextdefsym = 0;
4499  Cmd.nextdefsym = 0;
4500  Cmd.iundefsym = 0;
4501  Cmd.nundefsym = 0;
4502  Cmd.tocoff = 0;
4503  Cmd.ntoc = 0;
4504  Cmd.modtaboff = 0;
4505  Cmd.nmodtab = 0;
4506  Cmd.extrefsymoff = 0;
4507  Cmd.nextrefsyms = 0;
4508  Cmd.indirectsymoff = 0;
4509  Cmd.nindirectsyms = 0;
4510  Cmd.extreloff = 0;
4511  Cmd.nextrel = 0;
4512  Cmd.locreloff = 0;
4513  Cmd.nlocrel = 0;
4514  return Cmd;
4515 }
4516 
4519  if (DataInCodeLoadCmd)
4520  return getStruct<MachO::linkedit_data_command>(*this, DataInCodeLoadCmd);
4521 
4522  // If there is no DataInCodeLoadCmd return a load command with zero'ed fields.
4524  Cmd.cmd = MachO::LC_DATA_IN_CODE;
4525  Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
4526  Cmd.dataoff = 0;
4527  Cm