Bug Summary

File:llvm/lib/Object/MachOObjectFile.cpp
Warning:line 4017, column 41
The right operand of '-' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name MachOObjectFile.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/lib/Object -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Object -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/include -I /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/build-llvm/lib/Object -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-12-07-102640-14763-1 -x c++ /build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Object/MachOObjectFile.cpp

/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/llvm/lib/Object/MachOObjectFile.cpp

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

/usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/bits/unique_ptr.h

1// unique_ptr implementation -*- C++ -*-
2
3// Copyright (C) 2008-2016 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/** @file bits/unique_ptr.h
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{memory}
28 */
29
30#ifndef _UNIQUE_PTR_H1
31#define _UNIQUE_PTR_H1 1
32
33#include <bits/c++config.h>
34#include <debug/assertions.h>
35#include <type_traits>
36#include <utility>
37#include <tuple>
38
39namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
40{
41_GLIBCXX_BEGIN_NAMESPACE_VERSION
42
43 /**
44 * @addtogroup pointer_abstractions
45 * @{
46 */
47
48#if _GLIBCXX_USE_DEPRECATED1
49 template<typename> class auto_ptr;
50#endif
51
52 /// Primary template of default_delete, used by unique_ptr
53 template<typename _Tp>
54 struct default_delete
55 {
56 /// Default constructor
57 constexpr default_delete() noexcept = default;
58
59 /** @brief Converting constructor.
60 *
61 * Allows conversion from a deleter for arrays of another type, @p _Up,
62 * only if @p _Up* is convertible to @p _Tp*.
63 */
64 template<typename _Up, typename = typename
65 enable_if<is_convertible<_Up*, _Tp*>::value>::type>
66 default_delete(const default_delete<_Up>&) noexcept { }
67
68 /// Calls @c delete @p __ptr
69 void
70 operator()(_Tp* __ptr) const
71 {
72 static_assert(!is_void<_Tp>::value,
73 "can't delete pointer to incomplete type");
74 static_assert(sizeof(_Tp)>0,
75 "can't delete pointer to incomplete type");
76 delete __ptr;
77 }
78 };
79
80 // _GLIBCXX_RESOLVE_LIB_DEFECTS
81 // DR 740 - omit specialization for array objects with a compile time length
82 /// Specialization for arrays, default_delete.
83 template<typename _Tp>
84 struct default_delete<_Tp[]>
85 {
86 public:
87 /// Default constructor
88 constexpr default_delete() noexcept = default;
89
90 /** @brief Converting constructor.
91 *
92 * Allows conversion from a deleter for arrays of another type, such as
93 * a const-qualified version of @p _Tp.
94 *
95 * Conversions from types derived from @c _Tp are not allowed because
96 * it is unsafe to @c delete[] an array of derived types through a
97 * pointer to the base type.
98 */
99 template<typename _Up, typename = typename
100 enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type>
101 default_delete(const default_delete<_Up[]>&) noexcept { }
102
103 /// Calls @c delete[] @p __ptr
104 template<typename _Up>
105 typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
106 operator()(_Up* __ptr) const
107 {
108 static_assert(sizeof(_Tp)>0,
109 "can't delete pointer to incomplete type");
110 delete [] __ptr;
111 }
112 };
113
114 /// 20.7.1.2 unique_ptr for single objects.
115 template <typename _Tp, typename _Dp = default_delete<_Tp> >
116 class unique_ptr
117 {
118 // use SFINAE to determine whether _Del::pointer exists
119 class _Pointer
120 {
121 template<typename _Up>
122 static typename _Up::pointer __test(typename _Up::pointer*);
123
124 template<typename _Up>
125 static _Tp* __test(...);
126
127 typedef typename remove_reference<_Dp>::type _Del;
128
129 public:
130 typedef decltype(__test<_Del>(0)) type;
131 };
132
133 typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
134 __tuple_type _M_t;
135
136 public:
137 typedef typename _Pointer::type pointer;
138 typedef _Tp element_type;
139 typedef _Dp deleter_type;
140
141
142 // helper template for detecting a safe conversion from another
143 // unique_ptr
144 template<typename _Up, typename _Ep>
145 using __safe_conversion_up = __and_<
146 is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
147 __not_<is_array<_Up>>,
148 __or_<__and_<is_reference<deleter_type>,
149 is_same<deleter_type, _Ep>>,
150 __and_<__not_<is_reference<deleter_type>>,
151 is_convertible<_Ep, deleter_type>>
152 >
153 >;
154
155 // Constructors.
156
157 /// Default constructor, creates a unique_ptr that owns nothing.
158 constexpr unique_ptr() noexcept
159 : _M_t()
160 { static_assert(!is_pointer<deleter_type>::value,
161 "constructed with null function pointer deleter"); }
162
163 /** Takes ownership of a pointer.
164 *
165 * @param __p A pointer to an object of @c element_type
166 *
167 * The deleter will be value-initialized.
168 */
169 explicit
170 unique_ptr(pointer __p) noexcept
171 : _M_t()
172 {
173 std::get<0>(_M_t) = __p;
174 static_assert(!is_pointer<deleter_type>::value,
175 "constructed with null function pointer deleter");
176 }
177
178 /** Takes ownership of a pointer.
179 *
180 * @param __p A pointer to an object of @c element_type
181 * @param __d A reference to a deleter.
182 *
183 * The deleter will be initialized with @p __d
184 */
185 unique_ptr(pointer __p,
186 typename conditional<is_reference<deleter_type>::value,
187 deleter_type, const deleter_type&>::type __d) noexcept
188 : _M_t(__p, __d) { }
189
190 /** Takes ownership of a pointer.
191 *
192 * @param __p A pointer to an object of @c element_type
193 * @param __d An rvalue reference to a deleter.
194 *
195 * The deleter will be initialized with @p std::move(__d)
196 */
197 unique_ptr(pointer __p,
198 typename remove_reference<deleter_type>::type&& __d) noexcept
199 : _M_t(std::move(__p), std::move(__d))
200 { static_assert(!std::is_reference<deleter_type>::value,
201 "rvalue deleter bound to reference"); }
202
203 /// Creates a unique_ptr that owns nothing.
204 constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
205
206 // Move constructors.
207
208 /// Move constructor.
209 unique_ptr(unique_ptr&& __u) noexcept
210 : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
211
212 /** @brief Converting constructor from another type
213 *
214 * Requires that the pointer owned by @p __u is convertible to the
215 * type of pointer owned by this object, @p __u does not own an array,
216 * and @p __u has a compatible deleter type.
217 */
218 template<typename _Up, typename _Ep, typename = _Require<
219 __safe_conversion_up<_Up, _Ep>,
220 typename conditional<is_reference<_Dp>::value,
221 is_same<_Ep, _Dp>,
222 is_convertible<_Ep, _Dp>>::type>>
223 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
224 : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
225 { }
226
227#if _GLIBCXX_USE_DEPRECATED1
228 /// Converting constructor from @c auto_ptr
229 template<typename _Up, typename = _Require<
230 is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
231 unique_ptr(auto_ptr<_Up>&& __u) noexcept;
232#endif
233
234 /// Destructor, invokes the deleter if the stored pointer is not null.
235 ~unique_ptr() noexcept
236 {
237 auto& __ptr = std::get<0>(_M_t);
238 if (__ptr != nullptr)
239 get_deleter()(__ptr);
240 __ptr = pointer();
241 }
242
243 // Assignment.
244
245 /** @brief Move assignment operator.
246 *
247 * @param __u The object to transfer ownership from.
248 *
249 * Invokes the deleter first if this object owns a pointer.
250 */
251 unique_ptr&
252 operator=(unique_ptr&& __u) noexcept
253 {
254 reset(__u.release());
255 get_deleter() = std::forward<deleter_type>(__u.get_deleter());
256 return *this;
257 }
258
259 /** @brief Assignment from another type.
260 *
261 * @param __u The object to transfer ownership from, which owns a
262 * convertible pointer to a non-array object.
263 *
264 * Invokes the deleter first if this object owns a pointer.
265 */
266 template<typename _Up, typename _Ep>
267 typename enable_if< __and_<
268 __safe_conversion_up<_Up, _Ep>,
269 is_assignable<deleter_type&, _Ep&&>
270 >::value,
271 unique_ptr&>::type
272 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
273 {
274 reset(__u.release());
275 get_deleter() = std::forward<_Ep>(__u.get_deleter());
276 return *this;
277 }
278
279 /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
280 unique_ptr&
281 operator=(nullptr_t) noexcept
282 {
283 reset();
284 return *this;
285 }
286
287 // Observers.
288
289 /// Dereference the stored pointer.
290 typename add_lvalue_reference<element_type>::type
291 operator*() const
292 {
293 __glibcxx_assert(get() != pointer());
294 return *get();
295 }
296
297 /// Return the stored pointer.
298 pointer
299 operator->() const noexcept
300 {
301 _GLIBCXX_DEBUG_PEDASSERT(get() != pointer());
302 return get();
303 }
304
305 /// Return the stored pointer.
306 pointer
307 get() const noexcept
308 { return std::get<0>(_M_t); }
309
310 /// Return a reference to the stored deleter.
311 deleter_type&
312 get_deleter() noexcept
313 { return std::get<1>(_M_t); }
314
315 /// Return a reference to the stored deleter.
316 const deleter_type&
317 get_deleter() const noexcept
318 { return std::get<1>(_M_t); }
319
320 /// Return @c true if the stored pointer is not null.
321 explicit operator bool() const noexcept
322 { return get() == pointer() ? false : true; }
323
324 // Modifiers.
325
326 /// Release ownership of any stored pointer.
327 pointer
328 release() noexcept
329 {
330 pointer __p = get();
331 std::get<0>(_M_t) = pointer();
332 return __p;
333 }
334
335 /** @brief Replace the stored pointer.
336 *
337 * @param __p The new pointer to store.
338 *
339 * The deleter will be invoked if a pointer is already owned.
340 */
341 void
342 reset(pointer __p = pointer()) noexcept
343 {
344 using std::swap;
345 swap(std::get<0>(_M_t), __p);
346 if (__p != pointer())
347 get_deleter()(__p);
348 }
349
350 /// Exchange the pointer and deleter with another object.
351 void
352 swap(unique_ptr& __u) noexcept
353 {
354 using std::swap;
355 swap(_M_t, __u._M_t);
356 }
357
358 // Disable copy from lvalue.
359 unique_ptr(const unique_ptr&) = delete;
360 unique_ptr& operator=(const unique_ptr&) = delete;
361 };
362
363 /// 20.7.1.3 unique_ptr for array objects with a runtime length
364 // [unique.ptr.runtime]
365 // _GLIBCXX_RESOLVE_LIB_DEFECTS
366 // DR 740 - omit specialization for array objects with a compile time length
367 template<typename _Tp, typename _Dp>
368 class unique_ptr<_Tp[], _Dp>
369 {
370 // use SFINAE to determine whether _Del::pointer exists
371 class _Pointer
372 {
373 template<typename _Up>
374 static typename _Up::pointer __test(typename _Up::pointer*);
375
376 template<typename _Up>
377 static _Tp* __test(...);
378
379 typedef typename remove_reference<_Dp>::type _Del;
380
381 public:
382 typedef decltype(__test<_Del>(0)) type;
383 };
384
385 typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
386 __tuple_type _M_t;
387
388 template<typename _Up>
389 using __remove_cv = typename remove_cv<_Up>::type;
390
391 // like is_base_of<_Tp, _Up> but false if unqualified types are the same
392 template<typename _Up>
393 using __is_derived_Tp
394 = __and_< is_base_of<_Tp, _Up>,
395 __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
396
397
398 public:
399 typedef typename _Pointer::type pointer;
400 typedef _Tp element_type;
401 typedef _Dp deleter_type;
402
403 // helper template for detecting a safe conversion from another
404 // unique_ptr
405 template<typename _Up, typename _Ep,
406 typename _Up_up = unique_ptr<_Up, _Ep>,
407 typename _Up_element_type = typename _Up_up::element_type>
408 using __safe_conversion_up = __and_<
409 is_array<_Up>,
410 is_same<pointer, element_type*>,
411 is_same<typename _Up_up::pointer, _Up_element_type*>,
412 is_convertible<_Up_element_type(*)[], element_type(*)[]>,
413 __or_<__and_<is_reference<deleter_type>, is_same<deleter_type, _Ep>>,
414 __and_<__not_<is_reference<deleter_type>>,
415 is_convertible<_Ep, deleter_type>>>
416 >;
417
418 // helper template for detecting a safe conversion from a raw pointer
419 template<typename _Up>
420 using __safe_conversion_raw = __and_<
421 __or_<__or_<is_same<_Up, pointer>,
422 is_same<_Up, nullptr_t>>,
423 __and_<is_pointer<_Up>,
424 is_same<pointer, element_type*>,
425 is_convertible<
426 typename remove_pointer<_Up>::type(*)[],
427 element_type(*)[]>
428 >
429 >
430 >;
431
432 // Constructors.
433
434 /// Default constructor, creates a unique_ptr that owns nothing.
435 constexpr unique_ptr() noexcept
436 : _M_t()
437 { static_assert(!std::is_pointer<deleter_type>::value,
438 "constructed with null function pointer deleter"); }
439
440 /** Takes ownership of a pointer.
441 *
442 * @param __p A pointer to an array of a type safely convertible
443 * to an array of @c element_type
444 *
445 * The deleter will be value-initialized.
446 */
447 template<typename _Up,
448 typename = typename enable_if<
449 __safe_conversion_raw<_Up>::value, bool>::type>
450 explicit
451 unique_ptr(_Up __p) noexcept
452 : _M_t(__p, deleter_type())
453 { static_assert(!is_pointer<deleter_type>::value,
454 "constructed with null function pointer deleter"); }
455
456 /** Takes ownership of a pointer.
457 *
458 * @param __p A pointer to an array of a type safely convertible
459 * to an array of @c element_type
460 * @param __d A reference to a deleter.
461 *
462 * The deleter will be initialized with @p __d
463 */
464 template<typename _Up,
465 typename = typename enable_if<
466 __safe_conversion_raw<_Up>::value, bool>::type>
467 unique_ptr(_Up __p,
468 typename conditional<is_reference<deleter_type>::value,
469 deleter_type, const deleter_type&>::type __d) noexcept
470 : _M_t(__p, __d) { }
471
472 /** Takes ownership of a pointer.
473 *
474 * @param __p A pointer to an array of a type safely convertible
475 * to an array of @c element_type
476 * @param __d A reference to a deleter.
477 *
478 * The deleter will be initialized with @p std::move(__d)
479 */
480 template<typename _Up,
481 typename = typename enable_if<
482 __safe_conversion_raw<_Up>::value, bool>::type>
483 unique_ptr(_Up __p, typename
484 remove_reference<deleter_type>::type&& __d) noexcept
485 : _M_t(std::move(__p), std::move(__d))
486 { static_assert(!is_reference<deleter_type>::value,
487 "rvalue deleter bound to reference"); }
488
489 /// Move constructor.
490 unique_ptr(unique_ptr&& __u) noexcept
491 : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
492
493 /// Creates a unique_ptr that owns nothing.
494 constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
495
496 template<typename _Up, typename _Ep,
497 typename = _Require<__safe_conversion_up<_Up, _Ep>>>
498 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
499 : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
500 { }
501
502 /// Destructor, invokes the deleter if the stored pointer is not null.
503 ~unique_ptr()
504 {
505 auto& __ptr = std::get<0>(_M_t);
506 if (__ptr != nullptr)
507 get_deleter()(__ptr);
508 __ptr = pointer();
509 }
510
511 // Assignment.
512
513 /** @brief Move assignment operator.
514 *
515 * @param __u The object to transfer ownership from.
516 *
517 * Invokes the deleter first if this object owns a pointer.
518 */
519 unique_ptr&
520 operator=(unique_ptr&& __u) noexcept
521 {
522 reset(__u.release());
523 get_deleter() = std::forward<deleter_type>(__u.get_deleter());
524 return *this;
525 }
526
527 /** @brief Assignment from another type.
528 *
529 * @param __u The object to transfer ownership from, which owns a
530 * convertible pointer to an array object.
531 *
532 * Invokes the deleter first if this object owns a pointer.
533 */
534 template<typename _Up, typename _Ep>
535 typename
536 enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
537 is_assignable<deleter_type&, _Ep&&>
538 >::value,
539 unique_ptr&>::type
540 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
541 {
542 reset(__u.release());
543 get_deleter() = std::forward<_Ep>(__u.get_deleter());
544 return *this;
545 }
546
547 /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
548 unique_ptr&
549 operator=(nullptr_t) noexcept
550 {
551 reset();
552 return *this;
553 }
554
555 // Observers.
556
557 /// Access an element of owned array.
558 typename std::add_lvalue_reference<element_type>::type
559 operator[](size_t __i) const
560 {
561 __glibcxx_assert(get() != pointer());
562 return get()[__i];
563 }
564
565 /// Return the stored pointer.
566 pointer
567 get() const noexcept
568 { return std::get<0>(_M_t); }
569
570 /// Return a reference to the stored deleter.
571 deleter_type&
572 get_deleter() noexcept
573 { return std::get<1>(_M_t); }
574
575 /// Return a reference to the stored deleter.
576 const deleter_type&
577 get_deleter() const noexcept
578 { return std::get<1>(_M_t); }
579
580 /// Return @c true if the stored pointer is not null.
581 explicit operator bool() const noexcept
582 { return get() == pointer() ? false : true; }
583
584 // Modifiers.
585
586 /// Release ownership of any stored pointer.
587 pointer
588 release() noexcept
589 {
590 pointer __p = get();
591 std::get<0>(_M_t) = pointer();
592 return __p;
593 }
594
595 /** @brief Replace the stored pointer.
596 *
597 * @param __p The new pointer to store.
598 *
599 * The deleter will be invoked if a pointer is already owned.
600 */
601 template <typename _Up,
602 typename = _Require<
603 __or_<is_same<_Up, pointer>,
604 __and_<is_same<pointer, element_type*>,
605 is_pointer<_Up>,
606 is_convertible<
607 typename remove_pointer<_Up>::type(*)[],
608 element_type(*)[]
609 >
610 >
611 >
612 >>
613 void
614 reset(_Up __p) noexcept
615 {
616 pointer __ptr = __p;
617 using std::swap;
618 swap(std::get<0>(_M_t), __ptr);
619 if (__ptr != nullptr)
620 get_deleter()(__ptr);
621 }
622
623 void reset(nullptr_t = nullptr) noexcept
624 {
625 reset(pointer());
626 }
627
628 /// Exchange the pointer and deleter with another object.
629 void
630 swap(unique_ptr& __u) noexcept
631 {
632 using std::swap;
633 swap(_M_t, __u._M_t);
634 }
635
636 // Disable copy from lvalue.
637 unique_ptr(const unique_ptr&) = delete;
638 unique_ptr& operator=(const unique_ptr&) = delete;
639 };
640
641 template<typename _Tp, typename _Dp>
642 inline void
643 swap(unique_ptr<_Tp, _Dp>& __x,
644 unique_ptr<_Tp, _Dp>& __y) noexcept
645 { __x.swap(__y); }
646
647 template<typename _Tp, typename _Dp,
648 typename _Up, typename _Ep>
649 inline bool
650 operator==(const unique_ptr<_Tp, _Dp>& __x,
651 const unique_ptr<_Up, _Ep>& __y)
652 { return __x.get() == __y.get(); }
653
654 template<typename _Tp, typename _Dp>
655 inline bool
656 operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
657 { return !__x; }
658
659 template<typename _Tp, typename _Dp>
660 inline bool
661 operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
662 { return !__x; }
663
664 template<typename _Tp, typename _Dp,
665 typename _Up, typename _Ep>
666 inline bool
667 operator!=(const unique_ptr<_Tp, _Dp>& __x,
668 const unique_ptr<_Up, _Ep>& __y)
669 { return __x.get() != __y.get(); }
670
671 template<typename _Tp, typename _Dp>
672 inline bool
673 operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
674 { return (bool)__x; }
675
676 template<typename _Tp, typename _Dp>
677 inline bool
678 operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
679 { return (bool)__x; }
680
681 template<typename _Tp, typename _Dp,
682 typename _Up, typename _Ep>
683 inline bool
684 operator<(const unique_ptr<_Tp, _Dp>& __x,
685 const unique_ptr<_Up, _Ep>& __y)
686 {
687 typedef typename
688 std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
689 typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
690 return std::less<_CT>()(__x.get(), __y.get());
691 }
692
693 template<typename _Tp, typename _Dp>
694 inline bool
695 operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
696 { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
697 nullptr); }
698
699 template<typename _Tp, typename _Dp>
700 inline bool
701 operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
702 { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
703 __x.get()); }
704
705 template<typename _Tp, typename _Dp,
706 typename _Up, typename _Ep>
707 inline bool
708 operator<=(const unique_ptr<_Tp, _Dp>& __x,
709 const unique_ptr<_Up, _Ep>& __y)
710 { return !(__y < __x); }
711
712 template<typename _Tp, typename _Dp>
713 inline bool
714 operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
715 { return !(nullptr < __x); }
716
717 template<typename _Tp, typename _Dp>
718 inline bool
719 operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
720 { return !(__x < nullptr); }
721
722 template<typename _Tp, typename _Dp,
723 typename _Up, typename _Ep>
724 inline bool
725 operator>(const unique_ptr<_Tp, _Dp>& __x,
726 const unique_ptr<_Up, _Ep>& __y)
727 { return (__y < __x); }
728
729 template<typename _Tp, typename _Dp>
730 inline bool
731 operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
732 { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
733 __x.get()); }
734
735 template<typename _Tp, typename _Dp>
736 inline bool
737 operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
738 { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
739 nullptr); }
740
741 template<typename _Tp, typename _Dp,
742 typename _Up, typename _Ep>
743 inline bool
744 operator>=(const unique_ptr<_Tp, _Dp>& __x,
745 const unique_ptr<_Up, _Ep>& __y)
746 { return !(__x < __y); }
747
748 template<typename _Tp, typename _Dp>
749 inline bool
750 operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
751 { return !(__x < nullptr); }
752
753 template<typename _Tp, typename _Dp>
754 inline bool
755 operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
756 { return !(nullptr < __x); }
757
758 /// std::hash specialization for unique_ptr.
759 template<typename _Tp, typename _Dp>
760 struct hash<unique_ptr<_Tp, _Dp>>
761 : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>
762 {
763 size_t
764 operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
765 {
766 typedef unique_ptr<_Tp, _Dp> _UP;
767 return std::hash<typename _UP::pointer>()(__u.get());
768 }
769 };
770
771#if __cplusplus201402L > 201103L
772
773#define __cpp_lib_make_unique201304 201304
774
775 template<typename _Tp>
776 struct _MakeUniq
777 { typedef unique_ptr<_Tp> __single_object; };
778
779 template<typename _Tp>
780 struct _MakeUniq<_Tp[]>
781 { typedef unique_ptr<_Tp[]> __array; };
782
783 template<typename _Tp, size_t _Bound>
784 struct _MakeUniq<_Tp[_Bound]>
785 { struct __invalid_type { }; };
786
787 /// std::make_unique for single objects
788 template<typename _Tp, typename... _Args>
789 inline typename _MakeUniq<_Tp>::__single_object
790 make_unique(_Args&&... __args)
791 { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
4
Calling constructor for 'BindRebaseSegInfo'
792
793 /// std::make_unique for arrays of unknown bound
794 template<typename _Tp>
795 inline typename _MakeUniq<_Tp>::__array
796 make_unique(size_t __num)
797 { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }
798
799 /// Disable std::make_unique for arrays of known bound
800 template<typename _Tp, typename... _Args>
801 inline typename _MakeUniq<_Tp>::__invalid_type
802 make_unique(_Args&&...) = delete;
803#endif
804
805 // @} group pointer_abstractions
806
807_GLIBCXX_END_NAMESPACE_VERSION
808} // namespace
809
810#endif /* _UNIQUE_PTR_H */