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"
22 #include "llvm/BinaryFormat/MachO.h"
23 #include "llvm/Object/Error.h"
24 #include "llvm/Object/MachO.h"
25 #include "llvm/Object/ObjectFile.h"
26 #include "llvm/Object/SymbolicFile.h"
27 #include "llvm/Support/DataExtractor.h"
28 #include "llvm/Support/Debug.h"
29 #include "llvm/Support/Error.h"
30 #include "llvm/Support/ErrorHandling.h"
31 #include "llvm/Support/Format.h"
32 #include "llvm/Support/Host.h"
33 #include "llvm/Support/LEB128.h"
34 #include "llvm/Support/MemoryBuffer.h"
35 #include "llvm/Support/SwapByteOrder.h"
36 #include "llvm/Support/raw_ostream.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
malformedError(const Twine & Msg)60 static Error malformedError(const Twine &Msg) {
61 return make_error<GenericBinaryError>("truncated or malformed object (" +
62 Msg + ")",
63 object_error::parse_failed);
64 }
65
66 // FIXME: Replace all uses of this function with getStructOrErr.
67 template <typename T>
getStruct(const MachOObjectFile & O,const char * P)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>
getStructOrErr(const MachOObjectFile & O,const char * P)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 *
getSectionPtr(const MachOObjectFile & O,MachOObjectFile::LoadCommandInfo L,unsigned Sec)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
getPtr(const MachOObjectFile & O,size_t Offset)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
getSymbolTableEntryBase(const MachOObjectFile & O,DataRefImpl DRI)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
parseSegmentOrSectionName(const char * P)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
getCPUType(const MachOObjectFile & O)127 static unsigned getCPUType(const MachOObjectFile &O) {
128 return O.getHeader().cputype;
129 }
130
getCPUSubType(const MachOObjectFile & O)131 static unsigned getCPUSubType(const MachOObjectFile &O) {
132 return O.getHeader().cpusubtype;
133 }
134
135 static uint32_t
getPlainRelocationAddress(const MachO::any_relocation_info & RE)136 getPlainRelocationAddress(const MachO::any_relocation_info &RE) {
137 return RE.r_word0;
138 }
139
140 static unsigned
getScatteredRelocationAddress(const MachO::any_relocation_info & RE)141 getScatteredRelocationAddress(const MachO::any_relocation_info &RE) {
142 return RE.r_word0 & 0xffffff;
143 }
144
getPlainRelocationPCRel(const MachOObjectFile & O,const MachO::any_relocation_info & RE)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
getScatteredRelocationPCRel(const MachO::any_relocation_info & RE)153 getScatteredRelocationPCRel(const MachO::any_relocation_info &RE) {
154 return (RE.r_word0 >> 30) & 1;
155 }
156
getPlainRelocationLength(const MachOObjectFile & O,const MachO::any_relocation_info & RE)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
getScatteredRelocationLength(const MachO::any_relocation_info & RE)165 getScatteredRelocationLength(const MachO::any_relocation_info &RE) {
166 return (RE.r_word0 >> 28) & 3;
167 }
168
getPlainRelocationType(const MachOObjectFile & O,const MachO::any_relocation_info & RE)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
getSectionFlags(const MachOObjectFile & O,DataRefImpl Sec)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
186 static Expected<MachOObjectFile::LoadCommandInfo>
getLoadCommandInfo(const MachOObjectFile & Obj,const char * Ptr,uint32_t LoadCommandIndex)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
201 static Expected<MachOObjectFile::LoadCommandInfo>
getFirstLoadCommandInfo(const MachOObjectFile & Obj)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
211 static Expected<MachOObjectFile::LoadCommandInfo>
getNextLoadCommandInfo(const MachOObjectFile & Obj,uint32_t LoadCommandIndex,const MachOObjectFile::LoadCommandInfo & L)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>
parseHeader(const MachOObjectFile & Obj,T & Header,Error & Err)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
checkOverlappingElement(std::list<MachOElement> & Elements,uint64_t Offset,uint64_t Size,const char * Name)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>
parseSegmentLoadCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,SmallVectorImpl<const char * > & Sections,bool & IsPageZeroSegment,uint32_t LoadCommandIndex,const char * CmdName,uint64_t SizeOfHeaders,std::list<MachOElement> & Elements)277 static Error parseSegmentLoadCommand(
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();
290 if (S.nsects > std::numeric_limits<uint32_t>::max() / SectionSize ||
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 &&
305 s.flags != MachO::S_THREAD_LOCAL_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 &&
323 s.flags != MachO::S_THREAD_LOCAL_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 &&
332 s.flags != MachO::S_THREAD_LOCAL_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 &&
357 s.flags != MachO::S_THREAD_LOCAL_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
376 MachO::relocation_info),
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
checkSymtabCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char ** SymtabLoadCmd,std::list<MachOElement> & Elements)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
checkDysymtabCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char ** DysymtabLoadCmd,std::list<MachOElement> & Elements)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
492 MachO::dylib_table_of_contents),
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
checkLinkeditDataCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char ** LoadCmd,const char * CmdName,std::list<MachOElement> & Elements,const char * ElementName)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
checkDyldInfoCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char ** LoadCmd,const char * CmdName,std::list<MachOElement> & Elements)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
checkDylibCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char * CmdName)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
checkDylibIdCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char ** LoadCmd)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
checkDyldCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char * CmdName)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
checkVersCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char ** LoadCmd,const char * CmdName)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
checkNoteCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,std::list<MachOElement> & Elements)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
parseBuildVersionCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,SmallVectorImpl<const char * > & BuildTools,uint32_t LoadCommandIndex)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 !=
864 sizeof(MachO::build_version_command) +
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
checkRpathCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex)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
checkEncryptCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,uint64_t cryptoff,uint64_t cryptsize,const char ** LoadCmd,const char * CmdName)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
checkLinkerOptCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex)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
checkSubCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char * CmdName,size_t SizeOfCmd,const char * CmdStructName,uint32_t PathOffset,const char * PathFieldName)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
checkThreadCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char * CmdName)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)
1034 sys::swapByteOrder(count);
1035 state += sizeof(uint32_t);
1036
1037 if (cputype == MachO::CPU_TYPE_I386) {
1038 if (flavor == MachO::x86_THREAD_STATE32) {
1039 if (count != MachO::x86_THREAD_STATE32_COUNT)
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) {
1058 if (count != MachO::x86_THREAD_STATE_COUNT)
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) {
1070 if (count != MachO::x86_FLOAT_STATE_COUNT)
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) {
1082 if (count != MachO::x86_EXCEPTION_STATE_COUNT)
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) {
1094 if (count != MachO::x86_THREAD_STATE64_COUNT)
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) {
1106 if (count != MachO::x86_EXCEPTION_STATE64_COUNT)
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) {
1125 if (count != MachO::ARM_THREAD_STATE_COUNT)
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) {
1145 if (count != MachO::ARM_THREAD_STATE64_COUNT)
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) {
1164 if (count != MachO::PPC_THREAD_STATE_COUNT)
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
checkTwoLevelHintsCommand(const MachOObjectFile & Obj,const MachOObjectFile::LoadCommandInfo & Load,uint32_t LoadCommandIndex,const char ** LoadCmd,std::list<MachOElement> & Elements)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.
isLoadCommandObsolete(uint32_t cmd)1230 static bool isLoadCommandObsolete(uint32_t cmd) {
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
1244 Expected<std::unique_ptr<MachOObjectFile>>
create(MemoryBufferRef Object,bool IsLittleEndian,bool Is64Bits,uint32_t UniversalCputype,uint32_t UniversalIndex)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
MachOObjectFile(MemoryBufferRef Object,bool IsLittleEndian,bool Is64bits,Error & Err,uint32_t UniversalCputype,uint32_t UniversalIndex)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) {
1393 if ((Err = parseSegmentLoadCommand<MachO::segment_command_64,
1394 MachO::section_64>(
1395 *this, Load, Sections, HasPageZeroSegment, I,
1396 "LC_SEGMENT_64", SizeOfHeaders, Elements)))
1397 return;
1398 } else if (Load.C.cmd == MachO::LC_SEGMENT) {
1399 if ((Err = parseSegmentLoadCommand<MachO::segment_command,
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 }
1489 MachO::encryption_info_command E =
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 }
1500 MachO::encryption_info_command_64 E =
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 }
1514 MachO::sub_framework_command S =
1515 getStruct<MachO::sub_framework_command>(*this, Load.Ptr);
1516 if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_FRAMEWORK",
1517 sizeof(MachO::sub_framework_command),
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 }
1527 MachO::sub_umbrella_command S =
1528 getStruct<MachO::sub_umbrella_command>(*this, Load.Ptr);
1529 if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_UMBRELLA",
1530 sizeof(MachO::sub_umbrella_command),
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 }
1540 MachO::sub_library_command S =
1541 getStruct<MachO::sub_library_command>(*this, Load.Ptr);
1542 if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_LIBRARY",
1543 sizeof(MachO::sub_library_command),
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 }
1553 MachO::sub_client_command S =
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
checkSymbolTable() const1681 Error MachOObjectFile::checkSymbolTable() const {
1682 uint32_t Flags = 0;
1683 if (is64Bit()) {
1684 MachO::mach_header_64 H_64 = MachOObjectFile::getHeader64();
1685 Flags = H_64.flags;
1686 } else {
1687 MachO::mach_header H = MachOObjectFile::getHeader();
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;
1696 MachO::symtab_command S = getSymtabLoadCommand();
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
moveSymbolNext(DataRefImpl & Symb) const1748 void MachOObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
1749 unsigned SymbolTableEntrySize = is64Bit() ?
1750 sizeof(MachO::nlist_64) :
1751 sizeof(MachO::nlist);
1752 Symb.p += SymbolTableEntrySize;
1753 }
1754
getSymbolName(DataRefImpl Symb) const1755 Expected<StringRef> MachOObjectFile::getSymbolName(DataRefImpl Symb) const {
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
getSectionType(SectionRef Sec) const1770 unsigned MachOObjectFile::getSectionType(SectionRef Sec) const {
1771 DataRefImpl DRI = Sec.getRawDataRefImpl();
1772 uint32_t Flags = getSectionFlags(*this, DRI);
1773 return Flags & MachO::SECTION_TYPE;
1774 }
1775
getNValue(DataRefImpl Sym) const1776 uint64_t MachOObjectFile::getNValue(DataRefImpl Sym) const {
1777 if (is64Bit()) {
1778 MachO::nlist_64 Entry = getSymbol64TableEntry(Sym);
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.
getIndirectName(DataRefImpl Symb,StringRef & Res) const1787 std::error_code MachOObjectFile::getIndirectName(DataRefImpl Symb,
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)
1792 return object_error::parse_failed;
1793 uint64_t NValue = getNValue(Symb);
1794 if (NValue >= StringTable.size())
1795 return object_error::parse_failed;
1796 const char *Start = &StringTable.data()[NValue];
1797 Res = StringRef(Start);
1798 return std::error_code();
1799 }
1800
getSymbolValueImpl(DataRefImpl Sym) const1801 uint64_t MachOObjectFile::getSymbolValueImpl(DataRefImpl Sym) const {
1802 return getNValue(Sym);
1803 }
1804
getSymbolAddress(DataRefImpl Sym) const1805 Expected<uint64_t> MachOObjectFile::getSymbolAddress(DataRefImpl Sym) const {
1806 return getSymbolValue(Sym);
1807 }
1808
getSymbolAlignment(DataRefImpl DRI) const1809 uint32_t MachOObjectFile::getSymbolAlignment(DataRefImpl DRI) const {
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
getCommonSymbolSizeImpl(DataRefImpl DRI) const1818 uint64_t MachOObjectFile::getCommonSymbolSizeImpl(DataRefImpl DRI) const {
1819 return getNValue(DRI);
1820 }
1821
1822 Expected<SymbolRef::Type>
getSymbolType(DataRefImpl Symb) const1823 MachOObjectFile::getSymbolType(DataRefImpl Symb) const {
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->isData() || Sec->isBSS())
1840 return SymbolRef::ST_Data;
1841 return SymbolRef::ST_Function;
1842 }
1843 return SymbolRef::ST_Other;
1844 }
1845
getSymbolFlags(DataRefImpl DRI) const1846 Expected<uint32_t> MachOObjectFile::getSymbolFlags(DataRefImpl DRI) const {
1847 MachO::nlist_base Entry = getSymbolTableEntryBase(*this, DRI);
1848
1849 uint8_t MachOType = Entry.n_type;
1850 uint16_t MachOFlags = Entry.n_desc;
1851
1852 uint32_t Result = SymbolRef::SF_None;
1853
1854 if ((MachOType & MachO::N_TYPE) == MachO::N_INDR)
1855 Result |= SymbolRef::SF_Indirect;
1856
1857 if (MachOType & MachO::N_STAB)
1858 Result |= SymbolRef::SF_FormatSpecific;
1859
1860 if (MachOType & MachO::N_EXT) {
1861 Result |= SymbolRef::SF_Global;
1862 if ((MachOType & MachO::N_TYPE) == MachO::N_UNDF) {
1863 if (getNValue(DRI))
1864 Result |= SymbolRef::SF_Common;
1865 else
1866 Result |= SymbolRef::SF_Undefined;
1867 }
1868
1869 if (!(MachOType & MachO::N_PEXT))
1870 Result |= SymbolRef::SF_Exported;
1871 }
1872
1873 if (MachOFlags & (MachO::N_WEAK_REF | MachO::N_WEAK_DEF))
1874 Result |= SymbolRef::SF_Weak;
1875
1876 if (MachOFlags & (MachO::N_ARM_THUMB_DEF))
1877 Result |= SymbolRef::SF_Thumb;
1878
1879 if ((MachOType & MachO::N_TYPE) == MachO::N_ABS)
1880 Result |= SymbolRef::SF_Absolute;
1881
1882 return Result;
1883 }
1884
1885 Expected<section_iterator>
getSymbolSection(DataRefImpl Symb) const1886 MachOObjectFile::getSymbolSection(DataRefImpl Symb) const {
1887 MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1888 uint8_t index = Entry.n_sect;
1889
1890 if (index == 0)
1891 return section_end();
1892 DataRefImpl DRI;
1893 DRI.d.a = index - 1;
1894 if (DRI.d.a >= Sections.size()){
1895 return malformedError("bad section index: " + Twine((int)index) +
1896 " for symbol at index " + Twine(getSymbolIndex(Symb)));
1897 }
1898 return section_iterator(SectionRef(DRI, this));
1899 }
1900
getSymbolSectionID(SymbolRef Sym) const1901 unsigned MachOObjectFile::getSymbolSectionID(SymbolRef Sym) const {
1902 MachO::nlist_base Entry =
1903 getSymbolTableEntryBase(*this, Sym.getRawDataRefImpl());
1904 return Entry.n_sect - 1;
1905 }
1906
moveSectionNext(DataRefImpl & Sec) const1907 void MachOObjectFile::moveSectionNext(DataRefImpl &Sec) const {
1908 Sec.d.a++;
1909 }
1910
getSectionName(DataRefImpl Sec) const1911 Expected<StringRef> MachOObjectFile::getSectionName(DataRefImpl Sec) const {
1912 ArrayRef<char> Raw = getSectionRawName(Sec);
1913 return parseSegmentOrSectionName(Raw.data());
1914 }
1915
getSectionAddress(DataRefImpl Sec) const1916 uint64_t MachOObjectFile::getSectionAddress(DataRefImpl Sec) const {
1917 if (is64Bit())
1918 return getSection64(Sec).addr;
1919 return getSection(Sec).addr;
1920 }
1921
getSectionIndex(DataRefImpl Sec) const1922 uint64_t MachOObjectFile::getSectionIndex(DataRefImpl Sec) const {
1923 return Sec.d.a;
1924 }
1925
getSectionSize(DataRefImpl Sec) const1926 uint64_t MachOObjectFile::getSectionSize(DataRefImpl Sec) const {
1927 // In the case if a malformed Mach-O file where the section offset is past
1928 // the end of the file or some part of the section size is past the end of
1929 // the file return a size of zero or a size that covers the rest of the file
1930 // but does not extend past the end of the file.
1931 uint32_t SectOffset, SectType;
1932 uint64_t SectSize;
1933
1934 if (is64Bit()) {
1935 MachO::section_64 Sect = getSection64(Sec);
1936 SectOffset = Sect.offset;
1937 SectSize = Sect.size;
1938 SectType = Sect.flags & MachO::SECTION_TYPE;
1939 } else {
1940 MachO::section Sect = getSection(Sec);
1941 SectOffset = Sect.offset;
1942 SectSize = Sect.size;
1943 SectType = Sect.flags & MachO::SECTION_TYPE;
1944 }
1945 if (SectType == MachO::S_ZEROFILL || SectType == MachO::S_GB_ZEROFILL)
1946 return SectSize;
1947 uint64_t FileSize = getData().size();
1948 if (SectOffset > FileSize)
1949 return 0;
1950 if (FileSize - SectOffset < SectSize)
1951 return FileSize - SectOffset;
1952 return SectSize;
1953 }
1954
getSectionContents(uint32_t Offset,uint64_t Size) const1955 ArrayRef<uint8_t> MachOObjectFile::getSectionContents(uint32_t Offset,
1956 uint64_t Size) const {
1957 return arrayRefFromStringRef(getData().substr(Offset, Size));
1958 }
1959
1960 Expected<ArrayRef<uint8_t>>
getSectionContents(DataRefImpl Sec) const1961 MachOObjectFile::getSectionContents(DataRefImpl Sec) const {
1962 uint32_t Offset;
1963 uint64_t Size;
1964
1965 if (is64Bit()) {
1966 MachO::section_64 Sect = getSection64(Sec);
1967 Offset = Sect.offset;
1968 Size = Sect.size;
1969 } else {
1970 MachO::section Sect = getSection(Sec);
1971 Offset = Sect.offset;
1972 Size = Sect.size;
1973 }
1974
1975 return getSectionContents(Offset, Size);
1976 }
1977
getSectionAlignment(DataRefImpl Sec) const1978 uint64_t MachOObjectFile::getSectionAlignment(DataRefImpl Sec) const {
1979 uint32_t Align;
1980 if (is64Bit()) {
1981 MachO::section_64 Sect = getSection64(Sec);
1982 Align = Sect.align;
1983 } else {
1984 MachO::section Sect = getSection(Sec);
1985 Align = Sect.align;
1986 }
1987
1988 return uint64_t(1) << Align;
1989 }
1990
getSection(unsigned SectionIndex) const1991 Expected<SectionRef> MachOObjectFile::getSection(unsigned SectionIndex) const {
1992 if (SectionIndex < 1 || SectionIndex > Sections.size())
1993 return malformedError("bad section index: " + Twine((int)SectionIndex));
1994
1995 DataRefImpl DRI;
1996 DRI.d.a = SectionIndex - 1;
1997 return SectionRef(DRI, this);
1998 }
1999
getSection(StringRef SectionName) const2000 Expected<SectionRef> MachOObjectFile::getSection(StringRef SectionName) const {
2001 for (const SectionRef &Section : sections()) {
2002 auto NameOrErr = Section.getName();
2003 if (!NameOrErr)
2004 return NameOrErr.takeError();
2005 if (*NameOrErr == SectionName)
2006 return Section;
2007 }
2008 return errorCodeToError(object_error::parse_failed);
2009 }
2010
isSectionCompressed(DataRefImpl Sec) const2011 bool MachOObjectFile::isSectionCompressed(DataRefImpl Sec) const {
2012 return false;
2013 }
2014
isSectionText(DataRefImpl Sec) const2015 bool MachOObjectFile::isSectionText(DataRefImpl Sec) const {
2016 uint32_t Flags = getSectionFlags(*this, Sec);
2017 return Flags & MachO::S_ATTR_PURE_INSTRUCTIONS;
2018 }
2019
isSectionData(DataRefImpl Sec) const2020 bool MachOObjectFile::isSectionData(DataRefImpl Sec) const {
2021 uint32_t Flags = getSectionFlags(*this, Sec);
2022 unsigned SectionType = Flags & MachO::SECTION_TYPE;
2023 return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
2024 !(SectionType == MachO::S_ZEROFILL ||
2025 SectionType == MachO::S_GB_ZEROFILL);
2026 }
2027
isSectionBSS(DataRefImpl Sec) const2028 bool MachOObjectFile::isSectionBSS(DataRefImpl Sec) const {
2029 uint32_t Flags = getSectionFlags(*this, Sec);
2030 unsigned SectionType = Flags & MachO::SECTION_TYPE;
2031 return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
2032 (SectionType == MachO::S_ZEROFILL ||
2033 SectionType == MachO::S_GB_ZEROFILL);
2034 }
2035
isDebugSection(StringRef SectionName) const2036 bool MachOObjectFile::isDebugSection(StringRef SectionName) const {
2037 return SectionName.startswith("__debug") ||
2038 SectionName.startswith("__zdebug") ||
2039 SectionName.startswith("__apple") || SectionName == "__gdb_index" ||
2040 SectionName == "__swift_ast";
2041 }
2042
getSectionID(SectionRef Sec) const2043 unsigned MachOObjectFile::getSectionID(SectionRef Sec) const {
2044 return Sec.getRawDataRefImpl().d.a;
2045 }
2046
isSectionVirtual(DataRefImpl Sec) const2047 bool MachOObjectFile::isSectionVirtual(DataRefImpl Sec) const {
2048 uint32_t Flags = getSectionFlags(*this, Sec);
2049 unsigned SectionType = Flags & MachO::SECTION_TYPE;
2050 return SectionType == MachO::S_ZEROFILL ||
2051 SectionType == MachO::S_GB_ZEROFILL;
2052 }
2053
isSectionBitcode(DataRefImpl Sec) const2054 bool MachOObjectFile::isSectionBitcode(DataRefImpl Sec) const {
2055 StringRef SegmentName = getSectionFinalSegmentName(Sec);
2056 if (Expected<StringRef> NameOrErr = getSectionName(Sec))
2057 return (SegmentName == "__LLVM" && *NameOrErr == "__bitcode");
2058 return false;
2059 }
2060
isSectionStripped(DataRefImpl Sec) const2061 bool MachOObjectFile::isSectionStripped(DataRefImpl Sec) const {
2062 if (is64Bit())
2063 return getSection64(Sec).offset == 0;
2064 return getSection(Sec).offset == 0;
2065 }
2066
section_rel_begin(DataRefImpl Sec) const2067 relocation_iterator MachOObjectFile::section_rel_begin(DataRefImpl Sec) const {
2068 DataRefImpl Ret;
2069 Ret.d.a = Sec.d.a;
2070 Ret.d.b = 0;
2071 return relocation_iterator(RelocationRef(Ret, this));
2072 }
2073
2074 relocation_iterator
section_rel_end(DataRefImpl Sec) const2075 MachOObjectFile::section_rel_end(DataRefImpl Sec) const {
2076 uint32_t Num;
2077 if (is64Bit()) {
2078 MachO::section_64 Sect = getSection64(Sec);
2079 Num = Sect.nreloc;
2080 } else {
2081 MachO::section Sect = getSection(Sec);
2082 Num = Sect.nreloc;
2083 }
2084
2085 DataRefImpl Ret;
2086 Ret.d.a = Sec.d.a;
2087 Ret.d.b = Num;
2088 return relocation_iterator(RelocationRef(Ret, this));
2089 }
2090
extrel_begin() const2091 relocation_iterator MachOObjectFile::extrel_begin() const {
2092 DataRefImpl Ret;
2093 // for DYSYMTAB symbols, Ret.d.a == 0 for external relocations
2094 Ret.d.a = 0; // Would normally be a section index.
2095 Ret.d.b = 0; // Index into the external relocations
2096 return relocation_iterator(RelocationRef(Ret, this));
2097 }
2098
extrel_end() const2099 relocation_iterator MachOObjectFile::extrel_end() const {
2100 MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
2101 DataRefImpl Ret;
2102 // for DYSYMTAB symbols, Ret.d.a == 0 for external relocations
2103 Ret.d.a = 0; // Would normally be a section index.
2104 Ret.d.b = DysymtabLoadCmd.nextrel; // Index into the external relocations
2105 return relocation_iterator(RelocationRef(Ret, this));
2106 }
2107
locrel_begin() const2108 relocation_iterator MachOObjectFile::locrel_begin() const {
2109 DataRefImpl Ret;
2110 // for DYSYMTAB symbols, Ret.d.a == 1 for local relocations
2111 Ret.d.a = 1; // Would normally be a section index.
2112 Ret.d.b = 0; // Index into the local relocations
2113 return relocation_iterator(RelocationRef(Ret, this));
2114 }
2115
locrel_end() const2116 relocation_iterator MachOObjectFile::locrel_end() const {
2117 MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
2118 DataRefImpl Ret;
2119 // for DYSYMTAB symbols, Ret.d.a == 1 for local relocations
2120 Ret.d.a = 1; // Would normally be a section index.
2121 Ret.d.b = DysymtabLoadCmd.nlocrel; // Index into the local relocations
2122 return relocation_iterator(RelocationRef(Ret, this));
2123 }
2124
moveRelocationNext(DataRefImpl & Rel) const2125 void MachOObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
2126 ++Rel.d.b;
2127 }
2128
getRelocationOffset(DataRefImpl Rel) const2129 uint64_t MachOObjectFile::getRelocationOffset(DataRefImpl Rel) const {
2130 assert((getHeader().filetype == MachO::MH_OBJECT ||
2131 getHeader().filetype == MachO::MH_KEXT_BUNDLE) &&
2132 "Only implemented for MH_OBJECT && MH_KEXT_BUNDLE");
2133 MachO::any_relocation_info RE = getRelocation(Rel);
2134 return getAnyRelocationAddress(RE);
2135 }
2136
2137 symbol_iterator
getRelocationSymbol(DataRefImpl Rel) const2138 MachOObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
2139 MachO::any_relocation_info RE = getRelocation(Rel);
2140 if (isRelocationScattered(RE))
2141 return symbol_end();
2142
2143 uint32_t SymbolIdx = getPlainRelocationSymbolNum(RE);
2144 bool isExtern = getPlainRelocationExternal(RE);
2145 if (!isExtern)
2146 return symbol_end();
2147
2148 MachO::symtab_command S = getSymtabLoadCommand();
2149 unsigned SymbolTableEntrySize = is64Bit() ?
2150 sizeof(MachO::nlist_64) :
2151 sizeof(MachO::nlist);
2152 uint64_t Offset = S.symoff + SymbolIdx * SymbolTableEntrySize;
2153 DataRefImpl Sym;
2154 Sym.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2155 return symbol_iterator(SymbolRef(Sym, this));
2156 }
2157
2158 section_iterator
getRelocationSection(DataRefImpl Rel) const2159 MachOObjectFile::getRelocationSection(DataRefImpl Rel) const {
2160 return section_iterator(getAnyRelocationSection(getRelocation(Rel)));
2161 }
2162
getRelocationType(DataRefImpl Rel) const2163 uint64_t MachOObjectFile::getRelocationType(DataRefImpl Rel) const {
2164 MachO::any_relocation_info RE = getRelocation(Rel);
2165 return getAnyRelocationType(RE);
2166 }
2167
getRelocationTypeName(DataRefImpl Rel,SmallVectorImpl<char> & Result) const2168 void MachOObjectFile::getRelocationTypeName(
2169 DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
2170 StringRef res;
2171 uint64_t RType = getRelocationType(Rel);
2172
2173 unsigned Arch = this->getArch();
2174
2175 switch (Arch) {
2176 case Triple::x86: {
2177 static const char *const Table[] = {
2178 "GENERIC_RELOC_VANILLA",
2179 "GENERIC_RELOC_PAIR",
2180 "GENERIC_RELOC_SECTDIFF",
2181 "GENERIC_RELOC_PB_LA_PTR",
2182 "GENERIC_RELOC_LOCAL_SECTDIFF",
2183 "GENERIC_RELOC_TLV" };
2184
2185 if (RType > 5)
2186 res = "Unknown";
2187 else
2188 res = Table[RType];
2189 break;
2190 }
2191 case Triple::x86_64: {
2192 static const char *const Table[] = {
2193 "X86_64_RELOC_UNSIGNED",
2194 "X86_64_RELOC_SIGNED",
2195 "X86_64_RELOC_BRANCH",
2196 "X86_64_RELOC_GOT_LOAD",
2197 "X86_64_RELOC_GOT",
2198 "X86_64_RELOC_SUBTRACTOR",
2199 "X86_64_RELOC_SIGNED_1",
2200 "X86_64_RELOC_SIGNED_2",
2201 "X86_64_RELOC_SIGNED_4",
2202 "X86_64_RELOC_TLV" };
2203
2204 if (RType > 9)
2205 res = "Unknown";
2206 else
2207 res = Table[RType];
2208 break;
2209 }
2210 case Triple::arm: {
2211 static const char *const Table[] = {
2212 "ARM_RELOC_VANILLA",
2213 "ARM_RELOC_PAIR",
2214 "ARM_RELOC_SECTDIFF",
2215 "ARM_RELOC_LOCAL_SECTDIFF",
2216 "ARM_RELOC_PB_LA_PTR",
2217 "ARM_RELOC_BR24",
2218 "ARM_THUMB_RELOC_BR22",
2219 "ARM_THUMB_32BIT_BRANCH",
2220 "ARM_RELOC_HALF",
2221 "ARM_RELOC_HALF_SECTDIFF" };
2222
2223 if (RType > 9)
2224 res = "Unknown";
2225 else
2226 res = Table[RType];
2227 break;
2228 }
2229 case Triple::aarch64:
2230 case Triple::aarch64_32: {
2231 static const char *const Table[] = {
2232 "ARM64_RELOC_UNSIGNED", "ARM64_RELOC_SUBTRACTOR",
2233 "ARM64_RELOC_BRANCH26", "ARM64_RELOC_PAGE21",
2234 "ARM64_RELOC_PAGEOFF12", "ARM64_RELOC_GOT_LOAD_PAGE21",
2235 "ARM64_RELOC_GOT_LOAD_PAGEOFF12", "ARM64_RELOC_POINTER_TO_GOT",
2236 "ARM64_RELOC_TLVP_LOAD_PAGE21", "ARM64_RELOC_TLVP_LOAD_PAGEOFF12",
2237 "ARM64_RELOC_ADDEND"
2238 };
2239
2240 if (RType >= array_lengthof(Table))
2241 res = "Unknown";
2242 else
2243 res = Table[RType];
2244 break;
2245 }
2246 case Triple::ppc: {
2247 static const char *const Table[] = {
2248 "PPC_RELOC_VANILLA",
2249 "PPC_RELOC_PAIR",
2250 "PPC_RELOC_BR14",
2251 "PPC_RELOC_BR24",
2252 "PPC_RELOC_HI16",
2253 "PPC_RELOC_LO16",
2254 "PPC_RELOC_HA16",
2255 "PPC_RELOC_LO14",
2256 "PPC_RELOC_SECTDIFF",
2257 "PPC_RELOC_PB_LA_PTR",
2258 "PPC_RELOC_HI16_SECTDIFF",
2259 "PPC_RELOC_LO16_SECTDIFF",
2260 "PPC_RELOC_HA16_SECTDIFF",
2261 "PPC_RELOC_JBSR",
2262 "PPC_RELOC_LO14_SECTDIFF",
2263 "PPC_RELOC_LOCAL_SECTDIFF" };
2264
2265 if (RType > 15)
2266 res = "Unknown";
2267 else
2268 res = Table[RType];
2269 break;
2270 }
2271 case Triple::UnknownArch:
2272 res = "Unknown";
2273 break;
2274 }
2275 Result.append(res.begin(), res.end());
2276 }
2277
getRelocationLength(DataRefImpl Rel) const2278 uint8_t MachOObjectFile::getRelocationLength(DataRefImpl Rel) const {
2279 MachO::any_relocation_info RE = getRelocation(Rel);
2280 return getAnyRelocationLength(RE);
2281 }
2282
2283 //
2284 // guessLibraryShortName() is passed a name of a dynamic library and returns a
2285 // guess on what the short name is. Then name is returned as a substring of the
2286 // StringRef Name passed in. The name of the dynamic library is recognized as
2287 // a framework if it has one of the two following forms:
2288 // Foo.framework/Versions/A/Foo
2289 // Foo.framework/Foo
2290 // Where A and Foo can be any string. And may contain a trailing suffix
2291 // starting with an underbar. If the Name is recognized as a framework then
2292 // isFramework is set to true else it is set to false. If the Name has a
2293 // suffix then Suffix is set to the substring in Name that contains the suffix
2294 // else it is set to a NULL StringRef.
2295 //
2296 // The Name of the dynamic library is recognized as a library name if it has
2297 // one of the two following forms:
2298 // libFoo.A.dylib
2299 // libFoo.dylib
2300 //
2301 // The library may have a suffix trailing the name Foo of the form:
2302 // libFoo_profile.A.dylib
2303 // libFoo_profile.dylib
2304 // These dyld image suffixes are separated from the short name by a '_'
2305 // character. Because the '_' character is commonly used to separate words in
2306 // filenames guessLibraryShortName() cannot reliably separate a dylib's short
2307 // name from an arbitrary image suffix; imagine if both the short name and the
2308 // suffix contains an '_' character! To better deal with this ambiguity,
2309 // guessLibraryShortName() will recognize only "_debug" and "_profile" as valid
2310 // Suffix values. Calling code needs to be tolerant of guessLibraryShortName()
2311 // guessing incorrectly.
2312 //
2313 // The Name of the dynamic library is also recognized as a library name if it
2314 // has the following form:
2315 // Foo.qtx
2316 //
2317 // If the Name of the dynamic library is none of the forms above then a NULL
2318 // StringRef is returned.
guessLibraryShortName(StringRef Name,bool & isFramework,StringRef & Suffix)2319 StringRef MachOObjectFile::guessLibraryShortName(StringRef Name,
2320 bool &isFramework,
2321 StringRef &Suffix) {
2322 StringRef Foo, F, DotFramework, V, Dylib, Lib, Dot, Qtx;
2323 size_t a, b, c, d, Idx;
2324
2325 isFramework = false;
2326 Suffix = StringRef();
2327
2328 // Pull off the last component and make Foo point to it
2329 a = Name.rfind('/');
2330 if (a == Name.npos || a == 0)
2331 goto guess_library;
2332 Foo = Name.slice(a+1, Name.npos);
2333
2334 // Look for a suffix starting with a '_'
2335 Idx = Foo.rfind('_');
2336 if (Idx != Foo.npos && Foo.size() >= 2) {
2337 Suffix = Foo.slice(Idx, Foo.npos);
2338 if (Suffix != "_debug" && Suffix != "_profile")
2339 Suffix = StringRef();
2340 else
2341 Foo = Foo.slice(0, Idx);
2342 }
2343
2344 // First look for the form Foo.framework/Foo
2345 b = Name.rfind('/', a);
2346 if (b == Name.npos)
2347 Idx = 0;
2348 else
2349 Idx = b+1;
2350 F = Name.slice(Idx, Idx + Foo.size());
2351 DotFramework = Name.slice(Idx + Foo.size(),
2352 Idx + Foo.size() + sizeof(".framework/")-1);
2353 if (F == Foo && DotFramework == ".framework/") {
2354 isFramework = true;
2355 return Foo;
2356 }
2357
2358 // Next look for the form Foo.framework/Versions/A/Foo
2359 if (b == Name.npos)
2360 goto guess_library;
2361 c = Name.rfind('/', b);
2362 if (c == Name.npos || c == 0)
2363 goto guess_library;
2364 V = Name.slice(c+1, Name.npos);
2365 if (!V.startswith("Versions/"))
2366 goto guess_library;
2367 d = Name.rfind('/', c);
2368 if (d == Name.npos)
2369 Idx = 0;
2370 else
2371 Idx = d+1;
2372 F = Name.slice(Idx, Idx + Foo.size());
2373 DotFramework = Name.slice(Idx + Foo.size(),
2374 Idx + Foo.size() + sizeof(".framework/")-1);
2375 if (F == Foo && DotFramework == ".framework/") {
2376 isFramework = true;
2377 return Foo;
2378 }
2379
2380 guess_library:
2381 // pull off the suffix after the "." and make a point to it
2382 a = Name.rfind('.');
2383 if (a == Name.npos || a == 0)
2384 return StringRef();
2385 Dylib = Name.slice(a, Name.npos);
2386 if (Dylib != ".dylib")
2387 goto guess_qtx;
2388
2389 // First pull off the version letter for the form Foo.A.dylib if any.
2390 if (a >= 3) {
2391 Dot = Name.slice(a-2, a-1);
2392 if (Dot == ".")
2393 a = a - 2;
2394 }
2395
2396 b = Name.rfind('/', a);
2397 if (b == Name.npos)
2398 b = 0;
2399 else
2400 b = b+1;
2401 // ignore any suffix after an underbar like Foo_profile.A.dylib
2402 Idx = Name.rfind('_');
2403 if (Idx != Name.npos && Idx != b) {
2404 Lib = Name.slice(b, Idx);
2405 Suffix = Name.slice(Idx, a);
2406 if (Suffix != "_debug" && Suffix != "_profile") {
2407 Suffix = StringRef();
2408 Lib = Name.slice(b, a);
2409 }
2410 }
2411 else
2412 Lib = Name.slice(b, a);
2413 // There are incorrect library names of the form:
2414 // libATS.A_profile.dylib so check for these.
2415 if (Lib.size() >= 3) {
2416 Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
2417 if (Dot == ".")
2418 Lib = Lib.slice(0, Lib.size()-2);
2419 }
2420 return Lib;
2421
2422 guess_qtx:
2423 Qtx = Name.slice(a, Name.npos);
2424 if (Qtx != ".qtx")
2425 return StringRef();
2426 b = Name.rfind('/', a);
2427 if (b == Name.npos)
2428 Lib = Name.slice(0, a);
2429 else
2430 Lib = Name.slice(b+1, a);
2431 // There are library names of the form: QT.A.qtx so check for these.
2432 if (Lib.size() >= 3) {
2433 Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
2434 if (Dot == ".")
2435 Lib = Lib.slice(0, Lib.size()-2);
2436 }
2437 return Lib;
2438 }
2439
2440 // getLibraryShortNameByIndex() is used to get the short name of the library
2441 // for an undefined symbol in a linked Mach-O binary that was linked with the
2442 // normal two-level namespace default (that is MH_TWOLEVEL in the header).
2443 // It is passed the index (0 - based) of the library as translated from
2444 // GET_LIBRARY_ORDINAL (1 - based).
getLibraryShortNameByIndex(unsigned Index,StringRef & Res) const2445 std::error_code MachOObjectFile::getLibraryShortNameByIndex(unsigned Index,
2446 StringRef &Res) const {
2447 if (Index >= Libraries.size())
2448 return object_error::parse_failed;
2449
2450 // If the cache of LibrariesShortNames is not built up do that first for
2451 // all the Libraries.
2452 if (LibrariesShortNames.size() == 0) {
2453 for (unsigned i = 0; i < Libraries.size(); i++) {
2454 auto CommandOrErr =
2455 getStructOrErr<MachO::dylib_command>(*this, Libraries[i]);
2456 if (!CommandOrErr)
2457 return object_error::parse_failed;
2458 MachO::dylib_command D = CommandOrErr.get();
2459 if (D.dylib.name >= D.cmdsize)
2460 return object_error::parse_failed;
2461 const char *P = (const char *)(Libraries[i]) + D.dylib.name;
2462 StringRef Name = StringRef(P);
2463 if (D.dylib.name+Name.size() >= D.cmdsize)
2464 return object_error::parse_failed;
2465 StringRef Suffix;
2466 bool isFramework;
2467 StringRef shortName = guessLibraryShortName(Name, isFramework, Suffix);
2468 if (shortName.empty())
2469 LibrariesShortNames.push_back(Name);
2470 else
2471 LibrariesShortNames.push_back(shortName);
2472 }
2473 }
2474
2475 Res = LibrariesShortNames[Index];
2476 return std::error_code();
2477 }
2478
getLibraryCount() const2479 uint32_t MachOObjectFile::getLibraryCount() const {
2480 return Libraries.size();
2481 }
2482
2483 section_iterator
getRelocationRelocatedSection(relocation_iterator Rel) const2484 MachOObjectFile::getRelocationRelocatedSection(relocation_iterator Rel) const {
2485 DataRefImpl Sec;
2486 Sec.d.a = Rel->getRawDataRefImpl().d.a;
2487 return section_iterator(SectionRef(Sec, this));
2488 }
2489
symbol_begin() const2490 basic_symbol_iterator MachOObjectFile::symbol_begin() const {
2491 DataRefImpl DRI;
2492 MachO::symtab_command Symtab = getSymtabLoadCommand();
2493 if (!SymtabLoadCmd || Symtab.nsyms == 0)
2494 return basic_symbol_iterator(SymbolRef(DRI, this));
2495
2496 return getSymbolByIndex(0);
2497 }
2498
symbol_end() const2499 basic_symbol_iterator MachOObjectFile::symbol_end() const {
2500 DataRefImpl DRI;
2501 MachO::symtab_command Symtab = getSymtabLoadCommand();
2502 if (!SymtabLoadCmd || Symtab.nsyms == 0)
2503 return basic_symbol_iterator(SymbolRef(DRI, this));
2504
2505 unsigned SymbolTableEntrySize = is64Bit() ?
2506 sizeof(MachO::nlist_64) :
2507 sizeof(MachO::nlist);
2508 unsigned Offset = Symtab.symoff +
2509 Symtab.nsyms * SymbolTableEntrySize;
2510 DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2511 return basic_symbol_iterator(SymbolRef(DRI, this));
2512 }
2513
getSymbolByIndex(unsigned Index) const2514 symbol_iterator MachOObjectFile::getSymbolByIndex(unsigned Index) const {
2515 MachO::symtab_command Symtab = getSymtabLoadCommand();
2516 if (!SymtabLoadCmd || Index >= Symtab.nsyms)
2517 report_fatal_error("Requested symbol index is out of range.");
2518 unsigned SymbolTableEntrySize =
2519 is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
2520 DataRefImpl DRI;
2521 DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Symtab.symoff));
2522 DRI.p += Index * SymbolTableEntrySize;
2523 return basic_symbol_iterator(SymbolRef(DRI, this));
2524 }
2525
getSymbolIndex(DataRefImpl Symb) const2526 uint64_t MachOObjectFile::getSymbolIndex(DataRefImpl Symb) const {
2527 MachO::symtab_command Symtab = getSymtabLoadCommand();
2528 if (!SymtabLoadCmd)
2529 report_fatal_error("getSymbolIndex() called with no symbol table symbol");
2530 unsigned SymbolTableEntrySize =
2531 is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
2532 DataRefImpl DRIstart;
2533 DRIstart.p = reinterpret_cast<uintptr_t>(getPtr(*this, Symtab.symoff));
2534 uint64_t Index = (Symb.p - DRIstart.p) / SymbolTableEntrySize;
2535 return Index;
2536 }
2537
section_begin() const2538 section_iterator MachOObjectFile::section_begin() const {
2539 DataRefImpl DRI;
2540 return section_iterator(SectionRef(DRI, this));
2541 }
2542
section_end() const2543 section_iterator MachOObjectFile::section_end() const {
2544 DataRefImpl DRI;
2545 DRI.d.a = Sections.size();
2546 return section_iterator(SectionRef(DRI, this));
2547 }
2548
getBytesInAddress() const2549 uint8_t MachOObjectFile::getBytesInAddress() const {
2550 return is64Bit() ? 8 : 4;
2551 }
2552
getFileFormatName() const2553 StringRef MachOObjectFile::getFileFormatName() const {
2554 unsigned CPUType = getCPUType(*this);
2555 if (!is64Bit()) {
2556 switch (CPUType) {
2557 case MachO::CPU_TYPE_I386:
2558 return "Mach-O 32-bit i386";
2559 case MachO::CPU_TYPE_ARM:
2560 return "Mach-O arm";
2561 case MachO::CPU_TYPE_ARM64_32:
2562 return "Mach-O arm64 (ILP32)";
2563 case MachO::CPU_TYPE_POWERPC:
2564 return "Mach-O 32-bit ppc";
2565 default:
2566 return "Mach-O 32-bit unknown";
2567 }
2568 }
2569
2570 switch (CPUType) {
2571 case MachO::CPU_TYPE_X86_64:
2572 return "Mach-O 64-bit x86-64";
2573 case MachO::CPU_TYPE_ARM64:
2574 return "Mach-O arm64";
2575 case MachO::CPU_TYPE_POWERPC64:
2576 return "Mach-O 64-bit ppc64";
2577 default:
2578 return "Mach-O 64-bit unknown";
2579 }
2580 }
2581
getArch(uint32_t CPUType,uint32_t CPUSubType)2582 Triple::ArchType MachOObjectFile::getArch(uint32_t CPUType, uint32_t CPUSubType) {
2583 switch (CPUType) {
2584 case MachO::CPU_TYPE_I386:
2585 return Triple::x86;
2586 case MachO::CPU_TYPE_X86_64:
2587 return Triple::x86_64;
2588 case MachO::CPU_TYPE_ARM:
2589 return Triple::arm;
2590 case MachO::CPU_TYPE_ARM64:
2591 return Triple::aarch64;
2592 case MachO::CPU_TYPE_ARM64_32:
2593 return Triple::aarch64_32;
2594 case MachO::CPU_TYPE_POWERPC:
2595 return Triple::ppc;
2596 case MachO::CPU_TYPE_POWERPC64:
2597 return Triple::ppc64;
2598 default:
2599 return Triple::UnknownArch;
2600 }
2601 }
2602
getArchTriple(uint32_t CPUType,uint32_t CPUSubType,const char ** McpuDefault,const char ** ArchFlag)2603 Triple MachOObjectFile::getArchTriple(uint32_t CPUType, uint32_t CPUSubType,
2604 const char **McpuDefault,
2605 const char **ArchFlag) {
2606 if (McpuDefault)
2607 *McpuDefault = nullptr;
2608 if (ArchFlag)
2609 *ArchFlag = nullptr;
2610
2611 switch (CPUType) {
2612 case MachO::CPU_TYPE_I386:
2613 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2614 case MachO::CPU_SUBTYPE_I386_ALL:
2615 if (ArchFlag)
2616 *ArchFlag = "i386";
2617 return Triple("i386-apple-darwin");
2618 default:
2619 return Triple();
2620 }
2621 case MachO::CPU_TYPE_X86_64:
2622 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2623 case MachO::CPU_SUBTYPE_X86_64_ALL:
2624 if (ArchFlag)
2625 *ArchFlag = "x86_64";
2626 return Triple("x86_64-apple-darwin");
2627 case MachO::CPU_SUBTYPE_X86_64_H:
2628 if (ArchFlag)
2629 *ArchFlag = "x86_64h";
2630 return Triple("x86_64h-apple-darwin");
2631 default:
2632 return Triple();
2633 }
2634 case MachO::CPU_TYPE_ARM:
2635 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2636 case MachO::CPU_SUBTYPE_ARM_V4T:
2637 if (ArchFlag)
2638 *ArchFlag = "armv4t";
2639 return Triple("armv4t-apple-darwin");
2640 case MachO::CPU_SUBTYPE_ARM_V5TEJ:
2641 if (ArchFlag)
2642 *ArchFlag = "armv5e";
2643 return Triple("armv5e-apple-darwin");
2644 case MachO::CPU_SUBTYPE_ARM_XSCALE:
2645 if (ArchFlag)
2646 *ArchFlag = "xscale";
2647 return Triple("xscale-apple-darwin");
2648 case MachO::CPU_SUBTYPE_ARM_V6:
2649 if (ArchFlag)
2650 *ArchFlag = "armv6";
2651 return Triple("armv6-apple-darwin");
2652 case MachO::CPU_SUBTYPE_ARM_V6M:
2653 if (McpuDefault)
2654 *McpuDefault = "cortex-m0";
2655 if (ArchFlag)
2656 *ArchFlag = "armv6m";
2657 return Triple("armv6m-apple-darwin");
2658 case MachO::CPU_SUBTYPE_ARM_V7:
2659 if (ArchFlag)
2660 *ArchFlag = "armv7";
2661 return Triple("armv7-apple-darwin");
2662 case MachO::CPU_SUBTYPE_ARM_V7EM:
2663 if (McpuDefault)
2664 *McpuDefault = "cortex-m4";
2665 if (ArchFlag)
2666 *ArchFlag = "armv7em";
2667 return Triple("thumbv7em-apple-darwin");
2668 case MachO::CPU_SUBTYPE_ARM_V7K:
2669 if (McpuDefault)
2670 *McpuDefault = "cortex-a7";
2671 if (ArchFlag)
2672 *ArchFlag = "armv7k";
2673 return Triple("armv7k-apple-darwin");
2674 case MachO::CPU_SUBTYPE_ARM_V7M:
2675 if (McpuDefault)
2676 *McpuDefault = "cortex-m3";
2677 if (ArchFlag)
2678 *ArchFlag = "armv7m";
2679 return Triple("thumbv7m-apple-darwin");
2680 case MachO::CPU_SUBTYPE_ARM_V7S:
2681 if (McpuDefault)
2682 *McpuDefault = "cortex-a7";
2683 if (ArchFlag)
2684 *ArchFlag = "armv7s";
2685 return Triple("armv7s-apple-darwin");
2686 default:
2687 return Triple();
2688 }
2689 case MachO::CPU_TYPE_ARM64:
2690 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2691 case MachO::CPU_SUBTYPE_ARM64_ALL:
2692 if (McpuDefault)
2693 *McpuDefault = "cyclone";
2694 if (ArchFlag)
2695 *ArchFlag = "arm64";
2696 return Triple("arm64-apple-darwin");
2697 case MachO::CPU_SUBTYPE_ARM64E:
2698 if (McpuDefault)
2699 *McpuDefault = "apple-a12";
2700 if (ArchFlag)
2701 *ArchFlag = "arm64e";
2702 return Triple("arm64e-apple-darwin");
2703 default:
2704 return Triple();
2705 }
2706 case MachO::CPU_TYPE_ARM64_32:
2707 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2708 case MachO::CPU_SUBTYPE_ARM64_32_V8:
2709 if (McpuDefault)
2710 *McpuDefault = "cyclone";
2711 if (ArchFlag)
2712 *ArchFlag = "arm64_32";
2713 return Triple("arm64_32-apple-darwin");
2714 default:
2715 return Triple();
2716 }
2717 case MachO::CPU_TYPE_POWERPC:
2718 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2719 case MachO::CPU_SUBTYPE_POWERPC_ALL:
2720 if (ArchFlag)
2721 *ArchFlag = "ppc";
2722 return Triple("ppc-apple-darwin");
2723 default:
2724 return Triple();
2725 }
2726 case MachO::CPU_TYPE_POWERPC64:
2727 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2728 case MachO::CPU_SUBTYPE_POWERPC_ALL:
2729 if (ArchFlag)
2730 *ArchFlag = "ppc64";
2731 return Triple("ppc64-apple-darwin");
2732 default:
2733 return Triple();
2734 }
2735 default:
2736 return Triple();
2737 }
2738 }
2739
getHostArch()2740 Triple MachOObjectFile::getHostArch() {
2741 return Triple(sys::getDefaultTargetTriple());
2742 }
2743
isValidArch(StringRef ArchFlag)2744 bool MachOObjectFile::isValidArch(StringRef ArchFlag) {
2745 auto validArchs = getValidArchs();
2746 return llvm::is_contained(validArchs, ArchFlag);
2747 }
2748
getValidArchs()2749 ArrayRef<StringRef> MachOObjectFile::getValidArchs() {
2750 static const std::array<StringRef, 18> ValidArchs = {{
2751 "i386",
2752 "x86_64",
2753 "x86_64h",
2754 "armv4t",
2755 "arm",
2756 "armv5e",
2757 "armv6",
2758 "armv6m",
2759 "armv7",
2760 "armv7em",
2761 "armv7k",
2762 "armv7m",
2763 "armv7s",
2764 "arm64",
2765 "arm64e",
2766 "arm64_32",
2767 "ppc",
2768 "ppc64",
2769 }};
2770
2771 return ValidArchs;
2772 }
2773
getArch() const2774 Triple::ArchType MachOObjectFile::getArch() const {
2775 return getArch(getCPUType(*this), getCPUSubType(*this));
2776 }
2777
getArchTriple(const char ** McpuDefault) const2778 Triple MachOObjectFile::getArchTriple(const char **McpuDefault) const {
2779 return getArchTriple(Header.cputype, Header.cpusubtype, McpuDefault);
2780 }
2781
section_rel_begin(unsigned Index) const2782 relocation_iterator MachOObjectFile::section_rel_begin(unsigned Index) const {
2783 DataRefImpl DRI;
2784 DRI.d.a = Index;
2785 return section_rel_begin(DRI);
2786 }
2787
section_rel_end(unsigned Index) const2788 relocation_iterator MachOObjectFile::section_rel_end(unsigned Index) const {
2789 DataRefImpl DRI;
2790 DRI.d.a = Index;
2791 return section_rel_end(DRI);
2792 }
2793
begin_dices() const2794 dice_iterator MachOObjectFile::begin_dices() const {
2795 DataRefImpl DRI;
2796 if (!DataInCodeLoadCmd)
2797 return dice_iterator(DiceRef(DRI, this));
2798
2799 MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
2800 DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, DicLC.dataoff));
2801 return dice_iterator(DiceRef(DRI, this));
2802 }
2803
end_dices() const2804 dice_iterator MachOObjectFile::end_dices() const {
2805 DataRefImpl DRI;
2806 if (!DataInCodeLoadCmd)
2807 return dice_iterator(DiceRef(DRI, this));
2808
2809 MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
2810 unsigned Offset = DicLC.dataoff + DicLC.datasize;
2811 DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2812 return dice_iterator(DiceRef(DRI, this));
2813 }
2814
ExportEntry(Error * E,const MachOObjectFile * O,ArrayRef<uint8_t> T)2815 ExportEntry::ExportEntry(Error *E, const MachOObjectFile *O,
2816 ArrayRef<uint8_t> T) : E(E), O(O), Trie(T) {}
2817
moveToFirst()2818 void ExportEntry::moveToFirst() {
2819 ErrorAsOutParameter ErrAsOutParam(E);
2820 pushNode(0);
2821 if (*E)
2822 return;
2823 pushDownUntilBottom();
2824 }
2825
moveToEnd()2826 void ExportEntry::moveToEnd() {
2827 Stack.clear();
2828 Done = true;
2829 }
2830
operator ==(const ExportEntry & Other) const2831 bool ExportEntry::operator==(const ExportEntry &Other) const {
2832 // Common case, one at end, other iterating from begin.
2833 if (Done || Other.Done)
2834 return (Done == Other.Done);
2835 // Not equal if different stack sizes.
2836 if (Stack.size() != Other.Stack.size())
2837 return false;
2838 // Not equal if different cumulative strings.
2839 if (!CumulativeString.equals(Other.CumulativeString))
2840 return false;
2841 // Equal if all nodes in both stacks match.
2842 for (unsigned i=0; i < Stack.size(); ++i) {
2843 if (Stack[i].Start != Other.Stack[i].Start)
2844 return false;
2845 }
2846 return true;
2847 }
2848
readULEB128(const uint8_t * & Ptr,const char ** error)2849 uint64_t ExportEntry::readULEB128(const uint8_t *&Ptr, const char **error) {
2850 unsigned Count;
2851 uint64_t Result = decodeULEB128(Ptr, &Count, Trie.end(), error);
2852 Ptr += Count;
2853 if (Ptr > Trie.end())
2854 Ptr = Trie.end();
2855 return Result;
2856 }
2857
name() const2858 StringRef ExportEntry::name() const {
2859 return CumulativeString;
2860 }
2861
flags() const2862 uint64_t ExportEntry::flags() const {
2863 return Stack.back().Flags;
2864 }
2865
address() const2866 uint64_t ExportEntry::address() const {
2867 return Stack.back().Address;
2868 }
2869
other() const2870 uint64_t ExportEntry::other() const {
2871 return Stack.back().Other;
2872 }
2873
otherName() const2874 StringRef ExportEntry::otherName() const {
2875 const char* ImportName = Stack.back().ImportName;
2876 if (ImportName)
2877 return StringRef(ImportName);
2878 return StringRef();
2879 }
2880
nodeOffset() const2881 uint32_t ExportEntry::nodeOffset() const {
2882 return Stack.back().Start - Trie.begin();
2883 }
2884
NodeState(const uint8_t * Ptr)2885 ExportEntry::NodeState::NodeState(const uint8_t *Ptr)
2886 : Start(Ptr), Current(Ptr) {}
2887
pushNode(uint64_t offset)2888 void ExportEntry::pushNode(uint64_t offset) {
2889 ErrorAsOutParameter ErrAsOutParam(E);
2890 const uint8_t *Ptr = Trie.begin() + offset;
2891 NodeState State(Ptr);
2892 const char *error;
2893 uint64_t ExportInfoSize = readULEB128(State.Current, &error);
2894 if (error) {
2895 *E = malformedError("export info size " + Twine(error) +
2896 " in export trie data at node: 0x" +
2897 Twine::utohexstr(offset));
2898 moveToEnd();
2899 return;
2900 }
2901 State.IsExportNode = (ExportInfoSize != 0);
2902 const uint8_t* Children = State.Current + ExportInfoSize;
2903 if (Children > Trie.end()) {
2904 *E = malformedError(
2905 "export info size: 0x" + Twine::utohexstr(ExportInfoSize) +
2906 " in export trie data at node: 0x" + Twine::utohexstr(offset) +
2907 " too big and extends past end of trie data");
2908 moveToEnd();
2909 return;
2910 }
2911 if (State.IsExportNode) {
2912 const uint8_t *ExportStart = State.Current;
2913 State.Flags = readULEB128(State.Current, &error);
2914 if (error) {
2915 *E = malformedError("flags " + Twine(error) +
2916 " in export trie data at node: 0x" +
2917 Twine::utohexstr(offset));
2918 moveToEnd();
2919 return;
2920 }
2921 uint64_t Kind = State.Flags & MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK;
2922 if (State.Flags != 0 &&
2923 (Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_REGULAR &&
2924 Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE &&
2925 Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL)) {
2926 *E = malformedError(
2927 "unsupported exported symbol kind: " + Twine((int)Kind) +
2928 " in flags: 0x" + Twine::utohexstr(State.Flags) +
2929 " in export trie data at node: 0x" + Twine::utohexstr(offset));
2930 moveToEnd();
2931 return;
2932 }
2933 if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT) {
2934 State.Address = 0;
2935 State.Other = readULEB128(State.Current, &error); // dylib ordinal
2936 if (error) {
2937 *E = malformedError("dylib ordinal of re-export " + Twine(error) +
2938 " in export trie data at node: 0x" +
2939 Twine::utohexstr(offset));
2940 moveToEnd();
2941 return;
2942 }
2943 if (O != nullptr) {
2944 if (State.Other > O->getLibraryCount()) {
2945 *E = malformedError(
2946 "bad library ordinal: " + Twine((int)State.Other) + " (max " +
2947 Twine((int)O->getLibraryCount()) +
2948 ") in export trie data at node: 0x" + Twine::utohexstr(offset));
2949 moveToEnd();
2950 return;
2951 }
2952 }
2953 State.ImportName = reinterpret_cast<const char*>(State.Current);
2954 if (*State.ImportName == '\0') {
2955 State.Current++;
2956 } else {
2957 const uint8_t *End = State.Current + 1;
2958 if (End >= Trie.end()) {
2959 *E = malformedError("import name of re-export in export trie data at "
2960 "node: 0x" +
2961 Twine::utohexstr(offset) +
2962 " starts past end of trie data");
2963 moveToEnd();
2964 return;
2965 }
2966 while(*End != '\0' && End < Trie.end())
2967 End++;
2968 if (*End != '\0') {
2969 *E = malformedError("import name of re-export in export trie data at "
2970 "node: 0x" +
2971 Twine::utohexstr(offset) +
2972 " extends past end of trie data");
2973 moveToEnd();
2974 return;
2975 }
2976 State.Current = End + 1;
2977 }
2978 } else {
2979 State.Address = readULEB128(State.Current, &error);
2980 if (error) {
2981 *E = malformedError("address " + Twine(error) +
2982 " in export trie data at node: 0x" +
2983 Twine::utohexstr(offset));
2984 moveToEnd();
2985 return;
2986 }
2987 if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER) {
2988 State.Other = readULEB128(State.Current, &error);
2989 if (error) {
2990 *E = malformedError("resolver of stub and resolver " + Twine(error) +
2991 " in export trie data at node: 0x" +
2992 Twine::utohexstr(offset));
2993 moveToEnd();
2994 return;
2995 }
2996 }
2997 }
2998 if(ExportStart + ExportInfoSize != State.Current) {
2999 *E = malformedError(
3000 "inconsistant export info size: 0x" +
3001 Twine::utohexstr(ExportInfoSize) + " where actual size was: 0x" +
3002 Twine::utohexstr(State.Current - ExportStart) +
3003 " in export trie data at node: 0x" + Twine::utohexstr(offset));
3004 moveToEnd();
3005 return;
3006 }
3007 }
3008 State.ChildCount = *Children;
3009 if (State.ChildCount != 0 && Children + 1 >= Trie.end()) {
3010 *E = malformedError("byte for count of childern in export trie data at "
3011 "node: 0x" +
3012 Twine::utohexstr(offset) +
3013 " extends past end of trie data");
3014 moveToEnd();
3015 return;
3016 }
3017 State.Current = Children + 1;
3018 State.NextChildIndex = 0;
3019 State.ParentStringLength = CumulativeString.size();
3020 Stack.push_back(State);
3021 }
3022
pushDownUntilBottom()3023 void ExportEntry::pushDownUntilBottom() {
3024 ErrorAsOutParameter ErrAsOutParam(E);
3025 const char *error;
3026 while (Stack.back().NextChildIndex < Stack.back().ChildCount) {
3027 NodeState &Top = Stack.back();
3028 CumulativeString.resize(Top.ParentStringLength);
3029 for (;*Top.Current != 0 && Top.Current < Trie.end(); Top.Current++) {
3030 char C = *Top.Current;
3031 CumulativeString.push_back(C);
3032 }
3033 if (Top.Current >= Trie.end()) {
3034 *E = malformedError("edge sub-string in export trie data at node: 0x" +
3035 Twine::utohexstr(Top.Start - Trie.begin()) +
3036 " for child #" + Twine((int)Top.NextChildIndex) +
3037 " extends past end of trie data");
3038 moveToEnd();
3039 return;
3040 }
3041 Top.Current += 1;
3042 uint64_t childNodeIndex = readULEB128(Top.Current, &error);
3043 if (error) {
3044 *E = malformedError("child node offset " + Twine(error) +
3045 " in export trie data at node: 0x" +
3046 Twine::utohexstr(Top.Start - Trie.begin()));
3047 moveToEnd();
3048 return;
3049 }
3050 for (const NodeState &node : nodes()) {
3051 if (node.Start == Trie.begin() + childNodeIndex){
3052 *E = malformedError("loop in childern in export trie data at node: 0x" +
3053 Twine::utohexstr(Top.Start - Trie.begin()) +
3054 " back to node: 0x" +
3055 Twine::utohexstr(childNodeIndex));
3056 moveToEnd();
3057 return;
3058 }
3059 }
3060 Top.NextChildIndex += 1;
3061 pushNode(childNodeIndex);
3062 if (*E)
3063 return;
3064 }
3065 if (!Stack.back().IsExportNode) {
3066 *E = malformedError("node is not an export node in export trie data at "
3067 "node: 0x" +
3068 Twine::utohexstr(Stack.back().Start - Trie.begin()));
3069 moveToEnd();
3070 return;
3071 }
3072 }
3073
3074 // We have a trie data structure and need a way to walk it that is compatible
3075 // with the C++ iterator model. The solution is a non-recursive depth first
3076 // traversal where the iterator contains a stack of parent nodes along with a
3077 // string that is the accumulation of all edge strings along the parent chain
3078 // to this point.
3079 //
3080 // There is one "export" node for each exported symbol. But because some
3081 // symbols may be a prefix of another symbol (e.g. _dup and _dup2), an export
3082 // node may have child nodes too.
3083 //
3084 // The algorithm for moveNext() is to keep moving down the leftmost unvisited
3085 // child until hitting a node with no children (which is an export node or
3086 // else the trie is malformed). On the way down, each node is pushed on the
3087 // stack ivar. If there is no more ways down, it pops up one and tries to go
3088 // down a sibling path until a childless node is reached.
moveNext()3089 void ExportEntry::moveNext() {
3090 assert(!Stack.empty() && "ExportEntry::moveNext() with empty node stack");
3091 if (!Stack.back().IsExportNode) {
3092 *E = malformedError("node is not an export node in export trie data at "
3093 "node: 0x" +
3094 Twine::utohexstr(Stack.back().Start - Trie.begin()));
3095 moveToEnd();
3096 return;
3097 }
3098
3099 Stack.pop_back();
3100 while (!Stack.empty()) {
3101 NodeState &Top = Stack.back();
3102 if (Top.NextChildIndex < Top.ChildCount) {
3103 pushDownUntilBottom();
3104 // Now at the next export node.
3105 return;
3106 } else {
3107 if (Top.IsExportNode) {
3108 // This node has no children but is itself an export node.
3109 CumulativeString.resize(Top.ParentStringLength);
3110 return;
3111 }
3112 Stack.pop_back();
3113 }
3114 }
3115 Done = true;
3116 }
3117
3118 iterator_range<export_iterator>
exports(Error & E,ArrayRef<uint8_t> Trie,const MachOObjectFile * O)3119 MachOObjectFile::exports(Error &E, ArrayRef<uint8_t> Trie,
3120 const MachOObjectFile *O) {
3121 ExportEntry Start(&E, O, Trie);
3122 if (Trie.empty())
3123 Start.moveToEnd();
3124 else
3125 Start.moveToFirst();
3126
3127 ExportEntry Finish(&E, O, Trie);
3128 Finish.moveToEnd();
3129
3130 return make_range(export_iterator(Start), export_iterator(Finish));
3131 }
3132
exports(Error & Err) const3133 iterator_range<export_iterator> MachOObjectFile::exports(Error &Err) const {
3134 return exports(Err, getDyldInfoExportsTrie(), this);
3135 }
3136
MachORebaseEntry(Error * E,const MachOObjectFile * O,ArrayRef<uint8_t> Bytes,bool is64Bit)3137 MachORebaseEntry::MachORebaseEntry(Error *E, const MachOObjectFile *O,
3138 ArrayRef<uint8_t> Bytes, bool is64Bit)
3139 : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()),
3140 PointerSize(is64Bit ? 8 : 4) {}
3141
moveToFirst()3142 void MachORebaseEntry::moveToFirst() {
3143 Ptr = Opcodes.begin();
3144 moveNext();
3145 }
3146
moveToEnd()3147 void MachORebaseEntry::moveToEnd() {
3148 Ptr = Opcodes.end();
3149 RemainingLoopCount = 0;
3150 Done = true;
3151 }
3152
moveNext()3153 void MachORebaseEntry::moveNext() {
3154 ErrorAsOutParameter ErrAsOutParam(E);
3155 // If in the middle of some loop, move to next rebasing in loop.
3156 SegmentOffset += AdvanceAmount;
3157 if (RemainingLoopCount) {
3158 --RemainingLoopCount;
3159 return;
3160 }
3161 // REBASE_OPCODE_DONE is only used for padding if we are not aligned to
3162 // pointer size. Therefore it is possible to reach the end without ever having
3163 // seen REBASE_OPCODE_DONE.
3164 if (Ptr == Opcodes.end()) {
3165 Done = true;
3166 return;
3167 }
3168 bool More = true;
3169 while (More) {
3170 // Parse next opcode and set up next loop.
3171 const uint8_t *OpcodeStart = Ptr;
3172 uint8_t Byte = *Ptr++;
3173 uint8_t ImmValue = Byte & MachO::REBASE_IMMEDIATE_MASK;
3174 uint8_t Opcode = Byte & MachO::REBASE_OPCODE_MASK;
3175 uint32_t Count, Skip;
3176 const char *error = nullptr;
3177 switch (Opcode) {
3178 case MachO::REBASE_OPCODE_DONE:
3179 More = false;
3180 Done = true;
3181 moveToEnd();
3182 DEBUG_WITH_TYPE("mach-o-rebase", dbgs() << "REBASE_OPCODE_DONE\n");
3183 break;
3184 case MachO::REBASE_OPCODE_SET_TYPE_IMM:
3185 RebaseType = ImmValue;
3186 if (RebaseType > MachO::REBASE_TYPE_TEXT_PCREL32) {
3187 *E = malformedError("for REBASE_OPCODE_SET_TYPE_IMM bad bind type: " +
3188 Twine((int)RebaseType) + " for opcode at: 0x" +
3189 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3190 moveToEnd();
3191 return;
3192 }
3193 DEBUG_WITH_TYPE(
3194 "mach-o-rebase",
3195 dbgs() << "REBASE_OPCODE_SET_TYPE_IMM: "
3196 << "RebaseType=" << (int) RebaseType << "\n");
3197 break;
3198 case MachO::REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
3199 SegmentIndex = ImmValue;
3200 SegmentOffset = readULEB128(&error);
3201 if (error) {
3202 *E = malformedError("for REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3203 Twine(error) + " for opcode at: 0x" +
3204 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3205 moveToEnd();
3206 return;
3207 }
3208 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3209 PointerSize);
3210 if (error) {
3211 *E = malformedError("for REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3212 Twine(error) + " for opcode at: 0x" +
3213 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3214 moveToEnd();
3215 return;
3216 }
3217 DEBUG_WITH_TYPE(
3218 "mach-o-rebase",
3219 dbgs() << "REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
3220 << "SegmentIndex=" << SegmentIndex << ", "
3221 << format("SegmentOffset=0x%06X", SegmentOffset)
3222 << "\n");
3223 break;
3224 case MachO::REBASE_OPCODE_ADD_ADDR_ULEB:
3225 SegmentOffset += readULEB128(&error);
3226 if (error) {
3227 *E = malformedError("for REBASE_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3228 " for opcode at: 0x" +
3229 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3230 moveToEnd();
3231 return;
3232 }
3233 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3234 PointerSize);
3235 if (error) {
3236 *E = malformedError("for REBASE_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3237 " for opcode at: 0x" +
3238 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3239 moveToEnd();
3240 return;
3241 }
3242 DEBUG_WITH_TYPE("mach-o-rebase",
3243 dbgs() << "REBASE_OPCODE_ADD_ADDR_ULEB: "
3244 << format("SegmentOffset=0x%06X",
3245 SegmentOffset) << "\n");
3246 break;
3247 case MachO::REBASE_OPCODE_ADD_ADDR_IMM_SCALED:
3248 SegmentOffset += ImmValue * PointerSize;
3249 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3250 PointerSize);
3251 if (error) {
3252 *E = malformedError("for REBASE_OPCODE_ADD_ADDR_IMM_SCALED " +
3253 Twine(error) + " for opcode at: 0x" +
3254 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3255 moveToEnd();
3256 return;
3257 }
3258 DEBUG_WITH_TYPE("mach-o-rebase",
3259 dbgs() << "REBASE_OPCODE_ADD_ADDR_IMM_SCALED: "
3260 << format("SegmentOffset=0x%06X",
3261 SegmentOffset) << "\n");
3262 break;
3263 case MachO::REBASE_OPCODE_DO_REBASE_IMM_TIMES:
3264 AdvanceAmount = PointerSize;
3265 Skip = 0;
3266 Count = ImmValue;
3267 if (ImmValue != 0)
3268 RemainingLoopCount = ImmValue - 1;
3269 else
3270 RemainingLoopCount = 0;
3271 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3272 PointerSize, Count, Skip);
3273 if (error) {
3274 *E = malformedError("for REBASE_OPCODE_DO_REBASE_IMM_TIMES " +
3275 Twine(error) + " for opcode at: 0x" +
3276 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3277 moveToEnd();
3278 return;
3279 }
3280 DEBUG_WITH_TYPE(
3281 "mach-o-rebase",
3282 dbgs() << "REBASE_OPCODE_DO_REBASE_IMM_TIMES: "
3283 << format("SegmentOffset=0x%06X", SegmentOffset)
3284 << ", AdvanceAmount=" << AdvanceAmount
3285 << ", RemainingLoopCount=" << RemainingLoopCount
3286 << "\n");
3287 return;
3288 case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES:
3289 AdvanceAmount = PointerSize;
3290 Skip = 0;
3291 Count = readULEB128(&error);
3292 if (error) {
3293 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES " +
3294 Twine(error) + " for opcode at: 0x" +
3295 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3296 moveToEnd();
3297 return;
3298 }
3299 if (Count != 0)
3300 RemainingLoopCount = Count - 1;
3301 else
3302 RemainingLoopCount = 0;
3303 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3304 PointerSize, Count, Skip);
3305 if (error) {
3306 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES " +
3307 Twine(error) + " for opcode at: 0x" +
3308 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3309 moveToEnd();
3310 return;
3311 }
3312 DEBUG_WITH_TYPE(
3313 "mach-o-rebase",
3314 dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES: "
3315 << format("SegmentOffset=0x%06X", SegmentOffset)
3316 << ", AdvanceAmount=" << AdvanceAmount
3317 << ", RemainingLoopCount=" << RemainingLoopCount
3318 << "\n");
3319 return;
3320 case MachO::REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB:
3321 Skip = readULEB128(&error);
3322 if (error) {
3323 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB " +
3324 Twine(error) + " for opcode at: 0x" +
3325 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3326 moveToEnd();
3327 return;
3328 }
3329 AdvanceAmount = Skip + PointerSize;
3330 Count = 1;
3331 RemainingLoopCount = 0;
3332 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3333 PointerSize, Count, Skip);
3334 if (error) {
3335 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB " +
3336 Twine(error) + " for opcode at: 0x" +
3337 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3338 moveToEnd();
3339 return;
3340 }
3341 DEBUG_WITH_TYPE(
3342 "mach-o-rebase",
3343 dbgs() << "REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: "
3344 << format("SegmentOffset=0x%06X", SegmentOffset)
3345 << ", AdvanceAmount=" << AdvanceAmount
3346 << ", RemainingLoopCount=" << RemainingLoopCount
3347 << "\n");
3348 return;
3349 case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB:
3350 Count = readULEB128(&error);
3351 if (error) {
3352 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3353 "ULEB " +
3354 Twine(error) + " for opcode at: 0x" +
3355 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3356 moveToEnd();
3357 return;
3358 }
3359 if (Count != 0)
3360 RemainingLoopCount = Count - 1;
3361 else
3362 RemainingLoopCount = 0;
3363 Skip = readULEB128(&error);
3364 if (error) {
3365 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3366 "ULEB " +
3367 Twine(error) + " for opcode at: 0x" +
3368 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3369 moveToEnd();
3370 return;
3371 }
3372 AdvanceAmount = Skip + PointerSize;
3373
3374 error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3375 PointerSize, Count, Skip);
3376 if (error) {
3377 *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3378 "ULEB " +
3379 Twine(error) + " for opcode at: 0x" +
3380 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3381 moveToEnd();
3382 return;
3383 }
3384 DEBUG_WITH_TYPE(
3385 "mach-o-rebase",
3386 dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: "
3387 << format("SegmentOffset=0x%06X", SegmentOffset)
3388 << ", AdvanceAmount=" << AdvanceAmount
3389 << ", RemainingLoopCount=" << RemainingLoopCount
3390 << "\n");
3391 return;
3392 default:
3393 *E = malformedError("bad rebase info (bad opcode value 0x" +
3394 Twine::utohexstr(Opcode) + " for opcode at: 0x" +
3395 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3396 moveToEnd();
3397 return;
3398 }
3399 }
3400 }
3401
readULEB128(const char ** error)3402 uint64_t MachORebaseEntry::readULEB128(const char **error) {
3403 unsigned Count;
3404 uint64_t Result = decodeULEB128(Ptr, &Count, Opcodes.end(), error);
3405 Ptr += Count;
3406 if (Ptr > Opcodes.end())
3407 Ptr = Opcodes.end();
3408 return Result;
3409 }
3410
segmentIndex() const3411 int32_t MachORebaseEntry::segmentIndex() const { return SegmentIndex; }
3412
segmentOffset() const3413 uint64_t MachORebaseEntry::segmentOffset() const { return SegmentOffset; }
3414
typeName() const3415 StringRef MachORebaseEntry::typeName() const {
3416 switch (RebaseType) {
3417 case MachO::REBASE_TYPE_POINTER:
3418 return "pointer";
3419 case MachO::REBASE_TYPE_TEXT_ABSOLUTE32:
3420 return "text abs32";
3421 case MachO::REBASE_TYPE_TEXT_PCREL32:
3422 return "text rel32";
3423 }
3424 return "unknown";
3425 }
3426
3427 // For use with the SegIndex of a checked Mach-O Rebase entry
3428 // to get the segment name.
segmentName() const3429 StringRef MachORebaseEntry::segmentName() const {
3430 return O->BindRebaseSegmentName(SegmentIndex);
3431 }
3432
3433 // For use with a SegIndex,SegOffset pair from a checked Mach-O Rebase entry
3434 // to get the section name.
sectionName() const3435 StringRef MachORebaseEntry::sectionName() const {
3436 return O->BindRebaseSectionName(SegmentIndex, SegmentOffset);
3437 }
3438
3439 // For use with a SegIndex,SegOffset pair from a checked Mach-O Rebase entry
3440 // to get the address.
address() const3441 uint64_t MachORebaseEntry::address() const {
3442 return O->BindRebaseAddress(SegmentIndex, SegmentOffset);
3443 }
3444
operator ==(const MachORebaseEntry & Other) const3445 bool MachORebaseEntry::operator==(const MachORebaseEntry &Other) const {
3446 #ifdef EXPENSIVE_CHECKS
3447 assert(Opcodes == Other.Opcodes && "compare iterators of different files");
3448 #else
3449 assert(Opcodes.data() == Other.Opcodes.data() && "compare iterators of different files");
3450 #endif
3451 return (Ptr == Other.Ptr) &&
3452 (RemainingLoopCount == Other.RemainingLoopCount) &&
3453 (Done == Other.Done);
3454 }
3455
3456 iterator_range<rebase_iterator>
rebaseTable(Error & Err,MachOObjectFile * O,ArrayRef<uint8_t> Opcodes,bool is64)3457 MachOObjectFile::rebaseTable(Error &Err, MachOObjectFile *O,
3458 ArrayRef<uint8_t> Opcodes, bool is64) {
3459 if (O->BindRebaseSectionTable == nullptr)
3460 O->BindRebaseSectionTable = std::make_unique<BindRebaseSegInfo>(O);
3461 MachORebaseEntry Start(&Err, O, Opcodes, is64);
3462 Start.moveToFirst();
3463
3464 MachORebaseEntry Finish(&Err, O, Opcodes, is64);
3465 Finish.moveToEnd();
3466
3467 return make_range(rebase_iterator(Start), rebase_iterator(Finish));
3468 }
3469
rebaseTable(Error & Err)3470 iterator_range<rebase_iterator> MachOObjectFile::rebaseTable(Error &Err) {
3471 return rebaseTable(Err, this, getDyldInfoRebaseOpcodes(), is64Bit());
3472 }
3473
MachOBindEntry(Error * E,const MachOObjectFile * O,ArrayRef<uint8_t> Bytes,bool is64Bit,Kind BK)3474 MachOBindEntry::MachOBindEntry(Error *E, const MachOObjectFile *O,
3475 ArrayRef<uint8_t> Bytes, bool is64Bit, Kind BK)
3476 : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()),
3477 PointerSize(is64Bit ? 8 : 4), TableKind(BK) {}
3478
moveToFirst()3479 void MachOBindEntry::moveToFirst() {
3480 Ptr = Opcodes.begin();
3481 moveNext();
3482 }
3483
moveToEnd()3484 void MachOBindEntry::moveToEnd() {
3485 Ptr = Opcodes.end();
3486 RemainingLoopCount = 0;
3487 Done = true;
3488 }
3489
moveNext()3490 void MachOBindEntry::moveNext() {
3491 ErrorAsOutParameter ErrAsOutParam(E);
3492 // If in the middle of some loop, move to next binding in loop.
3493 SegmentOffset += AdvanceAmount;
3494 if (RemainingLoopCount) {
3495 --RemainingLoopCount;
3496 return;
3497 }
3498 // BIND_OPCODE_DONE is only used for padding if we are not aligned to
3499 // pointer size. Therefore it is possible to reach the end without ever having
3500 // seen BIND_OPCODE_DONE.
3501 if (Ptr == Opcodes.end()) {
3502 Done = true;
3503 return;
3504 }
3505 bool More = true;
3506 while (More) {
3507 // Parse next opcode and set up next loop.
3508 const uint8_t *OpcodeStart = Ptr;
3509 uint8_t Byte = *Ptr++;
3510 uint8_t ImmValue = Byte & MachO::BIND_IMMEDIATE_MASK;
3511 uint8_t Opcode = Byte & MachO::BIND_OPCODE_MASK;
3512 int8_t SignExtended;
3513 const uint8_t *SymStart;
3514 uint32_t Count, Skip;
3515 const char *error = nullptr;
3516 switch (Opcode) {
3517 case MachO::BIND_OPCODE_DONE:
3518 if (TableKind == Kind::Lazy) {
3519 // Lazying bindings have a DONE opcode between entries. Need to ignore
3520 // it to advance to next entry. But need not if this is last entry.
3521 bool NotLastEntry = false;
3522 for (const uint8_t *P = Ptr; P < Opcodes.end(); ++P) {
3523 if (*P) {
3524 NotLastEntry = true;
3525 }
3526 }
3527 if (NotLastEntry)
3528 break;
3529 }
3530 More = false;
3531 moveToEnd();
3532 DEBUG_WITH_TYPE("mach-o-bind", dbgs() << "BIND_OPCODE_DONE\n");
3533 break;
3534 case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
3535 if (TableKind == Kind::Weak) {
3536 *E = malformedError("BIND_OPCODE_SET_DYLIB_ORDINAL_IMM not allowed in "
3537 "weak bind table for opcode at: 0x" +
3538 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3539 moveToEnd();
3540 return;
3541 }
3542 Ordinal = ImmValue;
3543 LibraryOrdinalSet = true;
3544 if (ImmValue > O->getLibraryCount()) {
3545 *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB bad "
3546 "library ordinal: " +
3547 Twine((int)ImmValue) + " (max " +
3548 Twine((int)O->getLibraryCount()) +
3549 ") for opcode at: 0x" +
3550 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3551 moveToEnd();
3552 return;
3553 }
3554 DEBUG_WITH_TYPE(
3555 "mach-o-bind",
3556 dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: "
3557 << "Ordinal=" << Ordinal << "\n");
3558 break;
3559 case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
3560 if (TableKind == Kind::Weak) {
3561 *E = malformedError("BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB not allowed in "
3562 "weak bind table for opcode at: 0x" +
3563 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3564 moveToEnd();
3565 return;
3566 }
3567 Ordinal = readULEB128(&error);
3568 LibraryOrdinalSet = true;
3569 if (error) {
3570 *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB " +
3571 Twine(error) + " for opcode at: 0x" +
3572 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3573 moveToEnd();
3574 return;
3575 }
3576 if (Ordinal > (int)O->getLibraryCount()) {
3577 *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB bad "
3578 "library ordinal: " +
3579 Twine((int)Ordinal) + " (max " +
3580 Twine((int)O->getLibraryCount()) +
3581 ") for opcode at: 0x" +
3582 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3583 moveToEnd();
3584 return;
3585 }
3586 DEBUG_WITH_TYPE(
3587 "mach-o-bind",
3588 dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: "
3589 << "Ordinal=" << Ordinal << "\n");
3590 break;
3591 case MachO::BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:
3592 if (TableKind == Kind::Weak) {
3593 *E = malformedError("BIND_OPCODE_SET_DYLIB_SPECIAL_IMM not allowed in "
3594 "weak bind table for opcode at: 0x" +
3595 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3596 moveToEnd();
3597 return;
3598 }
3599 if (ImmValue) {
3600 SignExtended = MachO::BIND_OPCODE_MASK | ImmValue;
3601 Ordinal = SignExtended;
3602 if (Ordinal < MachO::BIND_SPECIAL_DYLIB_FLAT_LOOKUP) {
3603 *E = malformedError("for BIND_OPCODE_SET_DYLIB_SPECIAL_IMM unknown "
3604 "special ordinal: " +
3605 Twine((int)Ordinal) + " for opcode at: 0x" +
3606 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3607 moveToEnd();
3608 return;
3609 }
3610 } else
3611 Ordinal = 0;
3612 LibraryOrdinalSet = true;
3613 DEBUG_WITH_TYPE(
3614 "mach-o-bind",
3615 dbgs() << "BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: "
3616 << "Ordinal=" << Ordinal << "\n");
3617 break;
3618 case MachO::BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
3619 Flags = ImmValue;
3620 SymStart = Ptr;
3621 while (*Ptr && (Ptr < Opcodes.end())) {
3622 ++Ptr;
3623 }
3624 if (Ptr == Opcodes.end()) {
3625 *E = malformedError(
3626 "for BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM "
3627 "symbol name extends past opcodes for opcode at: 0x" +
3628 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3629 moveToEnd();
3630 return;
3631 }
3632 SymbolName = StringRef(reinterpret_cast<const char*>(SymStart),
3633 Ptr-SymStart);
3634 ++Ptr;
3635 DEBUG_WITH_TYPE(
3636 "mach-o-bind",
3637 dbgs() << "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: "
3638 << "SymbolName=" << SymbolName << "\n");
3639 if (TableKind == Kind::Weak) {
3640 if (ImmValue & MachO::BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION)
3641 return;
3642 }
3643 break;
3644 case MachO::BIND_OPCODE_SET_TYPE_IMM:
3645 BindType = ImmValue;
3646 if (ImmValue > MachO::BIND_TYPE_TEXT_PCREL32) {
3647 *E = malformedError("for BIND_OPCODE_SET_TYPE_IMM bad bind type: " +
3648 Twine((int)ImmValue) + " for opcode at: 0x" +
3649 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3650 moveToEnd();
3651 return;
3652 }
3653 DEBUG_WITH_TYPE(
3654 "mach-o-bind",
3655 dbgs() << "BIND_OPCODE_SET_TYPE_IMM: "
3656 << "BindType=" << (int)BindType << "\n");
3657 break;
3658 case MachO::BIND_OPCODE_SET_ADDEND_SLEB:
3659 Addend = readSLEB128(&error);
3660 if (error) {
3661 *E = malformedError("for BIND_OPCODE_SET_ADDEND_SLEB " + Twine(error) +
3662 " for opcode at: 0x" +
3663 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3664 moveToEnd();
3665 return;
3666 }
3667 DEBUG_WITH_TYPE(
3668 "mach-o-bind",
3669 dbgs() << "BIND_OPCODE_SET_ADDEND_SLEB: "
3670 << "Addend=" << Addend << "\n");
3671 break;
3672 case MachO::BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
3673 SegmentIndex = ImmValue;
3674 SegmentOffset = readULEB128(&error);
3675 if (error) {
3676 *E = malformedError("for BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3677 Twine(error) + " for opcode at: 0x" +
3678 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3679 moveToEnd();
3680 return;
3681 }
3682 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3683 PointerSize);
3684 if (error) {
3685 *E = malformedError("for BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3686 Twine(error) + " for opcode at: 0x" +
3687 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3688 moveToEnd();
3689 return;
3690 }
3691 DEBUG_WITH_TYPE(
3692 "mach-o-bind",
3693 dbgs() << "BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
3694 << "SegmentIndex=" << SegmentIndex << ", "
3695 << format("SegmentOffset=0x%06X", SegmentOffset)
3696 << "\n");
3697 break;
3698 case MachO::BIND_OPCODE_ADD_ADDR_ULEB:
3699 SegmentOffset += readULEB128(&error);
3700 if (error) {
3701 *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3702 " for opcode at: 0x" +
3703 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3704 moveToEnd();
3705 return;
3706 }
3707 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3708 PointerSize);
3709 if (error) {
3710 *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3711 " for opcode at: 0x" +
3712 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3713 moveToEnd();
3714 return;
3715 }
3716 DEBUG_WITH_TYPE("mach-o-bind",
3717 dbgs() << "BIND_OPCODE_ADD_ADDR_ULEB: "
3718 << format("SegmentOffset=0x%06X",
3719 SegmentOffset) << "\n");
3720 break;
3721 case MachO::BIND_OPCODE_DO_BIND:
3722 AdvanceAmount = PointerSize;
3723 RemainingLoopCount = 0;
3724 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3725 PointerSize);
3726 if (error) {
3727 *E = malformedError("for BIND_OPCODE_DO_BIND " + Twine(error) +
3728 " for opcode at: 0x" +
3729 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3730 moveToEnd();
3731 return;
3732 }
3733 if (SymbolName == StringRef()) {
3734 *E = malformedError(
3735 "for BIND_OPCODE_DO_BIND missing preceding "
3736 "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for opcode at: 0x" +
3737 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3738 moveToEnd();
3739 return;
3740 }
3741 if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3742 *E =
3743 malformedError("for BIND_OPCODE_DO_BIND missing preceding "
3744 "BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode at: 0x" +
3745 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3746 moveToEnd();
3747 return;
3748 }
3749 DEBUG_WITH_TYPE("mach-o-bind",
3750 dbgs() << "BIND_OPCODE_DO_BIND: "
3751 << format("SegmentOffset=0x%06X",
3752 SegmentOffset) << "\n");
3753 return;
3754 case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
3755 if (TableKind == Kind::Lazy) {
3756 *E = malformedError("BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB not allowed in "
3757 "lazy bind table for opcode at: 0x" +
3758 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3759 moveToEnd();
3760 return;
3761 }
3762 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3763 PointerSize);
3764 if (error) {
3765 *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB " +
3766 Twine(error) + " for opcode at: 0x" +
3767 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3768 moveToEnd();
3769 return;
3770 }
3771 if (SymbolName == StringRef()) {
3772 *E = malformedError(
3773 "for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB missing "
3774 "preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for opcode "
3775 "at: 0x" +
3776 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3777 moveToEnd();
3778 return;
3779 }
3780 if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3781 *E = malformedError(
3782 "for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB missing "
3783 "preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode at: 0x" +
3784 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3785 moveToEnd();
3786 return;
3787 }
3788 AdvanceAmount = readULEB128(&error) + PointerSize;
3789 if (error) {
3790 *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB " +
3791 Twine(error) + " for opcode at: 0x" +
3792 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3793 moveToEnd();
3794 return;
3795 }
3796 // Note, this is not really an error until the next bind but make no sense
3797 // for a BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB to not be followed by another
3798 // bind operation.
3799 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset +
3800 AdvanceAmount, PointerSize);
3801 if (error) {
3802 *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB (after adding "
3803 "ULEB) " +
3804 Twine(error) + " for opcode at: 0x" +
3805 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3806 moveToEnd();
3807 return;
3808 }
3809 RemainingLoopCount = 0;
3810 DEBUG_WITH_TYPE(
3811 "mach-o-bind",
3812 dbgs() << "BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: "
3813 << format("SegmentOffset=0x%06X", SegmentOffset)
3814 << ", AdvanceAmount=" << AdvanceAmount
3815 << ", RemainingLoopCount=" << RemainingLoopCount
3816 << "\n");
3817 return;
3818 case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
3819 if (TableKind == Kind::Lazy) {
3820 *E = malformedError("BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED not "
3821 "allowed in lazy bind table for opcode at: 0x" +
3822 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3823 moveToEnd();
3824 return;
3825 }
3826 if (SymbolName == StringRef()) {
3827 *E = malformedError(
3828 "for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED "
3829 "missing preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for "
3830 "opcode at: 0x" +
3831 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3832 moveToEnd();
3833 return;
3834 }
3835 if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3836 *E = malformedError(
3837 "for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED "
3838 "missing preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode "
3839 "at: 0x" +
3840 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3841 moveToEnd();
3842 return;
3843 }
3844 AdvanceAmount = ImmValue * PointerSize + PointerSize;
3845 RemainingLoopCount = 0;
3846 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset +
3847 AdvanceAmount, PointerSize);
3848 if (error) {
3849 *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED " +
3850 Twine(error) + " for opcode at: 0x" +
3851 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3852 moveToEnd();
3853 return;
3854 }
3855 DEBUG_WITH_TYPE("mach-o-bind",
3856 dbgs()
3857 << "BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: "
3858 << format("SegmentOffset=0x%06X", SegmentOffset) << "\n");
3859 return;
3860 case MachO::BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
3861 if (TableKind == Kind::Lazy) {
3862 *E = malformedError("BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB not "
3863 "allowed in lazy bind table for opcode at: 0x" +
3864 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3865 moveToEnd();
3866 return;
3867 }
3868 Count = readULEB128(&error);
3869 if (Count != 0)
3870 RemainingLoopCount = Count - 1;
3871 else
3872 RemainingLoopCount = 0;
3873 if (error) {
3874 *E = malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3875 " (count value) " +
3876 Twine(error) + " for opcode at: 0x" +
3877 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3878 moveToEnd();
3879 return;
3880 }
3881 Skip = readULEB128(&error);
3882 AdvanceAmount = Skip + PointerSize;
3883 if (error) {
3884 *E = malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3885 " (skip value) " +
3886 Twine(error) + " for opcode at: 0x" +
3887 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3888 moveToEnd();
3889 return;
3890 }
3891 if (SymbolName == StringRef()) {
3892 *E = malformedError(
3893 "for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3894 "missing preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for "
3895 "opcode at: 0x" +
3896 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3897 moveToEnd();
3898 return;
3899 }
3900 if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3901 *E = malformedError(
3902 "for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3903 "missing preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode "
3904 "at: 0x" +
3905 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3906 moveToEnd();
3907 return;
3908 }
3909 error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3910 PointerSize, Count, Skip);
3911 if (error) {
3912 *E =
3913 malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB " +
3914 Twine(error) + " for opcode at: 0x" +
3915 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3916 moveToEnd();
3917 return;
3918 }
3919 DEBUG_WITH_TYPE(
3920 "mach-o-bind",
3921 dbgs() << "BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: "
3922 << format("SegmentOffset=0x%06X", SegmentOffset)
3923 << ", AdvanceAmount=" << AdvanceAmount
3924 << ", RemainingLoopCount=" << RemainingLoopCount
3925 << "\n");
3926 return;
3927 default:
3928 *E = malformedError("bad bind info (bad opcode value 0x" +
3929 Twine::utohexstr(Opcode) + " for opcode at: 0x" +
3930 Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3931 moveToEnd();
3932 return;
3933 }
3934 }
3935 }
3936
readULEB128(const char ** error)3937 uint64_t MachOBindEntry::readULEB128(const char **error) {
3938 unsigned Count;
3939 uint64_t Result = decodeULEB128(Ptr, &Count, Opcodes.end(), error);
3940 Ptr += Count;
3941 if (Ptr > Opcodes.end())
3942 Ptr = Opcodes.end();
3943 return Result;
3944 }
3945
readSLEB128(const char ** error)3946 int64_t MachOBindEntry::readSLEB128(const char **error) {
3947 unsigned Count;
3948 int64_t Result = decodeSLEB128(Ptr, &Count, Opcodes.end(), error);
3949 Ptr += Count;
3950 if (Ptr > Opcodes.end())
3951 Ptr = Opcodes.end();
3952 return Result;
3953 }
3954
segmentIndex() const3955 int32_t MachOBindEntry::segmentIndex() const { return SegmentIndex; }
3956
segmentOffset() const3957 uint64_t MachOBindEntry::segmentOffset() const { return SegmentOffset; }
3958
typeName() const3959 StringRef MachOBindEntry::typeName() const {
3960 switch (BindType) {
3961 case MachO::BIND_TYPE_POINTER:
3962 return "pointer";
3963 case MachO::BIND_TYPE_TEXT_ABSOLUTE32:
3964 return "text abs32";
3965 case MachO::BIND_TYPE_TEXT_PCREL32:
3966 return "text rel32";
3967 }
3968 return "unknown";
3969 }
3970
symbolName() const3971 StringRef MachOBindEntry::symbolName() const { return SymbolName; }
3972
addend() const3973 int64_t MachOBindEntry::addend() const { return Addend; }
3974
flags() const3975 uint32_t MachOBindEntry::flags() const { return Flags; }
3976
ordinal() const3977 int MachOBindEntry::ordinal() const { return Ordinal; }
3978
3979 // For use with the SegIndex of a checked Mach-O Bind entry
3980 // to get the segment name.
segmentName() const3981 StringRef MachOBindEntry::segmentName() const {
3982 return O->BindRebaseSegmentName(SegmentIndex);
3983 }
3984
3985 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind entry
3986 // to get the section name.
sectionName() const3987 StringRef MachOBindEntry::sectionName() const {
3988 return O->BindRebaseSectionName(SegmentIndex, SegmentOffset);
3989 }
3990
3991 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind entry
3992 // to get the address.
address() const3993 uint64_t MachOBindEntry::address() const {
3994 return O->BindRebaseAddress(SegmentIndex, SegmentOffset);
3995 }
3996
operator ==(const MachOBindEntry & Other) const3997 bool MachOBindEntry::operator==(const MachOBindEntry &Other) const {
3998 #ifdef EXPENSIVE_CHECKS
3999 assert(Opcodes == Other.Opcodes && "compare iterators of different files");
4000 #else
4001 assert(Opcodes.data() == Other.Opcodes.data() && "compare iterators of different files");
4002 #endif
4003 return (Ptr == Other.Ptr) &&
4004 (RemainingLoopCount == Other.RemainingLoopCount) &&
4005 (Done == Other.Done);
4006 }
4007
4008 // Build table of sections so SegIndex/SegOffset pairs can be translated.
BindRebaseSegInfo(const object::MachOObjectFile * Obj)4009 BindRebaseSegInfo::BindRebaseSegInfo(const object::MachOObjectFile *Obj) {
4010 uint32_t CurSegIndex = Obj->hasPageZeroSegment() ? 1 : 0;
4011 StringRef CurSegName;
4012 uint64_t CurSegAddress;
4013 for (const SectionRef &Section : Obj->sections()) {
4014 SectionInfo Info;
4015 Expected<StringRef> NameOrErr = Section.getName();
4016 if (!NameOrErr)
4017 consumeError(NameOrErr.takeError());
4018 else
4019 Info.SectionName = *NameOrErr;
4020 Info.Address = Section.getAddress();
4021 Info.Size = Section.getSize();
4022 Info.SegmentName =
4023 Obj->getSectionFinalSegmentName(Section.getRawDataRefImpl());
4024 if (!Info.SegmentName.equals(CurSegName)) {
4025 ++CurSegIndex;
4026 CurSegName = Info.SegmentName;
4027 CurSegAddress = Info.Address;
4028 }
4029 Info.SegmentIndex = CurSegIndex - 1;
4030 Info.OffsetInSegment = Info.Address - CurSegAddress;
4031 Info.SegmentStartAddress = CurSegAddress;
4032 Sections.push_back(Info);
4033 }
4034 MaxSegIndex = CurSegIndex;
4035 }
4036
4037 // For use with a SegIndex, SegOffset, and PointerSize triple in
4038 // MachOBindEntry::moveNext() to validate a MachOBindEntry or MachORebaseEntry.
4039 //
4040 // Given a SegIndex, SegOffset, and PointerSize, verify a valid section exists
4041 // that fully contains a pointer at that location. Multiple fixups in a bind
4042 // (such as with the BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB opcode) can
4043 // be tested via the Count and Skip parameters.
checkSegAndOffsets(int32_t SegIndex,uint64_t SegOffset,uint8_t PointerSize,uint32_t Count,uint32_t Skip)4044 const char * BindRebaseSegInfo::checkSegAndOffsets(int32_t SegIndex,
4045 uint64_t SegOffset,
4046 uint8_t PointerSize,
4047 uint32_t Count,
4048 uint32_t Skip) {
4049 if (SegIndex == -1)
4050 return "missing preceding *_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB";
4051 if (SegIndex >= MaxSegIndex)
4052 return "bad segIndex (too large)";
4053 for (uint32_t i = 0; i < Count; ++i) {
4054 uint32_t Start = SegOffset + i * (PointerSize + Skip);
4055 uint32_t End = Start + PointerSize;
4056 bool Found = false;
4057 for (const SectionInfo &SI : Sections) {
4058 if (SI.SegmentIndex != SegIndex)
4059 continue;
4060 if ((SI.OffsetInSegment<=Start) && (Start<(SI.OffsetInSegment+SI.Size))) {
4061 if (End <= SI.OffsetInSegment + SI.Size) {
4062 Found = true;
4063 break;
4064 }
4065 else
4066 return "bad offset, extends beyond section boundary";
4067 }
4068 }
4069 if (!Found)
4070 return "bad offset, not in section";
4071 }
4072 return nullptr;
4073 }
4074
4075 // For use with the SegIndex of a checked Mach-O Bind or Rebase entry
4076 // to get the segment name.
segmentName(int32_t SegIndex)4077 StringRef BindRebaseSegInfo::segmentName(int32_t SegIndex) {
4078 for (const SectionInfo &SI : Sections) {
4079 if (SI.SegmentIndex == SegIndex)
4080 return SI.SegmentName;
4081 }
4082 llvm_unreachable("invalid SegIndex");
4083 }
4084
4085 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
4086 // to get the SectionInfo.
findSection(int32_t SegIndex,uint64_t SegOffset)4087 const BindRebaseSegInfo::SectionInfo &BindRebaseSegInfo::findSection(
4088 int32_t SegIndex, uint64_t SegOffset) {
4089 for (const SectionInfo &SI : Sections) {
4090 if (SI.SegmentIndex != SegIndex)
4091 continue;
4092 if (SI.OffsetInSegment > SegOffset)
4093 continue;
4094 if (SegOffset >= (SI.OffsetInSegment + SI.Size))
4095 continue;
4096 return SI;
4097 }
4098 llvm_unreachable("SegIndex and SegOffset not in any section");
4099 }
4100
4101 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
4102 // entry to get the section name.
sectionName(int32_t SegIndex,uint64_t SegOffset)4103 StringRef BindRebaseSegInfo::sectionName(int32_t SegIndex,
4104 uint64_t SegOffset) {
4105 return findSection(SegIndex, SegOffset).SectionName;
4106 }
4107
4108 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
4109 // entry to get the address.
address(uint32_t SegIndex,uint64_t OffsetInSeg)4110 uint64_t BindRebaseSegInfo::address(uint32_t SegIndex, uint64_t OffsetInSeg) {
4111 const SectionInfo &SI = findSection(SegIndex, OffsetInSeg);
4112 return SI.SegmentStartAddress + OffsetInSeg;
4113 }
4114
4115 iterator_range<bind_iterator>
bindTable(Error & Err,MachOObjectFile * O,ArrayRef<uint8_t> Opcodes,bool is64,MachOBindEntry::Kind BKind)4116 MachOObjectFile::bindTable(Error &Err, MachOObjectFile *O,
4117 ArrayRef<uint8_t> Opcodes, bool is64,
4118 MachOBindEntry::Kind BKind) {
4119 if (O->BindRebaseSectionTable == nullptr)
4120 O->BindRebaseSectionTable = std::make_unique<BindRebaseSegInfo>(O);
4121 MachOBindEntry Start(&Err, O, Opcodes, is64, BKind);
4122 Start.moveToFirst();
4123
4124 MachOBindEntry Finish(&Err, O, Opcodes, is64, BKind);
4125 Finish.moveToEnd();
4126
4127 return make_range(bind_iterator(Start), bind_iterator(Finish));
4128 }
4129
bindTable(Error & Err)4130 iterator_range<bind_iterator> MachOObjectFile::bindTable(Error &Err) {
4131 return bindTable(Err, this, getDyldInfoBindOpcodes(), is64Bit(),
4132 MachOBindEntry::Kind::Regular);
4133 }
4134
lazyBindTable(Error & Err)4135 iterator_range<bind_iterator> MachOObjectFile::lazyBindTable(Error &Err) {
4136 return bindTable(Err, this, getDyldInfoLazyBindOpcodes(), is64Bit(),
4137 MachOBindEntry::Kind::Lazy);
4138 }
4139
weakBindTable(Error & Err)4140 iterator_range<bind_iterator> MachOObjectFile::weakBindTable(Error &Err) {
4141 return bindTable(Err, this, getDyldInfoWeakBindOpcodes(), is64Bit(),
4142 MachOBindEntry::Kind::Weak);
4143 }
4144
4145 MachOObjectFile::load_command_iterator
begin_load_commands() const4146 MachOObjectFile::begin_load_commands() const {
4147 return LoadCommands.begin();
4148 }
4149
4150 MachOObjectFile::load_command_iterator
end_load_commands() const4151 MachOObjectFile::end_load_commands() const {
4152 return LoadCommands.end();
4153 }
4154
4155 iterator_range<MachOObjectFile::load_command_iterator>
load_commands() const4156 MachOObjectFile::load_commands() const {
4157 return make_range(begin_load_commands(), end_load_commands());
4158 }
4159
4160 StringRef
getSectionFinalSegmentName(DataRefImpl Sec) const4161 MachOObjectFile::getSectionFinalSegmentName(DataRefImpl Sec) const {
4162 ArrayRef<char> Raw = getSectionRawFinalSegmentName(Sec);
4163 return parseSegmentOrSectionName(Raw.data());
4164 }
4165
4166 ArrayRef<char>
getSectionRawName(DataRefImpl Sec) const4167 MachOObjectFile::getSectionRawName(DataRefImpl Sec) const {
4168 assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
4169 const section_base *Base =
4170 reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
4171 return makeArrayRef(Base->sectname);
4172 }
4173
4174 ArrayRef<char>
getSectionRawFinalSegmentName(DataRefImpl Sec) const4175 MachOObjectFile::getSectionRawFinalSegmentName(DataRefImpl Sec) const {
4176 assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
4177 const section_base *Base =
4178 reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
4179 return makeArrayRef(Base->segname);
4180 }
4181
4182 bool
isRelocationScattered(const MachO::any_relocation_info & RE) const4183 MachOObjectFile::isRelocationScattered(const MachO::any_relocation_info &RE)
4184 const {
4185 if (getCPUType(*this) == MachO::CPU_TYPE_X86_64)
4186 return false;
4187 return getPlainRelocationAddress(RE) & MachO::R_SCATTERED;
4188 }
4189
getPlainRelocationSymbolNum(const MachO::any_relocation_info & RE) const4190 unsigned MachOObjectFile::getPlainRelocationSymbolNum(
4191 const MachO::any_relocation_info &RE) const {
4192 if (isLittleEndian())
4193 return RE.r_word1 & 0xffffff;
4194 return RE.r_word1 >> 8;
4195 }
4196
getPlainRelocationExternal(const MachO::any_relocation_info & RE) const4197 bool MachOObjectFile::getPlainRelocationExternal(
4198 const MachO::any_relocation_info &RE) const {
4199 if (isLittleEndian())
4200 return (RE.r_word1 >> 27) & 1;
4201 return (RE.r_word1 >> 4) & 1;
4202 }
4203
getScatteredRelocationScattered(const MachO::any_relocation_info & RE) const4204 bool MachOObjectFile::getScatteredRelocationScattered(
4205 const MachO::any_relocation_info &RE) const {
4206 return RE.r_word0 >> 31;
4207 }
4208
getScatteredRelocationValue(const MachO::any_relocation_info & RE) const4209 uint32_t MachOObjectFile::getScatteredRelocationValue(
4210 const MachO::any_relocation_info &RE) const {
4211 return RE.r_word1;
4212 }
4213
getScatteredRelocationType(const MachO::any_relocation_info & RE) const4214 uint32_t MachOObjectFile::getScatteredRelocationType(
4215 const MachO::any_relocation_info &RE) const {
4216 return (RE.r_word0 >> 24) & 0xf;
4217 }
4218
getAnyRelocationAddress(const MachO::any_relocation_info & RE) const4219 unsigned MachOObjectFile::getAnyRelocationAddress(
4220 const MachO::any_relocation_info &RE) const {
4221 if (isRelocationScattered(RE))
4222 return getScatteredRelocationAddress(RE);
4223 return getPlainRelocationAddress(RE);
4224 }
4225
getAnyRelocationPCRel(const MachO::any_relocation_info & RE) const4226 unsigned MachOObjectFile::getAnyRelocationPCRel(
4227 const MachO::any_relocation_info &RE) const {
4228 if (isRelocationScattered(RE))
4229 return getScatteredRelocationPCRel(RE);
4230 return getPlainRelocationPCRel(*this, RE);
4231 }
4232
getAnyRelocationLength(const MachO::any_relocation_info & RE) const4233 unsigned MachOObjectFile::getAnyRelocationLength(
4234 const MachO::any_relocation_info &RE) const {
4235 if (isRelocationScattered(RE))
4236 return getScatteredRelocationLength(RE);
4237 return getPlainRelocationLength(*this, RE);
4238 }
4239
4240 unsigned
getAnyRelocationType(const MachO::any_relocation_info & RE) const4241 MachOObjectFile::getAnyRelocationType(
4242 const MachO::any_relocation_info &RE) const {
4243 if (isRelocationScattered(RE))
4244 return getScatteredRelocationType(RE);
4245 return getPlainRelocationType(*this, RE);
4246 }
4247
4248 SectionRef
getAnyRelocationSection(const MachO::any_relocation_info & RE) const4249 MachOObjectFile::getAnyRelocationSection(
4250 const MachO::any_relocation_info &RE) const {
4251 if (isRelocationScattered(RE) || getPlainRelocationExternal(RE))
4252 return *section_end();
4253 unsigned SecNum = getPlainRelocationSymbolNum(RE);
4254 if (SecNum == MachO::R_ABS || SecNum > Sections.size())
4255 return *section_end();
4256 DataRefImpl DRI;
4257 DRI.d.a = SecNum - 1;
4258 return SectionRef(DRI, this);
4259 }
4260
getSection(DataRefImpl DRI) const4261 MachO::section MachOObjectFile::getSection(DataRefImpl DRI) const {
4262 assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
4263 return getStruct<MachO::section>(*this, Sections[DRI.d.a]);
4264 }
4265
getSection64(DataRefImpl DRI) const4266 MachO::section_64 MachOObjectFile::getSection64(DataRefImpl DRI) const {
4267 assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
4268 return getStruct<MachO::section_64>(*this, Sections[DRI.d.a]);
4269 }
4270
getSection(const LoadCommandInfo & L,unsigned Index) const4271 MachO::section MachOObjectFile::getSection(const LoadCommandInfo &L,
4272 unsigned Index) const {
4273 const char *Sec = getSectionPtr(*this, L, Index);
4274 return getStruct<MachO::section>(*this, Sec);
4275 }
4276
getSection64(const LoadCommandInfo & L,unsigned Index) const4277 MachO::section_64 MachOObjectFile::getSection64(const LoadCommandInfo &L,
4278 unsigned Index) const {
4279 const char *Sec = getSectionPtr(*this, L, Index);
4280 return getStruct<MachO::section_64>(*this, Sec);
4281 }
4282
4283 MachO::nlist
getSymbolTableEntry(DataRefImpl DRI) const4284 MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI) const {
4285 const char *P = reinterpret_cast<const char *>(DRI.p);
4286 return getStruct<MachO::nlist>(*this, P);
4287 }
4288
4289 MachO::nlist_64
getSymbol64TableEntry(DataRefImpl DRI) const4290 MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI) const {
4291 const char *P = reinterpret_cast<const char *>(DRI.p);
4292 return getStruct<MachO::nlist_64>(*this, P);
4293 }
4294
4295 MachO::linkedit_data_command
getLinkeditDataLoadCommand(const LoadCommandInfo & L) const4296 MachOObjectFile::getLinkeditDataLoadCommand(const LoadCommandInfo &L) const {
4297 return getStruct<MachO::linkedit_data_command>(*this, L.Ptr);
4298 }
4299
4300 MachO::segment_command
getSegmentLoadCommand(const LoadCommandInfo & L) const4301 MachOObjectFile::getSegmentLoadCommand(const LoadCommandInfo &L) const {
4302 return getStruct<MachO::segment_command>(*this, L.Ptr);
4303 }
4304
4305 MachO::segment_command_64
getSegment64LoadCommand(const LoadCommandInfo & L) const4306 MachOObjectFile::getSegment64LoadCommand(const LoadCommandInfo &L) const {
4307 return getStruct<MachO::segment_command_64>(*this, L.Ptr);
4308 }
4309
4310 MachO::linker_option_command
getLinkerOptionLoadCommand(const LoadCommandInfo & L) const4311 MachOObjectFile::getLinkerOptionLoadCommand(const LoadCommandInfo &L) const {
4312 return getStruct<MachO::linker_option_command>(*this, L.Ptr);
4313 }
4314
4315 MachO::version_min_command
getVersionMinLoadCommand(const LoadCommandInfo & L) const4316 MachOObjectFile::getVersionMinLoadCommand(const LoadCommandInfo &L) const {
4317 return getStruct<MachO::version_min_command>(*this, L.Ptr);
4318 }
4319
4320 MachO::note_command
getNoteLoadCommand(const LoadCommandInfo & L) const4321 MachOObjectFile::getNoteLoadCommand(const LoadCommandInfo &L) const {
4322 return getStruct<MachO::note_command>(*this, L.Ptr);
4323 }
4324
4325 MachO::build_version_command
getBuildVersionLoadCommand(const LoadCommandInfo & L) const4326 MachOObjectFile::getBuildVersionLoadCommand(const LoadCommandInfo &L) const {
4327 return getStruct<MachO::build_version_command>(*this, L.Ptr);
4328 }
4329
4330 MachO::build_tool_version
getBuildToolVersion(unsigned index) const4331 MachOObjectFile::getBuildToolVersion(unsigned index) const {
4332 return getStruct<MachO::build_tool_version>(*this, BuildTools[index]);
4333 }
4334
4335 MachO::dylib_command
getDylibIDLoadCommand(const LoadCommandInfo & L) const4336 MachOObjectFile::getDylibIDLoadCommand(const LoadCommandInfo &L) const {
4337 return getStruct<MachO::dylib_command>(*this, L.Ptr);
4338 }
4339
4340 MachO::dyld_info_command
getDyldInfoLoadCommand(const LoadCommandInfo & L) const4341 MachOObjectFile::getDyldInfoLoadCommand(const LoadCommandInfo &L) const {
4342 return getStruct<MachO::dyld_info_command>(*this, L.Ptr);
4343 }
4344
4345 MachO::dylinker_command
getDylinkerCommand(const LoadCommandInfo & L) const4346 MachOObjectFile::getDylinkerCommand(const LoadCommandInfo &L) const {
4347 return getStruct<MachO::dylinker_command>(*this, L.Ptr);
4348 }
4349
4350 MachO::uuid_command
getUuidCommand(const LoadCommandInfo & L) const4351 MachOObjectFile::getUuidCommand(const LoadCommandInfo &L) const {
4352 return getStruct<MachO::uuid_command>(*this, L.Ptr);
4353 }
4354
4355 MachO::rpath_command
getRpathCommand(const LoadCommandInfo & L) const4356 MachOObjectFile::getRpathCommand(const LoadCommandInfo &L) const {
4357 return getStruct<MachO::rpath_command>(*this, L.Ptr);
4358 }
4359
4360 MachO::source_version_command
getSourceVersionCommand(const LoadCommandInfo & L) const4361 MachOObjectFile::getSourceVersionCommand(const LoadCommandInfo &L) const {
4362 return getStruct<MachO::source_version_command>(*this, L.Ptr);
4363 }
4364
4365 MachO::entry_point_command
getEntryPointCommand(const LoadCommandInfo & L) const4366 MachOObjectFile::getEntryPointCommand(const LoadCommandInfo &L) const {
4367 return getStruct<MachO::entry_point_command>(*this, L.Ptr);
4368 }
4369
4370 MachO::encryption_info_command
getEncryptionInfoCommand(const LoadCommandInfo & L) const4371 MachOObjectFile::getEncryptionInfoCommand(const LoadCommandInfo &L) const {
4372 return getStruct<MachO::encryption_info_command>(*this, L.Ptr);
4373 }
4374
4375 MachO::encryption_info_command_64
getEncryptionInfoCommand64(const LoadCommandInfo & L) const4376 MachOObjectFile::getEncryptionInfoCommand64(const LoadCommandInfo &L) const {
4377 return getStruct<MachO::encryption_info_command_64>(*this, L.Ptr);
4378 }
4379
4380 MachO::sub_framework_command
getSubFrameworkCommand(const LoadCommandInfo & L) const4381 MachOObjectFile::getSubFrameworkCommand(const LoadCommandInfo &L) const {
4382 return getStruct<MachO::sub_framework_command>(*this, L.Ptr);
4383 }
4384
4385 MachO::sub_umbrella_command
getSubUmbrellaCommand(const LoadCommandInfo & L) const4386 MachOObjectFile::getSubUmbrellaCommand(const LoadCommandInfo &L) const {
4387 return getStruct<MachO::sub_umbrella_command>(*this, L.Ptr);
4388 }
4389
4390 MachO::sub_library_command
getSubLibraryCommand(const LoadCommandInfo & L) const4391 MachOObjectFile::getSubLibraryCommand(const LoadCommandInfo &L) const {
4392 return getStruct<MachO::sub_library_command>(*this, L.Ptr);
4393 }
4394
4395 MachO::sub_client_command
getSubClientCommand(const LoadCommandInfo & L) const4396 MachOObjectFile::getSubClientCommand(const LoadCommandInfo &L) const {
4397 return getStruct<MachO::sub_client_command>(*this, L.Ptr);
4398 }
4399
4400 MachO::routines_command
getRoutinesCommand(const LoadCommandInfo & L) const4401 MachOObjectFile::getRoutinesCommand(const LoadCommandInfo &L) const {
4402 return getStruct<MachO::routines_command>(*this, L.Ptr);
4403 }
4404
4405 MachO::routines_command_64
getRoutinesCommand64(const LoadCommandInfo & L) const4406 MachOObjectFile::getRoutinesCommand64(const LoadCommandInfo &L) const {
4407 return getStruct<MachO::routines_command_64>(*this, L.Ptr);
4408 }
4409
4410 MachO::thread_command
getThreadCommand(const LoadCommandInfo & L) const4411 MachOObjectFile::getThreadCommand(const LoadCommandInfo &L) const {
4412 return getStruct<MachO::thread_command>(*this, L.Ptr);
4413 }
4414
4415 MachO::any_relocation_info
getRelocation(DataRefImpl Rel) const4416 MachOObjectFile::getRelocation(DataRefImpl Rel) const {
4417 uint32_t Offset;
4418 if (getHeader().filetype == MachO::MH_OBJECT) {
4419 DataRefImpl Sec;
4420 Sec.d.a = Rel.d.a;
4421 if (is64Bit()) {
4422 MachO::section_64 Sect = getSection64(Sec);
4423 Offset = Sect.reloff;
4424 } else {
4425 MachO::section Sect = getSection(Sec);
4426 Offset = Sect.reloff;
4427 }
4428 } else {
4429 MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
4430 if (Rel.d.a == 0)
4431 Offset = DysymtabLoadCmd.extreloff; // Offset to the external relocations
4432 else
4433 Offset = DysymtabLoadCmd.locreloff; // Offset to the local relocations
4434 }
4435
4436 auto P = reinterpret_cast<const MachO::any_relocation_info *>(
4437 getPtr(*this, Offset)) + Rel.d.b;
4438 return getStruct<MachO::any_relocation_info>(
4439 *this, reinterpret_cast<const char *>(P));
4440 }
4441
4442 MachO::data_in_code_entry
getDice(DataRefImpl Rel) const4443 MachOObjectFile::getDice(DataRefImpl Rel) const {
4444 const char *P = reinterpret_cast<const char *>(Rel.p);
4445 return getStruct<MachO::data_in_code_entry>(*this, P);
4446 }
4447
getHeader() const4448 const MachO::mach_header &MachOObjectFile::getHeader() const {
4449 return Header;
4450 }
4451
getHeader64() const4452 const MachO::mach_header_64 &MachOObjectFile::getHeader64() const {
4453 assert(is64Bit());
4454 return Header64;
4455 }
4456
getIndirectSymbolTableEntry(const MachO::dysymtab_command & DLC,unsigned Index) const4457 uint32_t MachOObjectFile::getIndirectSymbolTableEntry(
4458 const MachO::dysymtab_command &DLC,
4459 unsigned Index) const {
4460 uint64_t Offset = DLC.indirectsymoff + Index * sizeof(uint32_t);
4461 return getStruct<uint32_t>(*this, getPtr(*this, Offset));
4462 }
4463
4464 MachO::data_in_code_entry
getDataInCodeTableEntry(uint32_t DataOffset,unsigned Index) const4465 MachOObjectFile::getDataInCodeTableEntry(uint32_t DataOffset,
4466 unsigned Index) const {
4467 uint64_t Offset = DataOffset + Index * sizeof(MachO::data_in_code_entry);
4468 return getStruct<MachO::data_in_code_entry>(*this, getPtr(*this, Offset));
4469 }
4470
getSymtabLoadCommand() const4471 MachO::symtab_command MachOObjectFile::getSymtabLoadCommand() const {
4472 if (SymtabLoadCmd)
4473 return getStruct<MachO::symtab_command>(*this, SymtabLoadCmd);
4474
4475 // If there is no SymtabLoadCmd return a load command with zero'ed fields.
4476 MachO::symtab_command Cmd;
4477 Cmd.cmd = MachO::LC_SYMTAB;
4478 Cmd.cmdsize = sizeof(MachO::symtab_command);
4479 Cmd.symoff = 0;
4480 Cmd.nsyms = 0;
4481 Cmd.stroff = 0;
4482 Cmd.strsize = 0;
4483 return Cmd;
4484 }
4485
getDysymtabLoadCommand() const4486 MachO::dysymtab_command MachOObjectFile::getDysymtabLoadCommand() const {
4487 if (DysymtabLoadCmd)
4488 return getStruct<MachO::dysymtab_command>(*this, DysymtabLoadCmd);
4489
4490 // If there is no DysymtabLoadCmd return a load command with zero'ed fields.
4491 MachO::dysymtab_command Cmd;
4492 Cmd.cmd = MachO::LC_DYSYMTAB;
4493 Cmd.cmdsize = sizeof(MachO::dysymtab_command);
4494 Cmd.ilocalsym = 0;
4495 Cmd.nlocalsym = 0;
4496 Cmd.iextdefsym = 0;
4497 Cmd.nextdefsym = 0;
4498 Cmd.iundefsym = 0;
4499 Cmd.nundefsym = 0;
4500 Cmd.tocoff = 0;
4501 Cmd.ntoc = 0;
4502 Cmd.modtaboff = 0;
4503 Cmd.nmodtab = 0;
4504 Cmd.extrefsymoff = 0;
4505 Cmd.nextrefsyms = 0;
4506 Cmd.indirectsymoff = 0;
4507 Cmd.nindirectsyms = 0;
4508 Cmd.extreloff = 0;
4509 Cmd.nextrel = 0;
4510 Cmd.locreloff = 0;
4511 Cmd.nlocrel = 0;
4512 return Cmd;
4513 }
4514
4515 MachO::linkedit_data_command
getDataInCodeLoadCommand() const4516 MachOObjectFile::getDataInCodeLoadCommand() const {
4517 if (DataInCodeLoadCmd)
4518 return getStruct<MachO::linkedit_data_command>(*this, DataInCodeLoadCmd);
4519
4520 // If there is no DataInCodeLoadCmd return a load command with zero'ed fields.
4521 MachO::linkedit_data_command Cmd;
4522 Cmd.cmd = MachO::LC_DATA_IN_CODE;
4523 Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
4524 Cmd.dataoff = 0;
4525 Cmd.datasize = 0;
4526 return Cmd;
4527 }
4528
4529 MachO::linkedit_data_command
getLinkOptHintsLoadCommand() const4530 MachOObjectFile::getLinkOptHintsLoadCommand() const {
4531 if (LinkOptHintsLoadCmd)
4532 return getStruct<MachO::linkedit_data_command>(*this, LinkOptHintsLoadCmd);
4533
4534 // If there is no LinkOptHintsLoadCmd return a load command with zero'ed
4535 // fields.
4536 MachO::linkedit_data_command Cmd;
4537 Cmd.cmd = MachO::LC_LINKER_OPTIMIZATION_HINT;
4538 Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
4539 Cmd.dataoff = 0;
4540 Cmd.datasize = 0;
4541 return Cmd;
4542 }
4543
getDyldInfoRebaseOpcodes() const4544 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoRebaseOpcodes() const {
4545 if (!DyldInfoLoadCmd)
4546 return None;
4547
4548 auto DyldInfoOrErr =
4549 getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4550 if (!DyldInfoOrErr)
4551 return None;
4552 MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4553 const uint8_t *Ptr =
4554 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.rebase_off));
4555 return makeArrayRef(Ptr, DyldInfo.rebase_size);
4556 }
4557
getDyldInfoBindOpcodes() const4558 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoBindOpcodes() const {
4559 if (!DyldInfoLoadCmd)
4560 return None;
4561
4562 auto DyldInfoOrErr =
4563 getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4564 if (!DyldInfoOrErr)
4565 return None;
4566 MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4567 const uint8_t *Ptr =
4568 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.bind_off));
4569 return makeArrayRef(Ptr, DyldInfo.bind_size);
4570 }
4571
getDyldInfoWeakBindOpcodes() const4572 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoWeakBindOpcodes() const {
4573 if (!DyldInfoLoadCmd)
4574 return None;
4575
4576 auto DyldInfoOrErr =
4577 getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4578 if (!DyldInfoOrErr)
4579 return None;
4580 MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4581 const uint8_t *Ptr =
4582 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.weak_bind_off));
4583 return makeArrayRef(Ptr, DyldInfo.weak_bind_size);
4584 }
4585
getDyldInfoLazyBindOpcodes() const4586 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoLazyBindOpcodes() const {
4587 if (!DyldInfoLoadCmd)
4588 return None;
4589
4590 auto DyldInfoOrErr =
4591 getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4592 if (!DyldInfoOrErr)
4593 return None;
4594 MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4595 const uint8_t *Ptr =
4596 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.lazy_bind_off));
4597 return makeArrayRef(Ptr, DyldInfo.lazy_bind_size);
4598 }
4599
getDyldInfoExportsTrie() const4600 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoExportsTrie() const {
4601 if (!DyldInfoLoadCmd)
4602 return None;
4603
4604 auto DyldInfoOrErr =
4605 getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4606 if (!DyldInfoOrErr)
4607 return None;
4608 MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4609 const uint8_t *Ptr =
4610 reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.export_off));
4611 return makeArrayRef(Ptr, DyldInfo.export_size);
4612 }
4613
getUuid() const4614 ArrayRef<uint8_t> MachOObjectFile::getUuid() const {
4615 if (!UuidLoadCmd)
4616 return None;
4617 // Returning a pointer is fine as uuid doesn't need endian swapping.
4618 const char *Ptr = UuidLoadCmd + offsetof(MachO::uuid_command, uuid);
4619 return makeArrayRef(reinterpret_cast<const uint8_t *>(Ptr), 16);
4620 }
4621
getStringTableData() const4622 StringRef MachOObjectFile::getStringTableData() const {
4623 MachO::symtab_command S = getSymtabLoadCommand();
4624 return getData().substr(S.stroff, S.strsize);
4625 }
4626
is64Bit() const4627 bool MachOObjectFile::is64Bit() const {
4628 return getType() == getMachOType(false, true) ||
4629 getType() == getMachOType(true, true);
4630 }
4631
ReadULEB128s(uint64_t Index,SmallVectorImpl<uint64_t> & Out) const4632 void MachOObjectFile::ReadULEB128s(uint64_t Index,
4633 SmallVectorImpl<uint64_t> &Out) const {
4634 DataExtractor extractor(ObjectFile::getData(), true, 0);
4635
4636 uint64_t offset = Index;
4637 uint64_t data = 0;
4638 while (uint64_t delta = extractor.getULEB128(&offset)) {
4639 data += delta;
4640 Out.push_back(data);
4641 }
4642 }
4643
isRelocatableObject() const4644 bool MachOObjectFile::isRelocatableObject() const {
4645 return getHeader().filetype == MachO::MH_OBJECT;
4646 }
4647
4648 Expected<std::unique_ptr<MachOObjectFile>>
createMachOObjectFile(MemoryBufferRef Buffer,uint32_t UniversalCputype,uint32_t UniversalIndex)4649 ObjectFile::createMachOObjectFile(MemoryBufferRef Buffer,
4650 uint32_t UniversalCputype,
4651 uint32_t UniversalIndex) {
4652 StringRef Magic = Buffer.getBuffer().slice(0, 4);
4653 if (Magic == "\xFE\xED\xFA\xCE")
4654 return MachOObjectFile::create(Buffer, false, false,
4655 UniversalCputype, UniversalIndex);
4656 if (Magic == "\xCE\xFA\xED\xFE")
4657 return MachOObjectFile::create(Buffer, true, false,
4658 UniversalCputype, UniversalIndex);
4659 if (Magic == "\xFE\xED\xFA\xCF")
4660 return MachOObjectFile::create(Buffer, false, true,
4661 UniversalCputype, UniversalIndex);
4662 if (Magic == "\xCF\xFA\xED\xFE")
4663 return MachOObjectFile::create(Buffer, true, true,
4664 UniversalCputype, UniversalIndex);
4665 return make_error<GenericBinaryError>("Unrecognized MachO magic number",
4666 object_error::invalid_file_type);
4667 }
4668
mapDebugSectionName(StringRef Name) const4669 StringRef MachOObjectFile::mapDebugSectionName(StringRef Name) const {
4670 return StringSwitch<StringRef>(Name)
4671 .Case("debug_str_offs", "debug_str_offsets")
4672 .Default(Name);
4673 }
4674