Bug Summary

File:build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/tools/llvm-objdump/MachODump.cpp
Warning:line 2909, column 25
1st function call argument is an uninitialized value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name MachODump.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 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm -resource-dir /usr/lib/llvm-15/lib/clang/15.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/llvm-objdump -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/tools/llvm-objdump -I include -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-15/lib/clang/15.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-04-20-140412-16051-1 -x c++ /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/tools/llvm-objdump/MachODump.cpp
1//===-- MachODump.cpp - Object file dumping utility for llvm --------------===//
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 implements the MachO-specific dumper for llvm-objdump.
10//
11//===----------------------------------------------------------------------===//
12
13#include "MachODump.h"
14
15#include "ObjdumpOptID.h"
16#include "llvm-objdump.h"
17#include "llvm-c/Disassembler.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/StringExtras.h"
20#include "llvm/ADT/Triple.h"
21#include "llvm/BinaryFormat/MachO.h"
22#include "llvm/Config/config.h"
23#include "llvm/DebugInfo/DIContext.h"
24#include "llvm/DebugInfo/DWARF/DWARFContext.h"
25#include "llvm/Demangle/Demangle.h"
26#include "llvm/MC/MCAsmInfo.h"
27#include "llvm/MC/MCContext.h"
28#include "llvm/MC/MCDisassembler/MCDisassembler.h"
29#include "llvm/MC/MCInst.h"
30#include "llvm/MC/MCInstPrinter.h"
31#include "llvm/MC/MCInstrDesc.h"
32#include "llvm/MC/MCInstrInfo.h"
33#include "llvm/MC/MCRegisterInfo.h"
34#include "llvm/MC/MCSubtargetInfo.h"
35#include "llvm/MC/MCTargetOptions.h"
36#include "llvm/MC/TargetRegistry.h"
37#include "llvm/Object/MachO.h"
38#include "llvm/Object/MachOUniversal.h"
39#include "llvm/Option/ArgList.h"
40#include "llvm/Support/Casting.h"
41#include "llvm/Support/Debug.h"
42#include "llvm/Support/Endian.h"
43#include "llvm/Support/Format.h"
44#include "llvm/Support/FormattedStream.h"
45#include "llvm/Support/GraphWriter.h"
46#include "llvm/Support/LEB128.h"
47#include "llvm/Support/MemoryBuffer.h"
48#include "llvm/Support/TargetSelect.h"
49#include "llvm/Support/ToolOutputFile.h"
50#include "llvm/Support/WithColor.h"
51#include "llvm/Support/raw_ostream.h"
52#include <algorithm>
53#include <cstring>
54#include <system_error>
55
56#ifdef LLVM_HAVE_LIBXAR
57extern "C" {
58#include <xar/xar.h>
59}
60#endif
61
62using namespace llvm;
63using namespace llvm::object;
64using namespace llvm::objdump;
65
66bool objdump::FirstPrivateHeader;
67bool objdump::ExportsTrie;
68bool objdump::Rebase;
69bool objdump::Rpaths;
70bool objdump::Bind;
71bool objdump::LazyBind;
72bool objdump::WeakBind;
73static bool UseDbg;
74static std::string DSYMFile;
75bool objdump::FullLeadingAddr;
76bool objdump::LeadingHeaders;
77bool objdump::UniversalHeaders;
78static bool ArchiveMemberOffsets;
79bool objdump::IndirectSymbols;
80bool objdump::DataInCode;
81bool objdump::FunctionStarts;
82bool objdump::LinkOptHints;
83bool objdump::InfoPlist;
84bool objdump::DyldInfo;
85bool objdump::DylibsUsed;
86bool objdump::DylibId;
87bool objdump::Verbose;
88bool objdump::ObjcMetaData;
89std::string objdump::DisSymName;
90bool objdump::SymbolicOperands;
91static std::vector<std::string> ArchFlags;
92
93static bool ArchAll = false;
94static std::string ThumbTripleName;
95
96void objdump::parseMachOOptions(const llvm::opt::InputArgList &InputArgs) {
97 FirstPrivateHeader = InputArgs.hasArg(OBJDUMP_private_header);
98 ExportsTrie = InputArgs.hasArg(OBJDUMP_exports_trie);
99 Rebase = InputArgs.hasArg(OBJDUMP_rebase);
100 Rpaths = InputArgs.hasArg(OBJDUMP_rpaths);
101 Bind = InputArgs.hasArg(OBJDUMP_bind);
102 LazyBind = InputArgs.hasArg(OBJDUMP_lazy_bind);
103 WeakBind = InputArgs.hasArg(OBJDUMP_weak_bind);
104 UseDbg = InputArgs.hasArg(OBJDUMP_g);
105 DSYMFile = InputArgs.getLastArgValue(OBJDUMP_dsym_EQ).str();
106 FullLeadingAddr = InputArgs.hasArg(OBJDUMP_full_leading_addr);
107 LeadingHeaders = !InputArgs.hasArg(OBJDUMP_no_leading_headers);
108 UniversalHeaders = InputArgs.hasArg(OBJDUMP_universal_headers);
109 ArchiveMemberOffsets = InputArgs.hasArg(OBJDUMP_archive_member_offsets);
110 IndirectSymbols = InputArgs.hasArg(OBJDUMP_indirect_symbols);
111 DataInCode = InputArgs.hasArg(OBJDUMP_data_in_code);
112 FunctionStarts = InputArgs.hasArg(OBJDUMP_function_starts);
113 LinkOptHints = InputArgs.hasArg(OBJDUMP_link_opt_hints);
114 InfoPlist = InputArgs.hasArg(OBJDUMP_info_plist);
115 DyldInfo = InputArgs.hasArg(OBJDUMP_dyld_info);
116 DylibsUsed = InputArgs.hasArg(OBJDUMP_dylibs_used);
117 DylibId = InputArgs.hasArg(OBJDUMP_dylib_id);
118 Verbose = !InputArgs.hasArg(OBJDUMP_non_verbose);
119 ObjcMetaData = InputArgs.hasArg(OBJDUMP_objc_meta_data);
120 DisSymName = InputArgs.getLastArgValue(OBJDUMP_dis_symname).str();
121 SymbolicOperands = !InputArgs.hasArg(OBJDUMP_no_symbolic_operands);
122 ArchFlags = InputArgs.getAllArgValues(OBJDUMP_arch_EQ);
123}
124
125static const Target *GetTarget(const MachOObjectFile *MachOObj,
126 const char **McpuDefault,
127 const Target **ThumbTarget) {
128 // Figure out the target triple.
129 Triple TT(TripleName);
130 if (TripleName.empty()) {
131 TT = MachOObj->getArchTriple(McpuDefault);
132 TripleName = TT.str();
133 }
134
135 if (TT.getArch() == Triple::arm) {
136 // We've inferred a 32-bit ARM target from the object file. All MachO CPUs
137 // that support ARM are also capable of Thumb mode.
138 Triple ThumbTriple = TT;
139 std::string ThumbName = (Twine("thumb") + TT.getArchName().substr(3)).str();
140 ThumbTriple.setArchName(ThumbName);
141 ThumbTripleName = ThumbTriple.str();
142 }
143
144 // Get the target specific parser.
145 std::string Error;
146 const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
147 if (TheTarget && ThumbTripleName.empty())
148 return TheTarget;
149
150 *ThumbTarget = TargetRegistry::lookupTarget(ThumbTripleName, Error);
151 if (*ThumbTarget)
152 return TheTarget;
153
154 WithColor::error(errs(), "llvm-objdump") << "unable to get target for '";
155 if (!TheTarget)
156 errs() << TripleName;
157 else
158 errs() << ThumbTripleName;
159 errs() << "', see --version and --triple.\n";
160 return nullptr;
161}
162
163namespace {
164struct SymbolSorter {
165 bool operator()(const SymbolRef &A, const SymbolRef &B) {
166 Expected<SymbolRef::Type> ATypeOrErr = A.getType();
167 if (!ATypeOrErr)
168 reportError(ATypeOrErr.takeError(), A.getObject()->getFileName());
169 SymbolRef::Type AType = *ATypeOrErr;
170 Expected<SymbolRef::Type> BTypeOrErr = B.getType();
171 if (!BTypeOrErr)
172 reportError(BTypeOrErr.takeError(), B.getObject()->getFileName());
173 SymbolRef::Type BType = *BTypeOrErr;
174 uint64_t AAddr =
175 (AType != SymbolRef::ST_Function) ? 0 : cantFail(A.getValue());
176 uint64_t BAddr =
177 (BType != SymbolRef::ST_Function) ? 0 : cantFail(B.getValue());
178 return AAddr < BAddr;
179 }
180};
181} // namespace
182
183// Types for the storted data in code table that is built before disassembly
184// and the predicate function to sort them.
185typedef std::pair<uint64_t, DiceRef> DiceTableEntry;
186typedef std::vector<DiceTableEntry> DiceTable;
187typedef DiceTable::iterator dice_table_iterator;
188
189#ifdef LLVM_HAVE_LIBXAR
190namespace {
191struct ScopedXarFile {
192 xar_t xar;
193 ScopedXarFile(const char *filename, int32_t flags) {
194#pragma clang diagnostic push
195#pragma clang diagnostic ignored "-Wdeprecated-declarations"
196 xar = xar_open(filename, flags);
197#pragma clang diagnostic pop
198 }
199 ~ScopedXarFile() {
200 if (xar)
201 xar_close(xar);
202 }
203 ScopedXarFile(const ScopedXarFile &) = delete;
204 ScopedXarFile &operator=(const ScopedXarFile &) = delete;
205 operator xar_t() { return xar; }
206};
207
208struct ScopedXarIter {
209 xar_iter_t iter;
210 ScopedXarIter() : iter(xar_iter_new()) {}
211 ~ScopedXarIter() {
212 if (iter)
213 xar_iter_free(iter);
214 }
215 ScopedXarIter(const ScopedXarIter &) = delete;
216 ScopedXarIter &operator=(const ScopedXarIter &) = delete;
217 operator xar_iter_t() { return iter; }
218};
219} // namespace
220#endif // defined(LLVM_HAVE_LIBXAR)
221
222// This is used to search for a data in code table entry for the PC being
223// disassembled. The j parameter has the PC in j.first. A single data in code
224// table entry can cover many bytes for each of its Kind's. So if the offset,
225// aka the i.first value, of the data in code table entry plus its Length
226// covers the PC being searched for this will return true. If not it will
227// return false.
228static bool compareDiceTableEntries(const DiceTableEntry &i,
229 const DiceTableEntry &j) {
230 uint16_t Length;
231 i.second.getLength(Length);
232
233 return j.first >= i.first && j.first < i.first + Length;
234}
235
236static uint64_t DumpDataInCode(const uint8_t *bytes, uint64_t Length,
237 unsigned short Kind) {
238 uint32_t Value, Size = 1;
239
240 switch (Kind) {
241 default:
242 case MachO::DICE_KIND_DATA:
243 if (Length >= 4) {
244 if (ShowRawInsn)
245 dumpBytes(makeArrayRef(bytes, 4), outs());
246 Value = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
247 outs() << "\t.long " << Value;
248 Size = 4;
249 } else if (Length >= 2) {
250 if (ShowRawInsn)
251 dumpBytes(makeArrayRef(bytes, 2), outs());
252 Value = bytes[1] << 8 | bytes[0];
253 outs() << "\t.short " << Value;
254 Size = 2;
255 } else {
256 if (ShowRawInsn)
257 dumpBytes(makeArrayRef(bytes, 2), outs());
258 Value = bytes[0];
259 outs() << "\t.byte " << Value;
260 Size = 1;
261 }
262 if (Kind == MachO::DICE_KIND_DATA)
263 outs() << "\t@ KIND_DATA\n";
264 else
265 outs() << "\t@ data in code kind = " << Kind << "\n";
266 break;
267 case MachO::DICE_KIND_JUMP_TABLE8:
268 if (ShowRawInsn)
269 dumpBytes(makeArrayRef(bytes, 1), outs());
270 Value = bytes[0];
271 outs() << "\t.byte " << format("%3u", Value) << "\t@ KIND_JUMP_TABLE8\n";
272 Size = 1;
273 break;
274 case MachO::DICE_KIND_JUMP_TABLE16:
275 if (ShowRawInsn)
276 dumpBytes(makeArrayRef(bytes, 2), outs());
277 Value = bytes[1] << 8 | bytes[0];
278 outs() << "\t.short " << format("%5u", Value & 0xffff)
279 << "\t@ KIND_JUMP_TABLE16\n";
280 Size = 2;
281 break;
282 case MachO::DICE_KIND_JUMP_TABLE32:
283 case MachO::DICE_KIND_ABS_JUMP_TABLE32:
284 if (ShowRawInsn)
285 dumpBytes(makeArrayRef(bytes, 4), outs());
286 Value = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
287 outs() << "\t.long " << Value;
288 if (Kind == MachO::DICE_KIND_JUMP_TABLE32)
289 outs() << "\t@ KIND_JUMP_TABLE32\n";
290 else
291 outs() << "\t@ KIND_ABS_JUMP_TABLE32\n";
292 Size = 4;
293 break;
294 }
295 return Size;
296}
297
298static void getSectionsAndSymbols(MachOObjectFile *MachOObj,
299 std::vector<SectionRef> &Sections,
300 std::vector<SymbolRef> &Symbols,
301 SmallVectorImpl<uint64_t> &FoundFns,
302 uint64_t &BaseSegmentAddress) {
303 const StringRef FileName = MachOObj->getFileName();
304 for (const SymbolRef &Symbol : MachOObj->symbols()) {
305 StringRef SymName = unwrapOrError(Symbol.getName(), FileName);
306 if (!SymName.startswith("ltmp"))
307 Symbols.push_back(Symbol);
308 }
309
310 append_range(Sections, MachOObj->sections());
311
312 bool BaseSegmentAddressSet = false;
313 for (const auto &Command : MachOObj->load_commands()) {
314 if (Command.C.cmd == MachO::LC_FUNCTION_STARTS) {
315 // We found a function starts segment, parse the addresses for later
316 // consumption.
317 MachO::linkedit_data_command LLC =
318 MachOObj->getLinkeditDataLoadCommand(Command);
319
320 MachOObj->ReadULEB128s(LLC.dataoff, FoundFns);
321 } else if (Command.C.cmd == MachO::LC_SEGMENT) {
322 MachO::segment_command SLC = MachOObj->getSegmentLoadCommand(Command);
323 StringRef SegName = SLC.segname;
324 if (!BaseSegmentAddressSet && SegName != "__PAGEZERO") {
325 BaseSegmentAddressSet = true;
326 BaseSegmentAddress = SLC.vmaddr;
327 }
328 } else if (Command.C.cmd == MachO::LC_SEGMENT_64) {
329 MachO::segment_command_64 SLC = MachOObj->getSegment64LoadCommand(Command);
330 StringRef SegName = SLC.segname;
331 if (!BaseSegmentAddressSet && SegName != "__PAGEZERO") {
332 BaseSegmentAddressSet = true;
333 BaseSegmentAddress = SLC.vmaddr;
334 }
335 }
336 }
337}
338
339static bool DumpAndSkipDataInCode(uint64_t PC, const uint8_t *bytes,
340 DiceTable &Dices, uint64_t &InstSize) {
341 // Check the data in code table here to see if this is data not an
342 // instruction to be disassembled.
343 DiceTable Dice;
344 Dice.push_back(std::make_pair(PC, DiceRef()));
345 dice_table_iterator DTI =
346 std::search(Dices.begin(), Dices.end(), Dice.begin(), Dice.end(),
347 compareDiceTableEntries);
348 if (DTI != Dices.end()) {
349 uint16_t Length;
350 DTI->second.getLength(Length);
351 uint16_t Kind;
352 DTI->second.getKind(Kind);
353 InstSize = DumpDataInCode(bytes, Length, Kind);
354 if ((Kind == MachO::DICE_KIND_JUMP_TABLE8) &&
355 (PC == (DTI->first + Length - 1)) && (Length & 1))
356 InstSize++;
357 return true;
358 }
359 return false;
360}
361
362static void printRelocationTargetName(const MachOObjectFile *O,
363 const MachO::any_relocation_info &RE,
364 raw_string_ostream &Fmt) {
365 // Target of a scattered relocation is an address. In the interest of
366 // generating pretty output, scan through the symbol table looking for a
367 // symbol that aligns with that address. If we find one, print it.
368 // Otherwise, we just print the hex address of the target.
369 const StringRef FileName = O->getFileName();
370 if (O->isRelocationScattered(RE)) {
371 uint32_t Val = O->getPlainRelocationSymbolNum(RE);
372
373 for (const SymbolRef &Symbol : O->symbols()) {
374 uint64_t Addr = unwrapOrError(Symbol.getAddress(), FileName);
375 if (Addr != Val)
376 continue;
377 Fmt << unwrapOrError(Symbol.getName(), FileName);
378 return;
379 }
380
381 // If we couldn't find a symbol that this relocation refers to, try
382 // to find a section beginning instead.
383 for (const SectionRef &Section : ToolSectionFilter(*O)) {
384 uint64_t Addr = Section.getAddress();
385 if (Addr != Val)
386 continue;
387 StringRef NameOrErr = unwrapOrError(Section.getName(), O->getFileName());
388 Fmt << NameOrErr;
389 return;
390 }
391
392 Fmt << format("0x%x", Val);
393 return;
394 }
395
396 StringRef S;
397 bool isExtern = O->getPlainRelocationExternal(RE);
398 uint64_t Val = O->getPlainRelocationSymbolNum(RE);
399
400 if (O->getAnyRelocationType(RE) == MachO::ARM64_RELOC_ADDEND &&
401 (O->getArch() == Triple::aarch64 || O->getArch() == Triple::aarch64_be)) {
402 Fmt << format("0x%0" PRIx64"l" "x", Val);
403 return;
404 }
405
406 if (isExtern) {
407 symbol_iterator SI = O->symbol_begin();
408 std::advance(SI, Val);
409 S = unwrapOrError(SI->getName(), FileName);
410 } else {
411 section_iterator SI = O->section_begin();
412 // Adjust for the fact that sections are 1-indexed.
413 if (Val == 0) {
414 Fmt << "0 (?,?)";
415 return;
416 }
417 uint32_t I = Val - 1;
418 while (I != 0 && SI != O->section_end()) {
419 --I;
420 std::advance(SI, 1);
421 }
422 if (SI == O->section_end()) {
423 Fmt << Val << " (?,?)";
424 } else {
425 if (Expected<StringRef> NameOrErr = SI->getName())
426 S = *NameOrErr;
427 else
428 consumeError(NameOrErr.takeError());
429 }
430 }
431
432 Fmt << S;
433}
434
435Error objdump::getMachORelocationValueString(const MachOObjectFile *Obj,
436 const RelocationRef &RelRef,
437 SmallVectorImpl<char> &Result) {
438 DataRefImpl Rel = RelRef.getRawDataRefImpl();
439 MachO::any_relocation_info RE = Obj->getRelocation(Rel);
440
441 unsigned Arch = Obj->getArch();
442
443 std::string FmtBuf;
444 raw_string_ostream Fmt(FmtBuf);
445 unsigned Type = Obj->getAnyRelocationType(RE);
446 bool IsPCRel = Obj->getAnyRelocationPCRel(RE);
447
448 // Determine any addends that should be displayed with the relocation.
449 // These require decoding the relocation type, which is triple-specific.
450
451 // X86_64 has entirely custom relocation types.
452 if (Arch == Triple::x86_64) {
453 switch (Type) {
454 case MachO::X86_64_RELOC_GOT_LOAD:
455 case MachO::X86_64_RELOC_GOT: {
456 printRelocationTargetName(Obj, RE, Fmt);
457 Fmt << "@GOT";
458 if (IsPCRel)
459 Fmt << "PCREL";
460 break;
461 }
462 case MachO::X86_64_RELOC_SUBTRACTOR: {
463 DataRefImpl RelNext = Rel;
464 Obj->moveRelocationNext(RelNext);
465 MachO::any_relocation_info RENext = Obj->getRelocation(RelNext);
466
467 // X86_64_RELOC_SUBTRACTOR must be followed by a relocation of type
468 // X86_64_RELOC_UNSIGNED.
469 // NOTE: Scattered relocations don't exist on x86_64.
470 unsigned RType = Obj->getAnyRelocationType(RENext);
471 if (RType != MachO::X86_64_RELOC_UNSIGNED)
472 reportError(Obj->getFileName(), "Expected X86_64_RELOC_UNSIGNED after "
473 "X86_64_RELOC_SUBTRACTOR.");
474
475 // The X86_64_RELOC_UNSIGNED contains the minuend symbol;
476 // X86_64_RELOC_SUBTRACTOR contains the subtrahend.
477 printRelocationTargetName(Obj, RENext, Fmt);
478 Fmt << "-";
479 printRelocationTargetName(Obj, RE, Fmt);
480 break;
481 }
482 case MachO::X86_64_RELOC_TLV:
483 printRelocationTargetName(Obj, RE, Fmt);
484 Fmt << "@TLV";
485 if (IsPCRel)
486 Fmt << "P";
487 break;
488 case MachO::X86_64_RELOC_SIGNED_1:
489 printRelocationTargetName(Obj, RE, Fmt);
490 Fmt << "-1";
491 break;
492 case MachO::X86_64_RELOC_SIGNED_2:
493 printRelocationTargetName(Obj, RE, Fmt);
494 Fmt << "-2";
495 break;
496 case MachO::X86_64_RELOC_SIGNED_4:
497 printRelocationTargetName(Obj, RE, Fmt);
498 Fmt << "-4";
499 break;
500 default:
501 printRelocationTargetName(Obj, RE, Fmt);
502 break;
503 }
504 // X86 and ARM share some relocation types in common.
505 } else if (Arch == Triple::x86 || Arch == Triple::arm ||
506 Arch == Triple::ppc) {
507 // Generic relocation types...
508 switch (Type) {
509 case MachO::GENERIC_RELOC_PAIR: // prints no info
510 return Error::success();
511 case MachO::GENERIC_RELOC_SECTDIFF: {
512 DataRefImpl RelNext = Rel;
513 Obj->moveRelocationNext(RelNext);
514 MachO::any_relocation_info RENext = Obj->getRelocation(RelNext);
515
516 // X86 sect diff's must be followed by a relocation of type
517 // GENERIC_RELOC_PAIR.
518 unsigned RType = Obj->getAnyRelocationType(RENext);
519
520 if (RType != MachO::GENERIC_RELOC_PAIR)
521 reportError(Obj->getFileName(), "Expected GENERIC_RELOC_PAIR after "
522 "GENERIC_RELOC_SECTDIFF.");
523
524 printRelocationTargetName(Obj, RE, Fmt);
525 Fmt << "-";
526 printRelocationTargetName(Obj, RENext, Fmt);
527 break;
528 }
529 }
530
531 if (Arch == Triple::x86 || Arch == Triple::ppc) {
532 switch (Type) {
533 case MachO::GENERIC_RELOC_LOCAL_SECTDIFF: {
534 DataRefImpl RelNext = Rel;
535 Obj->moveRelocationNext(RelNext);
536 MachO::any_relocation_info RENext = Obj->getRelocation(RelNext);
537
538 // X86 sect diff's must be followed by a relocation of type
539 // GENERIC_RELOC_PAIR.
540 unsigned RType = Obj->getAnyRelocationType(RENext);
541 if (RType != MachO::GENERIC_RELOC_PAIR)
542 reportError(Obj->getFileName(), "Expected GENERIC_RELOC_PAIR after "
543 "GENERIC_RELOC_LOCAL_SECTDIFF.");
544
545 printRelocationTargetName(Obj, RE, Fmt);
546 Fmt << "-";
547 printRelocationTargetName(Obj, RENext, Fmt);
548 break;
549 }
550 case MachO::GENERIC_RELOC_TLV: {
551 printRelocationTargetName(Obj, RE, Fmt);
552 Fmt << "@TLV";
553 if (IsPCRel)
554 Fmt << "P";
555 break;
556 }
557 default:
558 printRelocationTargetName(Obj, RE, Fmt);
559 }
560 } else { // ARM-specific relocations
561 switch (Type) {
562 case MachO::ARM_RELOC_HALF:
563 case MachO::ARM_RELOC_HALF_SECTDIFF: {
564 // Half relocations steal a bit from the length field to encode
565 // whether this is an upper16 or a lower16 relocation.
566 bool isUpper = (Obj->getAnyRelocationLength(RE) & 0x1) == 1;
567
568 if (isUpper)
569 Fmt << ":upper16:(";
570 else
571 Fmt << ":lower16:(";
572 printRelocationTargetName(Obj, RE, Fmt);
573
574 DataRefImpl RelNext = Rel;
575 Obj->moveRelocationNext(RelNext);
576 MachO::any_relocation_info RENext = Obj->getRelocation(RelNext);
577
578 // ARM half relocs must be followed by a relocation of type
579 // ARM_RELOC_PAIR.
580 unsigned RType = Obj->getAnyRelocationType(RENext);
581 if (RType != MachO::ARM_RELOC_PAIR)
582 reportError(Obj->getFileName(), "Expected ARM_RELOC_PAIR after "
583 "ARM_RELOC_HALF");
584
585 // NOTE: The half of the target virtual address is stashed in the
586 // address field of the secondary relocation, but we can't reverse
587 // engineer the constant offset from it without decoding the movw/movt
588 // instruction to find the other half in its immediate field.
589
590 // ARM_RELOC_HALF_SECTDIFF encodes the second section in the
591 // symbol/section pointer of the follow-on relocation.
592 if (Type == MachO::ARM_RELOC_HALF_SECTDIFF) {
593 Fmt << "-";
594 printRelocationTargetName(Obj, RENext, Fmt);
595 }
596
597 Fmt << ")";
598 break;
599 }
600 default: {
601 printRelocationTargetName(Obj, RE, Fmt);
602 }
603 }
604 }
605 } else
606 printRelocationTargetName(Obj, RE, Fmt);
607
608 Fmt.flush();
609 Result.append(FmtBuf.begin(), FmtBuf.end());
610 return Error::success();
611}
612
613static void PrintIndirectSymbolTable(MachOObjectFile *O, bool verbose,
614 uint32_t n, uint32_t count,
615 uint32_t stride, uint64_t addr) {
616 MachO::dysymtab_command Dysymtab = O->getDysymtabLoadCommand();
617 uint32_t nindirectsyms = Dysymtab.nindirectsyms;
618 if (n > nindirectsyms)
619 outs() << " (entries start past the end of the indirect symbol "
620 "table) (reserved1 field greater than the table size)";
621 else if (n + count > nindirectsyms)
622 outs() << " (entries extends past the end of the indirect symbol "
623 "table)";
624 outs() << "\n";
625 uint32_t cputype = O->getHeader().cputype;
626 if (cputype & MachO::CPU_ARCH_ABI64)
627 outs() << "address index";
628 else
629 outs() << "address index";
630 if (verbose)
631 outs() << " name\n";
632 else
633 outs() << "\n";
634 for (uint32_t j = 0; j < count && n + j < nindirectsyms; j++) {
635 if (cputype & MachO::CPU_ARCH_ABI64)
636 outs() << format("0x%016" PRIx64"l" "x", addr + j * stride) << " ";
637 else
638 outs() << format("0x%08" PRIx32"x", (uint32_t)addr + j * stride) << " ";
639 MachO::dysymtab_command Dysymtab = O->getDysymtabLoadCommand();
640 uint32_t indirect_symbol = O->getIndirectSymbolTableEntry(Dysymtab, n + j);
641 if (indirect_symbol == MachO::INDIRECT_SYMBOL_LOCAL) {
642 outs() << "LOCAL\n";
643 continue;
644 }
645 if (indirect_symbol ==
646 (MachO::INDIRECT_SYMBOL_LOCAL | MachO::INDIRECT_SYMBOL_ABS)) {
647 outs() << "LOCAL ABSOLUTE\n";
648 continue;
649 }
650 if (indirect_symbol == MachO::INDIRECT_SYMBOL_ABS) {
651 outs() << "ABSOLUTE\n";
652 continue;
653 }
654 outs() << format("%5u ", indirect_symbol);
655 if (verbose) {
656 MachO::symtab_command Symtab = O->getSymtabLoadCommand();
657 if (indirect_symbol < Symtab.nsyms) {
658 symbol_iterator Sym = O->getSymbolByIndex(indirect_symbol);
659 SymbolRef Symbol = *Sym;
660 outs() << unwrapOrError(Symbol.getName(), O->getFileName());
661 } else {
662 outs() << "?";
663 }
664 }
665 outs() << "\n";
666 }
667}
668
669static void PrintIndirectSymbols(MachOObjectFile *O, bool verbose) {
670 for (const auto &Load : O->load_commands()) {
671 if (Load.C.cmd == MachO::LC_SEGMENT_64) {
672 MachO::segment_command_64 Seg = O->getSegment64LoadCommand(Load);
673 for (unsigned J = 0; J < Seg.nsects; ++J) {
674 MachO::section_64 Sec = O->getSection64(Load, J);
675 uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
676 if (section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
677 section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
678 section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
679 section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS ||
680 section_type == MachO::S_SYMBOL_STUBS) {
681 uint32_t stride;
682 if (section_type == MachO::S_SYMBOL_STUBS)
683 stride = Sec.reserved2;
684 else
685 stride = 8;
686 if (stride == 0) {
687 outs() << "Can't print indirect symbols for (" << Sec.segname << ","
688 << Sec.sectname << ") "
689 << "(size of stubs in reserved2 field is zero)\n";
690 continue;
691 }
692 uint32_t count = Sec.size / stride;
693 outs() << "Indirect symbols for (" << Sec.segname << ","
694 << Sec.sectname << ") " << count << " entries";
695 uint32_t n = Sec.reserved1;
696 PrintIndirectSymbolTable(O, verbose, n, count, stride, Sec.addr);
697 }
698 }
699 } else if (Load.C.cmd == MachO::LC_SEGMENT) {
700 MachO::segment_command Seg = O->getSegmentLoadCommand(Load);
701 for (unsigned J = 0; J < Seg.nsects; ++J) {
702 MachO::section Sec = O->getSection(Load, J);
703 uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
704 if (section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
705 section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
706 section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
707 section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS ||
708 section_type == MachO::S_SYMBOL_STUBS) {
709 uint32_t stride;
710 if (section_type == MachO::S_SYMBOL_STUBS)
711 stride = Sec.reserved2;
712 else
713 stride = 4;
714 if (stride == 0) {
715 outs() << "Can't print indirect symbols for (" << Sec.segname << ","
716 << Sec.sectname << ") "
717 << "(size of stubs in reserved2 field is zero)\n";
718 continue;
719 }
720 uint32_t count = Sec.size / stride;
721 outs() << "Indirect symbols for (" << Sec.segname << ","
722 << Sec.sectname << ") " << count << " entries";
723 uint32_t n = Sec.reserved1;
724 PrintIndirectSymbolTable(O, verbose, n, count, stride, Sec.addr);
725 }
726 }
727 }
728 }
729}
730
731static void PrintRType(const uint64_t cputype, const unsigned r_type) {
732 static char const *generic_r_types[] = {
733 "VANILLA ", "PAIR ", "SECTDIF ", "PBLAPTR ", "LOCSDIF ", "TLV ",
734 " 6 (?) ", " 7 (?) ", " 8 (?) ", " 9 (?) ", " 10 (?) ", " 11 (?) ",
735 " 12 (?) ", " 13 (?) ", " 14 (?) ", " 15 (?) "
736 };
737 static char const *x86_64_r_types[] = {
738 "UNSIGND ", "SIGNED ", "BRANCH ", "GOT_LD ", "GOT ", "SUB ",
739 "SIGNED1 ", "SIGNED2 ", "SIGNED4 ", "TLV ", " 10 (?) ", " 11 (?) ",
740 " 12 (?) ", " 13 (?) ", " 14 (?) ", " 15 (?) "
741 };
742 static char const *arm_r_types[] = {
743 "VANILLA ", "PAIR ", "SECTDIFF", "LOCSDIF ", "PBLAPTR ",
744 "BR24 ", "T_BR22 ", "T_BR32 ", "HALF ", "HALFDIF ",
745 " 10 (?) ", " 11 (?) ", " 12 (?) ", " 13 (?) ", " 14 (?) ", " 15 (?) "
746 };
747 static char const *arm64_r_types[] = {
748 "UNSIGND ", "SUB ", "BR26 ", "PAGE21 ", "PAGOF12 ",
749 "GOTLDP ", "GOTLDPOF", "PTRTGOT ", "TLVLDP ", "TLVLDPOF",
750 "ADDEND ", " 11 (?) ", " 12 (?) ", " 13 (?) ", " 14 (?) ", " 15 (?) "
751 };
752
753 if (r_type > 0xf){
754 outs() << format("%-7u", r_type) << " ";
755 return;
756 }
757 switch (cputype) {
758 case MachO::CPU_TYPE_I386:
759 outs() << generic_r_types[r_type];
760 break;
761 case MachO::CPU_TYPE_X86_64:
762 outs() << x86_64_r_types[r_type];
763 break;
764 case MachO::CPU_TYPE_ARM:
765 outs() << arm_r_types[r_type];
766 break;
767 case MachO::CPU_TYPE_ARM64:
768 case MachO::CPU_TYPE_ARM64_32:
769 outs() << arm64_r_types[r_type];
770 break;
771 default:
772 outs() << format("%-7u ", r_type);
773 }
774}
775
776static void PrintRLength(const uint64_t cputype, const unsigned r_type,
777 const unsigned r_length, const bool previous_arm_half){
778 if (cputype == MachO::CPU_TYPE_ARM &&
779 (r_type == MachO::ARM_RELOC_HALF ||
780 r_type == MachO::ARM_RELOC_HALF_SECTDIFF || previous_arm_half == true)) {
781 if ((r_length & 0x1) == 0)
782 outs() << "lo/";
783 else
784 outs() << "hi/";
785 if ((r_length & 0x1) == 0)
786 outs() << "arm ";
787 else
788 outs() << "thm ";
789 } else {
790 switch (r_length) {
791 case 0:
792 outs() << "byte ";
793 break;
794 case 1:
795 outs() << "word ";
796 break;
797 case 2:
798 outs() << "long ";
799 break;
800 case 3:
801 if (cputype == MachO::CPU_TYPE_X86_64)
802 outs() << "quad ";
803 else
804 outs() << format("?(%2d) ", r_length);
805 break;
806 default:
807 outs() << format("?(%2d) ", r_length);
808 }
809 }
810}
811
812static void PrintRelocationEntries(const MachOObjectFile *O,
813 const relocation_iterator Begin,
814 const relocation_iterator End,
815 const uint64_t cputype,
816 const bool verbose) {
817 const MachO::symtab_command Symtab = O->getSymtabLoadCommand();
818 bool previous_arm_half = false;
819 bool previous_sectdiff = false;
820 uint32_t sectdiff_r_type = 0;
821
822 for (relocation_iterator Reloc = Begin; Reloc != End; ++Reloc) {
823 const DataRefImpl Rel = Reloc->getRawDataRefImpl();
824 const MachO::any_relocation_info RE = O->getRelocation(Rel);
825 const unsigned r_type = O->getAnyRelocationType(RE);
826 const bool r_scattered = O->isRelocationScattered(RE);
827 const unsigned r_pcrel = O->getAnyRelocationPCRel(RE);
828 const unsigned r_length = O->getAnyRelocationLength(RE);
829 const unsigned r_address = O->getAnyRelocationAddress(RE);
830 const bool r_extern = (r_scattered ? false :
831 O->getPlainRelocationExternal(RE));
832 const uint32_t r_value = (r_scattered ?
833 O->getScatteredRelocationValue(RE) : 0);
834 const unsigned r_symbolnum = (r_scattered ? 0 :
835 O->getPlainRelocationSymbolNum(RE));
836
837 if (r_scattered && cputype != MachO::CPU_TYPE_X86_64) {
838 if (verbose) {
839 // scattered: address
840 if ((cputype == MachO::CPU_TYPE_I386 &&
841 r_type == MachO::GENERIC_RELOC_PAIR) ||
842 (cputype == MachO::CPU_TYPE_ARM && r_type == MachO::ARM_RELOC_PAIR))
843 outs() << " ";
844 else
845 outs() << format("%08x ", (unsigned int)r_address);
846
847 // scattered: pcrel
848 if (r_pcrel)
849 outs() << "True ";
850 else
851 outs() << "False ";
852
853 // scattered: length
854 PrintRLength(cputype, r_type, r_length, previous_arm_half);
855
856 // scattered: extern & type
857 outs() << "n/a ";
858 PrintRType(cputype, r_type);
859
860 // scattered: scattered & value
861 outs() << format("True 0x%08x", (unsigned int)r_value);
862 if (previous_sectdiff == false) {
863 if ((cputype == MachO::CPU_TYPE_ARM &&
864 r_type == MachO::ARM_RELOC_PAIR))
865 outs() << format(" half = 0x%04x ", (unsigned int)r_address);
866 } else if (cputype == MachO::CPU_TYPE_ARM &&
867 sectdiff_r_type == MachO::ARM_RELOC_HALF_SECTDIFF)
868 outs() << format(" other_half = 0x%04x ", (unsigned int)r_address);
869 if ((cputype == MachO::CPU_TYPE_I386 &&
870 (r_type == MachO::GENERIC_RELOC_SECTDIFF ||
871 r_type == MachO::GENERIC_RELOC_LOCAL_SECTDIFF)) ||
872 (cputype == MachO::CPU_TYPE_ARM &&
873 (sectdiff_r_type == MachO::ARM_RELOC_SECTDIFF ||
874 sectdiff_r_type == MachO::ARM_RELOC_LOCAL_SECTDIFF ||
875 sectdiff_r_type == MachO::ARM_RELOC_HALF_SECTDIFF))) {
876 previous_sectdiff = true;
877 sectdiff_r_type = r_type;
878 } else {
879 previous_sectdiff = false;
880 sectdiff_r_type = 0;
881 }
882 if (cputype == MachO::CPU_TYPE_ARM &&
883 (r_type == MachO::ARM_RELOC_HALF ||
884 r_type == MachO::ARM_RELOC_HALF_SECTDIFF))
885 previous_arm_half = true;
886 else
887 previous_arm_half = false;
888 outs() << "\n";
889 }
890 else {
891 // scattered: address pcrel length extern type scattered value
892 outs() << format("%08x %1d %-2d n/a %-7d 1 0x%08x\n",
893 (unsigned int)r_address, r_pcrel, r_length, r_type,
894 (unsigned int)r_value);
895 }
896 }
897 else {
898 if (verbose) {
899 // plain: address
900 if (cputype == MachO::CPU_TYPE_ARM && r_type == MachO::ARM_RELOC_PAIR)
901 outs() << " ";
902 else
903 outs() << format("%08x ", (unsigned int)r_address);
904
905 // plain: pcrel
906 if (r_pcrel)
907 outs() << "True ";
908 else
909 outs() << "False ";
910
911 // plain: length
912 PrintRLength(cputype, r_type, r_length, previous_arm_half);
913
914 if (r_extern) {
915 // plain: extern & type & scattered
916 outs() << "True ";
917 PrintRType(cputype, r_type);
918 outs() << "False ";
919
920 // plain: symbolnum/value
921 if (r_symbolnum > Symtab.nsyms)
922 outs() << format("?(%d)\n", r_symbolnum);
923 else {
924 SymbolRef Symbol = *O->getSymbolByIndex(r_symbolnum);
925 Expected<StringRef> SymNameNext = Symbol.getName();
926 const char *name = nullptr;
927 if (SymNameNext)
928 name = SymNameNext->data();
929 if (name == nullptr)
930 outs() << format("?(%d)\n", r_symbolnum);
931 else
932 outs() << name << "\n";
933 }
934 }
935 else {
936 // plain: extern & type & scattered
937 outs() << "False ";
938 PrintRType(cputype, r_type);
939 outs() << "False ";
940
941 // plain: symbolnum/value
942 if (cputype == MachO::CPU_TYPE_ARM && r_type == MachO::ARM_RELOC_PAIR)
943 outs() << format("other_half = 0x%04x\n", (unsigned int)r_address);
944 else if ((cputype == MachO::CPU_TYPE_ARM64 ||
945 cputype == MachO::CPU_TYPE_ARM64_32) &&
946 r_type == MachO::ARM64_RELOC_ADDEND)
947 outs() << format("addend = 0x%06x\n", (unsigned int)r_symbolnum);
948 else {
949 outs() << format("%d ", r_symbolnum);
950 if (r_symbolnum == MachO::R_ABS)
951 outs() << "R_ABS\n";
952 else {
953 // in this case, r_symbolnum is actually a 1-based section number
954 uint32_t nsects = O->section_end()->getRawDataRefImpl().d.a;
955 if (r_symbolnum > 0 && r_symbolnum <= nsects) {
956 object::DataRefImpl DRI;
957 DRI.d.a = r_symbolnum-1;
958 StringRef SegName = O->getSectionFinalSegmentName(DRI);
959 if (Expected<StringRef> NameOrErr = O->getSectionName(DRI))
960 outs() << "(" << SegName << "," << *NameOrErr << ")\n";
961 else
962 outs() << "(?,?)\n";
963 }
964 else {
965 outs() << "(?,?)\n";
966 }
967 }
968 }
969 }
970 if (cputype == MachO::CPU_TYPE_ARM &&
971 (r_type == MachO::ARM_RELOC_HALF ||
972 r_type == MachO::ARM_RELOC_HALF_SECTDIFF))
973 previous_arm_half = true;
974 else
975 previous_arm_half = false;
976 }
977 else {
978 // plain: address pcrel length extern type scattered symbolnum/section
979 outs() << format("%08x %1d %-2d %1d %-7d 0 %d\n",
980 (unsigned int)r_address, r_pcrel, r_length, r_extern,
981 r_type, r_symbolnum);
982 }
983 }
984 }
985}
986
987static void PrintRelocations(const MachOObjectFile *O, const bool verbose) {
988 const uint64_t cputype = O->getHeader().cputype;
989 const MachO::dysymtab_command Dysymtab = O->getDysymtabLoadCommand();
990 if (Dysymtab.nextrel != 0) {
991 outs() << "External relocation information " << Dysymtab.nextrel
992 << " entries";
993 outs() << "\naddress pcrel length extern type scattered "
994 "symbolnum/value\n";
995 PrintRelocationEntries(O, O->extrel_begin(), O->extrel_end(), cputype,
996 verbose);
997 }
998 if (Dysymtab.nlocrel != 0) {
999 outs() << format("Local relocation information %u entries",
1000 Dysymtab.nlocrel);
1001 outs() << "\naddress pcrel length extern type scattered "
1002 "symbolnum/value\n";
1003 PrintRelocationEntries(O, O->locrel_begin(), O->locrel_end(), cputype,
1004 verbose);
1005 }
1006 for (const auto &Load : O->load_commands()) {
1007 if (Load.C.cmd == MachO::LC_SEGMENT_64) {
1008 const MachO::segment_command_64 Seg = O->getSegment64LoadCommand(Load);
1009 for (unsigned J = 0; J < Seg.nsects; ++J) {
1010 const MachO::section_64 Sec = O->getSection64(Load, J);
1011 if (Sec.nreloc != 0) {
1012 DataRefImpl DRI;
1013 DRI.d.a = J;
1014 const StringRef SegName = O->getSectionFinalSegmentName(DRI);
1015 if (Expected<StringRef> NameOrErr = O->getSectionName(DRI))
1016 outs() << "Relocation information (" << SegName << "," << *NameOrErr
1017 << format(") %u entries", Sec.nreloc);
1018 else
1019 outs() << "Relocation information (" << SegName << ",?) "
1020 << format("%u entries", Sec.nreloc);
1021 outs() << "\naddress pcrel length extern type scattered "
1022 "symbolnum/value\n";
1023 PrintRelocationEntries(O, O->section_rel_begin(DRI),
1024 O->section_rel_end(DRI), cputype, verbose);
1025 }
1026 }
1027 } else if (Load.C.cmd == MachO::LC_SEGMENT) {
1028 const MachO::segment_command Seg = O->getSegmentLoadCommand(Load);
1029 for (unsigned J = 0; J < Seg.nsects; ++J) {
1030 const MachO::section Sec = O->getSection(Load, J);
1031 if (Sec.nreloc != 0) {
1032 DataRefImpl DRI;
1033 DRI.d.a = J;
1034 const StringRef SegName = O->getSectionFinalSegmentName(DRI);
1035 if (Expected<StringRef> NameOrErr = O->getSectionName(DRI))
1036 outs() << "Relocation information (" << SegName << "," << *NameOrErr
1037 << format(") %u entries", Sec.nreloc);
1038 else
1039 outs() << "Relocation information (" << SegName << ",?) "
1040 << format("%u entries", Sec.nreloc);
1041 outs() << "\naddress pcrel length extern type scattered "
1042 "symbolnum/value\n";
1043 PrintRelocationEntries(O, O->section_rel_begin(DRI),
1044 O->section_rel_end(DRI), cputype, verbose);
1045 }
1046 }
1047 }
1048 }
1049}
1050
1051static void PrintFunctionStarts(MachOObjectFile *O) {
1052 uint64_t BaseSegmentAddress = 0;
1053 for (const MachOObjectFile::LoadCommandInfo &Command : O->load_commands()) {
1054 if (Command.C.cmd == MachO::LC_SEGMENT) {
1055 MachO::segment_command SLC = O->getSegmentLoadCommand(Command);
1056 if (StringRef(SLC.segname) == "__TEXT") {
1057 BaseSegmentAddress = SLC.vmaddr;
1058 break;
1059 }
1060 } else if (Command.C.cmd == MachO::LC_SEGMENT_64) {
1061 MachO::segment_command_64 SLC = O->getSegment64LoadCommand(Command);
1062 if (StringRef(SLC.segname) == "__TEXT") {
1063 BaseSegmentAddress = SLC.vmaddr;
1064 break;
1065 }
1066 }
1067 }
1068
1069 SmallVector<uint64_t, 8> FunctionStarts;
1070 for (const MachOObjectFile::LoadCommandInfo &LC : O->load_commands()) {
1071 if (LC.C.cmd == MachO::LC_FUNCTION_STARTS) {
1072 MachO::linkedit_data_command FunctionStartsLC =
1073 O->getLinkeditDataLoadCommand(LC);
1074 O->ReadULEB128s(FunctionStartsLC.dataoff, FunctionStarts);
1075 break;
1076 }
1077 }
1078
1079 for (uint64_t S : FunctionStarts) {
1080 uint64_t Addr = BaseSegmentAddress + S;
1081 if (O->is64Bit())
1082 outs() << format("%016" PRIx64"l" "x", Addr) << "\n";
1083 else
1084 outs() << format("%08" PRIx32"x", static_cast<uint32_t>(Addr)) << "\n";
1085 }
1086}
1087
1088static void PrintDataInCodeTable(MachOObjectFile *O, bool verbose) {
1089 MachO::linkedit_data_command DIC = O->getDataInCodeLoadCommand();
1090 uint32_t nentries = DIC.datasize / sizeof(struct MachO::data_in_code_entry);
1091 outs() << "Data in code table (" << nentries << " entries)\n";
1092 outs() << "offset length kind\n";
1093 for (dice_iterator DI = O->begin_dices(), DE = O->end_dices(); DI != DE;
1094 ++DI) {
1095 uint32_t Offset;
1096 DI->getOffset(Offset);
1097 outs() << format("0x%08" PRIx32"x", Offset) << " ";
1098 uint16_t Length;
1099 DI->getLength(Length);
1100 outs() << format("%6u", Length) << " ";
1101 uint16_t Kind;
1102 DI->getKind(Kind);
1103 if (verbose) {
1104 switch (Kind) {
1105 case MachO::DICE_KIND_DATA:
1106 outs() << "DATA";
1107 break;
1108 case MachO::DICE_KIND_JUMP_TABLE8:
1109 outs() << "JUMP_TABLE8";
1110 break;
1111 case MachO::DICE_KIND_JUMP_TABLE16:
1112 outs() << "JUMP_TABLE16";
1113 break;
1114 case MachO::DICE_KIND_JUMP_TABLE32:
1115 outs() << "JUMP_TABLE32";
1116 break;
1117 case MachO::DICE_KIND_ABS_JUMP_TABLE32:
1118 outs() << "ABS_JUMP_TABLE32";
1119 break;
1120 default:
1121 outs() << format("0x%04" PRIx32"x", Kind);
1122 break;
1123 }
1124 } else
1125 outs() << format("0x%04" PRIx32"x", Kind);
1126 outs() << "\n";
1127 }
1128}
1129
1130static void PrintLinkOptHints(MachOObjectFile *O) {
1131 MachO::linkedit_data_command LohLC = O->getLinkOptHintsLoadCommand();
1132 const char *loh = O->getData().substr(LohLC.dataoff, 1).data();
1133 uint32_t nloh = LohLC.datasize;
1134 outs() << "Linker optimiztion hints (" << nloh << " total bytes)\n";
1135 for (uint32_t i = 0; i < nloh;) {
1136 unsigned n;
1137 uint64_t identifier = decodeULEB128((const uint8_t *)(loh + i), &n);
1138 i += n;
1139 outs() << " identifier " << identifier << " ";
1140 if (i >= nloh)
1141 return;
1142 switch (identifier) {
1143 case 1:
1144 outs() << "AdrpAdrp\n";
1145 break;
1146 case 2:
1147 outs() << "AdrpLdr\n";
1148 break;
1149 case 3:
1150 outs() << "AdrpAddLdr\n";
1151 break;
1152 case 4:
1153 outs() << "AdrpLdrGotLdr\n";
1154 break;
1155 case 5:
1156 outs() << "AdrpAddStr\n";
1157 break;
1158 case 6:
1159 outs() << "AdrpLdrGotStr\n";
1160 break;
1161 case 7:
1162 outs() << "AdrpAdd\n";
1163 break;
1164 case 8:
1165 outs() << "AdrpLdrGot\n";
1166 break;
1167 default:
1168 outs() << "Unknown identifier value\n";
1169 break;
1170 }
1171 uint64_t narguments = decodeULEB128((const uint8_t *)(loh + i), &n);
1172 i += n;
1173 outs() << " narguments " << narguments << "\n";
1174 if (i >= nloh)
1175 return;
1176
1177 for (uint32_t j = 0; j < narguments; j++) {
1178 uint64_t value = decodeULEB128((const uint8_t *)(loh + i), &n);
1179 i += n;
1180 outs() << "\tvalue " << format("0x%" PRIx64"l" "x", value) << "\n";
1181 if (i >= nloh)
1182 return;
1183 }
1184 }
1185}
1186
1187static void printMachOChainedFixups(object::MachOObjectFile *Obj) {
1188 Error Err = Error::success();
1189 for (const object::MachOChainedFixupEntry &Entry : Obj->fixupTable(Err)) {
1190 (void)Entry;
1191 }
1192 if (Err)
1193 reportError(std::move(Err), Obj->getFileName());
1194}
1195
1196static void PrintDyldInfo(MachOObjectFile *O) {
1197 outs() << "dyld information:" << '\n';
1198 printMachOChainedFixups(O);
1199}
1200
1201static void PrintDylibs(MachOObjectFile *O, bool JustId) {
1202 unsigned Index = 0;
1203 for (const auto &Load : O->load_commands()) {
1204 if ((JustId && Load.C.cmd == MachO::LC_ID_DYLIB) ||
1205 (!JustId && (Load.C.cmd == MachO::LC_ID_DYLIB ||
1206 Load.C.cmd == MachO::LC_LOAD_DYLIB ||
1207 Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB ||
1208 Load.C.cmd == MachO::LC_REEXPORT_DYLIB ||
1209 Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB ||
1210 Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB))) {
1211 MachO::dylib_command dl = O->getDylibIDLoadCommand(Load);
1212 if (dl.dylib.name < dl.cmdsize) {
1213 const char *p = (const char *)(Load.Ptr) + dl.dylib.name;
1214 if (JustId)
1215 outs() << p << "\n";
1216 else {
1217 outs() << "\t" << p;
1218 outs() << " (compatibility version "
1219 << ((dl.dylib.compatibility_version >> 16) & 0xffff) << "."
1220 << ((dl.dylib.compatibility_version >> 8) & 0xff) << "."
1221 << (dl.dylib.compatibility_version & 0xff) << ",";
1222 outs() << " current version "
1223 << ((dl.dylib.current_version >> 16) & 0xffff) << "."
1224 << ((dl.dylib.current_version >> 8) & 0xff) << "."
1225 << (dl.dylib.current_version & 0xff);
1226 if (Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB)
1227 outs() << ", weak";
1228 if (Load.C.cmd == MachO::LC_REEXPORT_DYLIB)
1229 outs() << ", reexport";
1230 if (Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB)
1231 outs() << ", upward";
1232 if (Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB)
1233 outs() << ", lazy";
1234 outs() << ")\n";
1235 }
1236 } else {
1237 outs() << "\tBad offset (" << dl.dylib.name << ") for name of ";
1238 if (Load.C.cmd == MachO::LC_ID_DYLIB)
1239 outs() << "LC_ID_DYLIB ";
1240 else if (Load.C.cmd == MachO::LC_LOAD_DYLIB)
1241 outs() << "LC_LOAD_DYLIB ";
1242 else if (Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB)
1243 outs() << "LC_LOAD_WEAK_DYLIB ";
1244 else if (Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB)
1245 outs() << "LC_LAZY_LOAD_DYLIB ";
1246 else if (Load.C.cmd == MachO::LC_REEXPORT_DYLIB)
1247 outs() << "LC_REEXPORT_DYLIB ";
1248 else if (Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB)
1249 outs() << "LC_LOAD_UPWARD_DYLIB ";
1250 else
1251 outs() << "LC_??? ";
1252 outs() << "command " << Index++ << "\n";
1253 }
1254 }
1255 }
1256}
1257
1258static void printRpaths(MachOObjectFile *O) {
1259 for (const auto &Command : O->load_commands()) {
1260 if (Command.C.cmd == MachO::LC_RPATH) {
1261 auto Rpath = O->getRpathCommand(Command);
1262 const char *P = (const char *)(Command.Ptr) + Rpath.path;
1263 outs() << P << "\n";
1264 }
1265 }
1266}
1267
1268typedef DenseMap<uint64_t, StringRef> SymbolAddressMap;
1269
1270static void CreateSymbolAddressMap(MachOObjectFile *O,
1271 SymbolAddressMap *AddrMap) {
1272 // Create a map of symbol addresses to symbol names.
1273 const StringRef FileName = O->getFileName();
1274 for (const SymbolRef &Symbol : O->symbols()) {
1275 SymbolRef::Type ST = unwrapOrError(Symbol.getType(), FileName);
1276 if (ST == SymbolRef::ST_Function || ST == SymbolRef::ST_Data ||
1277 ST == SymbolRef::ST_Other) {
1278 uint64_t Address = cantFail(Symbol.getValue());
1279 StringRef SymName = unwrapOrError(Symbol.getName(), FileName);
1280 if (!SymName.startswith(".objc"))
1281 (*AddrMap)[Address] = SymName;
1282 }
1283 }
1284}
1285
1286// GuessSymbolName is passed the address of what might be a symbol and a
1287// pointer to the SymbolAddressMap. It returns the name of a symbol
1288// with that address or nullptr if no symbol is found with that address.
1289static const char *GuessSymbolName(uint64_t value, SymbolAddressMap *AddrMap) {
1290 const char *SymbolName = nullptr;
1291 // A DenseMap can't lookup up some values.
1292 if (value != 0xffffffffffffffffULL && value != 0xfffffffffffffffeULL) {
1293 StringRef name = AddrMap->lookup(value);
1294 if (!name.empty())
1295 SymbolName = name.data();
1296 }
1297 return SymbolName;
1298}
1299
1300static void DumpCstringChar(const char c) {
1301 char p[2];
1302 p[0] = c;
1303 p[1] = '\0';
1304 outs().write_escaped(p);
1305}
1306
1307static void DumpCstringSection(MachOObjectFile *O, const char *sect,
1308 uint32_t sect_size, uint64_t sect_addr,
1309 bool print_addresses) {
1310 for (uint32_t i = 0; i < sect_size; i++) {
1311 if (print_addresses) {
1312 if (O->is64Bit())
1313 outs() << format("%016" PRIx64"l" "x", sect_addr + i) << " ";
1314 else
1315 outs() << format("%08" PRIx64"l" "x", sect_addr + i) << " ";
1316 }
1317 for (; i < sect_size && sect[i] != '\0'; i++)
1318 DumpCstringChar(sect[i]);
1319 if (i < sect_size && sect[i] == '\0')
1320 outs() << "\n";
1321 }
1322}
1323
1324static void DumpLiteral4(uint32_t l, float f) {
1325 outs() << format("0x%08" PRIx32"x", l);
1326 if ((l & 0x7f800000) != 0x7f800000)
1327 outs() << format(" (%.16e)\n", f);
1328 else {
1329 if (l == 0x7f800000)
1330 outs() << " (+Infinity)\n";
1331 else if (l == 0xff800000)
1332 outs() << " (-Infinity)\n";
1333 else if ((l & 0x00400000) == 0x00400000)
1334 outs() << " (non-signaling Not-a-Number)\n";
1335 else
1336 outs() << " (signaling Not-a-Number)\n";
1337 }
1338}
1339
1340static void DumpLiteral4Section(MachOObjectFile *O, const char *sect,
1341 uint32_t sect_size, uint64_t sect_addr,
1342 bool print_addresses) {
1343 for (uint32_t i = 0; i < sect_size; i += sizeof(float)) {
1344 if (print_addresses) {
1345 if (O->is64Bit())
1346 outs() << format("%016" PRIx64"l" "x", sect_addr + i) << " ";
1347 else
1348 outs() << format("%08" PRIx64"l" "x", sect_addr + i) << " ";
1349 }
1350 float f;
1351 memcpy(&f, sect + i, sizeof(float));
1352 if (O->isLittleEndian() != sys::IsLittleEndianHost)
1353 sys::swapByteOrder(f);
1354 uint32_t l;
1355 memcpy(&l, sect + i, sizeof(uint32_t));
1356 if (O->isLittleEndian() != sys::IsLittleEndianHost)
1357 sys::swapByteOrder(l);
1358 DumpLiteral4(l, f);
1359 }
1360}
1361
1362static void DumpLiteral8(MachOObjectFile *O, uint32_t l0, uint32_t l1,
1363 double d) {
1364 outs() << format("0x%08" PRIx32"x", l0) << " " << format("0x%08" PRIx32"x", l1);
1365 uint32_t Hi, Lo;
1366 Hi = (O->isLittleEndian()) ? l1 : l0;
1367 Lo = (O->isLittleEndian()) ? l0 : l1;
1368
1369 // Hi is the high word, so this is equivalent to if(isfinite(d))
1370 if ((Hi & 0x7ff00000) != 0x7ff00000)
1371 outs() << format(" (%.16e)\n", d);
1372 else {
1373 if (Hi == 0x7ff00000 && Lo == 0)
1374 outs() << " (+Infinity)\n";
1375 else if (Hi == 0xfff00000 && Lo == 0)
1376 outs() << " (-Infinity)\n";
1377 else if ((Hi & 0x00080000) == 0x00080000)
1378 outs() << " (non-signaling Not-a-Number)\n";
1379 else
1380 outs() << " (signaling Not-a-Number)\n";
1381 }
1382}
1383
1384static void DumpLiteral8Section(MachOObjectFile *O, const char *sect,
1385 uint32_t sect_size, uint64_t sect_addr,
1386 bool print_addresses) {
1387 for (uint32_t i = 0; i < sect_size; i += sizeof(double)) {
1388 if (print_addresses) {
1389 if (O->is64Bit())
1390 outs() << format("%016" PRIx64"l" "x", sect_addr + i) << " ";
1391 else
1392 outs() << format("%08" PRIx64"l" "x", sect_addr + i) << " ";
1393 }
1394 double d;
1395 memcpy(&d, sect + i, sizeof(double));
1396 if (O->isLittleEndian() != sys::IsLittleEndianHost)
1397 sys::swapByteOrder(d);
1398 uint32_t l0, l1;
1399 memcpy(&l0, sect + i, sizeof(uint32_t));
1400 memcpy(&l1, sect + i + sizeof(uint32_t), sizeof(uint32_t));
1401 if (O->isLittleEndian() != sys::IsLittleEndianHost) {
1402 sys::swapByteOrder(l0);
1403 sys::swapByteOrder(l1);
1404 }
1405 DumpLiteral8(O, l0, l1, d);
1406 }
1407}
1408
1409static void DumpLiteral16(uint32_t l0, uint32_t l1, uint32_t l2, uint32_t l3) {
1410 outs() << format("0x%08" PRIx32"x", l0) << " ";
1411 outs() << format("0x%08" PRIx32"x", l1) << " ";
1412 outs() << format("0x%08" PRIx32"x", l2) << " ";
1413 outs() << format("0x%08" PRIx32"x", l3) << "\n";
1414}
1415
1416static void DumpLiteral16Section(MachOObjectFile *O, const char *sect,
1417 uint32_t sect_size, uint64_t sect_addr,
1418 bool print_addresses) {
1419 for (uint32_t i = 0; i < sect_size; i += 16) {
1420 if (print_addresses) {
1421 if (O->is64Bit())
1422 outs() << format("%016" PRIx64"l" "x", sect_addr + i) << " ";
1423 else
1424 outs() << format("%08" PRIx64"l" "x", sect_addr + i) << " ";
1425 }
1426 uint32_t l0, l1, l2, l3;
1427 memcpy(&l0, sect + i, sizeof(uint32_t));
1428 memcpy(&l1, sect + i + sizeof(uint32_t), sizeof(uint32_t));
1429 memcpy(&l2, sect + i + 2 * sizeof(uint32_t), sizeof(uint32_t));
1430 memcpy(&l3, sect + i + 3 * sizeof(uint32_t), sizeof(uint32_t));
1431 if (O->isLittleEndian() != sys::IsLittleEndianHost) {
1432 sys::swapByteOrder(l0);
1433 sys::swapByteOrder(l1);
1434 sys::swapByteOrder(l2);
1435 sys::swapByteOrder(l3);
1436 }
1437 DumpLiteral16(l0, l1, l2, l3);
1438 }
1439}
1440
1441static void DumpLiteralPointerSection(MachOObjectFile *O,
1442 const SectionRef &Section,
1443 const char *sect, uint32_t sect_size,
1444 uint64_t sect_addr,
1445 bool print_addresses) {
1446 // Collect the literal sections in this Mach-O file.
1447 std::vector<SectionRef> LiteralSections;
1448 for (const SectionRef &Section : O->sections()) {
1449 DataRefImpl Ref = Section.getRawDataRefImpl();
1450 uint32_t section_type;
1451 if (O->is64Bit()) {
1452 const MachO::section_64 Sec = O->getSection64(Ref);
1453 section_type = Sec.flags & MachO::SECTION_TYPE;
1454 } else {
1455 const MachO::section Sec = O->getSection(Ref);
1456 section_type = Sec.flags & MachO::SECTION_TYPE;
1457 }
1458 if (section_type == MachO::S_CSTRING_LITERALS ||
1459 section_type == MachO::S_4BYTE_LITERALS ||
1460 section_type == MachO::S_8BYTE_LITERALS ||
1461 section_type == MachO::S_16BYTE_LITERALS)
1462 LiteralSections.push_back(Section);
1463 }
1464
1465 // Set the size of the literal pointer.
1466 uint32_t lp_size = O->is64Bit() ? 8 : 4;
1467
1468 // Collect the external relocation symbols for the literal pointers.
1469 std::vector<std::pair<uint64_t, SymbolRef>> Relocs;
1470 for (const RelocationRef &Reloc : Section.relocations()) {
1471 DataRefImpl Rel;
1472 MachO::any_relocation_info RE;
1473 bool isExtern = false;
1474 Rel = Reloc.getRawDataRefImpl();
1475 RE = O->getRelocation(Rel);
1476 isExtern = O->getPlainRelocationExternal(RE);
1477 if (isExtern) {
1478 uint64_t RelocOffset = Reloc.getOffset();
1479 symbol_iterator RelocSym = Reloc.getSymbol();
1480 Relocs.push_back(std::make_pair(RelocOffset, *RelocSym));
1481 }
1482 }
1483 array_pod_sort(Relocs.begin(), Relocs.end());
1484
1485 // Dump each literal pointer.
1486 for (uint32_t i = 0; i < sect_size; i += lp_size) {
1487 if (print_addresses) {
1488 if (O->is64Bit())
1489 outs() << format("%016" PRIx64"l" "x", sect_addr + i) << " ";
1490 else
1491 outs() << format("%08" PRIx64"l" "x", sect_addr + i) << " ";
1492 }
1493 uint64_t lp;
1494 if (O->is64Bit()) {
1495 memcpy(&lp, sect + i, sizeof(uint64_t));
1496 if (O->isLittleEndian() != sys::IsLittleEndianHost)
1497 sys::swapByteOrder(lp);
1498 } else {
1499 uint32_t li;
1500 memcpy(&li, sect + i, sizeof(uint32_t));
1501 if (O->isLittleEndian() != sys::IsLittleEndianHost)
1502 sys::swapByteOrder(li);
1503 lp = li;
1504 }
1505
1506 // First look for an external relocation entry for this literal pointer.
1507 auto Reloc = find_if(Relocs, [&](const std::pair<uint64_t, SymbolRef> &P) {
1508 return P.first == i;
1509 });
1510 if (Reloc != Relocs.end()) {
1511 symbol_iterator RelocSym = Reloc->second;
1512 StringRef SymName = unwrapOrError(RelocSym->getName(), O->getFileName());
1513 outs() << "external relocation entry for symbol:" << SymName << "\n";
1514 continue;
1515 }
1516
1517 // For local references see what the section the literal pointer points to.
1518 auto Sect = find_if(LiteralSections, [&](const SectionRef &R) {
1519 return lp >= R.getAddress() && lp < R.getAddress() + R.getSize();
1520 });
1521 if (Sect == LiteralSections.end()) {
1522 outs() << format("0x%" PRIx64"l" "x", lp) << " (not in a literal section)\n";
1523 continue;
1524 }
1525
1526 uint64_t SectAddress = Sect->getAddress();
1527 uint64_t SectSize = Sect->getSize();
1528
1529 StringRef SectName;
1530 Expected<StringRef> SectNameOrErr = Sect->getName();
1531 if (SectNameOrErr)
1532 SectName = *SectNameOrErr;
1533 else
1534 consumeError(SectNameOrErr.takeError());
1535
1536 DataRefImpl Ref = Sect->getRawDataRefImpl();
1537 StringRef SegmentName = O->getSectionFinalSegmentName(Ref);
1538 outs() << SegmentName << ":" << SectName << ":";
1539
1540 uint32_t section_type;
1541 if (O->is64Bit()) {
1542 const MachO::section_64 Sec = O->getSection64(Ref);
1543 section_type = Sec.flags & MachO::SECTION_TYPE;
1544 } else {
1545 const MachO::section Sec = O->getSection(Ref);
1546 section_type = Sec.flags & MachO::SECTION_TYPE;
1547 }
1548
1549 StringRef BytesStr = unwrapOrError(Sect->getContents(), O->getFileName());
1550
1551 const char *Contents = reinterpret_cast<const char *>(BytesStr.data());
1552
1553 switch (section_type) {
1554 case MachO::S_CSTRING_LITERALS:
1555 for (uint64_t i = lp - SectAddress; i < SectSize && Contents[i] != '\0';
1556 i++) {
1557 DumpCstringChar(Contents[i]);
1558 }
1559 outs() << "\n";
1560 break;
1561 case MachO::S_4BYTE_LITERALS:
1562 float f;
1563 memcpy(&f, Contents + (lp - SectAddress), sizeof(float));
1564 uint32_t l;
1565 memcpy(&l, Contents + (lp - SectAddress), sizeof(uint32_t));
1566 if (O->isLittleEndian() != sys::IsLittleEndianHost) {
1567 sys::swapByteOrder(f);
1568 sys::swapByteOrder(l);
1569 }
1570 DumpLiteral4(l, f);
1571 break;
1572 case MachO::S_8BYTE_LITERALS: {
1573 double d;
1574 memcpy(&d, Contents + (lp - SectAddress), sizeof(double));
1575 uint32_t l0, l1;
1576 memcpy(&l0, Contents + (lp - SectAddress), sizeof(uint32_t));
1577 memcpy(&l1, Contents + (lp - SectAddress) + sizeof(uint32_t),
1578 sizeof(uint32_t));
1579 if (O->isLittleEndian() != sys::IsLittleEndianHost) {
1580 sys::swapByteOrder(f);
1581 sys::swapByteOrder(l0);
1582 sys::swapByteOrder(l1);
1583 }
1584 DumpLiteral8(O, l0, l1, d);
1585 break;
1586 }
1587 case MachO::S_16BYTE_LITERALS: {
1588 uint32_t l0, l1, l2, l3;
1589 memcpy(&l0, Contents + (lp - SectAddress), sizeof(uint32_t));
1590 memcpy(&l1, Contents + (lp - SectAddress) + sizeof(uint32_t),
1591 sizeof(uint32_t));
1592 memcpy(&l2, Contents + (lp - SectAddress) + 2 * sizeof(uint32_t),
1593 sizeof(uint32_t));
1594 memcpy(&l3, Contents + (lp - SectAddress) + 3 * sizeof(uint32_t),
1595 sizeof(uint32_t));
1596 if (O->isLittleEndian() != sys::IsLittleEndianHost) {
1597 sys::swapByteOrder(l0);
1598 sys::swapByteOrder(l1);
1599 sys::swapByteOrder(l2);
1600 sys::swapByteOrder(l3);
1601 }
1602 DumpLiteral16(l0, l1, l2, l3);
1603 break;
1604 }
1605 }
1606 }
1607}
1608
1609static void DumpInitTermPointerSection(MachOObjectFile *O,
1610 const SectionRef &Section,
1611 const char *sect,
1612 uint32_t sect_size, uint64_t sect_addr,
1613 SymbolAddressMap *AddrMap,
1614 bool verbose) {
1615 uint32_t stride;
1616 stride = (O->is64Bit()) ? sizeof(uint64_t) : sizeof(uint32_t);
1617
1618 // Collect the external relocation symbols for the pointers.
1619 std::vector<std::pair<uint64_t, SymbolRef>> Relocs;
1620 for (const RelocationRef &Reloc : Section.relocations()) {
1621 DataRefImpl Rel;
1622 MachO::any_relocation_info RE;
1623 bool isExtern = false;
1624 Rel = Reloc.getRawDataRefImpl();
1625 RE = O->getRelocation(Rel);
1626 isExtern = O->getPlainRelocationExternal(RE);
1627 if (isExtern) {
1628 uint64_t RelocOffset = Reloc.getOffset();
1629 symbol_iterator RelocSym = Reloc.getSymbol();
1630 Relocs.push_back(std::make_pair(RelocOffset, *RelocSym));
1631 }
1632 }
1633 array_pod_sort(Relocs.begin(), Relocs.end());
1634
1635 for (uint32_t i = 0; i < sect_size; i += stride) {
1636 const char *SymbolName = nullptr;
1637 uint64_t p;
1638 if (O->is64Bit()) {
1639 outs() << format("0x%016" PRIx64"l" "x", sect_addr + i * stride) << " ";
1640 uint64_t pointer_value;
1641 memcpy(&pointer_value, sect + i, stride);
1642 if (O->isLittleEndian() != sys::IsLittleEndianHost)
1643 sys::swapByteOrder(pointer_value);
1644 outs() << format("0x%016" PRIx64"l" "x", pointer_value);
1645 p = pointer_value;
1646 } else {
1647 outs() << format("0x%08" PRIx64"l" "x", sect_addr + i * stride) << " ";
1648 uint32_t pointer_value;
1649 memcpy(&pointer_value, sect + i, stride);
1650 if (O->isLittleEndian() != sys::IsLittleEndianHost)
1651 sys::swapByteOrder(pointer_value);
1652 outs() << format("0x%08" PRIx32"x", pointer_value);
1653 p = pointer_value;
1654 }
1655 if (verbose) {
1656 // First look for an external relocation entry for this pointer.
1657 auto Reloc = find_if(Relocs, [&](const std::pair<uint64_t, SymbolRef> &P) {
1658 return P.first == i;
1659 });
1660 if (Reloc != Relocs.end()) {
1661 symbol_iterator RelocSym = Reloc->second;
1662 outs() << " " << unwrapOrError(RelocSym->getName(), O->getFileName());
1663 } else {
1664 SymbolName = GuessSymbolName(p, AddrMap);
1665 if (SymbolName)
1666 outs() << " " << SymbolName;
1667 }
1668 }
1669 outs() << "\n";
1670 }
1671}
1672
1673static void DumpRawSectionContents(MachOObjectFile *O, const char *sect,
1674 uint32_t size, uint64_t addr) {
1675 uint32_t cputype = O->getHeader().cputype;
1676 if (cputype == MachO::CPU_TYPE_I386 || cputype == MachO::CPU_TYPE_X86_64) {
1677 uint32_t j;
1678 for (uint32_t i = 0; i < size; i += j, addr += j) {
1679 if (O->is64Bit())
1680 outs() << format("%016" PRIx64"l" "x", addr) << "\t";
1681 else
1682 outs() << format("%08" PRIx64"l" "x", addr) << "\t";
1683 for (j = 0; j < 16 && i + j < size; j++) {
1684 uint8_t byte_word = *(sect + i + j);
1685 outs() << format("%02" PRIx32"x", (uint32_t)byte_word) << " ";
1686 }
1687 outs() << "\n";
1688 }
1689 } else {
1690 uint32_t j;
1691 for (uint32_t i = 0; i < size; i += j, addr += j) {
1692 if (O->is64Bit())
1693 outs() << format("%016" PRIx64"l" "x", addr) << "\t";
1694 else
1695 outs() << format("%08" PRIx64"l" "x", addr) << "\t";
1696 for (j = 0; j < 4 * sizeof(int32_t) && i + j < size;
1697 j += sizeof(int32_t)) {
1698 if (i + j + sizeof(int32_t) <= size) {
1699 uint32_t long_word;
1700 memcpy(&long_word, sect + i + j, sizeof(int32_t));
1701 if (O->isLittleEndian() != sys::IsLittleEndianHost)
1702 sys::swapByteOrder(long_word);
1703 outs() << format("%08" PRIx32"x", long_word) << " ";
1704 } else {
1705 for (uint32_t k = 0; i + j + k < size; k++) {
1706 uint8_t byte_word = *(sect + i + j + k);
1707 outs() << format("%02" PRIx32"x", (uint32_t)byte_word) << " ";
1708 }
1709 }
1710 }
1711 outs() << "\n";
1712 }
1713 }
1714}
1715
1716static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
1717 StringRef DisSegName, StringRef DisSectName);
1718static void DumpProtocolSection(MachOObjectFile *O, const char *sect,
1719 uint32_t size, uint32_t addr);
1720#ifdef LLVM_HAVE_LIBXAR
1721static void DumpBitcodeSection(MachOObjectFile *O, const char *sect,
1722 uint32_t size, bool verbose,
1723 bool PrintXarHeader, bool PrintXarFileHeaders,
1724 std::string XarMemberName);
1725#endif // defined(LLVM_HAVE_LIBXAR)
1726
1727static void DumpSectionContents(StringRef Filename, MachOObjectFile *O,
1728 bool verbose) {
1729 SymbolAddressMap AddrMap;
1730 if (verbose)
1731 CreateSymbolAddressMap(O, &AddrMap);
1732
1733 for (unsigned i = 0; i < FilterSections.size(); ++i) {
1734 StringRef DumpSection = FilterSections[i];
1735 std::pair<StringRef, StringRef> DumpSegSectName;
1736 DumpSegSectName = DumpSection.split(',');
1737 StringRef DumpSegName, DumpSectName;
1738 if (!DumpSegSectName.second.empty()) {
1739 DumpSegName = DumpSegSectName.first;
1740 DumpSectName = DumpSegSectName.second;
1741 } else {
1742 DumpSegName = "";
1743 DumpSectName = DumpSegSectName.first;
1744 }
1745 for (const SectionRef &Section : O->sections()) {
1746 StringRef SectName;
1747 Expected<StringRef> SecNameOrErr = Section.getName();
1748 if (SecNameOrErr)
1749 SectName = *SecNameOrErr;
1750 else
1751 consumeError(SecNameOrErr.takeError());
1752
1753 if (!DumpSection.empty())
1754 FoundSectionSet.insert(DumpSection);
1755
1756 DataRefImpl Ref = Section.getRawDataRefImpl();
1757 StringRef SegName = O->getSectionFinalSegmentName(Ref);
1758 if ((DumpSegName.empty() || SegName == DumpSegName) &&
1759 (SectName == DumpSectName)) {
1760
1761 uint32_t section_flags;
1762 if (O->is64Bit()) {
1763 const MachO::section_64 Sec = O->getSection64(Ref);
1764 section_flags = Sec.flags;
1765
1766 } else {
1767 const MachO::section Sec = O->getSection(Ref);
1768 section_flags = Sec.flags;
1769 }
1770 uint32_t section_type = section_flags & MachO::SECTION_TYPE;
1771
1772 StringRef BytesStr =
1773 unwrapOrError(Section.getContents(), O->getFileName());
1774 const char *sect = reinterpret_cast<const char *>(BytesStr.data());
1775 uint32_t sect_size = BytesStr.size();
1776 uint64_t sect_addr = Section.getAddress();
1777
1778 if (LeadingHeaders)
1779 outs() << "Contents of (" << SegName << "," << SectName
1780 << ") section\n";
1781
1782 if (verbose) {
1783 if ((section_flags & MachO::S_ATTR_PURE_INSTRUCTIONS) ||
1784 (section_flags & MachO::S_ATTR_SOME_INSTRUCTIONS)) {
1785 DisassembleMachO(Filename, O, SegName, SectName);
1786 continue;
1787 }
1788 if (SegName == "__TEXT" && SectName == "__info_plist") {
1789 outs() << sect;
1790 continue;
1791 }
1792 if (SegName == "__OBJC" && SectName == "__protocol") {
1793 DumpProtocolSection(O, sect, sect_size, sect_addr);
1794 continue;
1795 }
1796#ifdef LLVM_HAVE_LIBXAR
1797 if (SegName == "__LLVM" && SectName == "__bundle") {
1798 DumpBitcodeSection(O, sect, sect_size, verbose, SymbolicOperands,
1799 ArchiveHeaders, "");
1800 continue;
1801 }
1802#endif // defined(LLVM_HAVE_LIBXAR)
1803 switch (section_type) {
1804 case MachO::S_REGULAR:
1805 DumpRawSectionContents(O, sect, sect_size, sect_addr);
1806 break;
1807 case MachO::S_ZEROFILL:
1808 outs() << "zerofill section and has no contents in the file\n";
1809 break;
1810 case MachO::S_CSTRING_LITERALS:
1811 DumpCstringSection(O, sect, sect_size, sect_addr, LeadingAddr);
1812 break;
1813 case MachO::S_4BYTE_LITERALS:
1814 DumpLiteral4Section(O, sect, sect_size, sect_addr, LeadingAddr);
1815 break;
1816 case MachO::S_8BYTE_LITERALS:
1817 DumpLiteral8Section(O, sect, sect_size, sect_addr, LeadingAddr);
1818 break;
1819 case MachO::S_16BYTE_LITERALS:
1820 DumpLiteral16Section(O, sect, sect_size, sect_addr, LeadingAddr);
1821 break;
1822 case MachO::S_LITERAL_POINTERS:
1823 DumpLiteralPointerSection(O, Section, sect, sect_size, sect_addr,
1824 LeadingAddr);
1825 break;
1826 case MachO::S_MOD_INIT_FUNC_POINTERS:
1827 case MachO::S_MOD_TERM_FUNC_POINTERS:
1828 DumpInitTermPointerSection(O, Section, sect, sect_size, sect_addr,
1829 &AddrMap, verbose);
1830 break;
1831 default:
1832 outs() << "Unknown section type ("
1833 << format("0x%08" PRIx32"x", section_type) << ")\n";
1834 DumpRawSectionContents(O, sect, sect_size, sect_addr);
1835 break;
1836 }
1837 } else {
1838 if (section_type == MachO::S_ZEROFILL)
1839 outs() << "zerofill section and has no contents in the file\n";
1840 else
1841 DumpRawSectionContents(O, sect, sect_size, sect_addr);
1842 }
1843 }
1844 }
1845 }
1846}
1847
1848static void DumpInfoPlistSectionContents(StringRef Filename,
1849 MachOObjectFile *O) {
1850 for (const SectionRef &Section : O->sections()) {
1851 StringRef SectName;
1852 Expected<StringRef> SecNameOrErr = Section.getName();
1853 if (SecNameOrErr)
1854 SectName = *SecNameOrErr;
1855 else
1856 consumeError(SecNameOrErr.takeError());
1857
1858 DataRefImpl Ref = Section.getRawDataRefImpl();
1859 StringRef SegName = O->getSectionFinalSegmentName(Ref);
1860 if (SegName == "__TEXT" && SectName == "__info_plist") {
1861 if (LeadingHeaders)
1862 outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
1863 StringRef BytesStr =
1864 unwrapOrError(Section.getContents(), O->getFileName());
1865 const char *sect = reinterpret_cast<const char *>(BytesStr.data());
1866 outs() << format("%.*s", BytesStr.size(), sect) << "\n";
1867 return;
1868 }
1869 }
1870}
1871
1872// checkMachOAndArchFlags() checks to see if the ObjectFile is a Mach-O file
1873// and if it is and there is a list of architecture flags is specified then
1874// check to make sure this Mach-O file is one of those architectures or all
1875// architectures were specified. If not then an error is generated and this
1876// routine returns false. Else it returns true.
1877static bool checkMachOAndArchFlags(ObjectFile *O, StringRef Filename) {
1878 auto *MachO = dyn_cast<MachOObjectFile>(O);
1879
1880 if (!MachO || ArchAll || ArchFlags.empty())
1881 return true;
1882
1883 MachO::mach_header H;
1884 MachO::mach_header_64 H_64;
1885 Triple T;
1886 const char *McpuDefault, *ArchFlag;
1887 if (MachO->is64Bit()) {
1888 H_64 = MachO->MachOObjectFile::getHeader64();
1889 T = MachOObjectFile::getArchTriple(H_64.cputype, H_64.cpusubtype,
1890 &McpuDefault, &ArchFlag);
1891 } else {
1892 H = MachO->MachOObjectFile::getHeader();
1893 T = MachOObjectFile::getArchTriple(H.cputype, H.cpusubtype,
1894 &McpuDefault, &ArchFlag);
1895 }
1896 const std::string ArchFlagName(ArchFlag);
1897 if (!llvm::is_contained(ArchFlags, ArchFlagName)) {
1898 WithColor::error(errs(), "llvm-objdump")
1899 << Filename << ": no architecture specified.\n";
1900 return false;
1901 }
1902 return true;
1903}
1904
1905static void printObjcMetaData(MachOObjectFile *O, bool verbose);
1906
1907// ProcessMachO() is passed a single opened Mach-O file, which may be an
1908// archive member and or in a slice of a universal file. It prints the
1909// the file name and header info and then processes it according to the
1910// command line options.
1911static void ProcessMachO(StringRef Name, MachOObjectFile *MachOOF,
1912 StringRef ArchiveMemberName = StringRef(),
1913 StringRef ArchitectureName = StringRef()) {
1914 // If we are doing some processing here on the Mach-O file print the header
1915 // info. And don't print it otherwise like in the case of printing the
1916 // UniversalHeaders or ArchiveHeaders.
1917 if (Disassemble || Relocations || PrivateHeaders || ExportsTrie || Rebase ||
1918 Bind || SymbolTable || LazyBind || WeakBind || IndirectSymbols ||
1919 DataInCode || FunctionStarts || LinkOptHints || DyldInfo || DylibsUsed ||
1920 DylibId || Rpaths || ObjcMetaData || (!FilterSections.empty())) {
1921 if (LeadingHeaders) {
1922 outs() << Name;
1923 if (!ArchiveMemberName.empty())
1924 outs() << '(' << ArchiveMemberName << ')';
1925 if (!ArchitectureName.empty())
1926 outs() << " (architecture " << ArchitectureName << ")";
1927 outs() << ":\n";
1928 }
1929 }
1930 // To use the report_error() form with an ArchiveName and FileName set
1931 // these up based on what is passed for Name and ArchiveMemberName.
1932 StringRef ArchiveName;
1933 StringRef FileName;
1934 if (!ArchiveMemberName.empty()) {
1935 ArchiveName = Name;
1936 FileName = ArchiveMemberName;
1937 } else {
1938 ArchiveName = StringRef();
1939 FileName = Name;
1940 }
1941
1942 // If we need the symbol table to do the operation then check it here to
1943 // produce a good error message as to where the Mach-O file comes from in
1944 // the error message.
1945 if (Disassemble || IndirectSymbols || !FilterSections.empty() || UnwindInfo)
1946 if (Error Err = MachOOF->checkSymbolTable())
1947 reportError(std::move(Err), FileName, ArchiveName, ArchitectureName);
1948
1949 if (DisassembleAll) {
1950 for (const SectionRef &Section : MachOOF->sections()) {
1951 StringRef SectName;
1952 if (Expected<StringRef> NameOrErr = Section.getName())
1953 SectName = *NameOrErr;
1954 else
1955 consumeError(NameOrErr.takeError());
1956
1957 if (SectName.equals("__text")) {
1958 DataRefImpl Ref = Section.getRawDataRefImpl();
1959 StringRef SegName = MachOOF->getSectionFinalSegmentName(Ref);
1960 DisassembleMachO(FileName, MachOOF, SegName, SectName);
1961 }
1962 }
1963 }
1964 else if (Disassemble) {
1965 if (MachOOF->getHeader().filetype == MachO::MH_KEXT_BUNDLE &&
1966 MachOOF->getHeader().cputype == MachO::CPU_TYPE_ARM64)
1967 DisassembleMachO(FileName, MachOOF, "__TEXT_EXEC", "__text");
1968 else
1969 DisassembleMachO(FileName, MachOOF, "__TEXT", "__text");
1970 }
1971 if (IndirectSymbols)
1972 PrintIndirectSymbols(MachOOF, Verbose);
1973 if (DataInCode)
1974 PrintDataInCodeTable(MachOOF, Verbose);
1975 if (FunctionStarts)
1976 PrintFunctionStarts(MachOOF);
1977 if (LinkOptHints)
1978 PrintLinkOptHints(MachOOF);
1979 if (Relocations)
1980 PrintRelocations(MachOOF, Verbose);
1981 if (SectionHeaders)
1982 printSectionHeaders(MachOOF);
1983 if (SectionContents)
1984 printSectionContents(MachOOF);
1985 if (!FilterSections.empty())
1986 DumpSectionContents(FileName, MachOOF, Verbose);
1987 if (InfoPlist)
1988 DumpInfoPlistSectionContents(FileName, MachOOF);
1989 if (DyldInfo)
1990 PrintDyldInfo(MachOOF);
1991 if (DylibsUsed)
1992 PrintDylibs(MachOOF, false);
1993 if (DylibId)
1994 PrintDylibs(MachOOF, true);
1995 if (SymbolTable)
1996 printSymbolTable(MachOOF, ArchiveName, ArchitectureName);
1997 if (UnwindInfo)
1998 printMachOUnwindInfo(MachOOF);
1999 if (PrivateHeaders) {
2000 printMachOFileHeader(MachOOF);
2001 printMachOLoadCommands(MachOOF);
2002 }
2003 if (FirstPrivateHeader)
2004 printMachOFileHeader(MachOOF);
2005 if (ObjcMetaData)
2006 printObjcMetaData(MachOOF, Verbose);
2007 if (ExportsTrie)
2008 printExportsTrie(MachOOF);
2009 if (Rebase)
2010 printRebaseTable(MachOOF);
2011 if (Rpaths)
2012 printRpaths(MachOOF);
2013 if (Bind)
2014 printBindTable(MachOOF);
2015 if (LazyBind)
2016 printLazyBindTable(MachOOF);
2017 if (WeakBind)
2018 printWeakBindTable(MachOOF);
2019
2020 if (DwarfDumpType != DIDT_Null) {
2021 std::unique_ptr<DIContext> DICtx = DWARFContext::create(*MachOOF);
2022 // Dump the complete DWARF structure.
2023 DIDumpOptions DumpOpts;
2024 DumpOpts.DumpType = DwarfDumpType;
2025 DICtx->dump(outs(), DumpOpts);
2026 }
2027}
2028
2029// printUnknownCPUType() helps print_fat_headers for unknown CPU's.
2030static void printUnknownCPUType(uint32_t cputype, uint32_t cpusubtype) {
2031 outs() << " cputype (" << cputype << ")\n";
2032 outs() << " cpusubtype (" << cpusubtype << ")\n";
2033}
2034
2035// printCPUType() helps print_fat_headers by printing the cputype and
2036// pusubtype (symbolically for the one's it knows about).
2037static void printCPUType(uint32_t cputype, uint32_t cpusubtype) {
2038 switch (cputype) {
2039 case MachO::CPU_TYPE_I386:
2040 switch (cpusubtype) {
2041 case MachO::CPU_SUBTYPE_I386_ALL:
2042 outs() << " cputype CPU_TYPE_I386\n";
2043 outs() << " cpusubtype CPU_SUBTYPE_I386_ALL\n";
2044 break;
2045 default:
2046 printUnknownCPUType(cputype, cpusubtype);
2047 break;
2048 }
2049 break;
2050 case MachO::CPU_TYPE_X86_64:
2051 switch (cpusubtype) {
2052 case MachO::CPU_SUBTYPE_X86_64_ALL:
2053 outs() << " cputype CPU_TYPE_X86_64\n";
2054 outs() << " cpusubtype CPU_SUBTYPE_X86_64_ALL\n";
2055 break;
2056 case MachO::CPU_SUBTYPE_X86_64_H:
2057 outs() << " cputype CPU_TYPE_X86_64\n";
2058 outs() << " cpusubtype CPU_SUBTYPE_X86_64_H\n";
2059 break;
2060 default:
2061 printUnknownCPUType(cputype, cpusubtype);
2062 break;
2063 }
2064 break;
2065 case MachO::CPU_TYPE_ARM:
2066 switch (cpusubtype) {
2067 case MachO::CPU_SUBTYPE_ARM_ALL:
2068 outs() << " cputype CPU_TYPE_ARM\n";
2069 outs() << " cpusubtype CPU_SUBTYPE_ARM_ALL\n";
2070 break;
2071 case MachO::CPU_SUBTYPE_ARM_V4T:
2072 outs() << " cputype CPU_TYPE_ARM\n";
2073 outs() << " cpusubtype CPU_SUBTYPE_ARM_V4T\n";
2074 break;
2075 case MachO::CPU_SUBTYPE_ARM_V5TEJ:
2076 outs() << " cputype CPU_TYPE_ARM\n";
2077 outs() << " cpusubtype CPU_SUBTYPE_ARM_V5TEJ\n";
2078 break;
2079 case MachO::CPU_SUBTYPE_ARM_XSCALE:
2080 outs() << " cputype CPU_TYPE_ARM\n";
2081 outs() << " cpusubtype CPU_SUBTYPE_ARM_XSCALE\n";
2082 break;
2083 case MachO::CPU_SUBTYPE_ARM_V6:
2084 outs() << " cputype CPU_TYPE_ARM\n";
2085 outs() << " cpusubtype CPU_SUBTYPE_ARM_V6\n";
2086 break;
2087 case MachO::CPU_SUBTYPE_ARM_V6M:
2088 outs() << " cputype CPU_TYPE_ARM\n";
2089 outs() << " cpusubtype CPU_SUBTYPE_ARM_V6M\n";
2090 break;
2091 case MachO::CPU_SUBTYPE_ARM_V7:
2092 outs() << " cputype CPU_TYPE_ARM\n";
2093 outs() << " cpusubtype CPU_SUBTYPE_ARM_V7\n";
2094 break;
2095 case MachO::CPU_SUBTYPE_ARM_V7EM:
2096 outs() << " cputype CPU_TYPE_ARM\n";
2097 outs() << " cpusubtype CPU_SUBTYPE_ARM_V7EM\n";
2098 break;
2099 case MachO::CPU_SUBTYPE_ARM_V7K:
2100 outs() << " cputype CPU_TYPE_ARM\n";
2101 outs() << " cpusubtype CPU_SUBTYPE_ARM_V7K\n";
2102 break;
2103 case MachO::CPU_SUBTYPE_ARM_V7M:
2104 outs() << " cputype CPU_TYPE_ARM\n";
2105 outs() << " cpusubtype CPU_SUBTYPE_ARM_V7M\n";
2106 break;
2107 case MachO::CPU_SUBTYPE_ARM_V7S:
2108 outs() << " cputype CPU_TYPE_ARM\n";
2109 outs() << " cpusubtype CPU_SUBTYPE_ARM_V7S\n";
2110 break;
2111 default:
2112 printUnknownCPUType(cputype, cpusubtype);
2113 break;
2114 }
2115 break;
2116 case MachO::CPU_TYPE_ARM64:
2117 switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
2118 case MachO::CPU_SUBTYPE_ARM64_ALL:
2119 outs() << " cputype CPU_TYPE_ARM64\n";
2120 outs() << " cpusubtype CPU_SUBTYPE_ARM64_ALL\n";
2121 break;
2122 case MachO::CPU_SUBTYPE_ARM64_V8:
2123 outs() << " cputype CPU_TYPE_ARM64\n";
2124 outs() << " cpusubtype CPU_SUBTYPE_ARM64_V8\n";
2125 break;
2126 case MachO::CPU_SUBTYPE_ARM64E:
2127 outs() << " cputype CPU_TYPE_ARM64\n";
2128 outs() << " cpusubtype CPU_SUBTYPE_ARM64E\n";
2129 break;
2130 default:
2131 printUnknownCPUType(cputype, cpusubtype);
2132 break;
2133 }
2134 break;
2135 case MachO::CPU_TYPE_ARM64_32:
2136 switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
2137 case MachO::CPU_SUBTYPE_ARM64_32_V8:
2138 outs() << " cputype CPU_TYPE_ARM64_32\n";
2139 outs() << " cpusubtype CPU_SUBTYPE_ARM64_32_V8\n";
2140 break;
2141 default:
2142 printUnknownCPUType(cputype, cpusubtype);
2143 break;
2144 }
2145 break;
2146 default:
2147 printUnknownCPUType(cputype, cpusubtype);
2148 break;
2149 }
2150}
2151
2152static void printMachOUniversalHeaders(const object::MachOUniversalBinary *UB,
2153 bool verbose) {
2154 outs() << "Fat headers\n";
2155 if (verbose) {
2156 if (UB->getMagic() == MachO::FAT_MAGIC)
2157 outs() << "fat_magic FAT_MAGIC\n";
2158 else // UB->getMagic() == MachO::FAT_MAGIC_64
2159 outs() << "fat_magic FAT_MAGIC_64\n";
2160 } else
2161 outs() << "fat_magic " << format("0x%" PRIx32"x", MachO::FAT_MAGIC) << "\n";
2162
2163 uint32_t nfat_arch = UB->getNumberOfObjects();
2164 StringRef Buf = UB->getData();
2165 uint64_t size = Buf.size();
2166 uint64_t big_size = sizeof(struct MachO::fat_header) +
2167 nfat_arch * sizeof(struct MachO::fat_arch);
2168 outs() << "nfat_arch " << UB->getNumberOfObjects();
2169 if (nfat_arch == 0)
2170 outs() << " (malformed, contains zero architecture types)\n";
2171 else if (big_size > size)
2172 outs() << " (malformed, architectures past end of file)\n";
2173 else
2174 outs() << "\n";
2175
2176 for (uint32_t i = 0; i < nfat_arch; ++i) {
2177 MachOUniversalBinary::ObjectForArch OFA(UB, i);
2178 uint32_t cputype = OFA.getCPUType();
2179 uint32_t cpusubtype = OFA.getCPUSubType();
2180 outs() << "architecture ";
2181 for (uint32_t j = 0; i != 0 && j <= i - 1; j++) {
2182 MachOUniversalBinary::ObjectForArch other_OFA(UB, j);
2183 uint32_t other_cputype = other_OFA.getCPUType();
2184 uint32_t other_cpusubtype = other_OFA.getCPUSubType();
2185 if (cputype != 0 && cpusubtype != 0 && cputype == other_cputype &&
2186 (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) ==
2187 (other_cpusubtype & ~MachO::CPU_SUBTYPE_MASK)) {
2188 outs() << "(illegal duplicate architecture) ";
2189 break;
2190 }
2191 }
2192 if (verbose) {
2193 outs() << OFA.getArchFlagName() << "\n";
2194 printCPUType(cputype, cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
2195 } else {
2196 outs() << i << "\n";
2197 outs() << " cputype " << cputype << "\n";
2198 outs() << " cpusubtype " << (cpusubtype & ~MachO::CPU_SUBTYPE_MASK)
2199 << "\n";
2200 }
2201 if (verbose &&
2202 (cpusubtype & MachO::CPU_SUBTYPE_MASK) == MachO::CPU_SUBTYPE_LIB64)
2203 outs() << " capabilities CPU_SUBTYPE_LIB64\n";
2204 else
2205 outs() << " capabilities "
2206 << format("0x%" PRIx32"x",
2207 (cpusubtype & MachO::CPU_SUBTYPE_MASK) >> 24) << "\n";
2208 outs() << " offset " << OFA.getOffset();
2209 if (OFA.getOffset() > size)
2210 outs() << " (past end of file)";
2211 if (OFA.getOffset() % (1ull << OFA.getAlign()) != 0)
2212 outs() << " (not aligned on it's alignment (2^" << OFA.getAlign() << ")";
2213 outs() << "\n";
2214 outs() << " size " << OFA.getSize();
2215 big_size = OFA.getOffset() + OFA.getSize();
2216 if (big_size > size)
2217 outs() << " (past end of file)";
2218 outs() << "\n";
2219 outs() << " align 2^" << OFA.getAlign() << " (" << (1 << OFA.getAlign())
2220 << ")\n";
2221 }
2222}
2223
2224static void printArchiveChild(StringRef Filename, const Archive::Child &C,
2225 size_t ChildIndex, bool verbose,
2226 bool print_offset,
2227 StringRef ArchitectureName = StringRef()) {
2228 if (print_offset)
2229 outs() << C.getChildOffset() << "\t";
2230 sys::fs::perms Mode =
2231 unwrapOrError(C.getAccessMode(), getFileNameForError(C, ChildIndex),
2232 Filename, ArchitectureName);
2233 if (verbose) {
2234 // FIXME: this first dash, "-", is for (Mode & S_IFMT) == S_IFREG.
2235 // But there is nothing in sys::fs::perms for S_IFMT or S_IFREG.
2236 outs() << "-";
2237 outs() << ((Mode & sys::fs::owner_read) ? "r" : "-");
2238 outs() << ((Mode & sys::fs::owner_write) ? "w" : "-");
2239 outs() << ((Mode & sys::fs::owner_exe) ? "x" : "-");
2240 outs() << ((Mode & sys::fs::group_read) ? "r" : "-");
2241 outs() << ((Mode & sys::fs::group_write) ? "w" : "-");
2242 outs() << ((Mode & sys::fs::group_exe) ? "x" : "-");
2243 outs() << ((Mode & sys::fs::others_read) ? "r" : "-");
2244 outs() << ((Mode & sys::fs::others_write) ? "w" : "-");
2245 outs() << ((Mode & sys::fs::others_exe) ? "x" : "-");
2246 } else {
2247 outs() << format("0%o ", Mode);
2248 }
2249
2250 outs() << format("%3d/%-3d %5" PRId64"l" "d" " ",
2251 unwrapOrError(C.getUID(), getFileNameForError(C, ChildIndex),
2252 Filename, ArchitectureName),
2253 unwrapOrError(C.getGID(), getFileNameForError(C, ChildIndex),
2254 Filename, ArchitectureName),
2255 unwrapOrError(C.getRawSize(),
2256 getFileNameForError(C, ChildIndex), Filename,
2257 ArchitectureName));
2258
2259 StringRef RawLastModified = C.getRawLastModified();
2260 if (verbose) {
2261 unsigned Seconds;
2262 if (RawLastModified.getAsInteger(10, Seconds))
2263 outs() << "(date: \"" << RawLastModified
2264 << "\" contains non-decimal chars) ";
2265 else {
2266 // Since cime(3) returns a 26 character string of the form:
2267 // "Sun Sep 16 01:03:52 1973\n\0"
2268 // just print 24 characters.
2269 time_t t = Seconds;
2270 outs() << format("%.24s ", ctime(&t));
2271 }
2272 } else {
2273 outs() << RawLastModified << " ";
2274 }
2275
2276 if (verbose) {
2277 Expected<StringRef> NameOrErr = C.getName();
2278 if (!NameOrErr) {
2279 consumeError(NameOrErr.takeError());
2280 outs() << unwrapOrError(C.getRawName(),
2281 getFileNameForError(C, ChildIndex), Filename,
2282 ArchitectureName)
2283 << "\n";
2284 } else {
2285 StringRef Name = NameOrErr.get();
2286 outs() << Name << "\n";
2287 }
2288 } else {
2289 outs() << unwrapOrError(C.getRawName(), getFileNameForError(C, ChildIndex),
2290 Filename, ArchitectureName)
2291 << "\n";
2292 }
2293}
2294
2295static void printArchiveHeaders(StringRef Filename, Archive *A, bool verbose,
2296 bool print_offset,
2297 StringRef ArchitectureName = StringRef()) {
2298 Error Err = Error::success();
2299 size_t I = 0;
2300 for (const auto &C : A->children(Err, false))
2301 printArchiveChild(Filename, C, I++, verbose, print_offset,
2302 ArchitectureName);
2303
2304 if (Err)
2305 reportError(std::move(Err), Filename, "", ArchitectureName);
2306}
2307
2308static bool ValidateArchFlags() {
2309 // Check for -arch all and verifiy the -arch flags are valid.
2310 for (unsigned i = 0; i < ArchFlags.size(); ++i) {
2311 if (ArchFlags[i] == "all") {
2312 ArchAll = true;
2313 } else {
2314 if (!MachOObjectFile::isValidArch(ArchFlags[i])) {
2315 WithColor::error(errs(), "llvm-objdump")
2316 << "unknown architecture named '" + ArchFlags[i] +
2317 "'for the -arch option\n";
2318 return false;
2319 }
2320 }
2321 }
2322 return true;
2323}
2324
2325// ParseInputMachO() parses the named Mach-O file in Filename and handles the
2326// -arch flags selecting just those slices as specified by them and also parses
2327// archive files. Then for each individual Mach-O file ProcessMachO() is
2328// called to process the file based on the command line options.
2329void objdump::parseInputMachO(StringRef Filename) {
2330 if (!ValidateArchFlags())
2331 return;
2332
2333 // Attempt to open the binary.
2334 Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(Filename);
2335 if (!BinaryOrErr) {
2336 if (Error E = isNotObjectErrorInvalidFileType(BinaryOrErr.takeError()))
2337 reportError(std::move(E), Filename);
2338 else
2339 outs() << Filename << ": is not an object file\n";
2340 return;
2341 }
2342 Binary &Bin = *BinaryOrErr.get().getBinary();
2343
2344 if (Archive *A = dyn_cast<Archive>(&Bin)) {
2345 outs() << "Archive : " << Filename << "\n";
2346 if (ArchiveHeaders)
2347 printArchiveHeaders(Filename, A, Verbose, ArchiveMemberOffsets);
2348
2349 Error Err = Error::success();
2350 unsigned I = -1;
2351 for (auto &C : A->children(Err)) {
2352 ++I;
2353 Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
2354 if (!ChildOrErr) {
2355 if (Error E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
2356 reportError(std::move(E), getFileNameForError(C, I), Filename);
2357 continue;
2358 }
2359 if (MachOObjectFile *O = dyn_cast<MachOObjectFile>(&*ChildOrErr.get())) {
2360 if (!checkMachOAndArchFlags(O, Filename))
2361 return;
2362 ProcessMachO(Filename, O, O->getFileName());
2363 }
2364 }
2365 if (Err)
2366 reportError(std::move(Err), Filename);
2367 return;
2368 }
2369 if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Bin)) {
2370 parseInputMachO(UB);
2371 return;
2372 }
2373 if (ObjectFile *O = dyn_cast<ObjectFile>(&Bin)) {
2374 if (!checkMachOAndArchFlags(O, Filename))
2375 return;
2376 if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&*O))
2377 ProcessMachO(Filename, MachOOF);
2378 else
2379 WithColor::error(errs(), "llvm-objdump")
2380 << Filename << "': "
2381 << "object is not a Mach-O file type.\n";
2382 return;
2383 }
2384 llvm_unreachable("Input object can't be invalid at this point")::llvm::llvm_unreachable_internal("Input object can't be invalid at this point"
, "llvm/tools/llvm-objdump/MachODump.cpp", 2384)
;
2385}
2386
2387void objdump::parseInputMachO(MachOUniversalBinary *UB) {
2388 if (!ValidateArchFlags())
2389 return;
2390
2391 auto Filename = UB->getFileName();
2392
2393 if (UniversalHeaders)
2394 printMachOUniversalHeaders(UB, Verbose);
2395
2396 // If we have a list of architecture flags specified dump only those.
2397 if (!ArchAll && !ArchFlags.empty()) {
2398 // Look for a slice in the universal binary that matches each ArchFlag.
2399 bool ArchFound;
2400 for (unsigned i = 0; i < ArchFlags.size(); ++i) {
2401 ArchFound = false;
2402 for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
2403 E = UB->end_objects();
2404 I != E; ++I) {
2405 if (ArchFlags[i] == I->getArchFlagName()) {
2406 ArchFound = true;
2407 Expected<std::unique_ptr<ObjectFile>> ObjOrErr =
2408 I->getAsObjectFile();
2409 std::string ArchitectureName;
2410 if (ArchFlags.size() > 1)
2411 ArchitectureName = I->getArchFlagName();
2412 if (ObjOrErr) {
2413 ObjectFile &O = *ObjOrErr.get();
2414 if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&O))
2415 ProcessMachO(Filename, MachOOF, "", ArchitectureName);
2416 } else if (Error E = isNotObjectErrorInvalidFileType(
2417 ObjOrErr.takeError())) {
2418 reportError(std::move(E), "", Filename, ArchitectureName);
2419 continue;
2420 } else if (Expected<std::unique_ptr<Archive>> AOrErr =
2421 I->getAsArchive()) {
2422 std::unique_ptr<Archive> &A = *AOrErr;
2423 outs() << "Archive : " << Filename;
2424 if (!ArchitectureName.empty())
2425 outs() << " (architecture " << ArchitectureName << ")";
2426 outs() << "\n";
2427 if (ArchiveHeaders)
2428 printArchiveHeaders(Filename, A.get(), Verbose,
2429 ArchiveMemberOffsets, ArchitectureName);
2430 Error Err = Error::success();
2431 unsigned I = -1;
2432 for (auto &C : A->children(Err)) {
2433 ++I;
2434 Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
2435 if (!ChildOrErr) {
2436 if (Error E =
2437 isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
2438 reportError(std::move(E), getFileNameForError(C, I), Filename,
2439 ArchitectureName);
2440 continue;
2441 }
2442 if (MachOObjectFile *O =
2443 dyn_cast<MachOObjectFile>(&*ChildOrErr.get()))
2444 ProcessMachO(Filename, O, O->getFileName(), ArchitectureName);
2445 }
2446 if (Err)
2447 reportError(std::move(Err), Filename);
2448 } else {
2449 consumeError(AOrErr.takeError());
2450 reportError(Filename,
2451 "Mach-O universal file for architecture " +
2452 StringRef(I->getArchFlagName()) +
2453 " is not a Mach-O file or an archive file");
2454 }
2455 }
2456 }
2457 if (!ArchFound) {
2458 WithColor::error(errs(), "llvm-objdump")
2459 << "file: " + Filename + " does not contain "
2460 << "architecture: " + ArchFlags[i] + "\n";
2461 return;
2462 }
2463 }
2464 return;
2465 }
2466 // No architecture flags were specified so if this contains a slice that
2467 // matches the host architecture dump only that.
2468 if (!ArchAll) {
2469 for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
2470 E = UB->end_objects();
2471 I != E; ++I) {
2472 if (MachOObjectFile::getHostArch().getArchName() ==
2473 I->getArchFlagName()) {
2474 Expected<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile();
2475 std::string ArchiveName;
2476 ArchiveName.clear();
2477 if (ObjOrErr) {
2478 ObjectFile &O = *ObjOrErr.get();
2479 if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&O))
2480 ProcessMachO(Filename, MachOOF);
2481 } else if (Error E =
2482 isNotObjectErrorInvalidFileType(ObjOrErr.takeError())) {
2483 reportError(std::move(E), Filename);
2484 } else if (Expected<std::unique_ptr<Archive>> AOrErr =
2485 I->getAsArchive()) {
2486 std::unique_ptr<Archive> &A = *AOrErr;
2487 outs() << "Archive : " << Filename << "\n";
2488 if (ArchiveHeaders)
2489 printArchiveHeaders(Filename, A.get(), Verbose,
2490 ArchiveMemberOffsets);
2491 Error Err = Error::success();
2492 unsigned I = -1;
2493 for (auto &C : A->children(Err)) {
2494 ++I;
2495 Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
2496 if (!ChildOrErr) {
2497 if (Error E =
2498 isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
2499 reportError(std::move(E), getFileNameForError(C, I), Filename);
2500 continue;
2501 }
2502 if (MachOObjectFile *O =
2503 dyn_cast<MachOObjectFile>(&*ChildOrErr.get()))
2504 ProcessMachO(Filename, O, O->getFileName());
2505 }
2506 if (Err)
2507 reportError(std::move(Err), Filename);
2508 } else {
2509 consumeError(AOrErr.takeError());
2510 reportError(Filename, "Mach-O universal file for architecture " +
2511 StringRef(I->getArchFlagName()) +
2512 " is not a Mach-O file or an archive file");
2513 }
2514 return;
2515 }
2516 }
2517 }
2518 // Either all architectures have been specified or none have been specified
2519 // and this does not contain the host architecture so dump all the slices.
2520 bool moreThanOneArch = UB->getNumberOfObjects() > 1;
2521 for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
2522 E = UB->end_objects();
2523 I != E; ++I) {
2524 Expected<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile();
2525 std::string ArchitectureName;
2526 if (moreThanOneArch)
2527 ArchitectureName = I->getArchFlagName();
2528 if (ObjOrErr) {
2529 ObjectFile &Obj = *ObjOrErr.get();
2530 if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&Obj))
2531 ProcessMachO(Filename, MachOOF, "", ArchitectureName);
2532 } else if (Error E =
2533 isNotObjectErrorInvalidFileType(ObjOrErr.takeError())) {
2534 reportError(std::move(E), Filename, "", ArchitectureName);
2535 } else if (Expected<std::unique_ptr<Archive>> AOrErr = I->getAsArchive()) {
2536 std::unique_ptr<Archive> &A = *AOrErr;
2537 outs() << "Archive : " << Filename;
2538 if (!ArchitectureName.empty())
2539 outs() << " (architecture " << ArchitectureName << ")";
2540 outs() << "\n";
2541 if (ArchiveHeaders)
2542 printArchiveHeaders(Filename, A.get(), Verbose, ArchiveMemberOffsets,
2543 ArchitectureName);
2544 Error Err = Error::success();
2545 unsigned I = -1;
2546 for (auto &C : A->children(Err)) {
2547 ++I;
2548 Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary();
2549 if (!ChildOrErr) {
2550 if (Error E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
2551 reportError(std::move(E), getFileNameForError(C, I), Filename,
2552 ArchitectureName);
2553 continue;
2554 }
2555 if (MachOObjectFile *O =
2556 dyn_cast<MachOObjectFile>(&*ChildOrErr.get())) {
2557 if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(O))
2558 ProcessMachO(Filename, MachOOF, MachOOF->getFileName(),
2559 ArchitectureName);
2560 }
2561 }
2562 if (Err)
2563 reportError(std::move(Err), Filename);
2564 } else {
2565 consumeError(AOrErr.takeError());
2566 reportError(Filename, "Mach-O universal file for architecture " +
2567 StringRef(I->getArchFlagName()) +
2568 " is not a Mach-O file or an archive file");
2569 }
2570 }
2571}
2572
2573namespace {
2574// The block of info used by the Symbolizer call backs.
2575struct DisassembleInfo {
2576 DisassembleInfo(MachOObjectFile *O, SymbolAddressMap *AddrMap,
2577 std::vector<SectionRef> *Sections, bool verbose)
2578 : verbose(verbose), O(O), AddrMap(AddrMap), Sections(Sections) {}
2579 bool verbose;
2580 MachOObjectFile *O;
2581 SectionRef S;
2582 SymbolAddressMap *AddrMap;
2583 std::vector<SectionRef> *Sections;
2584 const char *class_name = nullptr;
2585 const char *selector_name = nullptr;
2586 std::unique_ptr<char[]> method = nullptr;
2587 char *demangled_name = nullptr;
2588 uint64_t adrp_addr = 0;
2589 uint32_t adrp_inst = 0;
2590 std::unique_ptr<SymbolAddressMap> bindtable;
2591 uint32_t depth = 0;
2592};
2593} // namespace
2594
2595// SymbolizerGetOpInfo() is the operand information call back function.
2596// This is called to get the symbolic information for operand(s) of an
2597// instruction when it is being done. This routine does this from
2598// the relocation information, symbol table, etc. That block of information
2599// is a pointer to the struct DisassembleInfo that was passed when the
2600// disassembler context was created and passed to back to here when
2601// called back by the disassembler for instruction operands that could have
2602// relocation information. The address of the instruction containing operand is
2603// at the Pc parameter. The immediate value the operand has is passed in
2604// op_info->Value and is at Offset past the start of the instruction and has a
2605// byte Size of 1, 2 or 4. The symbolc information is returned in TagBuf is the
2606// LLVMOpInfo1 struct defined in the header "llvm-c/Disassembler.h" as symbol
2607// names and addends of the symbolic expression to add for the operand. The
2608// value of TagType is currently 1 (for the LLVMOpInfo1 struct). If symbolic
2609// information is returned then this function returns 1 else it returns 0.
2610static int SymbolizerGetOpInfo(void *DisInfo, uint64_t Pc, uint64_t Offset,
2611 uint64_t Size, int TagType, void *TagBuf) {
2612 struct DisassembleInfo *info = (struct DisassembleInfo *)DisInfo;
2613 struct LLVMOpInfo1 *op_info = (struct LLVMOpInfo1 *)TagBuf;
2614 uint64_t value = op_info->Value;
2615
2616 // Make sure all fields returned are zero if we don't set them.
2617 memset((void *)op_info, '\0', sizeof(struct LLVMOpInfo1));
2618 op_info->Value = value;
2619
2620 // If the TagType is not the value 1 which it code knows about or if no
2621 // verbose symbolic information is wanted then just return 0, indicating no
2622 // information is being returned.
2623 if (TagType != 1 || !info->verbose)
1
Assuming 'TagType' is equal to 1
2
Assuming field 'verbose' is true
3
Taking false branch
2624 return 0;
2625
2626 unsigned int Arch = info->O->getArch();
2627 if (Arch == Triple::x86) {
4
Assuming 'Arch' is not equal to x86
5
Taking false branch
2628 if (Size != 1 && Size != 2 && Size != 4 && Size != 0)
2629 return 0;
2630 if (info->O->getHeader().filetype != MachO::MH_OBJECT) {
2631 // TODO:
2632 // Search the external relocation entries of a fully linked image
2633 // (if any) for an entry that matches this segment offset.
2634 // uint32_t seg_offset = (Pc + Offset);
2635 return 0;
2636 }
2637 // In MH_OBJECT filetypes search the section's relocation entries (if any)
2638 // for an entry for this section offset.
2639 uint32_t sect_addr = info->S.getAddress();
2640 uint32_t sect_offset = (Pc + Offset) - sect_addr;
2641 bool reloc_found = false;
2642 DataRefImpl Rel;
2643 MachO::any_relocation_info RE;
2644 bool isExtern = false;
2645 SymbolRef Symbol;
2646 bool r_scattered = false;
2647 uint32_t r_value, pair_r_value, r_type;
2648 for (const RelocationRef &Reloc : info->S.relocations()) {
2649 uint64_t RelocOffset = Reloc.getOffset();
2650 if (RelocOffset == sect_offset) {
2651 Rel = Reloc.getRawDataRefImpl();
2652 RE = info->O->getRelocation(Rel);
2653 r_type = info->O->getAnyRelocationType(RE);
2654 r_scattered = info->O->isRelocationScattered(RE);
2655 if (r_scattered) {
2656 r_value = info->O->getScatteredRelocationValue(RE);
2657 if (r_type == MachO::GENERIC_RELOC_SECTDIFF ||
2658 r_type == MachO::GENERIC_RELOC_LOCAL_SECTDIFF) {
2659 DataRefImpl RelNext = Rel;
2660 info->O->moveRelocationNext(RelNext);
2661 MachO::any_relocation_info RENext;
2662 RENext = info->O->getRelocation(RelNext);
2663 if (info->O->isRelocationScattered(RENext))
2664 pair_r_value = info->O->getScatteredRelocationValue(RENext);
2665 else
2666 return 0;
2667 }
2668 } else {
2669 isExtern = info->O->getPlainRelocationExternal(RE);
2670 if (isExtern) {
2671 symbol_iterator RelocSym = Reloc.getSymbol();
2672 Symbol = *RelocSym;
2673 }
2674 }
2675 reloc_found = true;
2676 break;
2677 }
2678 }
2679 if (reloc_found && isExtern) {
2680 op_info->AddSymbol.Present = 1;
2681 op_info->AddSymbol.Name =
2682 unwrapOrError(Symbol.getName(), info->O->getFileName()).data();
2683 // For i386 extern relocation entries the value in the instruction is
2684 // the offset from the symbol, and value is already set in op_info->Value.
2685 return 1;
2686 }
2687 if (reloc_found && (r_type == MachO::GENERIC_RELOC_SECTDIFF ||
2688 r_type == MachO::GENERIC_RELOC_LOCAL_SECTDIFF)) {
2689 const char *add = GuessSymbolName(r_value, info->AddrMap);
2690 const char *sub = GuessSymbolName(pair_r_value, info->AddrMap);
2691 uint32_t offset = value - (r_value - pair_r_value);
2692 op_info->AddSymbol.Present = 1;
2693 if (add != nullptr)
2694 op_info->AddSymbol.Name = add;
2695 else
2696 op_info->AddSymbol.Value = r_value;
2697 op_info->SubtractSymbol.Present = 1;
2698 if (sub != nullptr)
2699 op_info->SubtractSymbol.Name = sub;
2700 else
2701 op_info->SubtractSymbol.Value = pair_r_value;
2702 op_info->Value = offset;
2703 return 1;
2704 }
2705 return 0;
2706 }
2707 if (Arch == Triple::x86_64) {
6
Assuming 'Arch' is not equal to x86_64
7
Taking false branch
2708 if (Size != 1 && Size != 2 && Size != 4 && Size != 0)
2709 return 0;
2710 // For non MH_OBJECT types, like MH_KEXT_BUNDLE, Search the external
2711 // relocation entries of a linked image (if any) for an entry that matches
2712 // this segment offset.
2713 if (info->O->getHeader().filetype != MachO::MH_OBJECT) {
2714 uint64_t seg_offset = Pc + Offset;
2715 bool reloc_found = false;
2716 DataRefImpl Rel;
2717 MachO::any_relocation_info RE;
2718 bool isExtern = false;
2719 SymbolRef Symbol;
2720 for (const RelocationRef &Reloc : info->O->external_relocations()) {
2721 uint64_t RelocOffset = Reloc.getOffset();
2722 if (RelocOffset == seg_offset) {
2723 Rel = Reloc.getRawDataRefImpl();
2724 RE = info->O->getRelocation(Rel);
2725 // external relocation entries should always be external.
2726 isExtern = info->O->getPlainRelocationExternal(RE);
2727 if (isExtern) {
2728 symbol_iterator RelocSym = Reloc.getSymbol();
2729 Symbol = *RelocSym;
2730 }
2731 reloc_found = true;
2732 break;
2733 }
2734 }
2735 if (reloc_found && isExtern) {
2736 // The Value passed in will be adjusted by the Pc if the instruction
2737 // adds the Pc. But for x86_64 external relocation entries the Value
2738 // is the offset from the external symbol.
2739 if (info->O->getAnyRelocationPCRel(RE))
2740 op_info->Value -= Pc + Offset + Size;
2741 const char *name =
2742 unwrapOrError(Symbol.getName(), info->O->getFileName()).data();
2743 op_info->AddSymbol.Present = 1;
2744 op_info->AddSymbol.Name = name;
2745 return 1;
2746 }
2747 return 0;
2748 }
2749 // In MH_OBJECT filetypes search the section's relocation entries (if any)
2750 // for an entry for this section offset.
2751 uint64_t sect_addr = info->S.getAddress();
2752 uint64_t sect_offset = (Pc + Offset) - sect_addr;
2753 bool reloc_found = false;
2754 DataRefImpl Rel;
2755 MachO::any_relocation_info RE;
2756 bool isExtern = false;
2757 SymbolRef Symbol;
2758 for (const RelocationRef &Reloc : info->S.relocations()) {
2759 uint64_t RelocOffset = Reloc.getOffset();
2760 if (RelocOffset == sect_offset) {
2761 Rel = Reloc.getRawDataRefImpl();
2762 RE = info->O->getRelocation(Rel);
2763 // NOTE: Scattered relocations don't exist on x86_64.
2764 isExtern = info->O->getPlainRelocationExternal(RE);
2765 if (isExtern) {
2766 symbol_iterator RelocSym = Reloc.getSymbol();
2767 Symbol = *RelocSym;
2768 }
2769 reloc_found = true;
2770 break;
2771 }
2772 }
2773 if (reloc_found && isExtern) {
2774 // The Value passed in will be adjusted by the Pc if the instruction
2775 // adds the Pc. But for x86_64 external relocation entries the Value
2776 // is the offset from the external symbol.
2777 if (info->O->getAnyRelocationPCRel(RE))
2778 op_info->Value -= Pc + Offset + Size;
2779 const char *name =
2780 unwrapOrError(Symbol.getName(), info->O->getFileName()).data();
2781 unsigned Type = info->O->getAnyRelocationType(RE);
2782 if (Type == MachO::X86_64_RELOC_SUBTRACTOR) {
2783 DataRefImpl RelNext = Rel;
2784 info->O->moveRelocationNext(RelNext);
2785 MachO::any_relocation_info RENext = info->O->getRelocation(RelNext);
2786 unsigned TypeNext = info->O->getAnyRelocationType(RENext);
2787 bool isExternNext = info->O->getPlainRelocationExternal(RENext);
2788 unsigned SymbolNum = info->O->getPlainRelocationSymbolNum(RENext);
2789 if (TypeNext == MachO::X86_64_RELOC_UNSIGNED && isExternNext) {
2790 op_info->SubtractSymbol.Present = 1;
2791 op_info->SubtractSymbol.Name = name;
2792 symbol_iterator RelocSymNext = info->O->getSymbolByIndex(SymbolNum);
2793 Symbol = *RelocSymNext;
2794 name = unwrapOrError(Symbol.getName(), info->O->getFileName()).data();
2795 }
2796 }
2797 // TODO: add the VariantKinds to op_info->VariantKind for relocation types
2798 // like: X86_64_RELOC_TLV, X86_64_RELOC_GOT_LOAD and X86_64_RELOC_GOT.
2799 op_info->AddSymbol.Present = 1;
2800 op_info->AddSymbol.Name = name;
2801 return 1;
2802 }
2803 return 0;
2804 }
2805 if (Arch == Triple::arm) {
8
Assuming 'Arch' is equal to arm
2806 if (Offset != 0 || (Size != 4 && Size != 2))
9
Assuming 'Offset' is equal to 0
10
Assuming 'Size' is equal to 4
2807 return 0;
2808 if (info->O->getHeader().filetype != MachO::MH_OBJECT) {
11
Assuming field 'filetype' is equal to MH_OBJECT
12
Taking false branch
2809 // TODO:
2810 // Search the external relocation entries of a fully linked image
2811 // (if any) for an entry that matches this segment offset.
2812 // uint32_t seg_offset = (Pc + Offset);
2813 return 0;
2814 }
2815 // In MH_OBJECT filetypes search the section's relocation entries (if any)
2816 // for an entry for this section offset.
2817 uint32_t sect_addr = info->S.getAddress();
2818 uint32_t sect_offset = (Pc + Offset) - sect_addr;
2819 DataRefImpl Rel;
2820 MachO::any_relocation_info RE;
2821 bool isExtern = false;
2822 SymbolRef Symbol;
2823 bool r_scattered = false;
2824 uint32_t r_value, pair_r_value, r_type, r_length, other_half;
13
'r_value' declared without an initial value
2825 auto Reloc =
2826 find_if(info->S.relocations(), [&](const RelocationRef &Reloc) {
2827 uint64_t RelocOffset = Reloc.getOffset();
2828 return RelocOffset == sect_offset;
2829 });
2830
2831 if (Reloc == info->S.relocations().end())
14
Assuming the condition is false
15
Taking false branch
2832 return 0;
2833
2834 Rel = Reloc->getRawDataRefImpl();
2835 RE = info->O->getRelocation(Rel);
2836 r_length = info->O->getAnyRelocationLength(RE);
2837 r_scattered = info->O->isRelocationScattered(RE);
2838 if (r_scattered) {
16
Assuming 'r_scattered' is false
17
Taking false branch
2839 r_value = info->O->getScatteredRelocationValue(RE);
2840 r_type = info->O->getScatteredRelocationType(RE);
2841 } else {
2842 r_type = info->O->getAnyRelocationType(RE);
2843 isExtern = info->O->getPlainRelocationExternal(RE);
2844 if (isExtern) {
18
Assuming 'isExtern' is false
2845 symbol_iterator RelocSym = Reloc->getSymbol();
2846 Symbol = *RelocSym;
2847 }
2848 }
2849 if (r_type == MachO::ARM_RELOC_HALF ||
19
Assuming 'r_type' is not equal to ARM_RELOC_HALF
23
Taking true branch
2850 r_type == MachO::ARM_RELOC_SECTDIFF ||
20
Assuming 'r_type' is not equal to ARM_RELOC_SECTDIFF
2851 r_type == MachO::ARM_RELOC_LOCAL_SECTDIFF ||
21
Assuming 'r_type' is not equal to ARM_RELOC_LOCAL_SECTDIFF
2852 r_type == MachO::ARM_RELOC_HALF_SECTDIFF) {
22
Assuming 'r_type' is equal to ARM_RELOC_HALF_SECTDIFF
2853 DataRefImpl RelNext = Rel;
2854 info->O->moveRelocationNext(RelNext);
2855 MachO::any_relocation_info RENext;
2856 RENext = info->O->getRelocation(RelNext);
2857 other_half = info->O->getAnyRelocationAddress(RENext) & 0xffff;
2858 if (info->O->isRelocationScattered(RENext))
24
Assuming the condition is false
25
Taking false branch
2859 pair_r_value = info->O->getScatteredRelocationValue(RENext);
2860 }
2861
2862 if (isExtern
25.1
'isExtern' is false
) {
2863 const char *name =
2864 unwrapOrError(Symbol.getName(), info->O->getFileName()).data();
2865 op_info->AddSymbol.Present = 1;
2866 op_info->AddSymbol.Name = name;
2867 switch (r_type) {
2868 case MachO::ARM_RELOC_HALF:
2869 if ((r_length & 0x1) == 1) {
2870 op_info->Value = value << 16 | other_half;
2871 op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_HI161;
2872 } else {
2873 op_info->Value = other_half << 16 | value;
2874 op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_LO162;
2875 }
2876 break;
2877 default:
2878 break;
2879 }
2880 return 1;
2881 }
2882 // If we have a branch that is not an external relocation entry then
2883 // return 0 so the code in tryAddingSymbolicOperand() can use the
2884 // SymbolLookUp call back with the branch target address to look up the
2885 // symbol and possibility add an annotation for a symbol stub.
2886 if (isExtern
25.2
'isExtern' is equal to 0
== 0 && (r_type
25.3
'r_type' is not equal to ARM_RELOC_BR24
== MachO::ARM_RELOC_BR24 ||
26
Taking false branch
2887 r_type
25.4
'r_type' is not equal to ARM_THUMB_RELOC_BR22
== MachO::ARM_THUMB_RELOC_BR22))
2888 return 0;
2889
2890 uint32_t offset = 0;
2891 if (r_type
26.1
'r_type' is not equal to ARM_RELOC_HALF
== MachO::ARM_RELOC_HALF ||
27
Taking true branch
2892 r_type
26.2
'r_type' is equal to ARM_RELOC_HALF_SECTDIFF
== MachO::ARM_RELOC_HALF_SECTDIFF) {
2893 if ((r_length & 0x1) == 1)
28
Assuming the condition is false
29
Taking false branch
2894 value = value << 16 | other_half;
2895 else
2896 value = other_half << 16 | value;
2897 }
2898 if (r_scattered
29.1
'r_scattered' is false
&& (r_type != MachO::ARM_RELOC_HALF &&
2899 r_type != MachO::ARM_RELOC_HALF_SECTDIFF)) {
2900 offset = value - r_value;
2901 value = r_value;
2902 }
2903
2904 if (r_type
29.2
'r_type' is equal to ARM_RELOC_HALF_SECTDIFF
== MachO::ARM_RELOC_HALF_SECTDIFF) {
30
Taking true branch
2905 if ((r_length & 0x1) == 1)
31
Taking false branch
2906 op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_HI161;
2907 else
2908 op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_LO162;
2909 const char *add = GuessSymbolName(r_value, info->AddrMap);
32
1st function call argument is an uninitialized value
2910 const char *sub = GuessSymbolName(pair_r_value, info->AddrMap);
2911 int32_t offset = value - (r_value - pair_r_value);
2912 op_info->AddSymbol.Present = 1;
2913 if (add != nullptr)
2914 op_info->AddSymbol.Name = add;
2915 else
2916 op_info->AddSymbol.Value = r_value;
2917 op_info->SubtractSymbol.Present = 1;
2918 if (sub != nullptr)
2919 op_info->SubtractSymbol.Name = sub;
2920 else
2921 op_info->SubtractSymbol.Value = pair_r_value;
2922 op_info->Value = offset;
2923 return 1;
2924 }
2925
2926 op_info->AddSymbol.Present = 1;
2927 op_info->Value = offset;
2928 if (r_type == MachO::ARM_RELOC_HALF) {
2929 if ((r_length & 0x1) == 1)
2930 op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_HI161;
2931 else
2932 op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_LO162;
2933 }
2934 const char *add = GuessSymbolName(value, info->AddrMap);
2935 if (add != nullptr) {
2936 op_info->AddSymbol.Name = add;
2937 return 1;
2938 }
2939 op_info->AddSymbol.Value = value;
2940 return 1;
2941 }
2942 if (Arch == Triple::aarch64) {
2943 if (Offset != 0 || Size != 4)
2944 return 0;
2945 if (info->O->getHeader().filetype != MachO::MH_OBJECT) {
2946 // TODO:
2947 // Search the external relocation entries of a fully linked image
2948 // (if any) for an entry that matches this segment offset.
2949 // uint64_t seg_offset = (Pc + Offset);
2950 return 0;
2951 }
2952 // In MH_OBJECT filetypes search the section's relocation entries (if any)
2953 // for an entry for this section offset.
2954 uint64_t sect_addr = info->S.getAddress();
2955 uint64_t sect_offset = (Pc + Offset) - sect_addr;
2956 auto Reloc =
2957 find_if(info->S.relocations(), [&](const RelocationRef &Reloc) {
2958 uint64_t RelocOffset = Reloc.getOffset();
2959 return RelocOffset == sect_offset;
2960 });
2961
2962 if (Reloc == info->S.relocations().end())
2963 return 0;
2964
2965 DataRefImpl Rel = Reloc->getRawDataRefImpl();
2966 MachO::any_relocation_info RE = info->O->getRelocation(Rel);
2967 uint32_t r_type = info->O->getAnyRelocationType(RE);
2968 if (r_type == MachO::ARM64_RELOC_ADDEND) {
2969 DataRefImpl RelNext = Rel;
2970 info->O->moveRelocationNext(RelNext);
2971 MachO::any_relocation_info RENext = info->O->getRelocation(RelNext);
2972 if (value == 0) {
2973 value = info->O->getPlainRelocationSymbolNum(RENext);
2974 op_info->Value = value;
2975 }
2976 }
2977 // NOTE: Scattered relocations don't exist on arm64.
2978 if (!info->O->getPlainRelocationExternal(RE))
2979 return 0;
2980 const char *name =
2981 unwrapOrError(Reloc->getSymbol()->getName(), info->O->getFileName())
2982 .data();
2983 op_info->AddSymbol.Present = 1;
2984 op_info->AddSymbol.Name = name;
2985
2986 switch (r_type) {
2987 case MachO::ARM64_RELOC_PAGE21:
2988 /* @page */
2989 op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_PAGE1;
2990 break;
2991 case MachO::ARM64_RELOC_PAGEOFF12:
2992 /* @pageoff */
2993 op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_PAGEOFF2;
2994 break;
2995 case MachO::ARM64_RELOC_GOT_LOAD_PAGE21:
2996 /* @gotpage */
2997 op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_GOTPAGE3;
2998 break;
2999 case MachO::ARM64_RELOC_GOT_LOAD_PAGEOFF12:
3000 /* @gotpageoff */
3001 op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_GOTPAGEOFF4;
3002 break;
3003 case MachO::ARM64_RELOC_TLVP_LOAD_PAGE21:
3004 /* @tvlppage is not implemented in llvm-mc */
3005 op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_TLVP5;
3006 break;
3007 case MachO::ARM64_RELOC_TLVP_LOAD_PAGEOFF12:
3008 /* @tvlppageoff is not implemented in llvm-mc */
3009 op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_TLVOFF6;
3010 break;
3011 default:
3012 case MachO::ARM64_RELOC_BRANCH26:
3013 op_info->VariantKind = LLVMDisassembler_VariantKind_None0;
3014 break;
3015 }
3016 return 1;
3017 }
3018 return 0;
3019}
3020
3021// GuessCstringPointer is passed the address of what might be a pointer to a
3022// literal string in a cstring section. If that address is in a cstring section
3023// it returns a pointer to that string. Else it returns nullptr.
3024static const char *GuessCstringPointer(uint64_t ReferenceValue,
3025 struct DisassembleInfo *info) {
3026 for (const auto &Load : info->O->load_commands()) {
3027 if (Load.C.cmd == MachO::LC_SEGMENT_64) {
3028 MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load);
3029 for (unsigned J = 0; J < Seg.nsects; ++J) {
3030 MachO::section_64 Sec = info->O->getSection64(Load, J);
3031 uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
3032 if (section_type == MachO::S_CSTRING_LITERALS &&
3033 ReferenceValue >= Sec.addr &&
3034 ReferenceValue < Sec.addr + Sec.size) {
3035 uint64_t sect_offset = ReferenceValue - Sec.addr;
3036 uint64_t object_offset = Sec.offset + sect_offset;
3037 StringRef MachOContents = info->O->getData();
3038 uint64_t object_size = MachOContents.size();
3039 const char *object_addr = (const char *)MachOContents.data();
3040 if (object_offset < object_size) {
3041 const char *name = object_addr + object_offset;
3042 return name;
3043 } else {
3044 return nullptr;
3045 }
3046 }
3047 }
3048 } else if (Load.C.cmd == MachO::LC_SEGMENT) {
3049 MachO::segment_command Seg = info->O->getSegmentLoadCommand(Load);
3050 for (unsigned J = 0; J < Seg.nsects; ++J) {
3051 MachO::section Sec = info->O->getSection(Load, J);
3052 uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
3053 if (section_type == MachO::S_CSTRING_LITERALS &&
3054 ReferenceValue >= Sec.addr &&
3055 ReferenceValue < Sec.addr + Sec.size) {
3056 uint64_t sect_offset = ReferenceValue - Sec.addr;
3057 uint64_t object_offset = Sec.offset + sect_offset;
3058 StringRef MachOContents = info->O->getData();
3059 uint64_t object_size = MachOContents.size();
3060 const char *object_addr = (const char *)MachOContents.data();
3061 if (object_offset < object_size) {
3062 const char *name = object_addr + object_offset;
3063 return name;
3064 } else {
3065 return nullptr;
3066 }
3067 }
3068 }
3069 }
3070 }
3071 return nullptr;
3072}
3073
3074// GuessIndirectSymbol returns the name of the indirect symbol for the
3075// ReferenceValue passed in or nullptr. This is used when ReferenceValue maybe
3076// an address of a symbol stub or a lazy or non-lazy pointer to associate the
3077// symbol name being referenced by the stub or pointer.
3078static const char *GuessIndirectSymbol(uint64_t ReferenceValue,
3079 struct DisassembleInfo *info) {
3080 MachO::dysymtab_command Dysymtab = info->O->getDysymtabLoadCommand();
3081 MachO::symtab_command Symtab = info->O->getSymtabLoadCommand();
3082 for (const auto &Load : info->O->load_commands()) {
3083 if (Load.C.cmd == MachO::LC_SEGMENT_64) {
3084 MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load);
3085 for (unsigned J = 0; J < Seg.nsects; ++J) {
3086 MachO::section_64 Sec = info->O->getSection64(Load, J);
3087 uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
3088 if ((section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
3089 section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
3090 section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
3091 section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS ||
3092 section_type == MachO::S_SYMBOL_STUBS) &&
3093 ReferenceValue >= Sec.addr &&
3094 ReferenceValue < Sec.addr + Sec.size) {
3095 uint32_t stride;
3096 if (section_type == MachO::S_SYMBOL_STUBS)
3097 stride = Sec.reserved2;
3098 else
3099 stride = 8;
3100 if (stride == 0)
3101 return nullptr;
3102 uint32_t index = Sec.reserved1 + (ReferenceValue - Sec.addr) / stride;
3103 if (index < Dysymtab.nindirectsyms) {
3104 uint32_t indirect_symbol =
3105 info->O->getIndirectSymbolTableEntry(Dysymtab, index);
3106 if (indirect_symbol < Symtab.nsyms) {
3107 symbol_iterator Sym = info->O->getSymbolByIndex(indirect_symbol);
3108 return unwrapOrError(Sym->getName(), info->O->getFileName())
3109 .data();
3110 }
3111 }
3112 }
3113 }
3114 } else if (Load.C.cmd == MachO::LC_SEGMENT) {
3115 MachO::segment_command Seg = info->O->getSegmentLoadCommand(Load);
3116 for (unsigned J = 0; J < Seg.nsects; ++J) {
3117 MachO::section Sec = info->O->getSection(Load, J);
3118 uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
3119 if ((section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
3120 section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
3121 section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
3122 section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS ||
3123 section_type == MachO::S_SYMBOL_STUBS) &&
3124 ReferenceValue >= Sec.addr &&
3125 ReferenceValue < Sec.addr + Sec.size) {
3126 uint32_t stride;
3127 if (section_type == MachO::S_SYMBOL_STUBS)
3128 stride = Sec.reserved2;
3129 else
3130 stride = 4;
3131 if (stride == 0)
3132 return nullptr;
3133 uint32_t index = Sec.reserved1 + (ReferenceValue - Sec.addr) / stride;
3134 if (index < Dysymtab.nindirectsyms) {
3135 uint32_t indirect_symbol =
3136 info->O->getIndirectSymbolTableEntry(Dysymtab, index);
3137 if (indirect_symbol < Symtab.nsyms) {
3138 symbol_iterator Sym = info->O->getSymbolByIndex(indirect_symbol);
3139 return unwrapOrError(Sym->getName(), info->O->getFileName())
3140 .data();
3141 }
3142 }
3143 }
3144 }
3145 }
3146 }
3147 return nullptr;
3148}
3149
3150// method_reference() is called passing it the ReferenceName that might be
3151// a reference it to an Objective-C method call. If so then it allocates and
3152// assembles a method call string with the values last seen and saved in
3153// the DisassembleInfo's class_name and selector_name fields. This is saved
3154// into the method field of the info and any previous string is free'ed.
3155// Then the class_name field in the info is set to nullptr. The method call
3156// string is set into ReferenceName and ReferenceType is set to
3157// LLVMDisassembler_ReferenceType_Out_Objc_Message. If this not a method call
3158// then both ReferenceType and ReferenceName are left unchanged.
3159static void method_reference(struct DisassembleInfo *info,
3160 uint64_t *ReferenceType,
3161 const char **ReferenceName) {
3162 unsigned int Arch = info->O->getArch();
3163 if (*ReferenceName != nullptr) {
3164 if (strcmp(*ReferenceName, "_objc_msgSend") == 0) {
3165 if (info->selector_name != nullptr) {
3166 if (info->class_name != nullptr) {
3167 info->method = std::make_unique<char[]>(
3168 5 + strlen(info->class_name) + strlen(info->selector_name));
3169 char *method = info->method.get();
3170 if (method != nullptr) {
3171 strcpy(method, "+[");
3172 strcat(method, info->class_name);
3173 strcat(method, " ");
3174 strcat(method, info->selector_name);
3175 strcat(method, "]");
3176 *ReferenceName = method;
3177 *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message5;
3178 }
3179 } else {
3180 info->method =
3181 std::make_unique<char[]>(9 + strlen(info->selector_name));
3182 char *method = info->method.get();
3183 if (method != nullptr) {
3184 if (Arch == Triple::x86_64)
3185 strcpy(method, "-[%rdi ");
3186 else if (Arch == Triple::aarch64)
3187 strcpy(method, "-[x0 ");
3188 else
3189 strcpy(method, "-[r? ");
3190 strcat(method, info->selector_name);
3191 strcat(method, "]");
3192 *ReferenceName = method;
3193 *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message5;
3194 }
3195 }
3196 info->class_name = nullptr;
3197 }
3198 } else if (strcmp(*ReferenceName, "_objc_msgSendSuper2") == 0) {
3199 if (info->selector_name != nullptr) {
3200 info->method =
3201 std::make_unique<char[]>(17 + strlen(info->selector_name));
3202 char *method = info->method.get();
3203 if (method != nullptr) {
3204 if (Arch == Triple::x86_64)
3205 strcpy(method, "-[[%rdi super] ");
3206 else if (Arch == Triple::aarch64)
3207 strcpy(method, "-[[x0 super] ");
3208 else
3209 strcpy(method, "-[[r? super] ");
3210 strcat(method, info->selector_name);
3211 strcat(method, "]");
3212 *ReferenceName = method;
3213 *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message5;
3214 }
3215 info->class_name = nullptr;
3216 }
3217 }
3218 }
3219}
3220
3221// GuessPointerPointer() is passed the address of what might be a pointer to
3222// a reference to an Objective-C class, selector, message ref or cfstring.
3223// If so the value of the pointer is returned and one of the booleans are set
3224// to true. If not zero is returned and all the booleans are set to false.
3225static uint64_t GuessPointerPointer(uint64_t ReferenceValue,
3226 struct DisassembleInfo *info,
3227 bool &classref, bool &selref, bool &msgref,
3228 bool &cfstring) {
3229 classref = false;
3230 selref = false;
3231 msgref = false;
3232 cfstring = false;
3233 for (const auto &Load : info->O->load_commands()) {
3234 if (Load.C.cmd == MachO::LC_SEGMENT_64) {
3235 MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load);
3236 for (unsigned J = 0; J < Seg.nsects; ++J) {
3237 MachO::section_64 Sec = info->O->getSection64(Load, J);
3238 if ((strncmp(Sec.sectname, "__objc_selrefs", 16) == 0 ||
3239 strncmp(Sec.sectname, "__objc_classrefs", 16) == 0 ||
3240 strncmp(Sec.sectname, "__objc_superrefs", 16) == 0 ||
3241 strncmp(Sec.sectname, "__objc_msgrefs", 16) == 0 ||
3242 strncmp(Sec.sectname, "__cfstring", 16) == 0) &&
3243 ReferenceValue >= Sec.addr &&
3244 ReferenceValue < Sec.addr + Sec.size) {
3245 uint64_t sect_offset = ReferenceValue - Sec.addr;
3246 uint64_t object_offset = Sec.offset + sect_offset;
3247 StringRef MachOContents = info->O->getData();
3248 uint64_t object_size = MachOContents.size();
3249 const char *object_addr = (const char *)MachOContents.data();
3250 if (object_offset < object_size) {
3251 uint64_t pointer_value;
3252 memcpy(&pointer_value, object_addr + object_offset,
3253 sizeof(uint64_t));
3254 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3255 sys::swapByteOrder(pointer_value);
3256 if (strncmp(Sec.sectname, "__objc_selrefs", 16) == 0)
3257 selref = true;
3258 else if (strncmp(Sec.sectname, "__objc_classrefs", 16) == 0 ||
3259 strncmp(Sec.sectname, "__objc_superrefs", 16) == 0)
3260 classref = true;
3261 else if (strncmp(Sec.sectname, "__objc_msgrefs", 16) == 0 &&
3262 ReferenceValue + 8 < Sec.addr + Sec.size) {
3263 msgref = true;
3264 memcpy(&pointer_value, object_addr + object_offset + 8,
3265 sizeof(uint64_t));
3266 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
3267 sys::swapByteOrder(pointer_value);
3268 } else if (strncmp(Sec.sectname, "__cfstring", 16) == 0)
3269 cfstring = true;
3270 return pointer_value;
3271 } else {
3272 return 0;
3273 }
3274 }
3275 }
3276 }
3277 // TODO: Look for LC_SEGMENT for 32-bit Mach-O files.
3278 }
3279 return 0;
3280}
3281
3282// get_pointer_64 returns a pointer to the bytes in the object file at the
3283// Address from a section in the Mach-O file. And indirectly returns the
3284// offset into the section, number of bytes left in the section past the offset
3285// and which section is was being referenced. If the Address is not in a
3286// section nullptr is returned.
3287static const char *get_pointer_64(uint64_t Address, uint32_t &offset,
3288 uint32_t &left, SectionRef &S,
3289 DisassembleInfo *info,
3290 bool objc_only = false) {
3291 offset = 0;
3292 left = 0;
3293 S = SectionRef();
3294 for (unsigned SectIdx = 0; SectIdx != info->Sections->size(); SectIdx++) {
3295 uint64_t SectAddress = ((*(info->Sections))[SectIdx]).getAddress();
3296 uint64_t SectSize = ((*(info->Sections))[SectIdx]).getSize();
3297 if (SectSize == 0)
3298 continue;
3299 if (objc_only) {
3300 StringRef SectName;
3301 Expected<StringRef> SecNameOrErr =
3302 ((*(info->Sections))[SectIdx]).getName();
3303 if (SecNameOrErr)
3304 SectName = *SecNameOrErr;
3305 else
3306 consumeError(SecNameOrErr.takeError());
3307
3308 DataRefImpl Ref = ((*(info->Sections))[SectIdx]).getRawDataRefImpl();
3309 StringRef SegName = info->O->getSectionFinalSegmentName(Ref);
3310 if (SegName != "__OBJC" && SectName != "__cstring")
3311 continue;
3312 }
3313 if (Address >= SectAddress && Address < SectAddress + SectSize) {
3314 S = (*(info->Sections))[SectIdx];
3315 offset = Address - SectAddress;
3316 left = SectSize - offset;
3317 StringRef SectContents = unwrapOrError(
3318 ((*(info->Sections))[SectIdx]).getContents(), info->O->getFileName());
3319 return SectContents.data() + offset;
3320 }
3321 }
3322 return nullptr;
3323}
3324
3325static const char *get_pointer_32(uint32_t Address, uint32_t &offset,
3326 uint32_t &left, SectionRef &S,
3327 DisassembleInfo *info,
3328 bool objc_only = false) {
3329 return get_pointer_64(Address, offset, left, S, info, objc_only);
3330}
3331
3332// get_symbol_64() returns the name of a symbol (or nullptr) and the address of
3333// the symbol indirectly through n_value. Based on the relocation information
3334// for the specified section offset in the specified section reference.
3335// If no relocation information is found and a non-zero ReferenceValue for the
3336// symbol is passed, look up that address in the info's AddrMap.
3337static const char *get_symbol_64(uint32_t sect_offset, SectionRef S,
3338 DisassembleInfo *info, uint64_t &n_value,
3339 uint64_t ReferenceValue = 0) {
3340 n_value = 0;
3341 if (!info->verbose)
3342 return nullptr;
3343
3344 // See if there is an external relocation entry at the sect_offset.
3345 bool reloc_found = false;
3346 DataRefImpl Rel;
3347 MachO::any_relocation_info RE;
3348 bool isExtern = false;
3349 SymbolRef Symbol;
3350 for (const RelocationRef &Reloc : S.relocations()) {
3351 uint64_t RelocOffset = Reloc.getOffset();
3352 if (RelocOffset == sect_offset) {
3353 Rel = Reloc.getRawDataRefImpl();
3354 RE = info->O->getRelocation(Rel);
3355 if (info->O->isRelocationScattered(RE))
3356 continue;
3357 isExtern = info->O->getPlainRelocationExternal(RE);
3358 if (isExtern) {
3359 symbol_iterator RelocSym = Reloc.getSymbol();
3360 Symbol = *RelocSym;
3361 }
3362 reloc_found = true;
3363 break;
3364 }
3365 }
3366 // If there is an external relocation entry for a symbol in this section
3367 // at this section_offset then use that symbol's value for the n_value
3368 // and return its name.
3369 const char *SymbolName = nullptr;
3370 if (reloc_found && isExtern) {
3371 n_value = cantFail(Symbol.getValue());
3372 StringRef Name = unwrapOrError(Symbol.getName(), info->O->getFileName());
3373 if (!Name.empty()) {
3374 SymbolName = Name.data();
3375 return SymbolName;
3376 }
3377 }
3378
3379 // TODO: For fully linked images, look through the external relocation
3380 // entries off the dynamic symtab command. For these the r_offset is from the
3381 // start of the first writeable segment in the Mach-O file. So the offset
3382 // to this section from that segment is passed to this routine by the caller,
3383 // as the database_offset. Which is the difference of the section's starting
3384 // address and the first writable segment.
3385 //
3386 // NOTE: need add passing the database_offset to this routine.
3387
3388 // We did not find an external relocation entry so look up the ReferenceValue
3389 // as an address of a symbol and if found return that symbol's name.
3390 SymbolName = GuessSymbolName(ReferenceValue, info->AddrMap);
3391
3392 return SymbolName;
3393}
3394
3395static const char *get_symbol_32(uint32_t sect_offset, SectionRef S,
3396 DisassembleInfo *info,
3397 uint32_t ReferenceValue) {
3398 uint64_t n_value64;
3399 return get_symbol_64(sect_offset, S, info, n_value64, ReferenceValue);
3400}
3401
3402namespace {
3403
3404// These are structs in the Objective-C meta data and read to produce the
3405// comments for disassembly. While these are part of the ABI they are no
3406// public defintions. So the are here not in include/llvm/BinaryFormat/MachO.h
3407// .
3408
3409// The cfstring object in a 64-bit Mach-O file.
3410struct cfstring64_t {
3411 uint64_t isa; // class64_t * (64-bit pointer)
3412 uint64_t flags; // flag bits
3413 uint64_t characters; // char * (64-bit pointer)
3414 uint64_t length; // number of non-NULL characters in above
3415};
3416
3417// The class object in a 64-bit Mach-O file.
3418struct class64_t {
3419 uint64_t isa; // class64_t * (64-bit pointer)
3420 uint64_t superclass; // class64_t * (64-bit pointer)
3421 uint64_t cache; // Cache (64-bit pointer)
3422 uint64_t vtable; // IMP * (64-bit pointer)
3423 uint64_t data; // class_ro64_t * (64-bit pointer)
3424};
3425
3426struct class32_t {
3427 uint32_t isa; /* class32_t * (32-bit pointer) */
3428 uint32_t superclass; /* class32_t * (32-bit pointer) */
3429 uint32_t cache; /* Cache (32-bit pointer) */
3430 uint32_t vtable; /* IMP * (32-bit pointer) */
3431 uint32_t data; /* class_ro32_t * (32-bit pointer) */
3432};
3433
3434struct class_ro64_t {
3435 uint32_t flags;
3436 uint32_t instanceStart;
3437 uint32_t instanceSize;
3438 uint32_t reserved;
3439 uint64_t ivarLayout; // const uint8_t * (64-bit pointer)
3440 uint64_t name; // const char * (64-bit pointer)
3441 uint64_t baseMethods; // const method_list_t * (64-bit pointer)
3442 uint64_t baseProtocols; // const protocol_list_t * (64-bit pointer)
3443 uint64_t ivars; // const ivar_list_t * (64-bit pointer)
3444 uint64_t weakIvarLayout; // const uint8_t * (64-bit pointer)
3445 uint64_t baseProperties; // const struct objc_property_list (64-bit pointer)
3446};
3447
3448struct class_ro32_t {
3449 uint32_t flags;
3450 uint32_t instanceStart;
3451 uint32_t instanceSize;
3452 uint32_t ivarLayout; /* const uint8_t * (32-bit pointer) */
3453 uint32_t name; /* const char * (32-bit pointer) */
3454 uint32_t baseMethods; /* const method_list_t * (32-bit pointer) */
3455 uint32_t baseProtocols; /* const protocol_list_t * (32-bit pointer) */
3456 uint32_t ivars; /* const ivar_list_t * (32-bit pointer) */
3457 uint32_t weakIvarLayout; /* const uint8_t * (32-bit pointer) */
3458 uint32_t baseProperties; /* const struct objc_property_list *
3459 (32-bit pointer) */
3460};
3461
3462/* Values for class_ro{64,32}_t->flags */
3463#define RO_META(1 << 0) (1 << 0)
3464#define RO_ROOT(1 << 1) (1 << 1)
3465#define RO_HAS_CXX_STRUCTORS(1 << 2) (1 << 2)
3466
3467struct method_list64_t {
3468 uint32_t entsize;
3469 uint32_t count;
3470 /* struct method64_t first; These structures follow inline */
3471};
3472
3473struct method_list32_t {
3474 uint32_t entsize;
3475 uint32_t count;
3476 /* struct method32_t first; These structures follow inline */
3477};
3478
3479struct method64_t {
3480 uint64_t name; /* SEL (64-bit pointer) */
3481 uint64_t types; /* const char * (64-bit pointer) */
3482 uint64_t imp; /* IMP (64-bit pointer) */
3483};
3484
3485struct method32_t {
3486 uint32_t name; /* SEL (32-bit pointer) */
3487 uint32_t types; /* const char * (32-bit pointer) */
3488 uint32_t imp; /* IMP (32-bit pointer) */
3489};
3490
3491struct protocol_list64_t {
3492 uint64_t count; /* uintptr_t (a 64-bit value) */
3493 /* struct protocol64_t * list[0]; These pointers follow inline */
3494};
3495
3496struct protocol_list32_t {
3497 uint32_t count; /* uintptr_t (a 32-bit value) */
3498 /* struct protocol32_t * list[0]; These pointers follow inline */
3499};
3500
3501struct protocol64_t {
3502 uint64_t isa; /* id * (64-bit pointer) */
3503 uint64_t name; /* const char * (64-bit pointer) */
3504 uint64_t protocols; /* struct protocol_list64_t *
3505 (64-bit pointer) */
3506 uint64_t instanceMethods; /* method_list_t * (64-bit pointer) */
3507 uint64_t classMethods; /* method_list_t * (64-bit pointer) */
3508 uint64_t optionalInstanceMethods; /* method_list_t * (64-bit pointer) */
3509 uint64_t optionalClassMethods; /* method_list_t * (64-bit pointer) */
3510 uint64_t instanceProperties; /* struct objc_property_list *
3511 (64-bit pointer) */
3512};
3513
3514struct protocol32_t {
3515 uint32_t isa; /* id * (32-bit pointer) */
3516 uint32_t name; /* const char * (32-bit pointer) */
3517 uint32_t protocols; /* struct protocol_list_t *
3518 (32-bit pointer) */
3519 uint32_t instanceMethods; /* method_list_t * (32-bit pointer) */
3520 uint32_t classMethods; /* method_list_t * (32-bit pointer) */
3521 uint32_t optionalInstanceMethods; /* method_list_t * (32-bit pointer) */
3522 uint32_t optionalClassMethods; /* method_list_t * (32-bit pointer) */
3523 uint32_t instanceProperties; /* struct objc_property_list *
3524 (32-bit pointer) */
3525};
3526
3527struct ivar_list64_t {
3528 uint32_t entsize;
3529 uint32_t count;
3530 /* struct ivar64_t first; These structures follow inline */
3531};
3532
3533struct ivar_list32_t {
3534 uint32_t entsize;
3535 uint32_t count;
3536 /* struct ivar32_t first; These structures follow inline */
3537};
3538
3539struct ivar64_t {
3540 uint64_t offset; /* uintptr_t * (64-bit pointer) */
3541 uint64_t name; /* const char * (64-bit pointer) */
3542 uint64_t type; /* const char * (64-bit pointer) */
3543 uint32_t alignment;
3544 uint32_t size;
3545};
3546
3547struct ivar32_t {
3548 uint32_t offset; /* uintptr_t * (32-bit pointer) */
3549 uint32_t name; /* const char * (32-bit pointer) */
3550 uint32_t type; /* const char * (32-bit pointer) */
3551 uint32_t alignment;
3552 uint32_t size;
3553};
3554
3555struct objc_property_list64 {
3556 uint32_t entsize;
3557 uint32_t count;
3558 /* struct objc_property64 first; These structures follow inline */
3559};
3560
3561struct objc_property_list32 {
3562 uint32_t entsize;
3563 uint32_t count;
3564 /* struct objc_property32 first; These structures follow inline */
3565};
3566
3567struct objc_property64 {
3568 uint64_t name; /* const char * (64-bit pointer) */
3569 uint64_t attributes; /* const char * (64-bit pointer) */
3570};
3571
3572struct objc_property32 {
3573 uint32_t name; /* const char * (32-bit pointer) */
3574 uint32_t attributes; /* const char * (32-bit pointer) */
3575};
3576
3577struct category64_t {
3578 uint64_t name; /* const char * (64-bit pointer) */
3579 uint64_t cls; /* struct class_t * (64-bit pointer) */
3580 uint64_t instanceMethods; /* struct method_list_t * (64-bit pointer) */
3581 uint64_t classMethods; /* struct method_list_t * (64-bit pointer) */
3582 uint64_t protocols; /* struct protocol_list_t * (64-bit pointer) */
3583 uint64_t instanceProperties; /* struct objc_property_list *
3584 (64-bit pointer) */
3585};
3586
3587struct category32_t {
3588 uint32_t name; /* const char * (32-bit pointer) */
3589 uint32_t cls; /* struct class_t * (32-bit pointer) */
3590 uint32_t instanceMethods; /* struct method_list_t * (32-bit pointer) */
3591 uint32_t classMethods; /* struct method_list_t * (32-bit pointer) */
3592 uint32_t protocols; /* struct protocol_list_t * (32-bit pointer) */
3593 uint32_t instanceProperties; /* struct objc_property_list *
3594 (32-bit pointer) */
3595};
3596
3597struct objc_image_info64 {
3598 uint32_t version;
3599 uint32_t flags;
3600};
3601struct objc_image_info32 {
3602 uint32_t version;
3603 uint32_t flags;
3604};
3605struct imageInfo_t {
3606 uint32_t version;
3607 uint32_t flags;
3608};
3609/* masks for objc_image_info.flags */
3610#define OBJC_IMAGE_IS_REPLACEMENT(1 << 0) (1 << 0)
3611#define OBJC_IMAGE_SUPPORTS_GC(1 << 1) (1 << 1)
3612#define OBJC_IMAGE_IS_SIMULATED(1 << 5) (1 << 5)
3613#define OBJC_IMAGE_HAS_CATEGORY_CLASS_PROPERTIES(1 << 6) (1 << 6)
3614
3615struct message_ref64 {
3616 uint64_t imp; /* IMP (64-bit pointer) */
3617 uint64_t sel; /* SEL (64-bit pointer) */
3618};
3619
3620struct message_ref32 {
3621 uint32_t imp; /* IMP (32-bit pointer) */
3622 uint32_t sel; /* SEL (32-bit pointer) */
3623};
3624
3625// Objective-C 1 (32-bit only) meta data structs.
3626
3627struct objc_module_t {
3628 uint32_t version;
3629 uint32_t size;
3630 uint32_t name; /* char * (32-bit pointer) */
3631 uint32_t symtab; /* struct objc_symtab * (32-bit pointer) */
3632};
3633
3634struct objc_symtab_t {
3635 uint32_t sel_ref_cnt;
3636 uint32_t refs; /* SEL * (32-bit pointer) */
3637 uint16_t cls_def_cnt;
3638 uint16_t cat_def_cnt;
3639 // uint32_t defs[1]; /* void * (32-bit pointer) variable size */
3640};
3641
3642struct objc_class_t {
3643 uint32_t isa; /* struct objc_class * (32-bit pointer) */
3644 uint32_t super_class; /* struct objc_class * (32-bit pointer) */
3645 uint32_t name; /* const char * (32-bit pointer) */
3646 int32_t version;
3647 int32_t info;
3648 int32_t instance_size;
3649 uint32_t ivars; /* struct objc_ivar_list * (32-bit pointer) */
3650 uint32_t methodLists; /* struct objc_method_list ** (32-bit pointer) */
3651 uint32_t cache; /* struct objc_cache * (32-bit pointer) */
3652 uint32_t protocols; /* struct objc_protocol_list * (32-bit pointer) */
3653};
3654
3655#define CLS_GETINFO(cls, infomask)((cls)->info & (infomask)) ((cls)->info & (infomask))
3656// class is not a metaclass
3657#define CLS_CLASS0x1 0x1
3658// class is a metaclass
3659#define CLS_META0x2 0x2
3660
3661struct objc_category_t {
3662 uint32_t category_name; /* char * (32-bit pointer) */
3663 uint32_t class_name; /* char * (32-bit pointer) */
3664 uint32_t instance_methods; /* struct objc_method_list * (32-bit pointer) */
3665 uint32_t class_methods; /* struct objc_method_list * (32-bit pointer) */
3666 uint32_t protocols; /* struct objc_protocol_list * (32-bit ptr) */
3667};
3668
3669struct objc_ivar_t {
3670 uint32_t ivar_name; /* char * (32-bit pointer) */
3671 uint32_t ivar_type; /* char * (32-bit pointer) */
3672 int32_t ivar_offset;
3673};
3674
3675struct objc_ivar_list_t {
3676 int32_t ivar_count;
3677 // struct objc_ivar_t ivar_list[1]; /* variable length structure */
3678};
3679
3680struct objc_method_list_t {
3681 uint32_t obsolete; /* struct objc_method_list * (32-bit pointer) */
3682 int32_t method_count;
3683 // struct objc_method_t method_list[1]; /* variable length structure */
3684};
3685
3686struct objc_method_t {
3687 uint32_t method_name; /* SEL, aka struct objc_selector * (32-bit pointer) */
3688 uint32_t method_types; /* char * (32-bit pointer) */
3689 uint32_t method_imp; /* IMP, aka function pointer, (*IMP)(id, SEL, ...)
3690 (32-bit pointer) */
3691};
3692
3693struct objc_protocol_list_t {
3694 uint32_t next; /* struct objc_protocol_list * (32-bit pointer) */
3695 int32_t count;
3696 // uint32_t list[1]; /* Protocol *, aka struct objc_protocol_t *
3697 // (32-bit pointer) */
3698};
3699
3700struct objc_protocol_t {
3701 uint32_t isa; /* struct objc_class * (32-bit pointer) */
3702 uint32_t protocol_name; /* char * (32-bit pointer) */
3703 uint32_t protocol_list; /* struct objc_protocol_list * (32-bit pointer) */
3704 uint32_t instance_methods; /* struct objc_method_description_list *
3705 (32-bit pointer) */
3706 uint32_t class_methods; /* struct objc_method_description_list *
3707 (32-bit pointer) */
3708};
3709
3710struct objc_method_description_list_t {
3711 int32_t count;
3712 // struct objc_method_description_t list[1];
3713};
3714
3715struct objc_method_description_t {
3716 uint32_t name; /* SEL, aka struct objc_selector * (32-bit pointer) */
3717 uint32_t types; /* char * (32-bit pointer) */
3718};
3719
3720inline void swapStruct(struct cfstring64_t &cfs) {
3721 sys::swapByteOrder(cfs.isa);
3722 sys::swapByteOrder(cfs.flags);
3723 sys::swapByteOrder(cfs.characters);
3724 sys::swapByteOrder(cfs.length);
3725}
3726
3727inline void swapStruct(struct class64_t &c) {
3728 sys::swapByteOrder(c.isa);
3729 sys::swapByteOrder(c.superclass);
3730 sys::swapByteOrder(c.cache);
3731 sys::swapByteOrder(c.vtable);
3732 sys::swapByteOrder(c.data);
3733}
3734
3735inline void swapStruct(struct class32_t &c) {
3736 sys::swapByteOrder(c.isa);
3737 sys::swapByteOrder(c.superclass);
3738 sys::swapByteOrder(c.cache);
3739 sys::swapByteOrder(c.vtable);
3740 sys::swapByteOrder(c.data);
3741}
3742
3743inline void swapStruct(struct class_ro64_t &cro) {
3744 sys::swapByteOrder(cro.flags);
3745 sys::swapByteOrder(cro.instanceStart);
3746 sys::swapByteOrder(cro.instanceSize);
3747 sys::swapByteOrder(cro.reserved);
3748 sys::swapByteOrder(cro.ivarLayout);
3749 sys::swapByteOrder(cro.name);
3750 sys::swapByteOrder(cro.baseMethods);
3751 sys::swapByteOrder(cro.baseProtocols);
3752 sys::swapByteOrder(cro.ivars);
3753 sys::swapByteOrder(cro.weakIvarLayout);
3754 sys::swapByteOrder(cro.baseProperties);
3755}
3756
3757inline void swapStruct(struct class_ro32_t &cro) {
3758 sys::swapByteOrder(cro.flags);
3759 sys::swapByteOrder(cro.instanceStart);
3760 sys::swapByteOrder(cro.instanceSize);
3761 sys::swapByteOrder(cro.ivarLayout);
3762 sys::swapByteOrder(cro.name);
3763 sys::swapByteOrder(cro.baseMethods);
3764 sys::swapByteOrder(cro.baseProtocols);
3765 sys::swapByteOrder(cro.ivars);
3766 sys::swapByteOrder(cro.weakIvarLayout);
3767 sys::swapByteOrder(cro.baseProperties);
3768}
3769
3770inline void swapStruct(struct method_list64_t &ml) {
3771 sys::swapByteOrder(ml.entsize);
3772 sys::swapByteOrder(ml.count);
3773}
3774
3775inline void swapStruct(struct method_list32_t &ml) {
3776 sys::swapByteOrder(ml.entsize);
3777 sys::swapByteOrder(ml.count);
3778}
3779
3780inline void swapStruct(struct method64_t &m) {
3781 sys::swapByteOrder(m.name);
3782 sys::swapByteOrder(m.types);
3783 sys::swapByteOrder(m.imp);
3784}
3785
3786inline void swapStruct(struct method32_t &m) {
3787 sys::swapByteOrder(m.name);
3788 sys::swapByteOrder(m.types);
3789 sys::swapByteOrder(m.imp);
3790}
3791
3792inline void swapStruct(struct protocol_list64_t &pl) {
3793 sys::swapByteOrder(pl.count);
3794}
3795
3796inline void swapStruct(struct protocol_list32_t &pl) {
3797 sys::swapByteOrder(pl.count);
3798}
3799
3800inline void swapStruct(struct protocol64_t &p) {
3801 sys::swapByteOrder(p.isa);
3802 sys::swapByteOrder(p.name);
3803 sys::swapByteOrder(p.protocols);
3804 sys::swapByteOrder(p.instanceMethods);
3805 sys::swapByteOrder(p.classMethods);
3806 sys::swapByteOrder(p.optionalInstanceMethods);
3807 sys::swapByteOrder(p.optionalClassMethods);
3808 sys::swapByteOrder(p.instanceProperties);
3809}
3810
3811inline void swapStruct(struct protocol32_t &p) {
3812 sys::swapByteOrder(p.isa);
3813 sys::swapByteOrder(p.name);
3814 sys::swapByteOrder(p.protocols);
3815 sys::swapByteOrder(p.instanceMethods);
3816 sys::swapByteOrder(p.classMethods);
3817 sys::swapByteOrder(p.optionalInstanceMethods);
3818 sys::swapByteOrder(p.optionalClassMethods);
3819 sys::swapByteOrder(p.instanceProperties);
3820}
3821
3822inline void swapStruct(struct ivar_list64_t &il) {
3823 sys::swapByteOrder(il.entsize);
3824 sys::swapByteOrder(il.count);
3825}
3826
3827inline void swapStruct(struct ivar_list32_t &il) {
3828 sys::swapByteOrder(il.entsize);
3829 sys::swapByteOrder(il.count);
3830}
3831
3832inline void swapStruct(struct ivar64_t &i) {
3833 sys::swapByteOrder(i.offset);
3834 sys::swapByteOrder(i.name);
3835 sys::swapByteOrder(i.type);
3836 sys::swapByteOrder(i.alignment);
3837 sys::swapByteOrder(i.size);
3838}
3839
3840inline void swapStruct(struct ivar32_t &i) {
3841 sys::swapByteOrder(i.offset);
3842 sys::swapByteOrder(i.name);
3843 sys::swapByteOrder(i.type);
3844 sys::swapByteOrder(i.alignment);
3845 sys::swapByteOrder(i.size);
3846}
3847
3848inline void swapStruct(struct objc_property_list64 &pl) {
3849 sys::swapByteOrder(pl.entsize);
3850 sys::swapByteOrder(pl.count);
3851}
3852
3853inline void swapStruct(struct objc_property_list32 &pl) {
3854 sys::swapByteOrder(pl.entsize);
3855 sys::swapByteOrder(pl.count);
3856}
3857
3858inline void swapStruct(struct objc_property64 &op) {
3859 sys::swapByteOrder(op.name);
3860 sys::swapByteOrder(op.attributes);
3861}
3862
3863inline void swapStruct(struct objc_property32 &op) {
3864 sys::swapByteOrder(op.name);
3865 sys::swapByteOrder(op.attributes);
3866}
3867
3868inline void swapStruct(struct category64_t &c) {
3869 sys::swapByteOrder(c.name);
3870 sys::swapByteOrder(c.cls);
3871 sys::swapByteOrder(c.instanceMethods);
3872 sys::swapByteOrder(c.classMethods);
3873 sys::swapByteOrder(c.protocols);
3874 sys::swapByteOrder(c.instanceProperties);
3875}
3876
3877inline void swapStruct(struct category32_t &c) {
3878 sys::swapByteOrder(c.name);
3879 sys::swapByteOrder(c.cls);
3880 sys::swapByteOrder(c.instanceMethods);
3881 sys::swapByteOrder(c.classMethods);
3882 sys::swapByteOrder(c.protocols);
3883 sys::swapByteOrder(c.instanceProperties);
3884}
3885
3886inline void swapStruct(struct objc_image_info64 &o) {
3887 sys::swapByteOrder(o.version);
3888 sys::swapByteOrder(o.flags);
3889}
3890
3891inline void swapStruct(struct objc_image_info32 &o) {
3892 sys::swapByteOrder(o.version);
3893 sys::swapByteOrder(o.flags);
3894}
3895
3896inline void swapStruct(struct imageInfo_t &o) {
3897 sys::swapByteOrder(o.version);
3898 sys::swapByteOrder(o.flags);
3899}
3900
3901inline void swapStruct(struct message_ref64 &mr) {
3902 sys::swapByteOrder(mr.imp);
3903 sys::swapByteOrder(mr.sel);
3904}
3905
3906inline void swapStruct(struct message_ref32 &mr) {
3907 sys::swapByteOrder(mr.imp);
3908 sys::swapByteOrder(mr.sel);
3909}
3910
3911inline void swapStruct(struct objc_module_t &module) {
3912 sys::swapByteOrder(module.version);
3913 sys::swapByteOrder(module.size);
3914 sys::swapByteOrder(module.name);
3915 sys::swapByteOrder(module.symtab);
3916}
3917
3918inline void swapStruct(struct objc_symtab_t &symtab) {
3919 sys::swapByteOrder(symtab.sel_ref_cnt);
3920 sys::swapByteOrder(symtab.refs);
3921 sys::swapByteOrder(symtab.cls_def_cnt);
3922 sys::swapByteOrder(symtab.cat_def_cnt);
3923}
3924
3925inline void swapStruct(struct objc_class_t &objc_class) {
3926 sys::swapByteOrder(objc_class.isa);
3927 sys::swapByteOrder(objc_class.super_class);
3928 sys::swapByteOrder(objc_class.name);
3929 sys::swapByteOrder(objc_class.version);
3930 sys::swapByteOrder(objc_class.info);
3931 sys::swapByteOrder(objc_class.instance_size);
3932 sys::swapByteOrder(objc_class.ivars);
3933 sys::swapByteOrder(objc_class.methodLists);
3934 sys::swapByteOrder(objc_class.cache);
3935 sys::swapByteOrder(objc_class.protocols);
3936}
3937
3938inline void swapStruct(struct objc_category_t &objc_category) {
3939 sys::swapByteOrder(objc_category.category_name);
3940 sys::swapByteOrder(objc_category.class_name);
3941 sys::swapByteOrder(objc_category.instance_methods);
3942 sys::swapByteOrder(objc_category.class_methods);
3943 sys::swapByteOrder(objc_category.protocols);
3944}
3945
3946inline void swapStruct(struct objc_ivar_list_t &objc_ivar_list) {
3947 sys::swapByteOrder(objc_ivar_list.ivar_count);
3948}
3949
3950inline void swapStruct(struct objc_ivar_t &objc_ivar) {
3951 sys::swapByteOrder(objc_ivar.ivar_name);
3952 sys::swapByteOrder(objc_ivar.ivar_type);
3953 sys::swapByteOrder(objc_ivar.ivar_offset);
3954}
3955
3956inline void swapStruct(struct objc_method_list_t &method_list) {
3957 sys::swapByteOrder(method_list.obsolete);
3958 sys::swapByteOrder(method_list.method_count);
3959}
3960
3961inline void swapStruct(struct objc_method_t &method) {
3962 sys::swapByteOrder(method.method_name);
3963 sys::swapByteOrder(method.method_types);
3964 sys::swapByteOrder(method.method_imp);
3965}
3966
3967inline void swapStruct(struct objc_protocol_list_t &protocol_list) {
3968 sys::swapByteOrder(protocol_list.next);
3969 sys::swapByteOrder(protocol_list.count);
3970}
3971
3972inline void swapStruct(struct objc_protocol_t &protocol) {
3973 sys::swapByteOrder(protocol.isa);
3974 sys::swapByteOrder(protocol.protocol_name);
3975 sys::swapByteOrder(protocol.protocol_list);
3976 sys::swapByteOrder(protocol.instance_methods);
3977 sys::swapByteOrder(protocol.class_methods);
3978}
3979
3980inline void swapStruct(struct objc_method_description_list_t &mdl) {
3981 sys::swapByteOrder(mdl.count);
3982}
3983
3984inline void swapStruct(struct objc_method_description_t &md) {
3985 sys::swapByteOrder(md.name);
3986 sys::swapByteOrder(md.types);
3987}
3988
3989} // namespace
3990
3991static const char *get_dyld_bind_info_symbolname(uint64_t ReferenceValue,
3992 struct DisassembleInfo *info);
3993
3994// get_objc2_64bit_class_name() is used for disassembly and is passed a pointer
3995// to an Objective-C class and returns the class name. It is also passed the
3996// address of the pointer, so when the pointer is zero as it can be in an .o
3997// file, that is used to look for an external relocation entry with a symbol
3998// name.
3999static const char *get_objc2_64bit_class_name(uint64_t pointer_value,
4000 uint64_t ReferenceValue,
4001 struct DisassembleInfo *info) {
4002 const char *r;
4003 uint32_t offset, left;
4004 SectionRef S;
4005
4006 // The pointer_value can be 0 in an object file and have a relocation
4007 // entry for the class symbol at the ReferenceValue (the address of the
4008 // pointer).
4009 if (pointer_value == 0) {
4010 r = get_pointer_64(ReferenceValue, offset, left, S, info);
4011 if (r == nullptr || left < sizeof(uint64_t))
4012 return nullptr;
4013 uint64_t n_value;
4014 const char *symbol_name = get_symbol_64(offset, S, info, n_value);
4015 if (symbol_name == nullptr)
4016 return nullptr;
4017 const char *class_name = strrchr(symbol_name, '$');
4018 if (class_name != nullptr && class_name[1] == '_' && class_name[2] != '\0')
4019 return class_name + 2;
4020 else
4021 return nullptr;
4022 }
4023
4024 // The case were the pointer_value is non-zero and points to a class defined
4025 // in this Mach-O file.
4026 r = get_pointer_64(pointer_value, offset, left, S, info);
4027 if (r == nullptr || left < sizeof(struct class64_t))
4028 return nullptr;
4029 struct class64_t c;
4030 memcpy(&c, r, sizeof(struct class64_t));
4031 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4032 swapStruct(c);
4033 if (c.data == 0)
4034 return nullptr;
4035 r = get_pointer_64(c.data, offset, left, S, info);
4036 if (r == nullptr || left < sizeof(struct class_ro64_t))
4037 return nullptr;
4038 struct class_ro64_t cro;
4039 memcpy(&cro, r, sizeof(struct class_ro64_t));
4040 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4041 swapStruct(cro);
4042 if (cro.name == 0)
4043 return nullptr;
4044 const char *name = get_pointer_64(cro.name, offset, left, S, info);
4045 return name;
4046}
4047
4048// get_objc2_64bit_cfstring_name is used for disassembly and is passed a
4049// pointer to a cfstring and returns its name or nullptr.
4050static const char *get_objc2_64bit_cfstring_name(uint64_t ReferenceValue,
4051 struct DisassembleInfo *info) {
4052 const char *r, *name;
4053 uint32_t offset, left;
4054 SectionRef S;
4055 struct cfstring64_t cfs;
4056 uint64_t cfs_characters;
4057
4058 r = get_pointer_64(ReferenceValue, offset, left, S, info);
4059 if (r == nullptr || left < sizeof(struct cfstring64_t))
4060 return nullptr;
4061 memcpy(&cfs, r, sizeof(struct cfstring64_t));
4062 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4063 swapStruct(cfs);
4064 if (cfs.characters == 0) {
4065 uint64_t n_value;
4066 const char *symbol_name = get_symbol_64(
4067 offset + offsetof(struct cfstring64_t, characters)__builtin_offsetof(struct cfstring64_t, characters), S, info, n_value);
4068 if (symbol_name == nullptr)
4069 return nullptr;
4070 cfs_characters = n_value;
4071 } else
4072 cfs_characters = cfs.characters;
4073 name = get_pointer_64(cfs_characters, offset, left, S, info);
4074
4075 return name;
4076}
4077
4078// get_objc2_64bit_selref() is used for disassembly and is passed a the address
4079// of a pointer to an Objective-C selector reference when the pointer value is
4080// zero as in a .o file and is likely to have a external relocation entry with
4081// who's symbol's n_value is the real pointer to the selector name. If that is
4082// the case the real pointer to the selector name is returned else 0 is
4083// returned
4084static uint64_t get_objc2_64bit_selref(uint64_t ReferenceValue,
4085 struct DisassembleInfo *info) {
4086 uint32_t offset, left;
4087 SectionRef S;
4088
4089 const char *r = get_pointer_64(ReferenceValue, offset, left, S, info);
4090 if (r == nullptr || left < sizeof(uint64_t))
4091 return 0;
4092 uint64_t n_value;
4093 const char *symbol_name = get_symbol_64(offset, S, info, n_value);
4094 if (symbol_name == nullptr)
4095 return 0;
4096 return n_value;
4097}
4098
4099static const SectionRef get_section(MachOObjectFile *O, const char *segname,
4100 const char *sectname) {
4101 for (const SectionRef &Section : O->sections()) {
4102 StringRef SectName;
4103 Expected<StringRef> SecNameOrErr = Section.getName();
4104 if (SecNameOrErr)
4105 SectName = *SecNameOrErr;
4106 else
4107 consumeError(SecNameOrErr.takeError());
4108
4109 DataRefImpl Ref = Section.getRawDataRefImpl();
4110 StringRef SegName = O->getSectionFinalSegmentName(Ref);
4111 if (SegName == segname && SectName == sectname)
4112 return Section;
4113 }
4114 return SectionRef();
4115}
4116
4117static void
4118walk_pointer_list_64(const char *listname, const SectionRef S,
4119 MachOObjectFile *O, struct DisassembleInfo *info,
4120 void (*func)(uint64_t, struct DisassembleInfo *info)) {
4121 if (S == SectionRef())
4122 return;
4123
4124 StringRef SectName;
4125 Expected<StringRef> SecNameOrErr = S.getName();
4126 if (SecNameOrErr)
4127 SectName = *SecNameOrErr;
4128 else
4129 consumeError(SecNameOrErr.takeError());
4130
4131 DataRefImpl Ref = S.getRawDataRefImpl();
4132 StringRef SegName = O->getSectionFinalSegmentName(Ref);
4133 outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
4134
4135 StringRef BytesStr = unwrapOrError(S.getContents(), O->getFileName());
4136 const char *Contents = reinterpret_cast<const char *>(BytesStr.data());
4137
4138 for (uint32_t i = 0; i < S.getSize(); i += sizeof(uint64_t)) {
4139 uint32_t left = S.getSize() - i;
4140 uint32_t size = left < sizeof(uint64_t) ? left : sizeof(uint64_t);
4141 uint64_t p = 0;
4142 memcpy(&p, Contents + i, size);
4143 if (i + sizeof(uint64_t) > S.getSize())
4144 outs() << listname << " list pointer extends past end of (" << SegName
4145 << "," << SectName << ") section\n";
4146 outs() << format("%016" PRIx64"l" "x", S.getAddress() + i) << " ";
4147
4148 if (O->isLittleEndian() != sys::IsLittleEndianHost)
4149 sys::swapByteOrder(p);
4150
4151 uint64_t n_value = 0;
4152 const char *name = get_symbol_64(i, S, info, n_value, p);
4153 if (name == nullptr)
4154 name = get_dyld_bind_info_symbolname(S.getAddress() + i, info);
4155
4156 if (n_value != 0) {
4157 outs() << format("0x%" PRIx64"l" "x", n_value);
4158 if (p != 0)
4159 outs() << " + " << format("0x%" PRIx64"l" "x", p);
4160 } else
4161 outs() << format("0x%" PRIx64"l" "x", p);
4162 if (name != nullptr)
4163 outs() << " " << name;
4164 outs() << "\n";
4165
4166 p += n_value;
4167 if (func)
4168 func(p, info);
4169 }
4170}
4171
4172static void
4173walk_pointer_list_32(const char *listname, const SectionRef S,
4174 MachOObjectFile *O, struct DisassembleInfo *info,
4175 void (*func)(uint32_t, struct DisassembleInfo *info)) {
4176 if (S == SectionRef())
4177 return;
4178
4179 StringRef SectName = unwrapOrError(S.getName(), O->getFileName());
4180 DataRefImpl Ref = S.getRawDataRefImpl();
4181 StringRef SegName = O->getSectionFinalSegmentName(Ref);
4182 outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
4183
4184 StringRef BytesStr = unwrapOrError(S.getContents(), O->getFileName());
4185 const char *Contents = reinterpret_cast<const char *>(BytesStr.data());
4186
4187 for (uint32_t i = 0; i < S.getSize(); i += sizeof(uint32_t)) {
4188 uint32_t left = S.getSize() - i;
4189 uint32_t size = left < sizeof(uint32_t) ? left : sizeof(uint32_t);
4190 uint32_t p = 0;
4191 memcpy(&p, Contents + i, size);
4192 if (i + sizeof(uint32_t) > S.getSize())
4193 outs() << listname << " list pointer extends past end of (" << SegName
4194 << "," << SectName << ") section\n";
4195 uint32_t Address = S.getAddress() + i;
4196 outs() << format("%08" PRIx32"x", Address) << " ";
4197
4198 if (O->isLittleEndian() != sys::IsLittleEndianHost)
4199 sys::swapByteOrder(p);
4200 outs() << format("0x%" PRIx32"x", p);
4201
4202 const char *name = get_symbol_32(i, S, info, p);
4203 if (name != nullptr)
4204 outs() << " " << name;
4205 outs() << "\n";
4206
4207 if (func)
4208 func(p, info);
4209 }
4210}
4211
4212static void print_layout_map(const char *layout_map, uint32_t left) {
4213 if (layout_map == nullptr)
4214 return;
4215 outs() << " layout map: ";
4216 do {
4217 outs() << format("0x%02" PRIx32"x", (*layout_map) & 0xff) << " ";
4218 left--;
4219 layout_map++;
4220 } while (*layout_map != '\0' && left != 0);
4221 outs() << "\n";
4222}
4223
4224static void print_layout_map64(uint64_t p, struct DisassembleInfo *info) {
4225 uint32_t offset, left;
4226 SectionRef S;
4227 const char *layout_map;
4228
4229 if (p == 0)
4230 return;
4231 layout_map = get_pointer_64(p, offset, left, S, info);
4232 print_layout_map(layout_map, left);
4233}
4234
4235static void print_layout_map32(uint32_t p, struct DisassembleInfo *info) {
4236 uint32_t offset, left;
4237 SectionRef S;
4238 const char *layout_map;
4239
4240 if (p == 0)
4241 return;
4242 layout_map = get_pointer_32(p, offset, left, S, info);
4243 print_layout_map(layout_map, left);
4244}
4245
4246static void print_method_list64_t(uint64_t p, struct DisassembleInfo *info,
4247 const char *indent) {
4248 struct method_list64_t ml;
4249 struct method64_t m;
4250 const char *r;
4251 uint32_t offset, xoffset, left, i;
4252 SectionRef S, xS;
4253 const char *name, *sym_name;
4254 uint64_t n_value;
4255
4256 r = get_pointer_64(p, offset, left, S, info);
4257 if (r == nullptr)
4258 return;
4259 memset(&ml, '\0', sizeof(struct method_list64_t));
4260 if (left < sizeof(struct method_list64_t)) {
4261 memcpy(&ml, r, left);
4262 outs() << " (method_list_t entends past the end of the section)\n";
4263 } else
4264 memcpy(&ml, r, sizeof(struct method_list64_t));
4265 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4266 swapStruct(ml);
4267 outs() << indent << "\t\t entsize " << ml.entsize << "\n";
4268 outs() << indent << "\t\t count " << ml.count << "\n";
4269
4270 p += sizeof(struct method_list64_t);
4271 offset += sizeof(struct method_list64_t);
4272 for (i = 0; i < ml.count; i++) {
4273 r = get_pointer_64(p, offset, left, S, info);
4274 if (r == nullptr)
4275 return;
4276 memset(&m, '\0', sizeof(struct method64_t));
4277 if (left < sizeof(struct method64_t)) {
4278 memcpy(&m, r, left);
4279 outs() << indent << " (method_t extends past the end of the section)\n";
4280 } else
4281 memcpy(&m, r, sizeof(struct method64_t));
4282 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4283 swapStruct(m);
4284
4285 outs() << indent << "\t\t name ";
4286 sym_name = get_symbol_64(offset + offsetof(struct method64_t, name)__builtin_offsetof(struct method64_t, name), S,
4287 info, n_value, m.name);
4288 if (n_value != 0) {
4289 if (info->verbose && sym_name != nullptr)
4290 outs() << sym_name;
4291 else
4292 outs() << format("0x%" PRIx64"l" "x", n_value);
4293 if (m.name != 0)
4294 outs() << " + " << format("0x%" PRIx64"l" "x", m.name);
4295 } else
4296 outs() << format("0x%" PRIx64"l" "x", m.name);
4297 name = get_pointer_64(m.name + n_value, xoffset, left, xS, info);
4298 if (name != nullptr)
4299 outs() << format(" %.*s", left, name);
4300 outs() << "\n";
4301
4302 outs() << indent << "\t\t types ";
4303 sym_name = get_symbol_64(offset + offsetof(struct method64_t, types)__builtin_offsetof(struct method64_t, types), S,
4304 info, n_value, m.types);
4305 if (n_value != 0) {
4306 if (info->verbose && sym_name != nullptr)
4307 outs() << sym_name;
4308 else
4309 outs() << format("0x%" PRIx64"l" "x", n_value);
4310 if (m.types != 0)
4311 outs() << " + " << format("0x%" PRIx64"l" "x", m.types);
4312 } else
4313 outs() << format("0x%" PRIx64"l" "x", m.types);
4314 name = get_pointer_64(m.types + n_value, xoffset, left, xS, info);
4315 if (name != nullptr)
4316 outs() << format(" %.*s", left, name);
4317 outs() << "\n";
4318
4319 outs() << indent << "\t\t imp ";
4320 name = get_symbol_64(offset + offsetof(struct method64_t, imp)__builtin_offsetof(struct method64_t, imp), S, info,
4321 n_value, m.imp);
4322 if (info->verbose && name == nullptr) {
4323 if (n_value != 0) {
4324 outs() << format("0x%" PRIx64"l" "x", n_value) << " ";
4325 if (m.imp != 0)
4326 outs() << "+ " << format("0x%" PRIx64"l" "x", m.imp) << " ";
4327 } else
4328 outs() << format("0x%" PRIx64"l" "x", m.imp) << " ";
4329 }
4330 if (name != nullptr)
4331 outs() << name;
4332 outs() << "\n";
4333
4334 p += sizeof(struct method64_t);
4335 offset += sizeof(struct method64_t);
4336 }
4337}
4338
4339static void print_method_list32_t(uint64_t p, struct DisassembleInfo *info,
4340 const char *indent) {
4341 struct method_list32_t ml;
4342 struct method32_t m;
4343 const char *r, *name;
4344 uint32_t offset, xoffset, left, i;
4345 SectionRef S, xS;
4346
4347 r = get_pointer_32(p, offset, left, S, info);
4348 if (r == nullptr)
4349 return;
4350 memset(&ml, '\0', sizeof(struct method_list32_t));
4351 if (left < sizeof(struct method_list32_t)) {
4352 memcpy(&ml, r, left);
4353 outs() << " (method_list_t entends past the end of the section)\n";
4354 } else
4355 memcpy(&ml, r, sizeof(struct method_list32_t));
4356 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4357 swapStruct(ml);
4358 outs() << indent << "\t\t entsize " << ml.entsize << "\n";
4359 outs() << indent << "\t\t count " << ml.count << "\n";
4360
4361 p += sizeof(struct method_list32_t);
4362 offset += sizeof(struct method_list32_t);
4363 for (i = 0; i < ml.count; i++) {
4364 r = get_pointer_32(p, offset, left, S, info);
4365 if (r == nullptr)
4366 return;
4367 memset(&m, '\0', sizeof(struct method32_t));
4368 if (left < sizeof(struct method32_t)) {
4369 memcpy(&ml, r, left);
4370 outs() << indent << " (method_t entends past the end of the section)\n";
4371 } else
4372 memcpy(&m, r, sizeof(struct method32_t));
4373 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4374 swapStruct(m);
4375
4376 outs() << indent << "\t\t name " << format("0x%" PRIx32"x", m.name);
4377 name = get_pointer_32(m.name, xoffset, left, xS, info);
4378 if (name != nullptr)
4379 outs() << format(" %.*s", left, name);
4380 outs() << "\n";
4381
4382 outs() << indent << "\t\t types " << format("0x%" PRIx32"x", m.types);
4383 name = get_pointer_32(m.types, xoffset, left, xS, info);
4384 if (name != nullptr)
4385 outs() << format(" %.*s", left, name);
4386 outs() << "\n";
4387
4388 outs() << indent << "\t\t imp " << format("0x%" PRIx32"x", m.imp);
4389 name = get_symbol_32(offset + offsetof(struct method32_t, imp)__builtin_offsetof(struct method32_t, imp), S, info,
4390 m.imp);
4391 if (name != nullptr)
4392 outs() << " " << name;
4393 outs() << "\n";
4394
4395 p += sizeof(struct method32_t);
4396 offset += sizeof(struct method32_t);
4397 }
4398}
4399
4400static bool print_method_list(uint32_t p, struct DisassembleInfo *info) {
4401 uint32_t offset, left, xleft;
4402 SectionRef S;
4403 struct objc_method_list_t method_list;
4404 struct objc_method_t method;
4405 const char *r, *methods, *name, *SymbolName;
4406 int32_t i;
4407
4408 r = get_pointer_32(p, offset, left, S, info, true);
4409 if (r == nullptr)
4410 return true;
4411
4412 outs() << "\n";
4413 if (left > sizeof(struct objc_method_list_t)) {
4414 memcpy(&method_list, r, sizeof(struct objc_method_list_t));
4415 } else {
4416 outs() << "\t\t objc_method_list extends past end of the section\n";
4417 memset(&method_list, '\0', sizeof(struct objc_method_list_t));
4418 memcpy(&method_list, r, left);
4419 }
4420 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4421 swapStruct(method_list);
4422
4423 outs() << "\t\t obsolete "
4424 << format("0x%08" PRIx32"x", method_list.obsolete) << "\n";
4425 outs() << "\t\t method_count " << method_list.method_count << "\n";
4426
4427 methods = r + sizeof(struct objc_method_list_t);
4428 for (i = 0; i < method_list.method_count; i++) {
4429 if ((i + 1) * sizeof(struct objc_method_t) > left) {
4430 outs() << "\t\t remaining method's extend past the of the section\n";
4431 break;
4432 }
4433 memcpy(&method, methods + i * sizeof(struct objc_method_t),
4434 sizeof(struct objc_method_t));
4435 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4436 swapStruct(method);
4437
4438 outs() << "\t\t method_name "
4439 << format("0x%08" PRIx32"x", method.method_name);
4440 if (info->verbose) {
4441 name = get_pointer_32(method.method_name, offset, xleft, S, info, true);
4442 if (name != nullptr)
4443 outs() << format(" %.*s", xleft, name);
4444 else
4445 outs() << " (not in an __OBJC section)";
4446 }
4447 outs() << "\n";
4448
4449 outs() << "\t\t method_types "
4450 << format("0x%08" PRIx32"x", method.method_types);
4451 if (info->verbose) {
4452 name = get_pointer_32(method.method_types, offset, xleft, S, info, true);
4453 if (name != nullptr)
4454 outs() << format(" %.*s", xleft, name);
4455 else
4456 outs() << " (not in an __OBJC section)";
4457 }
4458 outs() << "\n";
4459
4460 outs() << "\t\t method_imp "
4461 << format("0x%08" PRIx32"x", method.method_imp) << " ";
4462 if (info->verbose) {
4463 SymbolName = GuessSymbolName(method.method_imp, info->AddrMap);
4464 if (SymbolName != nullptr)
4465 outs() << SymbolName;
4466 }
4467 outs() << "\n";
4468 }
4469 return false;
4470}
4471
4472static void print_protocol_list64_t(uint64_t p, struct DisassembleInfo *info) {
4473 struct protocol_list64_t pl;
4474 uint64_t q, n_value;
4475 struct protocol64_t pc;
4476 const char *r;
4477 uint32_t offset, xoffset, left, i;
4478 SectionRef S, xS;
4479 const char *name, *sym_name;
4480
4481 r = get_pointer_64(p, offset, left, S, info);
4482 if (r == nullptr)
4483 return;
4484 memset(&pl, '\0', sizeof(struct protocol_list64_t));
4485 if (left < sizeof(struct protocol_list64_t)) {
4486 memcpy(&pl, r, left);
4487 outs() << " (protocol_list_t entends past the end of the section)\n";
4488 } else
4489 memcpy(&pl, r, sizeof(struct protocol_list64_t));
4490 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4491 swapStruct(pl);
4492 outs() << " count " << pl.count << "\n";
4493
4494 p += sizeof(struct protocol_list64_t);
4495 offset += sizeof(struct protocol_list64_t);
4496 for (i = 0; i < pl.count; i++) {
4497 r = get_pointer_64(p, offset, left, S, info);
4498 if (r == nullptr)
4499 return;
4500 q = 0;
4501 if (left < sizeof(uint64_t)) {
4502 memcpy(&q, r, left);
4503 outs() << " (protocol_t * entends past the end of the section)\n";
4504 } else
4505 memcpy(&q, r, sizeof(uint64_t));
4506 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4507 sys::swapByteOrder(q);
4508
4509 outs() << "\t\t list[" << i << "] ";
4510 sym_name = get_symbol_64(offset, S, info, n_value, q);
4511 if (n_value != 0) {
4512 if (info->verbose && sym_name != nullptr)
4513 outs() << sym_name;
4514 else
4515 outs() << format("0x%" PRIx64"l" "x", n_value);
4516 if (q != 0)
4517 outs() << " + " << format("0x%" PRIx64"l" "x", q);
4518 } else
4519 outs() << format("0x%" PRIx64"l" "x", q);
4520 outs() << " (struct protocol_t *)\n";
4521
4522 r = get_pointer_64(q + n_value, offset, left, S, info);
4523 if (r == nullptr)
4524 return;
4525 memset(&pc, '\0', sizeof(struct protocol64_t));
4526 if (left < sizeof(struct protocol64_t)) {
4527 memcpy(&pc, r, left);
4528 outs() << " (protocol_t entends past the end of the section)\n";
4529 } else
4530 memcpy(&pc, r, sizeof(struct protocol64_t));
4531 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4532 swapStruct(pc);
4533
4534 outs() << "\t\t\t isa " << format("0x%" PRIx64"l" "x", pc.isa) << "\n";
4535
4536 outs() << "\t\t\t name ";
4537 sym_name = get_symbol_64(offset + offsetof(struct protocol64_t, name)__builtin_offsetof(struct protocol64_t, name), S,
4538 info, n_value, pc.name);
4539 if (n_value != 0) {
4540 if (info->verbose && sym_name != nullptr)
4541 outs() << sym_name;
4542 else
4543 outs() << format("0x%" PRIx64"l" "x", n_value);
4544 if (pc.name != 0)
4545 outs() << " + " << format("0x%" PRIx64"l" "x", pc.name);
4546 } else
4547 outs() << format("0x%" PRIx64"l" "x", pc.name);
4548 name = get_pointer_64(pc.name + n_value, xoffset, left, xS, info);
4549 if (name != nullptr)
4550 outs() << format(" %.*s", left, name);
4551 outs() << "\n";
4552
4553 outs() << "\t\t\tprotocols " << format("0x%" PRIx64"l" "x", pc.protocols) << "\n";
4554
4555 outs() << "\t\t instanceMethods ";
4556 sym_name =
4557 get_symbol_64(offset + offsetof(struct protocol64_t, instanceMethods)__builtin_offsetof(struct protocol64_t, instanceMethods),
4558 S, info, n_value, pc.instanceMethods);
4559 if (n_value != 0) {
4560 if (info->verbose && sym_name != nullptr)
4561 outs() << sym_name;
4562 else
4563 outs() << format("0x%" PRIx64"l" "x", n_value);
4564 if (pc.instanceMethods != 0)
4565 outs() << " + " << format("0x%" PRIx64"l" "x", pc.instanceMethods);
4566 } else
4567 outs() << format("0x%" PRIx64"l" "x", pc.instanceMethods);
4568 outs() << " (struct method_list_t *)\n";
4569 if (pc.instanceMethods + n_value != 0)
4570 print_method_list64_t(pc.instanceMethods + n_value, info, "\t");
4571
4572 outs() << "\t\t classMethods ";
4573 sym_name =
4574 get_symbol_64(offset + offsetof(struct protocol64_t, classMethods)__builtin_offsetof(struct protocol64_t, classMethods), S,
4575 info, n_value, pc.classMethods);
4576 if (n_value != 0) {
4577 if (info->verbose && sym_name != nullptr)
4578 outs() << sym_name;
4579 else
4580 outs() << format("0x%" PRIx64"l" "x", n_value);
4581 if (pc.classMethods != 0)
4582 outs() << " + " << format("0x%" PRIx64"l" "x", pc.classMethods);
4583 } else
4584 outs() << format("0x%" PRIx64"l" "x", pc.classMethods);
4585 outs() << " (struct method_list_t *)\n";
4586 if (pc.classMethods + n_value != 0)
4587 print_method_list64_t(pc.classMethods + n_value, info, "\t");
4588
4589 outs() << "\t optionalInstanceMethods "
4590 << format("0x%" PRIx64"l" "x", pc.optionalInstanceMethods) << "\n";
4591 outs() << "\t optionalClassMethods "
4592 << format("0x%" PRIx64"l" "x", pc.optionalClassMethods) << "\n";
4593 outs() << "\t instanceProperties "
4594 << format("0x%" PRIx64"l" "x", pc.instanceProperties) << "\n";
4595
4596 p += sizeof(uint64_t);
4597 offset += sizeof(uint64_t);
4598 }
4599}
4600
4601static void print_protocol_list32_t(uint32_t p, struct DisassembleInfo *info) {
4602 struct protocol_list32_t pl;
4603 uint32_t q;
4604 struct protocol32_t pc;
4605 const char *r;
4606 uint32_t offset, xoffset, left, i;
4607 SectionRef S, xS;
4608 const char *name;
4609
4610 r = get_pointer_32(p, offset, left, S, info);
4611 if (r == nullptr)
4612 return;
4613 memset(&pl, '\0', sizeof(struct protocol_list32_t));
4614 if (left < sizeof(struct protocol_list32_t)) {
4615 memcpy(&pl, r, left);
4616 outs() << " (protocol_list_t entends past the end of the section)\n";
4617 } else
4618 memcpy(&pl, r, sizeof(struct protocol_list32_t));
4619 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4620 swapStruct(pl);
4621 outs() << " count " << pl.count << "\n";
4622
4623 p += sizeof(struct protocol_list32_t);
4624 offset += sizeof(struct protocol_list32_t);
4625 for (i = 0; i < pl.count; i++) {
4626 r = get_pointer_32(p, offset, left, S, info);
4627 if (r == nullptr)
4628 return;
4629 q = 0;
4630 if (left < sizeof(uint32_t)) {
4631 memcpy(&q, r, left);
4632 outs() << " (protocol_t * entends past the end of the section)\n";
4633 } else
4634 memcpy(&q, r, sizeof(uint32_t));
4635 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4636 sys::swapByteOrder(q);
4637 outs() << "\t\t list[" << i << "] " << format("0x%" PRIx32"x", q)
4638 << " (struct protocol_t *)\n";
4639 r = get_pointer_32(q, offset, left, S, info);
4640 if (r == nullptr)
4641 return;
4642 memset(&pc, '\0', sizeof(struct protocol32_t));
4643 if (left < sizeof(struct protocol32_t)) {
4644 memcpy(&pc, r, left);
4645 outs() << " (protocol_t entends past the end of the section)\n";
4646 } else
4647 memcpy(&pc, r, sizeof(struct protocol32_t));
4648 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4649 swapStruct(pc);
4650 outs() << "\t\t\t isa " << format("0x%" PRIx32"x", pc.isa) << "\n";
4651 outs() << "\t\t\t name " << format("0x%" PRIx32"x", pc.name);
4652 name = get_pointer_32(pc.name, xoffset, left, xS, info);
4653 if (name != nullptr)
4654 outs() << format(" %.*s", left, name);
4655 outs() << "\n";
4656 outs() << "\t\t\tprotocols " << format("0x%" PRIx32"x", pc.protocols) << "\n";
4657 outs() << "\t\t instanceMethods "
4658 << format("0x%" PRIx32"x", pc.instanceMethods)
4659 << " (struct method_list_t *)\n";
4660 if (pc.instanceMethods != 0)
4661 print_method_list32_t(pc.instanceMethods, info, "\t");
4662 outs() << "\t\t classMethods " << format("0x%" PRIx32"x", pc.classMethods)
4663 << " (struct method_list_t *)\n";
4664 if (pc.classMethods != 0)
4665 print_method_list32_t(pc.classMethods, info, "\t");
4666 outs() << "\t optionalInstanceMethods "
4667 << format("0x%" PRIx32"x", pc.optionalInstanceMethods) << "\n";
4668 outs() << "\t optionalClassMethods "
4669 << format("0x%" PRIx32"x", pc.optionalClassMethods) << "\n";
4670 outs() << "\t instanceProperties "
4671 << format("0x%" PRIx32"x", pc.instanceProperties) << "\n";
4672 p += sizeof(uint32_t);
4673 offset += sizeof(uint32_t);
4674 }
4675}
4676
4677static void print_indent(uint32_t indent) {
4678 for (uint32_t i = 0; i < indent;) {
4679 if (indent - i >= 8) {
4680 outs() << "\t";
4681 i += 8;
4682 } else {
4683 for (uint32_t j = i; j < indent; j++)
4684 outs() << " ";
4685 return;
4686 }
4687 }
4688}
4689
4690static bool print_method_description_list(uint32_t p, uint32_t indent,
4691 struct DisassembleInfo *info) {
4692 uint32_t offset, left, xleft;
4693 SectionRef S;
4694 struct objc_method_description_list_t mdl;
4695 struct objc_method_description_t md;
4696 const char *r, *list, *name;
4697 int32_t i;
4698
4699 r = get_pointer_32(p, offset, left, S, info, true);
4700 if (r == nullptr)
4701 return true;
4702
4703 outs() << "\n";
4704 if (left > sizeof(struct objc_method_description_list_t)) {
4705 memcpy(&mdl, r, sizeof(struct objc_method_description_list_t));
4706 } else {
4707 print_indent(indent);
4708 outs() << " objc_method_description_list extends past end of the section\n";
4709 memset(&mdl, '\0', sizeof(struct objc_method_description_list_t));
4710 memcpy(&mdl, r, left);
4711 }
4712 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4713 swapStruct(mdl);
4714
4715 print_indent(indent);
4716 outs() << " count " << mdl.count << "\n";
4717
4718 list = r + sizeof(struct objc_method_description_list_t);
4719 for (i = 0; i < mdl.count; i++) {
4720 if ((i + 1) * sizeof(struct objc_method_description_t) > left) {
4721 print_indent(indent);
4722 outs() << " remaining list entries extend past the of the section\n";
4723 break;
4724 }
4725 print_indent(indent);
4726 outs() << " list[" << i << "]\n";
4727 memcpy(&md, list + i * sizeof(struct objc_method_description_t),
4728 sizeof(struct objc_method_description_t));
4729 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4730 swapStruct(md);
4731
4732 print_indent(indent);
4733 outs() << " name " << format("0x%08" PRIx32"x", md.name);
4734 if (info->verbose) {
4735 name = get_pointer_32(md.name, offset, xleft, S, info, true);
4736 if (name != nullptr)
4737 outs() << format(" %.*s", xleft, name);
4738 else
4739 outs() << " (not in an __OBJC section)";
4740 }
4741 outs() << "\n";
4742
4743 print_indent(indent);
4744 outs() << " types " << format("0x%08" PRIx32"x", md.types);
4745 if (info->verbose) {
4746 name = get_pointer_32(md.types, offset, xleft, S, info, true);
4747 if (name != nullptr)
4748 outs() << format(" %.*s", xleft, name);
4749 else
4750 outs() << " (not in an __OBJC section)";
4751 }
4752 outs() << "\n";
4753 }
4754 return false;
4755}
4756
4757static bool print_protocol_list(uint32_t p, uint32_t indent,
4758 struct DisassembleInfo *info);
4759
4760static bool print_protocol(uint32_t p, uint32_t indent,
4761 struct DisassembleInfo *info) {
4762 uint32_t offset, left;
4763 SectionRef S;
4764 struct objc_protocol_t protocol;
4765 const char *r, *name;
4766
4767 r = get_pointer_32(p, offset, left, S, info, true);
4768 if (r == nullptr)
4769 return true;
4770
4771 outs() << "\n";
4772 if (left >= sizeof(struct objc_protocol_t)) {
4773 memcpy(&protocol, r, sizeof(struct objc_protocol_t));
4774 } else {
4775 print_indent(indent);
4776 outs() << " Protocol extends past end of the section\n";
4777 memset(&protocol, '\0', sizeof(struct objc_protocol_t));
4778 memcpy(&protocol, r, left);
4779 }
4780 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4781 swapStruct(protocol);
4782
4783 print_indent(indent);
4784 outs() << " isa " << format("0x%08" PRIx32"x", protocol.isa)
4785 << "\n";
4786
4787 print_indent(indent);
4788 outs() << " protocol_name "
4789 << format("0x%08" PRIx32"x", protocol.protocol_name);
4790 if (info->verbose) {
4791 name = get_pointer_32(protocol.protocol_name, offset, left, S, info, true);
4792 if (name != nullptr)
4793 outs() << format(" %.*s", left, name);
4794 else
4795 outs() << " (not in an __OBJC section)";
4796 }
4797 outs() << "\n";
4798
4799 print_indent(indent);
4800 outs() << " protocol_list "
4801 << format("0x%08" PRIx32"x", protocol.protocol_list);
4802 if (print_protocol_list(protocol.protocol_list, indent + 4, info))
4803 outs() << " (not in an __OBJC section)\n";
4804
4805 print_indent(indent);
4806 outs() << " instance_methods "
4807 << format("0x%08" PRIx32"x", protocol.instance_methods);
4808 if (print_method_description_list(protocol.instance_methods, indent, info))
4809 outs() << " (not in an __OBJC section)\n";
4810
4811 print_indent(indent);
4812 outs() << " class_methods "
4813 << format("0x%08" PRIx32"x", protocol.class_methods);
4814 if (print_method_description_list(protocol.class_methods, indent, info))
4815 outs() << " (not in an __OBJC section)\n";
4816
4817 return false;
4818}
4819
4820static bool print_protocol_list(uint32_t p, uint32_t indent,
4821 struct DisassembleInfo *info) {
4822 uint32_t offset, left, l;
4823 SectionRef S;
4824 struct objc_protocol_list_t protocol_list;
4825 const char *r, *list;
4826 int32_t i;
4827
4828 r = get_pointer_32(p, offset, left, S, info, true);
4829 if (r == nullptr)
4830 return true;
4831
4832 outs() << "\n";
4833 if (left > sizeof(struct objc_protocol_list_t)) {
4834 memcpy(&protocol_list, r, sizeof(struct objc_protocol_list_t));
4835 } else {
4836 outs() << "\t\t objc_protocol_list_t extends past end of the section\n";
4837 memset(&protocol_list, '\0', sizeof(struct objc_protocol_list_t));
4838 memcpy(&protocol_list, r, left);
4839 }
4840 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4841 swapStruct(protocol_list);
4842
4843 print_indent(indent);
4844 outs() << " next " << format("0x%08" PRIx32"x", protocol_list.next)
4845 << "\n";
4846 print_indent(indent);
4847 outs() << " count " << protocol_list.count << "\n";
4848
4849 list = r + sizeof(struct objc_protocol_list_t);
4850 for (i = 0; i < protocol_list.count; i++) {
4851 if ((i + 1) * sizeof(uint32_t) > left) {
4852 outs() << "\t\t remaining list entries extend past the of the section\n";
4853 break;
4854 }
4855 memcpy(&l, list + i * sizeof(uint32_t), sizeof(uint32_t));
4856 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4857 sys::swapByteOrder(l);
4858
4859 print_indent(indent);
4860 outs() << " list[" << i << "] " << format("0x%08" PRIx32"x", l);
4861 if (print_protocol(l, indent, info))
4862 outs() << "(not in an __OBJC section)\n";
4863 }
4864 return false;
4865}
4866
4867static void print_ivar_list64_t(uint64_t p, struct DisassembleInfo *info) {
4868 struct ivar_list64_t il;
4869 struct ivar64_t i;
4870 const char *r;
4871 uint32_t offset, xoffset, left, j;
4872 SectionRef S, xS;
4873 const char *name, *sym_name, *ivar_offset_p;
4874 uint64_t ivar_offset, n_value;
4875
4876 r = get_pointer_64(p, offset, left, S, info);
4877 if (r == nullptr)
4878 return;
4879 memset(&il, '\0', sizeof(struct ivar_list64_t));
4880 if (left < sizeof(struct ivar_list64_t)) {
4881 memcpy(&il, r, left);
4882 outs() << " (ivar_list_t entends past the end of the section)\n";
4883 } else
4884 memcpy(&il, r, sizeof(struct ivar_list64_t));
4885 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4886 swapStruct(il);
4887 outs() << " entsize " << il.entsize << "\n";
4888 outs() << " count " << il.count << "\n";
4889
4890 p += sizeof(struct ivar_list64_t);
4891 offset += sizeof(struct ivar_list64_t);
4892 for (j = 0; j < il.count; j++) {
4893 r = get_pointer_64(p, offset, left, S, info);
4894 if (r == nullptr)
4895 return;
4896 memset(&i, '\0', sizeof(struct ivar64_t));
4897 if (left < sizeof(struct ivar64_t)) {
4898 memcpy(&i, r, left);
4899 outs() << " (ivar_t entends past the end of the section)\n";
4900 } else
4901 memcpy(&i, r, sizeof(struct ivar64_t));
4902 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4903 swapStruct(i);
4904
4905 outs() << "\t\t\t offset ";
4906 sym_name = get_symbol_64(offset + offsetof(struct ivar64_t, offset)__builtin_offsetof(struct ivar64_t, offset), S,
4907 info, n_value, i.offset);
4908 if (n_value != 0) {
4909 if (info->verbose && sym_name != nullptr)
4910 outs() << sym_name;
4911 else
4912 outs() << format("0x%" PRIx64"l" "x", n_value);
4913 if (i.offset != 0)
4914 outs() << " + " << format("0x%" PRIx64"l" "x", i.offset);
4915 } else
4916 outs() << format("0x%" PRIx64"l" "x", i.offset);
4917 ivar_offset_p = get_pointer_64(i.offset + n_value, xoffset, left, xS, info);
4918 if (ivar_offset_p != nullptr && left >= sizeof(*ivar_offset_p)) {
4919 memcpy(&ivar_offset, ivar_offset_p, sizeof(ivar_offset));
4920 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4921 sys::swapByteOrder(ivar_offset);
4922 outs() << " " << ivar_offset << "\n";
4923 } else
4924 outs() << "\n";
4925
4926 outs() << "\t\t\t name ";
4927 sym_name = get_symbol_64(offset + offsetof(struct ivar64_t, name)__builtin_offsetof(struct ivar64_t, name), S, info,
4928 n_value, i.name);
4929 if (n_value != 0) {
4930 if (info->verbose && sym_name != nullptr)
4931 outs() << sym_name;
4932 else
4933 outs() << format("0x%" PRIx64"l" "x", n_value);
4934 if (i.name != 0)
4935 outs() << " + " << format("0x%" PRIx64"l" "x", i.name);
4936 } else
4937 outs() << format("0x%" PRIx64"l" "x", i.name);
4938 name = get_pointer_64(i.name + n_value, xoffset, left, xS, info);
4939 if (name != nullptr)
4940 outs() << format(" %.*s", left, name);
4941 outs() << "\n";
4942
4943 outs() << "\t\t\t type ";
4944 sym_name = get_symbol_64(offset + offsetof(struct ivar64_t, type)__builtin_offsetof(struct ivar64_t, type), S, info,
4945 n_value, i.name);
4946 name = get_pointer_64(i.type + n_value, xoffset, left, xS, info);
4947 if (n_value != 0) {
4948 if (info->verbose && sym_name != nullptr)
4949 outs() << sym_name;
4950 else
4951 outs() << format("0x%" PRIx64"l" "x", n_value);
4952 if (i.type != 0)
4953 outs() << " + " << format("0x%" PRIx64"l" "x", i.type);
4954 } else
4955 outs() << format("0x%" PRIx64"l" "x", i.type);
4956 if (name != nullptr)
4957 outs() << format(" %.*s", left, name);
4958 outs() << "\n";
4959
4960 outs() << "\t\t\talignment " << i.alignment << "\n";
4961 outs() << "\t\t\t size " << i.size << "\n";
4962
4963 p += sizeof(struct ivar64_t);
4964 offset += sizeof(struct ivar64_t);
4965 }
4966}
4967
4968static void print_ivar_list32_t(uint32_t p, struct DisassembleInfo *info) {
4969 struct ivar_list32_t il;
4970 struct ivar32_t i;
4971 const char *r;
4972 uint32_t offset, xoffset, left, j;
4973 SectionRef S, xS;
4974 const char *name, *ivar_offset_p;
4975 uint32_t ivar_offset;
4976
4977 r = get_pointer_32(p, offset, left, S, info);
4978 if (r == nullptr)
4979 return;
4980 memset(&il, '\0', sizeof(struct ivar_list32_t));
4981 if (left < sizeof(struct ivar_list32_t)) {
4982 memcpy(&il, r, left);
4983 outs() << " (ivar_list_t entends past the end of the section)\n";
4984 } else
4985 memcpy(&il, r, sizeof(struct ivar_list32_t));
4986 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
4987 swapStruct(il);
4988 outs() << " entsize " << il.entsize << "\n";
4989 outs() << " count " << il.count << "\n";
4990
4991 p += sizeof(struct ivar_list32_t);
4992 offset += sizeof(struct ivar_list32_t);
4993 for (j = 0; j < il.count; j++) {
4994 r = get_pointer_32(p, offset, left, S, info);
4995 if (r == nullptr)
4996 return;
4997 memset(&i, '\0', sizeof(struct ivar32_t));
4998 if (left < sizeof(struct ivar32_t)) {
4999 memcpy(&i, r, left);
5000 outs() << " (ivar_t entends past the end of the section)\n";
5001 } else
5002 memcpy(&i, r, sizeof(struct ivar32_t));
5003 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5004 swapStruct(i);
5005
5006 outs() << "\t\t\t offset " << format("0x%" PRIx32"x", i.offset);
5007 ivar_offset_p = get_pointer_32(i.offset, xoffset, left, xS, info);
5008 if (ivar_offset_p != nullptr && left >= sizeof(*ivar_offset_p)) {
5009 memcpy(&ivar_offset, ivar_offset_p, sizeof(ivar_offset));
5010 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5011 sys::swapByteOrder(ivar_offset);
5012 outs() << " " << ivar_offset << "\n";
5013 } else
5014 outs() << "\n";
5015
5016 outs() << "\t\t\t name " << format("0x%" PRIx32"x", i.name);
5017 name = get_pointer_32(i.name, xoffset, left, xS, info);
5018 if (name != nullptr)
5019 outs() << format(" %.*s", left, name);
5020 outs() << "\n";
5021
5022 outs() << "\t\t\t type " << format("0x%" PRIx32"x", i.type);
5023 name = get_pointer_32(i.type, xoffset, left, xS, info);
5024 if (name != nullptr)
5025 outs() << format(" %.*s", left, name);
5026 outs() << "\n";
5027
5028 outs() << "\t\t\talignment " << i.alignment << "\n";
5029 outs() << "\t\t\t size " << i.size << "\n";
5030
5031 p += sizeof(struct ivar32_t);
5032 offset += sizeof(struct ivar32_t);
5033 }
5034}
5035
5036static void print_objc_property_list64(uint64_t p,
5037 struct DisassembleInfo *info) {
5038 struct objc_property_list64 opl;
5039 struct objc_property64 op;
5040 const char *r;
5041 uint32_t offset, xoffset, left, j;
5042 SectionRef S, xS;
5043 const char *name, *sym_name;
5044 uint64_t n_value;
5045
5046 r = get_pointer_64(p, offset, left, S, info);
5047 if (r == nullptr)
5048 return;
5049 memset(&opl, '\0', sizeof(struct objc_property_list64));
5050 if (left < sizeof(struct objc_property_list64)) {
5051 memcpy(&opl, r, left);
5052 outs() << " (objc_property_list entends past the end of the section)\n";
5053 } else
5054 memcpy(&opl, r, sizeof(struct objc_property_list64));
5055 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5056 swapStruct(opl);
5057 outs() << " entsize " << opl.entsize << "\n";
5058 outs() << " count " << opl.count << "\n";
5059
5060 p += sizeof(struct objc_property_list64);
5061 offset += sizeof(struct objc_property_list64);
5062 for (j = 0; j < opl.count; j++) {
5063 r = get_pointer_64(p, offset, left, S, info);
5064 if (r == nullptr)
5065 return;
5066 memset(&op, '\0', sizeof(struct objc_property64));
5067 if (left < sizeof(struct objc_property64)) {
5068 memcpy(&op, r, left);
5069 outs() << " (objc_property entends past the end of the section)\n";
5070 } else
5071 memcpy(&op, r, sizeof(struct objc_property64));
5072 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5073 swapStruct(op);
5074
5075 outs() << "\t\t\t name ";
5076 sym_name = get_symbol_64(offset + offsetof(struct objc_property64, name)__builtin_offsetof(struct objc_property64, name), S,
5077 info, n_value, op.name);
5078 if (n_value != 0) {
5079 if (info->verbose && sym_name != nullptr)
5080 outs() << sym_name;
5081 else
5082 outs() << format("0x%" PRIx64"l" "x", n_value);
5083 if (op.name != 0)
5084 outs() << " + " << format("0x%" PRIx64"l" "x", op.name);
5085 } else
5086 outs() << format("0x%" PRIx64"l" "x", op.name);
5087 name = get_pointer_64(op.name + n_value, xoffset, left, xS, info);
5088 if (name != nullptr)
5089 outs() << format(" %.*s", left, name);
5090 outs() << "\n";
5091
5092 outs() << "\t\t\tattributes ";
5093 sym_name =
5094 get_symbol_64(offset + offsetof(struct objc_property64, attributes)__builtin_offsetof(struct objc_property64, attributes), S,
5095 info, n_value, op.attributes);
5096 if (n_value != 0) {
5097 if (info->verbose && sym_name != nullptr)
5098 outs() << sym_name;
5099 else
5100 outs() << format("0x%" PRIx64"l" "x", n_value);
5101 if (op.attributes != 0)
5102 outs() << " + " << format("0x%" PRIx64"l" "x", op.attributes);
5103 } else
5104 outs() << format("0x%" PRIx64"l" "x", op.attributes);
5105 name = get_pointer_64(op.attributes + n_value, xoffset, left, xS, info);
5106 if (name != nullptr)
5107 outs() << format(" %.*s", left, name);
5108 outs() << "\n";
5109
5110 p += sizeof(struct objc_property64);
5111 offset += sizeof(struct objc_property64);
5112 }
5113}
5114
5115static void print_objc_property_list32(uint32_t p,
5116 struct DisassembleInfo *info) {
5117 struct objc_property_list32 opl;
5118 struct objc_property32 op;
5119 const char *r;
5120 uint32_t offset, xoffset, left, j;
5121 SectionRef S, xS;
5122 const char *name;
5123
5124 r = get_pointer_32(p, offset, left, S, info);
5125 if (r == nullptr)
5126 return;
5127 memset(&opl, '\0', sizeof(struct objc_property_list32));
5128 if (left < sizeof(struct objc_property_list32)) {
5129 memcpy(&opl, r, left);
5130 outs() << " (objc_property_list entends past the end of the section)\n";
5131 } else
5132 memcpy(&opl, r, sizeof(struct objc_property_list32));
5133 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5134 swapStruct(opl);
5135 outs() << " entsize " << opl.entsize << "\n";
5136 outs() << " count " << opl.count << "\n";
5137
5138 p += sizeof(struct objc_property_list32);
5139 offset += sizeof(struct objc_property_list32);
5140 for (j = 0; j < opl.count; j++) {
5141 r = get_pointer_32(p, offset, left, S, info);
5142 if (r == nullptr)
5143 return;
5144 memset(&op, '\0', sizeof(struct objc_property32));
5145 if (left < sizeof(struct objc_property32)) {
5146 memcpy(&op, r, left);
5147 outs() << " (objc_property entends past the end of the section)\n";
5148 } else
5149 memcpy(&op, r, sizeof(struct objc_property32));
5150 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5151 swapStruct(op);
5152
5153 outs() << "\t\t\t name " << format("0x%" PRIx32"x", op.name);
5154 name = get_pointer_32(op.name, xoffset, left, xS, info);
5155 if (name != nullptr)
5156 outs() << format(" %.*s", left, name);
5157 outs() << "\n";
5158
5159 outs() << "\t\t\tattributes " << format("0x%" PRIx32"x", op.attributes);
5160 name = get_pointer_32(op.attributes, xoffset, left, xS, info);
5161 if (name != nullptr)
5162 outs() << format(" %.*s", left, name);
5163 outs() << "\n";
5164
5165 p += sizeof(struct objc_property32);
5166 offset += sizeof(struct objc_property32);
5167 }
5168}
5169
5170static bool print_class_ro64_t(uint64_t p, struct DisassembleInfo *info,
5171 bool &is_meta_class) {
5172 struct class_ro64_t cro;
5173 const char *r;
5174 uint32_t offset, xoffset, left;
5175 SectionRef S, xS;
5176 const char *name, *sym_name;
5177 uint64_t n_value;
5178
5179 r = get_pointer_64(p, offset, left, S, info);
5180 if (r == nullptr || left < sizeof(struct class_ro64_t))
5181 return false;
5182 memcpy(&cro, r, sizeof(struct class_ro64_t));
5183 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5184 swapStruct(cro);
5185 outs() << " flags " << format("0x%" PRIx32"x", cro.flags);
5186 if (cro.flags & RO_META(1 << 0))
5187 outs() << " RO_META";
5188 if (cro.flags & RO_ROOT(1 << 1))
5189 outs() << " RO_ROOT";
5190 if (cro.flags & RO_HAS_CXX_STRUCTORS(1 << 2))
5191 outs() << " RO_HAS_CXX_STRUCTORS";
5192 outs() << "\n";
5193 outs() << " instanceStart " << cro.instanceStart << "\n";
5194 outs() << " instanceSize " << cro.instanceSize << "\n";
5195 outs() << " reserved " << format("0x%" PRIx32"x", cro.reserved)
5196 << "\n";
5197 outs() << " ivarLayout " << format("0x%" PRIx64"l" "x", cro.ivarLayout)
5198 << "\n";
5199 print_layout_map64(cro.ivarLayout, info);
5200
5201 outs() << " name ";
5202 sym_name = get_symbol_64(offset + offsetof(struct class_ro64_t, name)__builtin_offsetof(struct class_ro64_t, name), S,
5203 info, n_value, cro.name);
5204 if (n_value != 0) {
5205 if (info->verbose && sym_name != nullptr)
5206 outs() << sym_name;
5207 else
5208 outs() << format("0x%" PRIx64"l" "x", n_value);
5209 if (cro.name != 0)
5210 outs() << " + " << format("0x%" PRIx64"l" "x", cro.name);
5211 } else
5212 outs() << format("0x%" PRIx64"l" "x", cro.name);
5213 name = get_pointer_64(cro.name + n_value, xoffset, left, xS, info);
5214 if (name != nullptr)
5215 outs() << format(" %.*s", left, name);
5216 outs() << "\n";
5217
5218 outs() << " baseMethods ";
5219 sym_name = get_symbol_64(offset + offsetof(struct class_ro64_t, baseMethods)__builtin_offsetof(struct class_ro64_t, baseMethods),
5220 S, info, n_value, cro.baseMethods);
5221 if (n_value != 0) {
5222 if (info->verbose && sym_name != nullptr)
5223 outs() << sym_name;
5224 else
5225 outs() << format("0x%" PRIx64"l" "x", n_value);
5226 if (cro.baseMethods != 0)
5227 outs() << " + " << format("0x%" PRIx64"l" "x", cro.baseMethods);
5228 } else
5229 outs() << format("0x%" PRIx64"l" "x", cro.baseMethods);
5230 outs() << " (struct method_list_t *)\n";
5231 if (cro.baseMethods + n_value != 0)
5232 print_method_list64_t(cro.baseMethods + n_value, info, "");
5233
5234 outs() << " baseProtocols ";
5235 sym_name =
5236 get_symbol_64(offset + offsetof(struct class_ro64_t, baseProtocols)__builtin_offsetof(struct class_ro64_t, baseProtocols), S,
5237 info, n_value, cro.baseProtocols);
5238 if (n_value != 0) {
5239 if (info->verbose && sym_name != nullptr)
5240 outs() << sym_name;
5241 else
5242 outs() << format("0x%" PRIx64"l" "x", n_value);
5243 if (cro.baseProtocols != 0)
5244 outs() << " + " << format("0x%" PRIx64"l" "x", cro.baseProtocols);
5245 } else
5246 outs() << format("0x%" PRIx64"l" "x", cro.baseProtocols);
5247 outs() << "\n";
5248 if (cro.baseProtocols + n_value != 0)
5249 print_protocol_list64_t(cro.baseProtocols + n_value, info);
5250
5251 outs() << " ivars ";
5252 sym_name = get_symbol_64(offset + offsetof(struct class_ro64_t, ivars)__builtin_offsetof(struct class_ro64_t, ivars), S,
5253 info, n_value, cro.ivars);
5254 if (n_value != 0) {
5255 if (info->verbose && sym_name != nullptr)
5256 outs() << sym_name;
5257 else
5258 outs() << format("0x%" PRIx64"l" "x", n_value);
5259 if (cro.ivars != 0)
5260 outs() << " + " << format("0x%" PRIx64"l" "x", cro.ivars);
5261 } else
5262 outs() << format("0x%" PRIx64"l" "x", cro.ivars);
5263 outs() << "\n";
5264 if (cro.ivars + n_value != 0)
5265 print_ivar_list64_t(cro.ivars + n_value, info);
5266
5267 outs() << " weakIvarLayout ";
5268 sym_name =
5269 get_symbol_64(offset + offsetof(struct class_ro64_t, weakIvarLayout)__builtin_offsetof(struct class_ro64_t, weakIvarLayout), S,
5270 info, n_value, cro.weakIvarLayout);
5271 if (n_value != 0) {
5272 if (info->verbose && sym_name != nullptr)
5273 outs() << sym_name;
5274 else
5275 outs() << format("0x%" PRIx64"l" "x", n_value);
5276 if (cro.weakIvarLayout != 0)
5277 outs() << " + " << format("0x%" PRIx64"l" "x", cro.weakIvarLayout);
5278 } else
5279 outs() << format("0x%" PRIx64"l" "x", cro.weakIvarLayout);
5280 outs() << "\n";
5281 print_layout_map64(cro.weakIvarLayout + n_value, info);
5282
5283 outs() << " baseProperties ";
5284 sym_name =
5285 get_symbol_64(offset + offsetof(struct class_ro64_t, baseProperties)__builtin_offsetof(struct class_ro64_t, baseProperties), S,
5286 info, n_value, cro.baseProperties);
5287 if (n_value != 0) {
5288 if (info->verbose && sym_name != nullptr)
5289 outs() << sym_name;
5290 else
5291 outs() << format("0x%" PRIx64"l" "x", n_value);
5292 if (cro.baseProperties != 0)
5293 outs() << " + " << format("0x%" PRIx64"l" "x", cro.baseProperties);
5294 } else
5295 outs() << format("0x%" PRIx64"l" "x", cro.baseProperties);
5296 outs() << "\n";
5297 if (cro.baseProperties + n_value != 0)
5298 print_objc_property_list64(cro.baseProperties + n_value, info);
5299
5300 is_meta_class = (cro.flags & RO_META(1 << 0)) != 0;
5301 return true;
5302}
5303
5304static bool print_class_ro32_t(uint32_t p, struct DisassembleInfo *info,
5305 bool &is_meta_class) {
5306 struct class_ro32_t cro;
5307 const char *r;
5308 uint32_t offset, xoffset, left;
5309 SectionRef S, xS;
5310 const char *name;
5311
5312 r = get_pointer_32(p, offset, left, S, info);
5313 if (r == nullptr)
5314 return false;
5315 memset(&cro, '\0', sizeof(struct class_ro32_t));
5316 if (left < sizeof(struct class_ro32_t)) {
5317 memcpy(&cro, r, left);
5318 outs() << " (class_ro_t entends past the end of the section)\n";
5319 } else
5320 memcpy(&cro, r, sizeof(struct class_ro32_t));
5321 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5322 swapStruct(cro);
5323 outs() << " flags " << format("0x%" PRIx32"x", cro.flags);
5324 if (cro.flags & RO_META(1 << 0))
5325 outs() << " RO_META";
5326 if (cro.flags & RO_ROOT(1 << 1))
5327 outs() << " RO_ROOT";
5328 if (cro.flags & RO_HAS_CXX_STRUCTORS(1 << 2))
5329 outs() << " RO_HAS_CXX_STRUCTORS";
5330 outs() << "\n";
5331 outs() << " instanceStart " << cro.instanceStart << "\n";
5332 outs() << " instanceSize " << cro.instanceSize << "\n";
5333 outs() << " ivarLayout " << format("0x%" PRIx32"x", cro.ivarLayout)
5334 << "\n";
5335 print_layout_map32(cro.ivarLayout, info);
5336
5337 outs() << " name " << format("0x%" PRIx32"x", cro.name);
5338 name = get_pointer_32(cro.name, xoffset, left, xS, info);
5339 if (name != nullptr)
5340 outs() << format(" %.*s", left, name);
5341 outs() << "\n";
5342
5343 outs() << " baseMethods "
5344 << format("0x%" PRIx32"x", cro.baseMethods)
5345 << " (struct method_list_t *)\n";
5346 if (cro.baseMethods != 0)
5347 print_method_list32_t(cro.baseMethods, info, "");
5348
5349 outs() << " baseProtocols "
5350 << format("0x%" PRIx32"x", cro.baseProtocols) << "\n";
5351 if (cro.baseProtocols != 0)
5352 print_protocol_list32_t(cro.baseProtocols, info);
5353 outs() << " ivars " << format("0x%" PRIx32"x", cro.ivars)
5354 << "\n";
5355 if (cro.ivars != 0)
5356 print_ivar_list32_t(cro.ivars, info);
5357 outs() << " weakIvarLayout "
5358 << format("0x%" PRIx32"x", cro.weakIvarLayout) << "\n";
5359 print_layout_map32(cro.weakIvarLayout, info);
5360 outs() << " baseProperties "
5361 << format("0x%" PRIx32"x", cro.baseProperties) << "\n";
5362 if (cro.baseProperties != 0)
5363 print_objc_property_list32(cro.baseProperties, info);
5364 is_meta_class = (cro.flags & RO_META(1 << 0)) != 0;
5365 return true;
5366}
5367
5368static void print_class64_t(uint64_t p, struct DisassembleInfo *info) {
5369 struct class64_t c;
5370 const char *r;
5371 uint32_t offset, left;
5372 SectionRef S;
5373 const char *name;
5374 uint64_t isa_n_value, n_value;
5375
5376 r = get_pointer_64(p, offset, left, S, info);
5377 if (r == nullptr || left < sizeof(struct class64_t))
5378 return;
5379 memcpy(&c, r, sizeof(struct class64_t));
5380 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5381 swapStruct(c);
5382
5383 outs() << " isa " << format("0x%" PRIx64"l" "x", c.isa);
5384 name = get_symbol_64(offset + offsetof(struct class64_t, isa)__builtin_offsetof(struct class64_t, isa), S, info,
5385 isa_n_value, c.isa);
5386 if (name != nullptr)
5387 outs() << " " << name;
5388 outs() << "\n";
5389
5390 outs() << " superclass " << format("0x%" PRIx64"l" "x", c.superclass);
5391 name = get_symbol_64(offset + offsetof(struct class64_t, superclass)__builtin_offsetof(struct class64_t, superclass), S, info,
5392 n_value, c.superclass);
5393 if (name != nullptr)
5394 outs() << " " << name;
5395 else {
5396 name = get_dyld_bind_info_symbolname(S.getAddress() +
5397 offset + offsetof(struct class64_t, superclass)__builtin_offsetof(struct class64_t, superclass), info);
5398 if (name != nullptr)
5399 outs() << " " << name;
5400 }
5401 outs() << "\n";
5402
5403 outs() << " cache " << format("0x%" PRIx64"l" "x", c.cache);
5404 name = get_symbol_64(offset + offsetof(struct class64_t, cache)__builtin_offsetof(struct class64_t, cache), S, info,
5405 n_value, c.cache);
5406 if (name != nullptr)
5407 outs() << " " << name;
5408 outs() << "\n";
5409
5410 outs() << " vtable " << format("0x%" PRIx64"l" "x", c.vtable);
5411 name = get_symbol_64(offset + offsetof(struct class64_t, vtable)__builtin_offsetof(struct class64_t, vtable), S, info,
5412 n_value, c.vtable);
5413 if (name != nullptr)
5414 outs() << " " << name;
5415 outs() << "\n";
5416
5417 name = get_symbol_64(offset + offsetof(struct class64_t, data)__builtin_offsetof(struct class64_t, data), S, info,
5418 n_value, c.data);
5419 outs() << " data ";
5420 if (n_value != 0) {
5421 if (info->verbose && name != nullptr)
5422 outs() << name;
5423 else
5424 outs() << format("0x%" PRIx64"l" "x", n_value);
5425 if (c.data != 0)
5426 outs() << " + " << format("0x%" PRIx64"l" "x", c.data);
5427 } else
5428 outs() << format("0x%" PRIx64"l" "x", c.data);
5429 outs() << " (struct class_ro_t *)";
5430
5431 // This is a Swift class if some of the low bits of the pointer are set.
5432 if ((c.data + n_value) & 0x7)
5433 outs() << " Swift class";
5434 outs() << "\n";
5435 bool is_meta_class;
5436 if (!print_class_ro64_t((c.data + n_value) & ~0x7, info, is_meta_class))
5437 return;
5438
5439 if (!is_meta_class &&
5440 c.isa + isa_n_value != p &&
5441 c.isa + isa_n_value != 0 &&
5442 info->depth < 100) {
5443 info->depth++;
5444 outs() << "Meta Class\n";
5445 print_class64_t(c.isa + isa_n_value, info);
5446 }
5447}
5448
5449static void print_class32_t(uint32_t p, struct DisassembleInfo *info) {
5450 struct class32_t c;
5451 const char *r;
5452 uint32_t offset, left;
5453 SectionRef S;
5454 const char *name;
5455
5456 r = get_pointer_32(p, offset, left, S, info);
5457 if (r == nullptr)
5458 return;
5459 memset(&c, '\0', sizeof(struct class32_t));
5460 if (left < sizeof(struct class32_t)) {
5461 memcpy(&c, r, left);
5462 outs() << " (class_t entends past the end of the section)\n";
5463 } else
5464 memcpy(&c, r, sizeof(struct class32_t));
5465 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5466 swapStruct(c);
5467
5468 outs() << " isa " << format("0x%" PRIx32"x", c.isa);
5469 name =
5470 get_symbol_32(offset + offsetof(struct class32_t, isa)__builtin_offsetof(struct class32_t, isa), S, info, c.isa);
5471 if (name != nullptr)
5472 outs() << " " << name;
5473 outs() << "\n";
5474
5475 outs() << " superclass " << format("0x%" PRIx32"x", c.superclass);
5476 name = get_symbol_32(offset + offsetof(struct class32_t, superclass)__builtin_offsetof(struct class32_t, superclass), S, info,
5477 c.superclass);
5478 if (name != nullptr)
5479 outs() << " " << name;
5480 outs() << "\n";
5481
5482 outs() << " cache " << format("0x%" PRIx32"x", c.cache);
5483 name = get_symbol_32(offset + offsetof(struct class32_t, cache)__builtin_offsetof(struct class32_t, cache), S, info,
5484 c.cache);
5485 if (name != nullptr)
5486 outs() << " " << name;
5487 outs() << "\n";
5488
5489 outs() << " vtable " << format("0x%" PRIx32"x", c.vtable);
5490 name = get_symbol_32(offset + offsetof(struct class32_t, vtable)__builtin_offsetof(struct class32_t, vtable), S, info,
5491 c.vtable);
5492 if (name != nullptr)
5493 outs() << " " << name;
5494 outs() << "\n";
5495
5496 name =
5497 get_symbol_32(offset + offsetof(struct class32_t, data)__builtin_offsetof(struct class32_t, data), S, info, c.data);
5498 outs() << " data " << format("0x%" PRIx32"x", c.data)
5499 << " (struct class_ro_t *)";
5500
5501 // This is a Swift class if some of the low bits of the pointer are set.
5502 if (c.data & 0x3)
5503 outs() << " Swift class";
5504 outs() << "\n";
5505 bool is_meta_class;
5506 if (!print_class_ro32_t(c.data & ~0x3, info, is_meta_class))
5507 return;
5508
5509 if (!is_meta_class) {
5510 outs() << "Meta Class\n";
5511 print_class32_t(c.isa, info);
5512 }
5513}
5514
5515static void print_objc_class_t(struct objc_class_t *objc_class,
5516 struct DisassembleInfo *info) {
5517 uint32_t offset, left, xleft;
5518 const char *name, *p, *ivar_list;
5519 SectionRef S;
5520 int32_t i;
5521 struct objc_ivar_list_t objc_ivar_list;
5522 struct objc_ivar_t ivar;
5523
5524 outs() << "\t\t isa " << format("0x%08" PRIx32"x", objc_class->isa);
5525 if (info->verbose && CLS_GETINFO(objc_class, CLS_META)((objc_class)->info & (0x2))) {
5526 name = get_pointer_32(objc_class->isa, offset, left, S, info, true);
5527 if (name != nullptr)
5528 outs() << format(" %.*s", left, name);
5529 else
5530 outs() << " (not in an __OBJC section)";
5531 }
5532 outs() << "\n";
5533
5534 outs() << "\t super_class "
5535 << format("0x%08" PRIx32"x", objc_class->super_class);
5536 if (info->verbose) {
5537 name = get_pointer_32(objc_class->super_class, offset, left, S, info, true);
5538 if (name != nullptr)
5539 outs() << format(" %.*s", left, name);
5540 else
5541 outs() << " (not in an __OBJC section)";
5542 }
5543 outs() << "\n";
5544
5545 outs() << "\t\t name " << format("0x%08" PRIx32"x", objc_class->name);
5546 if (info->verbose) {
5547 name = get_pointer_32(objc_class->name, offset, left, S, info, true);
5548 if (name != nullptr)
5549 outs() << format(" %.*s", left, name);
5550 else
5551 outs() << " (not in an __OBJC section)";
5552 }
5553 outs() << "\n";
5554
5555 outs() << "\t\t version " << format("0x%08" PRIx32"x", objc_class->version)
5556 << "\n";
5557
5558 outs() << "\t\t info " << format("0x%08" PRIx32"x", objc_class->info);
5559 if (info->verbose) {
5560 if (CLS_GETINFO(objc_class, CLS_CLASS)((objc_class)->info & (0x1)))
5561 outs() << " CLS_CLASS";
5562 else if (CLS_GETINFO(objc_class, CLS_META)((objc_class)->info & (0x2)))
5563 outs() << " CLS_META";
5564 }
5565 outs() << "\n";
5566
5567 outs() << "\t instance_size "
5568 << format("0x%08" PRIx32"x", objc_class->instance_size) << "\n";
5569
5570 p = get_pointer_32(objc_class->ivars, offset, left, S, info, true);
5571 outs() << "\t\t ivars " << format("0x%08" PRIx32"x", objc_class->ivars);
5572 if (p != nullptr) {
5573 if (left > sizeof(struct objc_ivar_list_t)) {
5574 outs() << "\n";
5575 memcpy(&objc_ivar_list, p, sizeof(struct objc_ivar_list_t));
5576 } else {
5577 outs() << " (entends past the end of the section)\n";
5578 memset(&objc_ivar_list, '\0', sizeof(struct objc_ivar_list_t));
5579 memcpy(&objc_ivar_list, p, left);
5580 }
5581 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5582 swapStruct(objc_ivar_list);
5583 outs() << "\t\t ivar_count " << objc_ivar_list.ivar_count << "\n";
5584 ivar_list = p + sizeof(struct objc_ivar_list_t);
5585 for (i = 0; i < objc_ivar_list.ivar_count; i++) {
5586 if ((i + 1) * sizeof(struct objc_ivar_t) > left) {
5587 outs() << "\t\t remaining ivar's extend past the of the section\n";
5588 break;
5589 }
5590 memcpy(&ivar, ivar_list + i * sizeof(struct objc_ivar_t),
5591 sizeof(struct objc_ivar_t));
5592 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5593 swapStruct(ivar);
5594
5595 outs() << "\t\t\tivar_name " << format("0x%08" PRIx32"x", ivar.ivar_name);
5596 if (info->verbose) {
5597 name = get_pointer_32(ivar.ivar_name, offset, xleft, S, info, true);
5598 if (name != nullptr)
5599 outs() << format(" %.*s", xleft, name);
5600 else
5601 outs() << " (not in an __OBJC section)";
5602 }
5603 outs() << "\n";
5604
5605 outs() << "\t\t\tivar_type " << format("0x%08" PRIx32"x", ivar.ivar_type);
5606 if (info->verbose) {
5607 name = get_pointer_32(ivar.ivar_type, offset, xleft, S, info, true);
5608 if (name != nullptr)
5609 outs() << format(" %.*s", xleft, name);
5610 else
5611 outs() << " (not in an __OBJC section)";
5612 }
5613 outs() << "\n";
5614
5615 outs() << "\t\t ivar_offset "
5616 << format("0x%08" PRIx32"x", ivar.ivar_offset) << "\n";
5617 }
5618 } else {
5619 outs() << " (not in an __OBJC section)\n";
5620 }
5621
5622 outs() << "\t\t methods " << format("0x%08" PRIx32"x", objc_class->methodLists);
5623 if (print_method_list(objc_class->methodLists, info))
5624 outs() << " (not in an __OBJC section)\n";
5625
5626 outs() << "\t\t cache " << format("0x%08" PRIx32"x", objc_class->cache)
5627 << "\n";
5628
5629 outs() << "\t\tprotocols " << format("0x%08" PRIx32"x", objc_class->protocols);
5630 if (print_protocol_list(objc_class->protocols, 16, info))
5631 outs() << " (not in an __OBJC section)\n";
5632}
5633
5634static void print_objc_objc_category_t(struct objc_category_t *objc_category,
5635 struct DisassembleInfo *info) {
5636 uint32_t offset, left;
5637 const char *name;
5638 SectionRef S;
5639
5640 outs() << "\t category name "
5641 << format("0x%08" PRIx32"x", objc_category->category_name);
5642 if (info->verbose) {
5643 name = get_pointer_32(objc_category->category_name, offset, left, S, info,
5644 true);
5645 if (name != nullptr)
5646 outs() << format(" %.*s", left, name);
5647 else
5648 outs() << " (not in an __OBJC section)";
5649 }
5650 outs() << "\n";
5651
5652 outs() << "\t\t class name "
5653 << format("0x%08" PRIx32"x", objc_category->class_name);
5654 if (info->verbose) {
5655 name =
5656 get_pointer_32(objc_category->class_name, offset, left, S, info, true);
5657 if (name != nullptr)
5658 outs() << format(" %.*s", left, name);
5659 else
5660 outs() << " (not in an __OBJC section)";
5661 }
5662 outs() << "\n";
5663
5664 outs() << "\t instance methods "
5665 << format("0x%08" PRIx32"x", objc_category->instance_methods);
5666 if (print_method_list(objc_category->instance_methods, info))
5667 outs() << " (not in an __OBJC section)\n";
5668
5669 outs() << "\t class methods "
5670 << format("0x%08" PRIx32"x", objc_category->class_methods);
5671 if (print_method_list(objc_category->class_methods, info))
5672 outs() << " (not in an __OBJC section)\n";
5673}
5674
5675static void print_category64_t(uint64_t p, struct DisassembleInfo *info) {
5676 struct category64_t c;
5677 const char *r;
5678 uint32_t offset, xoffset, left;
5679 SectionRef S, xS;
5680 const char *name, *sym_name;
5681 uint64_t n_value;
5682
5683 r = get_pointer_64(p, offset, left, S, info);
5684 if (r == nullptr)
5685 return;
5686 memset(&c, '\0', sizeof(struct category64_t));
5687 if (left < sizeof(struct category64_t)) {
5688 memcpy(&c, r, left);
5689 outs() << " (category_t entends past the end of the section)\n";
5690 } else
5691 memcpy(&c, r, sizeof(struct category64_t));
5692 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5693 swapStruct(c);
5694
5695 outs() << " name ";
5696 sym_name = get_symbol_64(offset + offsetof(struct category64_t, name)__builtin_offsetof(struct category64_t, name), S,
5697 info, n_value, c.name);
5698 if (n_value != 0) {
5699 if (info->verbose && sym_name != nullptr)
5700 outs() << sym_name;
5701 else
5702 outs() << format("0x%" PRIx64"l" "x", n_value);
5703 if (c.name != 0)
5704 outs() << " + " << format("0x%" PRIx64"l" "x", c.name);
5705 } else
5706 outs() << format("0x%" PRIx64"l" "x", c.name);
5707 name = get_pointer_64(c.name + n_value, xoffset, left, xS, info);
5708 if (name != nullptr)
5709 outs() << format(" %.*s", left, name);
5710 outs() << "\n";
5711
5712 outs() << " cls ";
5713 sym_name = get_symbol_64(offset + offsetof(struct category64_t, cls)__builtin_offsetof(struct category64_t, cls), S, info,
5714 n_value, c.cls);
5715 if (n_value != 0) {
5716 if (info->verbose && sym_name != nullptr)
5717 outs() << sym_name;
5718 else
5719 outs() << format("0x%" PRIx64"l" "x", n_value);
5720 if (c.cls != 0)
5721 outs() << " + " << format("0x%" PRIx64"l" "x", c.cls);
5722 } else
5723 outs() << format("0x%" PRIx64"l" "x", c.cls);
5724 outs() << "\n";
5725 if (c.cls + n_value != 0)
5726 print_class64_t(c.cls + n_value, info);
5727
5728 outs() << " instanceMethods ";
5729 sym_name =
5730 get_symbol_64(offset + offsetof(struct category64_t, instanceMethods)__builtin_offsetof(struct category64_t, instanceMethods), S,
5731 info, n_value, c.instanceMethods);
5732 if (n_value != 0) {
5733 if (info->verbose && sym_name != nullptr)
5734 outs() << sym_name;
5735 else
5736 outs() << format("0x%" PRIx64"l" "x", n_value);
5737 if (c.instanceMethods != 0)
5738 outs() << " + " << format("0x%" PRIx64"l" "x", c.instanceMethods);
5739 } else
5740 outs() << format("0x%" PRIx64"l" "x", c.instanceMethods);
5741 outs() << "\n";
5742 if (c.instanceMethods + n_value != 0)
5743 print_method_list64_t(c.instanceMethods + n_value, info, "");
5744
5745 outs() << " classMethods ";
5746 sym_name = get_symbol_64(offset + offsetof(struct category64_t, classMethods)__builtin_offsetof(struct category64_t, classMethods),
5747 S, info, n_value, c.classMethods);
5748 if (n_value != 0) {
5749 if (info->verbose && sym_name != nullptr)
5750 outs() << sym_name;
5751 else
5752 outs() << format("0x%" PRIx64"l" "x", n_value);
5753 if (c.classMethods != 0)
5754 outs() << " + " << format("0x%" PRIx64"l" "x", c.classMethods);
5755 } else
5756 outs() << format("0x%" PRIx64"l" "x", c.classMethods);
5757 outs() << "\n";
5758 if (c.classMethods + n_value != 0)
5759 print_method_list64_t(c.classMethods + n_value, info, "");
5760
5761 outs() << " protocols ";
5762 sym_name = get_symbol_64(offset + offsetof(struct category64_t, protocols)__builtin_offsetof(struct category64_t, protocols), S,
5763 info, n_value, c.protocols);
5764 if (n_value != 0) {
5765 if (info->verbose && sym_name != nullptr)
5766 outs() << sym_name;
5767 else
5768 outs() << format("0x%" PRIx64"l" "x", n_value);
5769 if (c.protocols != 0)
5770 outs() << " + " << format("0x%" PRIx64"l" "x", c.protocols);
5771 } else
5772 outs() << format("0x%" PRIx64"l" "x", c.protocols);
5773 outs() << "\n";
5774 if (c.protocols + n_value != 0)
5775 print_protocol_list64_t(c.protocols + n_value, info);
5776
5777 outs() << "instanceProperties ";
5778 sym_name =
5779 get_symbol_64(offset + offsetof(struct category64_t, instanceProperties)__builtin_offsetof(struct category64_t, instanceProperties),
5780 S, info, n_value, c.instanceProperties);
5781 if (n_value != 0) {
5782 if (info->verbose && sym_name != nullptr)
5783 outs() << sym_name;
5784 else
5785 outs() << format("0x%" PRIx64"l" "x", n_value);
5786 if (c.instanceProperties != 0)
5787 outs() << " + " << format("0x%" PRIx64"l" "x", c.instanceProperties);
5788 } else
5789 outs() << format("0x%" PRIx64"l" "x", c.instanceProperties);
5790 outs() << "\n";
5791 if (c.instanceProperties + n_value != 0)
5792 print_objc_property_list64(c.instanceProperties + n_value, info);
5793}
5794
5795static void print_category32_t(uint32_t p, struct DisassembleInfo *info) {
5796 struct category32_t c;
5797 const char *r;
5798 uint32_t offset, left;
5799 SectionRef S, xS;
5800 const char *name;
5801
5802 r = get_pointer_32(p, offset, left, S, info);
5803 if (r == nullptr)
5804 return;
5805 memset(&c, '\0', sizeof(struct category32_t));
5806 if (left < sizeof(struct category32_t)) {
5807 memcpy(&c, r, left);
5808 outs() << " (category_t entends past the end of the section)\n";
5809 } else
5810 memcpy(&c, r, sizeof(struct category32_t));
5811 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5812 swapStruct(c);
5813
5814 outs() << " name " << format("0x%" PRIx32"x", c.name);
5815 name = get_symbol_32(offset + offsetof(struct category32_t, name)__builtin_offsetof(struct category32_t, name), S, info,
5816 c.name);
5817 if (name)
5818 outs() << " " << name;
5819 outs() << "\n";
5820
5821 outs() << " cls " << format("0x%" PRIx32"x", c.cls) << "\n";
5822 if (c.cls != 0)
5823 print_class32_t(c.cls, info);
5824 outs() << " instanceMethods " << format("0x%" PRIx32"x", c.instanceMethods)
5825 << "\n";
5826 if (c.instanceMethods != 0)
5827 print_method_list32_t(c.instanceMethods, info, "");
5828 outs() << " classMethods " << format("0x%" PRIx32"x", c.classMethods)
5829 << "\n";
5830 if (c.classMethods != 0)
5831 print_method_list32_t(c.classMethods, info, "");
5832 outs() << " protocols " << format("0x%" PRIx32"x", c.protocols) << "\n";
5833 if (c.protocols != 0)
5834 print_protocol_list32_t(c.protocols, info);
5835 outs() << "instanceProperties " << format("0x%" PRIx32"x", c.instanceProperties)
5836 << "\n";
5837 if (c.instanceProperties != 0)
5838 print_objc_property_list32(c.instanceProperties, info);
5839}
5840
5841static void print_message_refs64(SectionRef S, struct DisassembleInfo *info) {
5842 uint32_t i, left, offset, xoffset;
5843 uint64_t p, n_value;
5844 struct message_ref64 mr;
5845 const char *name, *sym_name;
5846 const char *r;
5847 SectionRef xS;
5848
5849 if (S == SectionRef())
5850 return;
5851
5852 StringRef SectName;
5853 Expected<StringRef> SecNameOrErr = S.getName();
5854 if (SecNameOrErr)
5855 SectName = *SecNameOrErr;
5856 else
5857 consumeError(SecNameOrErr.takeError());
5858
5859 DataRefImpl Ref = S.getRawDataRefImpl();
5860 StringRef SegName = info->O->getSectionFinalSegmentName(Ref);
5861 outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
5862 offset = 0;
5863 for (i = 0; i < S.getSize(); i += sizeof(struct message_ref64)) {
5864 p = S.getAddress() + i;
5865 r = get_pointer_64(p, offset, left, S, info);
5866 if (r == nullptr)
5867 return;
5868 memset(&mr, '\0', sizeof(struct message_ref64));
5869 if (left < sizeof(struct message_ref64)) {
5870 memcpy(&mr, r, left);
5871 outs() << " (message_ref entends past the end of the section)\n";
5872 } else
5873 memcpy(&mr, r, sizeof(struct message_ref64));
5874 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5875 swapStruct(mr);
5876
5877 outs() << " imp ";
5878 name = get_symbol_64(offset + offsetof(struct message_ref64, imp)__builtin_offsetof(struct message_ref64, imp), S, info,
5879 n_value, mr.imp);
5880 if (n_value != 0) {
5881 outs() << format("0x%" PRIx64"l" "x", n_value) << " ";
5882 if (mr.imp != 0)
5883 outs() << "+ " << format("0x%" PRIx64"l" "x", mr.imp) << " ";
5884 } else
5885 outs() << format("0x%" PRIx64"l" "x", mr.imp) << " ";
5886 if (name != nullptr)
5887 outs() << " " << name;
5888 outs() << "\n";
5889
5890 outs() << " sel ";
5891 sym_name = get_symbol_64(offset + offsetof(struct message_ref64, sel)__builtin_offsetof(struct message_ref64, sel), S,
5892 info, n_value, mr.sel);
5893 if (n_value != 0) {
5894 if (info->verbose && sym_name != nullptr)
5895 outs() << sym_name;
5896 else
5897 outs() << format("0x%" PRIx64"l" "x", n_value);
5898 if (mr.sel != 0)
5899 outs() << " + " << format("0x%" PRIx64"l" "x", mr.sel);
5900 } else
5901 outs() << format("0x%" PRIx64"l" "x", mr.sel);
5902 name = get_pointer_64(mr.sel + n_value, xoffset, left, xS, info);
5903 if (name != nullptr)
5904 outs() << format(" %.*s", left, name);
5905 outs() << "\n";
5906
5907 offset += sizeof(struct message_ref64);
5908 }
5909}
5910
5911static void print_message_refs32(SectionRef S, struct DisassembleInfo *info) {
5912 uint32_t i, left, offset, xoffset, p;
5913 struct message_ref32 mr;
5914 const char *name, *r;
5915 SectionRef xS;
5916
5917 if (S == SectionRef())
5918 return;
5919
5920 StringRef SectName;
5921 Expected<StringRef> SecNameOrErr = S.getName();
5922 if (SecNameOrErr)
5923 SectName = *SecNameOrErr;
5924 else
5925 consumeError(SecNameOrErr.takeError());
5926
5927 DataRefImpl Ref = S.getRawDataRefImpl();
5928 StringRef SegName = info->O->getSectionFinalSegmentName(Ref);
5929 outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
5930 offset = 0;
5931 for (i = 0; i < S.getSize(); i += sizeof(struct message_ref64)) {
5932 p = S.getAddress() + i;
5933 r = get_pointer_32(p, offset, left, S, info);
5934 if (r == nullptr)
5935 return;
5936 memset(&mr, '\0', sizeof(struct message_ref32));
5937 if (left < sizeof(struct message_ref32)) {
5938 memcpy(&mr, r, left);
5939 outs() << " (message_ref entends past the end of the section)\n";
5940 } else
5941 memcpy(&mr, r, sizeof(struct message_ref32));
5942 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5943 swapStruct(mr);
5944
5945 outs() << " imp " << format("0x%" PRIx32"x", mr.imp);
5946 name = get_symbol_32(offset + offsetof(struct message_ref32, imp)__builtin_offsetof(struct message_ref32, imp), S, info,
5947 mr.imp);
5948 if (name != nullptr)
5949 outs() << " " << name;
5950 outs() << "\n";
5951
5952 outs() << " sel " << format("0x%" PRIx32"x", mr.sel);
5953 name = get_pointer_32(mr.sel, xoffset, left, xS, info);
5954 if (name != nullptr)
5955 outs() << " " << name;
5956 outs() << "\n";
5957
5958 offset += sizeof(struct message_ref32);
5959 }
5960}
5961
5962static void print_image_info64(SectionRef S, struct DisassembleInfo *info) {
5963 uint32_t left, offset, swift_version;
5964 uint64_t p;
5965 struct objc_image_info64 o;
5966 const char *r;
5967
5968 if (S == SectionRef())
5969 return;
5970
5971 StringRef SectName;
5972 Expected<StringRef> SecNameOrErr = S.getName();
5973 if (SecNameOrErr)
5974 SectName = *SecNameOrErr;
5975 else
5976 consumeError(SecNameOrErr.takeError());
5977
5978 DataRefImpl Ref = S.getRawDataRefImpl();
5979 StringRef SegName = info->O->getSectionFinalSegmentName(Ref);
5980 outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
5981 p = S.getAddress();
5982 r = get_pointer_64(p, offset, left, S, info);
5983 if (r == nullptr)
5984 return;
5985 memset(&o, '\0', sizeof(struct objc_image_info64));
5986 if (left < sizeof(struct objc_image_info64)) {
5987 memcpy(&o, r, left);
5988 outs() << " (objc_image_info entends past the end of the section)\n";
5989 } else
5990 memcpy(&o, r, sizeof(struct objc_image_info64));
5991 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
5992 swapStruct(o);
5993 outs() << " version " << o.version << "\n";
5994 outs() << " flags " << format("0x%" PRIx32"x", o.flags);
5995 if (o.flags & OBJC_IMAGE_IS_REPLACEMENT(1 << 0))
5996 outs() << " OBJC_IMAGE_IS_REPLACEMENT";
5997 if (o.flags & OBJC_IMAGE_SUPPORTS_GC(1 << 1))
5998 outs() << " OBJC_IMAGE_SUPPORTS_GC";
5999 if (o.flags & OBJC_IMAGE_IS_SIMULATED(1 << 5))
6000 outs() << " OBJC_IMAGE_IS_SIMULATED";
6001 if (o.flags & OBJC_IMAGE_HAS_CATEGORY_CLASS_PROPERTIES(1 << 6))
6002 outs() << " OBJC_IMAGE_HAS_CATEGORY_CLASS_PROPERTIES";
6003 swift_version = (o.flags >> 8) & 0xff;
6004 if (swift_version != 0) {
6005 if (swift_version == 1)
6006 outs() << " Swift 1.0";
6007 else if (swift_version == 2)
6008 outs() << " Swift 1.1";
6009 else if(swift_version == 3)
6010 outs() << " Swift 2.0";
6011 else if(swift_version == 4)
6012 outs() << " Swift 3.0";
6013 else if(swift_version == 5)
6014 outs() << " Swift 4.0";
6015 else if(swift_version == 6)
6016 outs() << " Swift 4.1/Swift 4.2";
6017 else if(swift_version == 7)
6018 outs() << " Swift 5 or later";
6019 else
6020 outs() << " unknown future Swift version (" << swift_version << ")";
6021 }
6022 outs() << "\n";
6023}
6024
6025static void print_image_info32(SectionRef S, struct DisassembleInfo *info) {
6026 uint32_t left, offset, swift_version, p;
6027 struct objc_image_info32 o;
6028 const char *r;
6029
6030 if (S == SectionRef())
6031 return;
6032
6033 StringRef SectName;
6034 Expected<StringRef> SecNameOrErr = S.getName();
6035 if (SecNameOrErr)
6036 SectName = *SecNameOrErr;
6037 else
6038 consumeError(SecNameOrErr.takeError());
6039
6040 DataRefImpl Ref = S.getRawDataRefImpl();
6041 StringRef SegName = info->O->getSectionFinalSegmentName(Ref);
6042 outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
6043 p = S.getAddress();
6044 r = get_pointer_32(p, offset, left, S, info);
6045 if (r == nullptr)
6046 return;
6047 memset(&o, '\0', sizeof(struct objc_image_info32));
6048 if (left < sizeof(struct objc_image_info32)) {
6049 memcpy(&o, r, left);
6050 outs() << " (objc_image_info entends past the end of the section)\n";
6051 } else
6052 memcpy(&o, r, sizeof(struct objc_image_info32));
6053 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
6054 swapStruct(o);
6055 outs() << " version " << o.version << "\n";
6056 outs() << " flags " << format("0x%" PRIx32"x", o.flags);
6057 if (o.flags & OBJC_IMAGE_IS_REPLACEMENT(1 << 0))
6058 outs() << " OBJC_IMAGE_IS_REPLACEMENT";
6059 if (o.flags & OBJC_IMAGE_SUPPORTS_GC(1 << 1))
6060 outs() << " OBJC_IMAGE_SUPPORTS_GC";
6061 swift_version = (o.flags >> 8) & 0xff;
6062 if (swift_version != 0) {
6063 if (swift_version == 1)
6064 outs() << " Swift 1.0";
6065 else if (swift_version == 2)
6066 outs() << " Swift 1.1";
6067 else if(swift_version == 3)
6068 outs() << " Swift 2.0";
6069 else if(swift_version == 4)
6070 outs() << " Swift 3.0";
6071 else if(swift_version == 5)
6072 outs() << " Swift 4.0";
6073 else if(swift_version == 6)
6074 outs() << " Swift 4.1/Swift 4.2";
6075 else if(swift_version == 7)
6076 outs() << " Swift 5 or later";
6077 else
6078 outs() << " unknown future Swift version (" << swift_version << ")";
6079 }
6080 outs() << "\n";
6081}
6082
6083static void print_image_info(SectionRef S, struct DisassembleInfo *info) {
6084 uint32_t left, offset, p;
6085 struct imageInfo_t o;
6086 const char *r;
6087
6088 StringRef SectName;
6089 Expected<StringRef> SecNameOrErr = S.getName();
6090 if (SecNameOrErr)
6091 SectName = *SecNameOrErr;
6092 else
6093 consumeError(SecNameOrErr.takeError());
6094
6095 DataRefImpl Ref = S.getRawDataRefImpl();
6096 StringRef SegName = info->O->getSectionFinalSegmentName(Ref);
6097 outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
6098 p = S.getAddress();
6099 r = get_pointer_32(p, offset, left, S, info);
6100 if (r == nullptr)
6101 return;
6102 memset(&o, '\0', sizeof(struct imageInfo_t));
6103 if (left < sizeof(struct imageInfo_t)) {
6104 memcpy(&o, r, left);
6105 outs() << " (imageInfo entends past the end of the section)\n";
6106 } else
6107 memcpy(&o, r, sizeof(struct imageInfo_t));
6108 if (info->O->isLittleEndian() != sys::IsLittleEndianHost)
6109 swapStruct(o);
6110 outs() << " version " << o.version << "\n";
6111 outs() << " flags " << format("0x%" PRIx32"x", o.flags);
6112 if (o.flags & 0x1)
6113 outs() << " F&C";
6114 if (o.flags & 0x2)
6115 outs() << " GC";
6116 if (o.flags & 0x4)
6117 outs() << " GC-only";
6118 else
6119 outs() << " RR";
6120 outs() << "\n";
6121}
6122
6123static void printObjc2_64bit_MetaData(MachOObjectFile *O, bool verbose) {
6124 SymbolAddressMap AddrMap;
6125 if (verbose)
6126 CreateSymbolAddressMap(O, &AddrMap);
6127
6128 std::vector<SectionRef> Sections;
6129 append_range(Sections, O->sections());
6130
6131 struct DisassembleInfo info(O, &AddrMap, &Sections, verbose);
6132
6133 SectionRef CL = get_section(O, "__OBJC2", "__class_list");
6134 if (CL == SectionRef())
6135 CL = get_section(O, "__DATA", "__objc_classlist");
6136 if (CL == SectionRef())
6137 CL = get_section(O, "__DATA_CONST", "__objc_classlist");
6138 if (CL == SectionRef())
6139 CL = get_section(O, "__DATA_DIRTY", "__objc_classlist");
6140 info.S = CL;
6141 walk_pointer_list_64("class", CL, O, &info, print_class64_t);
6142
6143 SectionRef CR = get_section(O, "__OBJC2", "__class_refs");
6144 if (CR == SectionRef())
6145 CR = get_section(O, "__DATA", "__objc_classrefs");
6146 if (CR == SectionRef())
6147 CR = get_section(O, "__DATA_CONST", "__objc_classrefs");
6148 if (CR == SectionRef())
6149 CR = get_section(O, "__DATA_DIRTY", "__objc_classrefs");
6150 info.S = CR;
6151 walk_pointer_list_64("class refs", CR, O, &info, nullptr);
6152
6153 SectionRef SR = get_section(O, "__OBJC2", "__super_refs");
6154 if (SR == SectionRef())
6155 SR = get_section(O, "__DATA", "__objc_superrefs");
6156 if (SR == SectionRef())
6157 SR = get_section(O, "__DATA_CONST", "__objc_superrefs");
6158 if (SR == SectionRef())
6159 SR = get_section(O, "__DATA_DIRTY", "__objc_superrefs");
6160 info.S = SR;
6161 walk_pointer_list_64("super refs", SR, O, &info, nullptr);
6162
6163 SectionRef CA = get_section(O, "__OBJC2", "__category_list");
6164 if (CA == SectionRef())
6165 CA = get_section(O, "__DATA", "__objc_catlist");
6166 if (CA == SectionRef())
6167 CA = get_section(O, "__DATA_CONST", "__objc_catlist");
6168 if (CA == SectionRef())
6169 CA = get_section(O, "__DATA_DIRTY", "__objc_catlist");
6170 info.S = CA;
6171 walk_pointer_list_64("category", CA, O, &info, print_category64_t);
6172
6173 SectionRef PL = get_section(O, "__OBJC2", "__protocol_list");
6174 if (PL == SectionRef())
6175 PL = get_section(O, "__DATA", "__objc_protolist");
6176 if (PL == SectionRef())
6177 PL = get_section(O, "__DATA_CONST", "__objc_protolist");
6178 if (PL == SectionRef())
6179 PL = get_section(O, "__DATA_DIRTY", "__objc_protolist");
6180 info.S = PL;
6181 walk_pointer_list_64("protocol", PL, O, &info, nullptr);
6182
6183 SectionRef MR = get_section(O, "__OBJC2", "__message_refs");
6184 if (MR == SectionRef())
6185 MR = get_section(O, "__DATA", "__objc_msgrefs");
6186 if (MR == SectionRef())
6187 MR = get_section(O, "__DATA_CONST", "__objc_msgrefs");
6188 if (MR == SectionRef())
6189 MR = get_section(O, "__DATA_DIRTY", "__objc_msgrefs");
6190 info.S = MR;
6191 print_message_refs64(MR, &info);
6192
6193 SectionRef II = get_section(O, "__OBJC2", "__image_info");
6194 if (II == SectionRef())
6195 II = get_section(O, "__DATA", "__objc_imageinfo");
6196 if (II == SectionRef())
6197 II = get_section(O, "__DATA_CONST", "__objc_imageinfo");
6198 if (II == SectionRef())
6199 II = get_section(O, "__DATA_DIRTY", "__objc_imageinfo");
6200 info.S = II;
6201 print_image_info64(II, &info);
6202}
6203
6204static void printObjc2_32bit_MetaData(MachOObjectFile *O, bool verbose) {
6205 SymbolAddressMap AddrMap;
6206 if (verbose)
6207 CreateSymbolAddressMap(O, &AddrMap);
6208
6209 std::vector<SectionRef> Sections;
6210 append_range(Sections, O->sections());
6211
6212 struct DisassembleInfo info(O, &AddrMap, &Sections, verbose);
6213
6214 SectionRef CL = get_section(O, "__OBJC2", "__class_list");
6215 if (CL == SectionRef())
6216 CL = get_section(O, "__DATA", "__objc_classlist");
6217 if (CL == SectionRef())
6218 CL = get_section(O, "__DATA_CONST", "__objc_classlist");
6219 if (CL == SectionRef())
6220 CL = get_section(O, "__DATA_DIRTY", "__objc_classlist");
6221 info.S = CL;
6222 walk_pointer_list_32("class", CL, O, &info, print_class32_t);
6223
6224 SectionRef CR = get_section(O, "__OBJC2", "__class_refs");
6225 if (CR == SectionRef())
6226 CR = get_section(O, "__DATA", "__objc_classrefs");
6227 if (CR == SectionRef())
6228 CR = get_section(O, "__DATA_CONST", "__objc_classrefs");
6229 if (CR == SectionRef())
6230 CR = get_section(O, "__DATA_DIRTY", "__objc_classrefs");
6231 info.S = CR;
6232 walk_pointer_list_32("class refs", CR, O, &info, nullptr);
6233
6234 SectionRef SR = get_section(O, "__OBJC2", "__super_refs");
6235 if (SR == SectionRef())
6236 SR = get_section(O, "__DATA", "__objc_superrefs");
6237 if (SR == SectionRef())
6238 SR = get_section(O, "__DATA_CONST", "__objc_superrefs");
6239 if (SR == SectionRef())
6240 SR = get_section(O, "__DATA_DIRTY", "__objc_superrefs");
6241 info.S = SR;
6242 walk_pointer_list_32("super refs", SR, O, &info, nullptr);
6243
6244 SectionRef CA = get_section(O, "__OBJC2", "__category_list");
6245 if (CA == SectionRef())
6246 CA = get_section(O, "__DATA", "__objc_catlist");
6247 if (CA == SectionRef())
6248 CA = get_section(O, "__DATA_CONST", "__objc_catlist");
6249 if (CA == SectionRef())
6250 CA = get_section(O, "__DATA_DIRTY", "__objc_catlist");
6251 info.S = CA;
6252 walk_pointer_list_32("category", CA, O, &info, print_category32_t);
6253
6254 SectionRef PL = get_section(O, "__OBJC2", "__protocol_list");
6255 if (PL == SectionRef())
6256 PL = get_section(O, "__DATA", "__objc_protolist");
6257 if (PL == SectionRef())
6258 PL = get_section(O, "__DATA_CONST", "__objc_protolist");
6259 if (PL == SectionRef())
6260 PL = get_section(O, "__DATA_DIRTY", "__objc_protolist");
6261 info.S = PL;
6262 walk_pointer_list_32("protocol", PL, O, &info, nullptr);
6263
6264 SectionRef MR = get_section(O, "__OBJC2", "__message_refs");
6265 if (MR == SectionRef())
6266 MR = get_section(O, "__DATA", "__objc_msgrefs");
6267 if (MR == SectionRef())
6268 MR = get_section(O, "__DATA_CONST", "__objc_msgrefs");
6269 if (MR == SectionRef())
6270 MR = get_section(O, "__DATA_DIRTY", "__objc_msgrefs");
6271 info.S = MR;
6272 print_message_refs32(MR, &info);
6273
6274 SectionRef II = get_section(O, "__OBJC2", "__image_info");
6275 if (II == SectionRef())
6276 II = get_section(O, "__DATA", "__objc_imageinfo");
6277 if (II == SectionRef())
6278 II = get_section(O, "__DATA_CONST", "__objc_imageinfo");
6279 if (II == SectionRef())
6280 II = get_section(O, "__DATA_DIRTY", "__objc_imageinfo");
6281 info.S = II;
6282 print_image_info32(II, &info);
6283}
6284
6285static bool printObjc1_32bit_MetaData(MachOObjectFile *O, bool verbose) {
6286 uint32_t i, j, p, offset, xoffset, left, defs_left, def;
6287 const char *r, *name, *defs;
6288 struct objc_module_t module;
6289 SectionRef S, xS;
6290 struct objc_symtab_t symtab;
6291 struct objc_class_t objc_class;
6292 struct objc_category_t objc_category;
6293
6294 outs() << "Objective-C segment\n";
6295 S = get_section(O, "__OBJC", "__module_info");
6296 if (S == SectionRef())
6297 return false;
6298
6299 SymbolAddressMap AddrMap;
6300 if (verbose)
6301 CreateSymbolAddressMap(O, &AddrMap);
6302
6303 std::vector<SectionRef> Sections;
6304 append_range(Sections, O->sections());
6305
6306 struct DisassembleInfo info(O, &AddrMap, &Sections, verbose);
6307
6308 for (i = 0; i < S.getSize(); i += sizeof(struct objc_module_t)) {
6309 p = S.getAddress() + i;
6310 r = get_pointer_32(p, offset, left, S, &info, true);
6311 if (r == nullptr)
6312 return true;
6313 memset(&module, '\0', sizeof(struct objc_module_t));
6314 if (left < sizeof(struct objc_module_t)) {
6315 memcpy(&module, r, left);
6316 outs() << " (module extends past end of __module_info section)\n";
6317 } else
6318 memcpy(&module, r, sizeof(struct objc_module_t));
6319 if (O->isLittleEndian() != sys::IsLittleEndianHost)
6320 swapStruct(module);
6321
6322 outs() << "Module " << format("0x%" PRIx32"x", p) << "\n";
6323 outs() << " version " << module.version << "\n";
6324 outs() << " size " << module.size << "\n";
6325 outs() << " name ";
6326 name = get_pointer_32(module.name, xoffset, left, xS, &info, true);
6327 if (name != nullptr)
6328 outs() << format("%.*s", left, name);
6329 else
6330 outs() << format("0x%08" PRIx32"x", module.name)
6331 << "(not in an __OBJC section)";
6332 outs() << "\n";
6333
6334 r = get_pointer_32(module.symtab, xoffset, left, xS, &info, true);
6335 if (module.symtab == 0 || r == nullptr) {
6336 outs() << " symtab " << format("0x%08" PRIx32"x", module.symtab)
6337 << " (not in an __OBJC section)\n";
6338 continue;
6339 }
6340 outs() << " symtab " << format("0x%08" PRIx32"x", module.symtab) << "\n";
6341 memset(&symtab, '\0', sizeof(struct objc_symtab_t));
6342 defs_left = 0;
6343 defs = nullptr;
6344 if (left < sizeof(struct objc_symtab_t)) {
6345 memcpy(&symtab, r, left);
6346 outs() << "\tsymtab extends past end of an __OBJC section)\n";
6347 } else {
6348 memcpy(&symtab, r, sizeof(struct objc_symtab_t));
6349 if (left > sizeof(struct objc_symtab_t)) {
6350 defs_left = left - sizeof(struct objc_symtab_t);
6351 defs = r + sizeof(struct objc_symtab_t);
6352 }
6353 }
6354 if (O->isLittleEndian() != sys::IsLittleEndianHost)
6355 swapStruct(symtab);
6356
6357 outs() << "\tsel_ref_cnt " << symtab.sel_ref_cnt << "\n";
6358 r = get_pointer_32(symtab.refs, xoffset, left, xS, &info, true);
6359 outs() << "\trefs " << format("0x%08" PRIx32"x", symtab.refs);
6360 if (r == nullptr)
6361 outs() << " (not in an __OBJC section)";
6362 outs() << "\n";
6363 outs() << "\tcls_def_cnt " << symtab.cls_def_cnt << "\n";
6364 outs() << "\tcat_def_cnt " << symtab.cat_def_cnt << "\n";
6365 if (symtab.cls_def_cnt > 0)
6366 outs() << "\tClass Definitions\n";
6367 for (j = 0; j < symtab.cls_def_cnt; j++) {
6368 if ((j + 1) * sizeof(uint32_t) > defs_left) {
6369 outs() << "\t(remaining class defs entries entends past the end of the "
6370 << "section)\n";
6371 break;
6372 }
6373 memcpy(&def, defs + j * sizeof(uint32_t), sizeof(uint32_t));
6374 if (O->isLittleEndian() != sys::IsLittleEndianHost)
6375 sys::swapByteOrder(def);
6376
6377 r = get_pointer_32(def, xoffset, left, xS, &info, true);
6378 outs() << "\tdefs[" << j << "] " << format("0x%08" PRIx32"x", def);
6379 if (r != nullptr) {
6380 if (left > sizeof(struct objc_class_t)) {
6381 outs() << "\n";
6382 memcpy(&objc_class, r, sizeof(struct objc_class_t));
6383 } else {
6384 outs() << " (entends past the end of the section)\n";
6385 memset(&objc_class, '\0', sizeof(struct objc_class_t));
6386 memcpy(&objc_class, r, left);
6387 }
6388 if (O->isLittleEndian() != sys::IsLittleEndianHost)
6389 swapStruct(objc_class);
6390 print_objc_class_t(&objc_class, &info);
6391 } else {
6392 outs() << "(not in an __OBJC section)\n";
6393 }
6394
6395 if (CLS_GETINFO(&objc_class, CLS_CLASS)((&objc_class)->info & (0x1))) {
6396 outs() << "\tMeta Class";
6397 r = get_pointer_32(objc_class.isa, xoffset, left, xS, &info, true);
6398 if (r != nullptr) {
6399 if (left > sizeof(struct objc_class_t)) {
6400 outs() << "\n";
6401 memcpy(&objc_class, r, sizeof(struct objc_class_t));
6402 } else {
6403 outs() << " (entends past the end of the section)\n";
6404 memset(&objc_class, '\0', sizeof(struct objc_class_t));
6405 memcpy(&objc_class, r, left);
6406 }
6407 if (O->isLittleEndian() != sys::IsLittleEndianHost)
6408 swapStruct(objc_class);
6409 print_objc_class_t(&objc_class, &info);
6410 } else {
6411 outs() << "(not in an __OBJC section)\n";
6412 }
6413 }
6414 }
6415 if (symtab.cat_def_cnt > 0)
6416 outs() << "\tCategory Definitions\n";
6417 for (j = 0; j < symtab.cat_def_cnt; j++) {
6418 if ((j + symtab.cls_def_cnt + 1) * sizeof(uint32_t) > defs_left) {
6419 outs() << "\t(remaining category defs entries entends past the end of "
6420 << "the section)\n";
6421 break;
6422 }
6423 memcpy(&def, defs + (j + symtab.cls_def_cnt) * sizeof(uint32_t),
6424 sizeof(uint32_t));
6425 if (O->isLittleEndian() != sys::IsLittleEndianHost)
6426 sys::swapByteOrder(def);
6427
6428 r = get_pointer_32(def, xoffset, left, xS, &info, true);
6429 outs() << "\tdefs[" << j + symtab.cls_def_cnt << "] "
6430 << format("0x%08" PRIx32"x", def);
6431 if (r != nullptr) {
6432 if (left > sizeof(struct objc_category_t)) {
6433 outs() << "\n";
6434 memcpy(&objc_category, r, sizeof(struct objc_category_t));
6435 } else {
6436 outs() << " (entends past the end of the section)\n";
6437 memset(&objc_category, '\0', sizeof(struct objc_category_t));
6438 memcpy(&objc_category, r, left);
6439 }
6440 if (O->isLittleEndian() != sys::IsLittleEndianHost)
6441 swapStruct(objc_category);
6442 print_objc_objc_category_t(&objc_category, &info);
6443 } else {
6444 outs() << "(not in an __OBJC section)\n";
6445 }
6446 }
6447 }
6448 const SectionRef II = get_section(O, "__OBJC", "__image_info");
6449 if (II != SectionRef())
6450 print_image_info(II, &info);
6451
6452 return true;
6453}
6454
6455static void DumpProtocolSection(MachOObjectFile *O, const char *sect,
6456 uint32_t size, uint32_t addr) {
6457 SymbolAddressMap AddrMap;
6458 CreateSymbolAddressMap(O, &AddrMap);
6459
6460 std::vector<SectionRef> Sections;
6461 append_range(Sections, O->sections());
6462
6463 struct DisassembleInfo info(O, &AddrMap, &Sections, true);
6464
6465 const char *p;
6466 struct objc_protocol_t protocol;
6467 uint32_t left, paddr;
6468 for (p = sect; p < sect + size; p += sizeof(struct objc_protocol_t)) {
6469 memset(&protocol, '\0', sizeof(struct objc_protocol_t));
6470 left = size - (p - sect);
6471 if (left < sizeof(struct objc_protocol_t)) {
6472 outs() << "Protocol extends past end of __protocol section\n";
6473 memcpy(&protocol, p, left);
6474 } else
6475 memcpy(&protocol, p, sizeof(struct objc_protocol_t));
6476 if (O->isLittleEndian() != sys::IsLittleEndianHost)
6477 swapStruct(protocol);
6478 paddr = addr + (p - sect);
6479 outs() << "Protocol " << format("0x%" PRIx32"x", paddr);
6480 if (print_protocol(paddr, 0, &info))
6481 outs() << "(not in an __OBJC section)\n";
6482 }
6483}
6484
6485#ifdef LLVM_HAVE_LIBXAR
6486static inline void swapStruct(struct xar_header &xar) {
6487 sys::swapByteOrder(xar.magic);
6488 sys::swapByteOrder(xar.size);
6489 sys::swapByteOrder(xar.version);
6490 sys::swapByteOrder(xar.toc_length_compressed);
6491 sys::swapByteOrder(xar.toc_length_uncompressed);
6492 sys::swapByteOrder(xar.cksum_alg);
6493}
6494
6495static void PrintModeVerbose(uint32_t mode) {
6496 switch(mode & S_IFMT){
6497 case S_IFDIR:
6498 outs() << "d";
6499 break;
6500 case S_IFCHR:
6501 outs() << "c";
6502 break;
6503 case S_IFBLK:
6504 outs() << "b";
6505 break;
6506 case S_IFREG:
6507 outs() << "-";
6508 break;
6509 case S_IFLNK:
6510 outs() << "l";
6511 break;
6512 case S_IFSOCK:
6513 outs() << "s";
6514 break;
6515 default:
6516 outs() << "?";
6517 break;
6518 }
6519
6520 /* owner permissions */
6521 if(mode & S_IREAD)
6522 outs() << "r";
6523 else
6524 outs() << "-";
6525 if(mode & S_IWRITE)
6526 outs() << "w";
6527 else
6528 outs() << "-";
6529 if(mode & S_ISUID)
6530 outs() << "s";
6531 else if(mode & S_IEXEC)
6532 outs() << "x";
6533 else
6534 outs() << "-";
6535
6536 /* group permissions */
6537 if(mode & (S_IREAD >> 3))
6538 outs() << "r";
6539 else
6540 outs() << "-";
6541 if(mode & (S_IWRITE >> 3))
6542 outs() << "w";
6543 else
6544 outs() << "-";
6545 if(mode & S_ISGID)
6546 outs() << "s";
6547 else if(mode & (S_IEXEC >> 3))
6548 outs() << "x";
6549 else
6550 outs() << "-";
6551
6552 /* other permissions */
6553 if(mode & (S_IREAD >> 6))
6554 outs() << "r";
6555 else
6556 outs() << "-";
6557 if(mode & (S_IWRITE >> 6))
6558 outs() << "w";
6559 else
6560 outs() << "-";
6561 if(mode & S_ISVTX)
6562 outs() << "t";
6563 else if(mode & (S_IEXEC >> 6))
6564 outs() << "x";
6565 else
6566 outs() << "-";
6567}
6568
6569static void PrintXarFilesSummary(const char *XarFilename, xar_t xar) {
6570 xar_file_t xf;
6571 const char *key, *type, *mode, *user, *group, *size, *mtime, *name, *m;
6572 char *endp;
6573 uint32_t mode_value;
6574
6575 ScopedXarIter xi;
6576 if (!xi) {
6577 WithColor::error(errs(), "llvm-objdump")
6578 << "can't obtain an xar iterator for xar archive " << XarFilename
6579 << "\n";
6580 return;
6581 }
6582
6583 // Go through the xar's files.
6584 for (xf = xar_file_first(xar, xi); xf; xf = xar_file_next(xi)) {
6585 ScopedXarIter xp;
6586 if(!xp){
6587 WithColor::error(errs(), "llvm-objdump")
6588 << "can't obtain an xar iterator for xar archive " << XarFilename
6589 << "\n";
6590 return;
6591 }
6592 type = nullptr;
6593 mode = nullptr;
6594 user = nullptr;
6595 group = nullptr;
6596 size = nullptr;
6597 mtime = nullptr;
6598 name = nullptr;
6599 for(key = xar_prop_first(xf, xp); key; key = xar_prop_next(xp)){
6600 const char *val = nullptr;
6601 xar_prop_get(xf, key, &val);
6602#if 0 // Useful for debugging.
6603 outs() << "key: " << key << " value: " << val << "\n";
6604#endif
6605 if(strcmp(key, "type") == 0)
6606 type = val;
6607 if(strcmp(key, "mode") == 0)
6608 mode = val;
6609 if(strcmp(key, "user") == 0)
6610 user = val;
6611 if(strcmp(key, "group") == 0)
6612 group = val;
6613 if(strcmp(key, "data/size") == 0)
6614 size = val;
6615 if(strcmp(key, "mtime") == 0)
6616 mtime = val;
6617 if(strcmp(key, "name") == 0)
6618 name = val;
6619 }
6620 if(mode != nullptr){
6621 mode_value = strtoul(mode, &endp, 8);
6622 if(*endp != '\0')
6623 outs() << "(mode: \"" << mode << "\" contains non-octal chars) ";
6624 if(strcmp(type, "file") == 0)
6625 mode_value |= S_IFREG;
6626 PrintModeVerbose(mode_value);
6627 outs() << " ";
6628 }
6629 if(user != nullptr)
6630 outs() << format("%10s/", user);
6631 if(group != nullptr)
6632 outs() << format("%-10s ", group);
6633 if(size != nullptr)
6634 outs() << format("%7s ", size);
6635 if(mtime != nullptr){
6636 for(m = mtime; *m != 'T' && *m != '\0'; m++)
6637 outs() << *m;
6638 if(*m == 'T')
6639 m++;
6640 outs() << " ";
6641 for( ; *m != 'Z' && *m != '\0'; m++)
6642 outs() << *m;
6643 outs() << " ";
6644 }
6645 if(name != nullptr)
6646 outs() << name;
6647 outs() << "\n";
6648 }
6649}
6650
6651static void DumpBitcodeSection(MachOObjectFile *O, const char *sect,
6652 uint32_t size, bool verbose,
6653 bool PrintXarHeader, bool PrintXarFileHeaders,
6654 std::string XarMemberName) {
6655 if(size < sizeof(struct xar_header)) {
6656 outs() << "size of (__LLVM,__bundle) section too small (smaller than size "
6657 "of struct xar_header)\n";
6658 return;
6659 }
6660 struct xar_header XarHeader;
6661 memcpy(&XarHeader, sect, sizeof(struct xar_header));
6662 if (sys::IsLittleEndianHost)
6663 swapStruct(XarHeader);
6664 if (PrintXarHeader) {
6665 if (!XarMemberName.empty())
6666 outs() << "In xar member " << XarMemberName << ": ";
6667 else
6668 outs() << "For (__LLVM,__bundle) section: ";
6669 outs() << "xar header\n";
6670 if (XarHeader.magic == XAR_HEADER_MAGIC)
6671 outs() << " magic XAR_HEADER_MAGIC\n";
6672 else
6673 outs() << " magic "
6674 << format_hex(XarHeader.magic, 10, true)
6675 << " (not XAR_HEADER_MAGIC)\n";
6676 outs() << " size " << XarHeader.size << "\n";
6677 outs() << " version " << XarHeader.version << "\n";
6678 outs() << " toc_length_compressed " << XarHeader.toc_length_compressed
6679 << "\n";
6680 outs() << "toc_length_uncompressed " << XarHeader.toc_length_uncompressed
6681 << "\n";
6682 outs() << " cksum_alg ";
6683 switch (XarHeader.cksum_alg) {
6684 case XAR_CKSUM_NONE:
6685 outs() << "XAR_CKSUM_NONE\n";
6686 break;
6687 case XAR_CKSUM_SHA1:
6688 outs() << "XAR_CKSUM_SHA1\n";
6689 break;
6690 case XAR_CKSUM_MD5:
6691 outs() << "XAR_CKSUM_MD5\n";
6692 break;
6693#ifdef XAR_CKSUM_SHA256
6694 case XAR_CKSUM_SHA256:
6695 outs() << "XAR_CKSUM_SHA256\n";
6696 break;
6697#endif
6698#ifdef XAR_CKSUM_SHA512
6699 case XAR_CKSUM_SHA512:
6700 outs() << "XAR_CKSUM_SHA512\n";
6701 break;
6702#endif
6703 default:
6704 outs() << XarHeader.cksum_alg << "\n";
6705 }
6706 }
6707
6708 SmallString<128> XarFilename;
6709 int FD;
6710 std::error_code XarEC =
6711 sys::fs::createTemporaryFile("llvm-objdump", "xar", FD, XarFilename);
6712 if (XarEC) {
6713 WithColor::error(errs(), "llvm-objdump") << XarEC.message() << "\n";
6714 return;
6715 }
6716 ToolOutputFile XarFile(XarFilename, FD);
6717 raw_fd_ostream &XarOut = XarFile.os();
6718 StringRef XarContents(sect, size);
6719 XarOut << XarContents;
6720 XarOut.close();
6721 if (XarOut.has_error())
6722 return;
6723
6724 ScopedXarFile xar(XarFilename.c_str(), READ);
6725 if (!xar) {
6726 WithColor::error(errs(), "llvm-objdump")
6727 << "can't create temporary xar archive " << XarFilename << "\n";
6728 return;
6729 }
6730
6731 SmallString<128> TocFilename;
6732 std::error_code TocEC =
6733 sys::fs::createTemporaryFile("llvm-objdump", "toc", TocFilename);
6734 if (TocEC) {
6735 WithColor::error(errs(), "llvm-objdump") << TocEC.message() << "\n";
6736 return;
6737 }
6738 xar_serialize(xar, TocFilename.c_str());
6739
6740 if (PrintXarFileHeaders) {
6741 if (!XarMemberName.empty())
6742 outs() << "In xar member " << XarMemberName << ": ";
6743 else
6744 outs() << "For (__LLVM,__bundle) section: ";
6745 outs() << "xar archive files:\n";
6746 PrintXarFilesSummary(XarFilename.c_str(), xar);
6747 }
6748
6749 ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
6750 MemoryBuffer::getFileOrSTDIN(TocFilename.c_str());
6751 if (std::error_code EC = FileOrErr.getError()) {
6752 WithColor::error(errs(), "llvm-objdump") << EC.message() << "\n";
6753 return;
6754 }
6755 std::unique_ptr<MemoryBuffer> &Buffer = FileOrErr.get();
6756
6757 if (!XarMemberName.empty())
6758 outs() << "In xar member " << XarMemberName << ": ";
6759 else
6760 outs() << "For (__LLVM,__bundle) section: ";
6761 outs() << "xar table of contents:\n";
6762 outs() << Buffer->getBuffer() << "\n";
6763
6764 // TODO: Go through the xar's files.
6765 ScopedXarIter xi;
6766 if(!xi){
6767 WithColor::error(errs(), "llvm-objdump")
6768 << "can't obtain an xar iterator for xar archive "
6769 << XarFilename.c_str() << "\n";
6770 return;
6771 }
6772 for(xar_file_t xf = xar_file_first(xar, xi); xf; xf = xar_file_next(xi)){
6773 const char *key;
6774 const char *member_name, *member_type, *member_size_string;
6775 size_t member_size;
6776
6777 ScopedXarIter xp;
6778 if(!xp){
6779 WithColor::error(errs(), "llvm-objdump")
6780 << "can't obtain an xar iterator for xar archive "
6781 << XarFilename.c_str() << "\n";
6782 return;
6783 }
6784 member_name = NULL__null;
6785 member_type = NULL__null;
6786 member_size_string = NULL__null;
6787 for(key = xar_prop_first(xf, xp); key; key = xar_prop_next(xp)){
6788 const char *val = nullptr;
6789 xar_prop_get(xf, key, &val);
6790#if 0 // Useful for debugging.
6791 outs() << "key: " << key << " value: " << val << "\n";
6792#endif
6793 if (strcmp(key, "name") == 0)
6794 member_name = val;
6795 if (strcmp(key, "type") == 0)
6796 member_type = val;
6797 if (strcmp(key, "data/size") == 0)
6798 member_size_string = val;
6799 }
6800 /*
6801 * If we find a file with a name, date/size and type properties
6802 * and with the type being "file" see if that is a xar file.
6803 */
6804 if (member_name != NULL__null && member_type != NULL__null &&
6805 strcmp(member_type, "file") == 0 &&
6806 member_size_string != NULL__null){
6807 // Extract the file into a buffer.
6808 char *endptr;
6809 member_size = strtoul(member_size_string, &endptr, 10);
6810 if (*endptr == '\0' && member_size != 0) {
6811 char *buffer;
6812 if (xar_extract_tobuffersz(xar, xf, &buffer, &member_size) == 0) {
6813#if 0 // Useful for debugging.
6814 outs() << "xar member: " << member_name << " extracted\n";
6815#endif
6816 // Set the XarMemberName we want to see printed in the header.
6817 std::string OldXarMemberName;
6818 // If XarMemberName is already set this is nested. So
6819 // save the old name and create the nested name.
6820 if (!XarMemberName.empty()) {
6821 OldXarMemberName = XarMemberName;
6822 XarMemberName =
6823 (Twine("[") + XarMemberName + "]" + member_name).str();
6824 } else {
6825 OldXarMemberName = "";
6826 XarMemberName = member_name;
6827 }
6828 // See if this is could be a xar file (nested).
6829 if (member_size >= sizeof(struct xar_header)) {
6830#if 0 // Useful for debugging.
6831 outs() << "could be a xar file: " << member_name << "\n";
6832#endif
6833 memcpy((char *)&XarHeader, buffer, sizeof(struct xar_header));
6834 if (sys::IsLittleEndianHost)
6835 swapStruct(XarHeader);
6836 if (XarHeader.magic == XAR_HEADER_MAGIC)
6837 DumpBitcodeSection(O, buffer, member_size, verbose,
6838 PrintXarHeader, PrintXarFileHeaders,
6839 XarMemberName);
6840 }
6841 XarMemberName = OldXarMemberName;
6842 delete buffer;
6843 }
6844 }
6845 }
6846 }
6847}
6848#endif // defined(LLVM_HAVE_LIBXAR)
6849
6850static void printObjcMetaData(MachOObjectFile *O, bool verbose) {
6851 if (O->is64Bit())
6852 printObjc2_64bit_MetaData(O, verbose);
6853 else {
6854 MachO::mach_header H;
6855 H = O->getHeader();
6856 if (H.cputype == MachO::CPU_TYPE_ARM)
6857 printObjc2_32bit_MetaData(O, verbose);
6858 else {
6859 // This is the 32-bit non-arm cputype case. Which is normally
6860 // the first Objective-C ABI. But it may be the case of a
6861 // binary for the iOS simulator which is the second Objective-C
6862 // ABI. In that case printObjc1_32bit_MetaData() will determine that
6863 // and return false.
6864 if (!printObjc1_32bit_MetaData(O, verbose))
6865 printObjc2_32bit_MetaData(O, verbose);
6866 }
6867 }
6868}
6869
6870// GuessLiteralPointer returns a string which for the item in the Mach-O file
6871// for the address passed in as ReferenceValue for printing as a comment with
6872// the instruction and also returns the corresponding type of that item
6873// indirectly through ReferenceType.
6874//
6875// If ReferenceValue is an address of literal cstring then a pointer to the
6876// cstring is returned and ReferenceType is set to
6877// LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr .
6878//
6879// If ReferenceValue is an address of an Objective-C CFString, Selector ref or
6880// Class ref that name is returned and the ReferenceType is set accordingly.
6881//
6882// Lastly, literals which are Symbol address in a literal pool are looked for
6883// and if found the symbol name is returned and ReferenceType is set to
6884// LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr .
6885//
6886// If there is no item in the Mach-O file for the address passed in as
6887// ReferenceValue nullptr is returned and ReferenceType is unchanged.
6888static const char *GuessLiteralPointer(uint64_t ReferenceValue,
6889 uint64_t ReferencePC,
6890 uint64_t *ReferenceType,
6891 struct DisassembleInfo *info) {
6892 // First see if there is an external relocation entry at the ReferencePC.
6893 if (info->O->getHeader().filetype == MachO::MH_OBJECT) {
6894 uint64_t sect_addr = info->S.getAddress();
6895 uint64_t sect_offset = ReferencePC - sect_addr;
6896 bool reloc_found = false;
6897 DataRefImpl Rel;
6898 MachO::any_relocation_info RE;
6899 bool isExtern = false;
6900 SymbolRef Symbol;
6901 for (const RelocationRef &Reloc : info->S.relocations()) {
6902 uint64_t RelocOffset = Reloc.getOffset();
6903 if (RelocOffset == sect_offset) {
6904 Rel = Reloc.getRawDataRefImpl();
6905 RE = info->O->getRelocation(Rel);
6906 if (info->O->isRelocationScattered(RE))
6907 continue;
6908 isExtern = info->O->getPlainRelocationExternal(RE);
6909 if (isExtern) {
6910 symbol_iterator RelocSym = Reloc.getSymbol();
6911 Symbol = *RelocSym;
6912 }
6913 reloc_found = true;
6914 break;
6915 }
6916 }
6917 // If there is an external relocation entry for a symbol in a section
6918 // then used that symbol's value for the value of the reference.
6919 if (reloc_found && isExtern) {
6920 if (info->O->getAnyRelocationPCRel(RE)) {
6921 unsigned Type = info->O->getAnyRelocationType(RE);
6922 if (Type == MachO::X86_64_RELOC_SIGNED) {
6923 ReferenceValue = cantFail(Symbol.getValue());
6924 }
6925 }
6926 }
6927 }
6928
6929 // Look for literals such as Objective-C CFStrings refs, Selector refs,
6930 // Message refs and Class refs.
6931 bool classref, selref, msgref, cfstring;
6932 uint64_t pointer_value = GuessPointerPointer(ReferenceValue, info, classref,
6933 selref, msgref, cfstring);
6934 if (classref && pointer_value == 0) {
6935 // Note the ReferenceValue is a pointer into the __objc_classrefs section.
6936 // And the pointer_value in that section is typically zero as it will be
6937 // set by dyld as part of the "bind information".
6938 const char *name = get_dyld_bind_info_symbolname(ReferenceValue, info);
6939 if (name != nullptr) {
6940 *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref8;
6941 const char *class_name = strrchr(name, '$');
6942 if (class_name != nullptr && class_name[1] == '_' &&
6943 class_name[2] != '\0') {
6944 info->class_name = class_name + 2;
6945 return name;
6946 }
6947 }
6948 }
6949
6950 if (classref) {
6951 *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref8;
6952 const char *name =
6953 get_objc2_64bit_class_name(pointer_value, ReferenceValue, info);
6954 if (name != nullptr)
6955 info->class_name = name;
6956 else
6957 name = "bad class ref";
6958 return name;
6959 }
6960
6961 if (cfstring) {
6962 *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_CFString_Ref4;
6963 const char *name = get_objc2_64bit_cfstring_name(ReferenceValue, info);
6964 return name;
6965 }
6966
6967 if (selref && pointer_value == 0)
6968 pointer_value = get_objc2_64bit_selref(ReferenceValue, info);
6969
6970 if (pointer_value != 0)
6971 ReferenceValue = pointer_value;
6972
6973 const char *name = GuessCstringPointer(ReferenceValue, info);
6974 if (name) {
6975 if (pointer_value != 0 && selref) {
6976 *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Selector_Ref7;
6977 info->selector_name = name;
6978 } else if (pointer_value != 0 && msgref) {
6979 info->class_name = nullptr;
6980 *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message_Ref6;
6981 info->selector_name = name;
6982 } else
6983 *ReferenceType = LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr3;
6984 return name;
6985 }
6986
6987 // Lastly look for an indirect symbol with this ReferenceValue which is in
6988 // a literal pool. If found return that symbol name.
6989 name = GuessIndirectSymbol(ReferenceValue, info);
6990 if (name) {
6991 *ReferenceType = LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr2;
6992 return name;
6993 }
6994
6995 return nullptr;
6996}
6997
6998// SymbolizerSymbolLookUp is the symbol lookup function passed when creating
6999// the Symbolizer. It looks up the ReferenceValue using the info passed via the
7000// pointer to the struct DisassembleInfo that was passed when MCSymbolizer
7001// is created and returns the symbol name that matches the ReferenceValue or
7002// nullptr if none. The ReferenceType is passed in for the IN type of
7003// reference the instruction is making from the values in defined in the header
7004// "llvm-c/Disassembler.h". On return the ReferenceType can set to a specific
7005// Out type and the ReferenceName will also be set which is added as a comment
7006// to the disassembled instruction.
7007//
7008// If the symbol name is a C++ mangled name then the demangled name is
7009// returned through ReferenceName and ReferenceType is set to
7010// LLVMDisassembler_ReferenceType_DeMangled_Name .
7011//
7012// When this is called to get a symbol name for a branch target then the
7013// ReferenceType will be LLVMDisassembler_ReferenceType_In_Branch and then
7014// SymbolValue will be looked for in the indirect symbol table to determine if
7015// it is an address for a symbol stub. If so then the symbol name for that
7016// stub is returned indirectly through ReferenceName and then ReferenceType is
7017// set to LLVMDisassembler_ReferenceType_Out_SymbolStub.
7018//
7019// When this is called with an value loaded via a PC relative load then
7020// ReferenceType will be LLVMDisassembler_ReferenceType_In_PCrel_Load then the
7021// SymbolValue is checked to be an address of literal pointer, symbol pointer,
7022// or an Objective-C meta data reference. If so the output ReferenceType is
7023// set to correspond to that as well as setting the ReferenceName.
7024static const char *SymbolizerSymbolLookUp(void *DisInfo,
7025 uint64_t ReferenceValue,
7026 uint64_t *ReferenceType,
7027 uint64_t ReferencePC,
7028 const char **ReferenceName) {
7029 struct DisassembleInfo *info = (struct DisassembleInfo *)DisInfo;
7030 // If no verbose symbolic information is wanted then just return nullptr.
7031 if (!info->verbose) {
7032 *ReferenceName = nullptr;
7033 *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0;
7034 return nullptr;
7035 }
7036
7037 const char *SymbolName = GuessSymbolName(ReferenceValue, info->AddrMap);
7038
7039 if (*ReferenceType == LLVMDisassembler_ReferenceType_In_Branch1) {
7040 *ReferenceName = GuessIndirectSymbol(ReferenceValue, info);
7041 if (*ReferenceName != nullptr) {
7042 method_reference(info, ReferenceType, ReferenceName);
7043 if (*ReferenceType != LLVMDisassembler_ReferenceType_Out_Objc_Message5)
7044 *ReferenceType = LLVMDisassembler_ReferenceType_Out_SymbolStub1;
7045 } else if (SymbolName != nullptr && strncmp(SymbolName, "__Z", 3) == 0) {
7046 if (info->demangled_name != nullptr)
7047 free(info->demangled_name);
7048 int status;
7049 info->demangled_name =
7050 itaniumDemangle(SymbolName + 1, nullptr, nullptr, &status);
7051 if (info->demangled_name != nullptr) {
7052 *ReferenceName = info->demangled_name;
7053 *ReferenceType = LLVMDisassembler_ReferenceType_DeMangled_Name9;
7054 } else
7055 *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0;
7056 } else
7057 *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0;
7058 } else if (*ReferenceType == LLVMDisassembler_ReferenceType_In_PCrel_Load2) {
7059 *ReferenceName =
7060 GuessLiteralPointer(ReferenceValue, ReferencePC, ReferenceType, info);
7061 if (*ReferenceName)
7062 method_reference(info, ReferenceType, ReferenceName);
7063 else
7064 *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0;
7065 // If this is arm64 and the reference is an adrp instruction save the
7066 // instruction, passed in ReferenceValue and the address of the instruction
7067 // for use later if we see and add immediate instruction.
7068 } else if (info->O->getArch() == Triple::aarch64 &&
7069 *ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_ADRP0x100000001) {
7070 info->adrp_inst = ReferenceValue;
7071 info->adrp_addr = ReferencePC;
7072 SymbolName = nullptr;
7073 *ReferenceName = nullptr;
7074 *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0;
7075 // If this is arm64 and reference is an add immediate instruction and we
7076 // have
7077 // seen an adrp instruction just before it and the adrp's Xd register
7078 // matches
7079 // this add's Xn register reconstruct the value being referenced and look to
7080 // see if it is a literal pointer. Note the add immediate instruction is
7081 // passed in ReferenceValue.
7082 } else if (info->O->getArch() == Triple::aarch64 &&
7083 *ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_ADDXri0x100000002 &&
7084 ReferencePC - 4 == info->adrp_addr &&
7085 (info->adrp_inst & 0x9f000000) == 0x90000000 &&
7086 (info->adrp_inst & 0x1f) == ((ReferenceValue >> 5) & 0x1f)) {
7087 uint32_t addxri_inst;
7088 uint64_t adrp_imm, addxri_imm;
7089
7090 adrp_imm =
7091 ((info->adrp_inst & 0x00ffffe0) >> 3) | ((info->adrp_inst >> 29) & 0x3);
7092 if (info->adrp_inst & 0x0200000)
7093 adrp_imm |= 0xfffffffffc000000LL;
7094
7095 addxri_inst = ReferenceValue;
7096 addxri_imm = (addxri_inst >> 10) & 0xfff;
7097 if (((addxri_inst >> 22) & 0x3) == 1)
7098 addxri_imm <<= 12;
7099
7100 ReferenceValue = (info->adrp_addr & 0xfffffffffffff000LL) +
7101 (adrp_imm << 12) + addxri_imm;
7102
7103 *ReferenceName =
7104 GuessLiteralPointer(ReferenceValue, ReferencePC, ReferenceType, info);
7105 if (*ReferenceName == nullptr)
7106 *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0;
7107 // If this is arm64 and the reference is a load register instruction and we
7108 // have seen an adrp instruction just before it and the adrp's Xd register
7109 // matches this add's Xn register reconstruct the value being referenced and
7110 // look to see if it is a literal pointer. Note the load register
7111 // instruction is passed in ReferenceValue.
7112 } else if (info->O->getArch() == Triple::aarch64 &&
7113 *ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_LDRXui0x100000003 &&
7114 ReferencePC - 4 == info->adrp_addr &&
7115 (info->adrp_inst & 0x9f000000) == 0x90000000 &&
7116 (info->adrp_inst & 0x1f) == ((ReferenceValue >> 5) & 0x1f)) {
7117 uint32_t ldrxui_inst;
7118 uint64_t adrp_imm, ldrxui_imm;
7119
7120 adrp_imm =
7121 ((info->adrp_inst & 0x00ffffe0) >> 3) | ((info->adrp_inst >> 29) & 0x3);
7122 if (info->adrp_inst & 0x0200000)
7123 adrp_imm |= 0xfffffffffc000000LL;
7124
7125 ldrxui_inst = ReferenceValue;
7126 ldrxui_imm = (ldrxui_inst >> 10) & 0xfff;
7127
7128 ReferenceValue = (info->adrp_addr & 0xfffffffffffff000LL) +
7129 (adrp_imm << 12) + (ldrxui_imm << 3);
7130
7131 *ReferenceName =
7132 GuessLiteralPointer(ReferenceValue, ReferencePC, ReferenceType, info);
7133 if (*ReferenceName == nullptr)
7134 *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0;
7135 }
7136 // If this arm64 and is an load register (PC-relative) instruction the
7137 // ReferenceValue is the PC plus the immediate value.
7138 else if (info->O->getArch() == Triple::aarch64 &&
7139 (*ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_LDRXl0x100000004 ||
7140 *ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_ADR0x100000005)) {
7141 *ReferenceName =
7142 GuessLiteralPointer(ReferenceValue, ReferencePC, ReferenceType, info);
7143 if (*ReferenceName == nullptr)
7144 *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0;
7145 } else if (SymbolName != nullptr && strncmp(SymbolName, "__Z", 3) == 0) {
7146 if (info->demangled_name != nullptr)
7147 free(info->demangled_name);
7148 int status;
7149 info->demangled_name =
7150 itaniumDemangle(SymbolName + 1, nullptr, nullptr, &status);
7151 if (info->demangled_name != nullptr) {
7152 *ReferenceName = info->demangled_name;
7153 *ReferenceType = LLVMDisassembler_ReferenceType_DeMangled_Name9;
7154 }
7155 }
7156 else {
7157 *ReferenceName = nullptr;
7158 *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0;
7159 }
7160
7161 return SymbolName;
7162}
7163
7164/// Emits the comments that are stored in the CommentStream.
7165/// Each comment in the CommentStream must end with a newline.
7166static void emitComments(raw_svector_ostream &CommentStream,
7167 SmallString<128> &CommentsToEmit,
7168 formatted_raw_ostream &FormattedOS,
7169 const MCAsmInfo &MAI) {
7170 // Flush the stream before taking its content.
7171 StringRef Comments = CommentsToEmit.str();
7172 // Get the default information for printing a comment.
7173 StringRef CommentBegin = MAI.getCommentString();
7174 unsigned CommentColumn = MAI.getCommentColumn();
7175 ListSeparator LS("\n");
7176 while (!Comments.empty()) {
7177 FormattedOS << LS;
7178 // Emit a line of comments.
7179 FormattedOS.PadToColumn(CommentColumn);
7180 size_t Position = Comments.find('\n');
7181 FormattedOS << CommentBegin << ' ' << Comments.substr(0, Position);
7182 // Move after the newline character.
7183 Comments = Comments.substr(Position + 1);
7184 }
7185 FormattedOS.flush();
7186
7187 // Tell the comment stream that the vector changed underneath it.
7188 CommentsToEmit.clear();
7189}
7190
7191static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
7192 StringRef DisSegName, StringRef DisSectName) {
7193 const char *McpuDefault = nullptr;
7194 const Target *ThumbTarget = nullptr;
7195 const Target *TheTarget = GetTarget(MachOOF, &McpuDefault, &ThumbTarget);
7196 if (!TheTarget) {
7197 // GetTarget prints out stuff.
7198 return;
7199 }
7200 std::string MachOMCPU;
7201 if (MCPU.empty() && McpuDefault)
7202 MachOMCPU = McpuDefault;
7203 else
7204 MachOMCPU = MCPU;
7205
7206#define CHECK_TARGET_INFO_CREATION(NAME) \
7207 do { \
7208 if (!NAME) { \
7209 WithColor::error(errs(), "llvm-objdump") \
7210 << "couldn't initialize disassembler for target " << TripleName \
7211 << '\n'; \
7212 return; \
7213 } \
7214 } while (false)
7215#define CHECK_THUMB_TARGET_INFO_CREATION(NAME) \
7216 do { \
7217 if (!NAME) { \
7218 WithColor::error(errs(), "llvm-objdump") \
7219 << "couldn't initialize disassembler for target " << ThumbTripleName \
7220 << '\n'; \
7221 return; \
7222 } \
7223 } while (false)
7224
7225 std::unique_ptr<const MCInstrInfo> InstrInfo(TheTarget->createMCInstrInfo());
7226 CHECK_TARGET_INFO_CREATION(InstrInfo);
7227 std::unique_ptr<const MCInstrInfo> ThumbInstrInfo;
7228 if (ThumbTarget) {
7229 ThumbInstrInfo.reset(ThumbTarget->createMCInstrInfo());
7230 CHECK_THUMB_TARGET_INFO_CREATION(ThumbInstrInfo);
7231 }
7232
7233 // Package up features to be passed to target/subtarget
7234 std::string FeaturesStr;
7235 if (!MAttrs.empty()) {
7236 SubtargetFeatures Features;
7237 for (unsigned i = 0; i != MAttrs.size(); ++i)
7238 Features.AddFeature(MAttrs[i]);
7239 FeaturesStr = Features.getString();
7240 }
7241
7242 MCTargetOptions MCOptions;
7243 // Set up disassembler.
7244 std::unique_ptr<const MCRegisterInfo> MRI(
7245 TheTarget->createMCRegInfo(TripleName));
7246 CHECK_TARGET_INFO_CREATION(MRI);
7247 std::unique_ptr<const MCAsmInfo> AsmInfo(
7248 TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
7249 CHECK_TARGET_INFO_CREATION(AsmInfo);
7250 std::unique_ptr<const MCSubtargetInfo> STI(
7251 TheTarget->createMCSubtargetInfo(TripleName, MachOMCPU, FeaturesStr));
7252 CHECK_TARGET_INFO_CREATION(STI);
7253 MCContext Ctx(Triple(TripleName), AsmInfo.get(), MRI.get(), STI.get());
7254 std::unique_ptr<MCDisassembler> DisAsm(
7255 TheTarget->createMCDisassembler(*STI, Ctx));
7256 CHECK_TARGET_INFO_CREATION(DisAsm);
7257 std::unique_ptr<MCSymbolizer> Symbolizer;
7258 struct DisassembleInfo SymbolizerInfo(nullptr, nullptr, nullptr, false);
7259 std::unique_ptr<MCRelocationInfo> RelInfo(
7260 TheTarget->createMCRelocationInfo(TripleName, Ctx));
7261 if (RelInfo) {
7262 Symbolizer.reset(TheTarget->createMCSymbolizer(
7263 TripleName, SymbolizerGetOpInfo, SymbolizerSymbolLookUp,
7264 &SymbolizerInfo, &Ctx, std::move(RelInfo)));
7265 DisAsm->setSymbolizer(std::move(Symbolizer));
7266 }
7267 int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
7268 std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
7269 Triple(TripleName), AsmPrinterVariant, *AsmInfo, *InstrInfo, *MRI));
7270 CHECK_TARGET_INFO_CREATION(IP);
7271 // Set the display preference for hex vs. decimal immediates.
7272 IP->setPrintImmHex(PrintImmHex);
7273 // Comment stream and backing vector.
7274 SmallString<128> CommentsToEmit;
7275 raw_svector_ostream CommentStream(CommentsToEmit);
7276 // FIXME: Setting the CommentStream in the InstPrinter is problematic in that
7277 // if it is done then arm64 comments for string literals don't get printed
7278 // and some constant get printed instead and not setting it causes intel
7279 // (32-bit and 64-bit) comments printed with different spacing before the
7280 // comment causing different diffs with the 'C' disassembler library API.
7281 // IP->setCommentStream(CommentStream);
7282
7283 // Set up separate thumb disassembler if needed.
7284 std::unique_ptr<const MCRegisterInfo> ThumbMRI;
7285 std::unique_ptr<const MCAsmInfo> ThumbAsmInfo;
7286 std::unique_ptr<const MCSubtargetInfo> ThumbSTI;
7287 std::unique_ptr<MCDisassembler> ThumbDisAsm;
7288 std::unique_ptr<MCInstPrinter> ThumbIP;
7289 std::unique_ptr<MCContext> ThumbCtx;
7290 std::unique_ptr<MCSymbolizer> ThumbSymbolizer;
7291 struct DisassembleInfo ThumbSymbolizerInfo(nullptr, nullptr, nullptr, false);
7292 std::unique_ptr<MCRelocationInfo> ThumbRelInfo;
7293 if (ThumbTarget) {
7294 ThumbMRI.reset(ThumbTarget->createMCRegInfo(ThumbTripleName));
7295 CHECK_THUMB_TARGET_INFO_CREATION(ThumbMRI);
7296 ThumbAsmInfo.reset(
7297 ThumbTarget->createMCAsmInfo(*ThumbMRI, ThumbTripleName, MCOptions));
7298 CHECK_THUMB_TARGET_INFO_CREATION(ThumbAsmInfo);
7299 ThumbSTI.reset(
7300 ThumbTarget->createMCSubtargetInfo(ThumbTripleName, MachOMCPU,
7301 FeaturesStr));
7302 CHECK_THUMB_TARGET_INFO_CREATION(ThumbSTI);
7303 ThumbCtx.reset(new MCContext(Triple(ThumbTripleName), ThumbAsmInfo.get(),
7304 ThumbMRI.get(), ThumbSTI.get()));
7305 ThumbDisAsm.reset(ThumbTarget->createMCDisassembler(*ThumbSTI, *ThumbCtx));
7306 CHECK_THUMB_TARGET_INFO_CREATION(ThumbDisAsm);
7307 MCContext *PtrThumbCtx = ThumbCtx.get();
7308 ThumbRelInfo.reset(
7309 ThumbTarget->createMCRelocationInfo(ThumbTripleName, *PtrThumbCtx));
7310 if (ThumbRelInfo) {
7311 ThumbSymbolizer.reset(ThumbTarget->createMCSymbolizer(
7312 ThumbTripleName, SymbolizerGetOpInfo, SymbolizerSymbolLookUp,
7313 &ThumbSymbolizerInfo, PtrThumbCtx, std::move(ThumbRelInfo)));
7314 ThumbDisAsm->setSymbolizer(std::move(ThumbSymbolizer));
7315 }
7316 int ThumbAsmPrinterVariant = ThumbAsmInfo->getAssemblerDialect();
7317 ThumbIP.reset(ThumbTarget->createMCInstPrinter(
7318 Triple(ThumbTripleName), ThumbAsmPrinterVariant, *ThumbAsmInfo,
7319 *ThumbInstrInfo, *ThumbMRI));
7320 CHECK_THUMB_TARGET_INFO_CREATION(ThumbIP);
7321 // Set the display preference for hex vs. decimal immediates.
7322 ThumbIP->setPrintImmHex(PrintImmHex);
7323 }
7324
7325#undef CHECK_TARGET_INFO_CREATION
7326#undef CHECK_THUMB_TARGET_INFO_CREATION
7327
7328 MachO::mach_header Header = MachOOF->getHeader();
7329
7330 // FIXME: Using the -cfg command line option, this code used to be able to
7331 // annotate relocations with the referenced symbol's name, and if this was
7332 // inside a __[cf]string section, the data it points to. This is now replaced
7333 // by the upcoming MCSymbolizer, which needs the appropriate setup done above.
7334 std::vector<SectionRef> Sections;
7335 std::vector<SymbolRef> Symbols;
7336 SmallVector<uint64_t, 8> FoundFns;
7337 uint64_t BaseSegmentAddress = 0;
7338
7339 getSectionsAndSymbols(MachOOF, Sections, Symbols, FoundFns,
7340 BaseSegmentAddress);
7341
7342 // Sort the symbols by address, just in case they didn't come in that way.
7343 llvm::stable_sort(Symbols, SymbolSorter());
7344
7345 // Build a data in code table that is sorted on by the address of each entry.
7346 uint64_t BaseAddress = 0;
7347 if (Header.filetype == MachO::MH_OBJECT)
7348 BaseAddress = Sections[0].getAddress();
7349 else
7350 BaseAddress = BaseSegmentAddress;
7351 DiceTable Dices;
7352 for (dice_iterator DI = MachOOF->begin_dices(), DE = MachOOF->end_dices();
7353 DI != DE; ++DI) {
7354 uint32_t Offset;
7355 DI->getOffset(Offset);
7356 Dices.push_back(std::make_pair(BaseAddress + Offset, *DI));
7357 }
7358 array_pod_sort(Dices.begin(), Dices.end());
7359
7360 // Try to find debug info and set up the DIContext for it.
7361 std::unique_ptr<DIContext> diContext;
7362 std::unique_ptr<Binary> DSYMBinary;
7363 std::unique_ptr<MemoryBuffer> DSYMBuf;
7364 if (UseDbg) {
7365 ObjectFile *DbgObj = MachOOF;
7366
7367 // A separate DSym file path was specified, parse it as a macho file,
7368 // get the sections and supply it to the section name parsing machinery.
7369 if (!DSYMFile.empty()) {
7370 std::string DSYMPath(DSYMFile);
7371
7372 // If DSYMPath is a .dSYM directory, append the Mach-O file.
7373 if (llvm::sys::fs::is_directory(DSYMPath) &&
7374 llvm::sys::path::extension(DSYMPath) == ".dSYM") {
7375 SmallString<128> ShortName(llvm::sys::path::filename(DSYMPath));
7376 llvm::sys::path::replace_extension(ShortName, "");
7377 SmallString<1024> FullPath(DSYMPath);
7378 llvm::sys::path::append(FullPath, "Contents", "Resources", "DWARF",
7379 ShortName);
7380 DSYMPath = std::string(FullPath.str());
7381 }
7382
7383 // Load the file.
7384 ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
7385 MemoryBuffer::getFileOrSTDIN(DSYMPath);
7386 if (std::error_code EC = BufOrErr.getError()) {
7387 reportError(errorCodeToError(EC), DSYMPath);
7388 return;
7389 }
7390
7391 // We need to keep the file alive, because we're replacing DbgObj with it.
7392 DSYMBuf = std::move(BufOrErr.get());
7393
7394 Expected<std::unique_ptr<Binary>> BinaryOrErr =
7395 createBinary(DSYMBuf.get()->getMemBufferRef());
7396 if (!BinaryOrErr) {
7397 reportError(BinaryOrErr.takeError(), DSYMPath);
7398 return;
7399 }
7400
7401 // We need to keep the Binary alive with the buffer
7402 DSYMBinary = std::move(BinaryOrErr.get());
7403 if (ObjectFile *O = dyn_cast<ObjectFile>(DSYMBinary.get())) {
7404 // this is a Mach-O object file, use it
7405 if (MachOObjectFile *MachDSYM = dyn_cast<MachOObjectFile>(&*O)) {
7406 DbgObj = MachDSYM;
7407 }
7408 else {
7409 WithColor::error(errs(), "llvm-objdump")
7410 << DSYMPath << " is not a Mach-O file type.\n";
7411 return;
7412 }
7413 }
7414 else if (auto UB = dyn_cast<MachOUniversalBinary>(DSYMBinary.get())){
7415 // this is a Universal Binary, find a Mach-O for this architecture
7416 uint32_t CPUType, CPUSubType;
7417 const char *ArchFlag;
7418 if (MachOOF->is64Bit()) {
7419 const MachO::mach_header_64 H_64 = MachOOF->getHeader64();
7420 CPUType = H_64.cputype;
7421 CPUSubType = H_64.cpusubtype;
7422 } else {
7423 const MachO::mach_header H = MachOOF->getHeader();
7424 CPUType = H.cputype;
7425 CPUSubType = H.cpusubtype;
7426 }
7427 Triple T = MachOObjectFile::getArchTriple(CPUType, CPUSubType, nullptr,
7428 &ArchFlag);
7429 Expected<std::unique_ptr<MachOObjectFile>> MachDSYM =
7430 UB->getMachOObjectForArch(ArchFlag);
7431 if (!MachDSYM) {
7432 reportError(MachDSYM.takeError(), DSYMPath);
7433 return;
7434 }
7435
7436 // We need to keep the Binary alive with the buffer
7437 DbgObj = &*MachDSYM.get();
7438 DSYMBinary = std::move(*MachDSYM);
7439 }
7440 else {
7441 WithColor::error(errs(), "llvm-objdump")
7442 << DSYMPath << " is not a Mach-O or Universal file type.\n";
7443 return;
7444 }
7445 }
7446
7447 // Setup the DIContext
7448 diContext = DWARFContext::create(*DbgObj);
7449 }
7450
7451 if (FilterSections.empty())
7452 outs() << "(" << DisSegName << "," << DisSectName << ") section\n";
7453
7454 for (unsigned SectIdx = 0; SectIdx != Sections.size(); SectIdx++) {
7455 Expected<StringRef> SecNameOrErr = Sections[SectIdx].getName();
7456 if (!SecNameOrErr) {
7457 consumeError(SecNameOrErr.takeError());
7458 continue;
7459 }
7460 if (*SecNameOrErr != DisSectName)
7461 continue;
7462
7463 DataRefImpl DR = Sections[SectIdx].getRawDataRefImpl();
7464
7465 StringRef SegmentName = MachOOF->getSectionFinalSegmentName(DR);
7466 if (SegmentName != DisSegName)
7467 continue;
7468
7469 StringRef BytesStr =
7470 unwrapOrError(Sections[SectIdx].getContents(), Filename);
7471 ArrayRef<uint8_t> Bytes = arrayRefFromStringRef(BytesStr);
7472 uint64_t SectAddress = Sections[SectIdx].getAddress();
7473
7474 bool symbolTableWorked = false;
7475
7476 // Create a map of symbol addresses to symbol names for use by
7477 // the SymbolizerSymbolLookUp() routine.
7478 SymbolAddressMap AddrMap;
7479 bool DisSymNameFound = false;
7480 for (const SymbolRef &Symbol : MachOOF->symbols()) {
7481 SymbolRef::Type ST =
7482 unwrapOrError(Symbol.getType(), MachOOF->getFileName());
7483 if (ST == SymbolRef::ST_Function || ST == SymbolRef::ST_Data ||
7484 ST == SymbolRef::ST_Other) {
7485 uint64_t Address = cantFail(Symbol.getValue());
7486 StringRef SymName =
7487 unwrapOrError(Symbol.getName(), MachOOF->getFileName());
7488 AddrMap[Address] = SymName;
7489 if (!DisSymName.empty() && DisSymName == SymName)
7490 DisSymNameFound = true;
7491 }
7492 }
7493 if (!DisSymName.empty() && !DisSymNameFound) {
7494 outs() << "Can't find -dis-symname: " << DisSymName << "\n";
7495 return;
7496 }
7497 // Set up the block of info used by the Symbolizer call backs.
7498 SymbolizerInfo.verbose = SymbolicOperands;
7499 SymbolizerInfo.O = MachOOF;
7500 SymbolizerInfo.S = Sections[SectIdx];
7501 SymbolizerInfo.AddrMap = &AddrMap;
7502 SymbolizerInfo.Sections = &Sections;
7503 // Same for the ThumbSymbolizer
7504 ThumbSymbolizerInfo.verbose = SymbolicOperands;
7505 ThumbSymbolizerInfo.O = MachOOF;
7506 ThumbSymbolizerInfo.S = Sections[SectIdx];
7507 ThumbSymbolizerInfo.AddrMap = &AddrMap;
7508 ThumbSymbolizerInfo.Sections = &Sections;
7509
7510 unsigned int Arch = MachOOF->getArch();
7511
7512 // Skip all symbols if this is a stubs file.
7513 if (Bytes.empty())
7514 return;
7515
7516 // If the section has symbols but no symbol at the start of the section
7517 // these are used to make sure the bytes before the first symbol are
7518 // disassembled.
7519 bool FirstSymbol = true;
7520 bool FirstSymbolAtSectionStart = true;
7521
7522 // Disassemble symbol by symbol.
7523 for (unsigned SymIdx = 0; SymIdx != Symbols.size(); SymIdx++) {
7524 StringRef SymName =
7525 unwrapOrError(Symbols[SymIdx].getName(), MachOOF->getFileName());
7526 SymbolRef::Type ST =
7527 unwrapOrError(Symbols[SymIdx].getType(), MachOOF->getFileName());
7528 if (ST != SymbolRef::ST_Function && ST != SymbolRef::ST_Data)
7529 continue;
7530
7531 // Make sure the symbol is defined in this section.
7532 bool containsSym = Sections[SectIdx].containsSymbol(Symbols[SymIdx]);
7533 if (!containsSym) {
7534 if (!DisSymName.empty() && DisSymName == SymName) {
7535 outs() << "-dis-symname: " << DisSymName << " not in the section\n";
7536 return;
7537 }
7538 continue;
7539 }
7540 // The __mh_execute_header is special and we need to deal with that fact
7541 // this symbol is before the start of the (__TEXT,__text) section and at the
7542 // address of the start of the __TEXT segment. This is because this symbol
7543 // is an N_SECT symbol in the (__TEXT,__text) but its address is before the
7544 // start of the section in a standard MH_EXECUTE filetype.
7545 if (!DisSymName.empty() && DisSymName == "__mh_execute_header") {
7546 outs() << "-dis-symname: __mh_execute_header not in any section\n";
7547 return;
7548 }
7549 // When this code is trying to disassemble a symbol at a time and in the
7550 // case there is only the __mh_execute_header symbol left as in a stripped
7551 // executable, we need to deal with this by ignoring this symbol so the
7552 // whole section is disassembled and this symbol is then not displayed.
7553 if (SymName == "__mh_execute_header" || SymName == "__mh_dylib_header" ||
7554 SymName == "__mh_bundle_header" || SymName == "__mh_object_header" ||
7555 SymName == "__mh_preload_header" || SymName == "__mh_dylinker_header")
7556 continue;
7557
7558 // If we are only disassembling one symbol see if this is that symbol.
7559 if (!DisSymName.empty() && DisSymName != SymName)
7560 continue;
7561
7562 // Start at the address of the symbol relative to the section's address.
7563 uint64_t SectSize = Sections[SectIdx].getSize();
7564 uint64_t Start = cantFail(Symbols[SymIdx].getValue());
7565 uint64_t SectionAddress = Sections[SectIdx].getAddress();
7566 Start -= SectionAddress;
7567
7568 if (Start > SectSize) {
7569 outs() << "section data ends, " << SymName
7570 << " lies outside valid range\n";
7571 return;
7572 }
7573
7574 // Stop disassembling either at the beginning of the next symbol or at
7575 // the end of the section.
7576 bool containsNextSym = false;
7577 uint64_t NextSym = 0;
7578 uint64_t NextSymIdx = SymIdx + 1;
7579 while (Symbols.size() > NextSymIdx) {
7580 SymbolRef::Type NextSymType = unwrapOrError(
7581 Symbols[NextSymIdx].getType(), MachOOF->getFileName());
7582 if (NextSymType == SymbolRef::ST_Function) {
7583 containsNextSym =
7584 Sections[SectIdx].containsSymbol(Symbols[NextSymIdx]);
7585 NextSym = cantFail(Symbols[NextSymIdx].getValue());
7586 NextSym -= SectionAddress;
7587 break;
7588 }
7589 ++NextSymIdx;
7590 }
7591
7592 uint64_t End = containsNextSym ? std::min(NextSym, SectSize) : SectSize;
7593 uint64_t Size;
7594
7595 symbolTableWorked = true;
7596
7597 DataRefImpl Symb = Symbols[SymIdx].getRawDataRefImpl();
7598 uint32_t SymbolFlags = cantFail(MachOOF->getSymbolFlags(Symb));
7599 bool IsThumb = SymbolFlags & SymbolRef::SF_Thumb;
7600
7601 // We only need the dedicated Thumb target if there's a real choice
7602 // (i.e. we're not targeting M-class) and the function is Thumb.
7603 bool UseThumbTarget = IsThumb && ThumbTarget;
7604
7605 // If we are not specifying a symbol to start disassembly with and this
7606 // is the first symbol in the section but not at the start of the section
7607 // then move the disassembly index to the start of the section and
7608 // don't print the symbol name just yet. This is so the bytes before the
7609 // first symbol are disassembled.
7610 uint64_t SymbolStart = Start;
7611 if (DisSymName.empty() && FirstSymbol && Start != 0) {
7612 FirstSymbolAtSectionStart = false;
7613 Start = 0;
7614 }
7615 else
7616 outs() << SymName << ":\n";
7617
7618 DILineInfo lastLine;
7619 for (uint64_t Index = Start; Index < End; Index += Size) {
7620 MCInst Inst;
7621
7622 // If this is the first symbol in the section and it was not at the
7623 // start of the section, see if we are at its Index now and if so print
7624 // the symbol name.
7625 if (FirstSymbol && !FirstSymbolAtSectionStart && Index == SymbolStart)
7626 outs() << SymName << ":\n";
7627
7628 uint64_t PC = SectAddress + Index;
7629 if (LeadingAddr) {
7630 if (FullLeadingAddr) {
7631 if (MachOOF->is64Bit())
7632 outs() << format("%016" PRIx64"l" "x", PC);
7633 else
7634 outs() << format("%08" PRIx64"l" "x", PC);
7635 } else {
7636 outs() << format("%8" PRIx64"l" "x" ":", PC);
7637 }
7638 }
7639 if (ShowRawInsn || Arch == Triple::arm)
7640 outs() << "\t";
7641
7642 if (DumpAndSkipDataInCode(PC, Bytes.data() + Index, Dices, Size))
7643 continue;
7644
7645 SmallVector<char, 64> AnnotationsBytes;
7646 raw_svector_ostream Annotations(AnnotationsBytes);
7647
7648 bool gotInst;
7649 if (UseThumbTarget)
7650 gotInst = ThumbDisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
7651 PC, Annotations);
7652 else
7653 gotInst = DisAsm->getInstruction(Inst, Size, Bytes.slice(Index), PC,
7654 Annotations);
7655 if (gotInst) {
7656 if (ShowRawInsn || Arch == Triple::arm) {
7657 dumpBytes(makeArrayRef(Bytes.data() + Index, Size), outs());
7658 }
7659 formatted_raw_ostream FormattedOS(outs());
7660 StringRef AnnotationsStr = Annotations.str();
7661 if (UseThumbTarget)
7662 ThumbIP->printInst(&Inst, PC, AnnotationsStr, *ThumbSTI,
7663 FormattedOS);
7664 else
7665 IP->printInst(&Inst, PC, AnnotationsStr, *STI, FormattedOS);
7666 emitComments(CommentStream, CommentsToEmit, FormattedOS, *AsmInfo);
7667
7668 // Print debug info.
7669 if (diContext) {
7670 DILineInfo dli = diContext->getLineInfoForAddress({PC, SectIdx});
7671 // Print valid line info if it changed.
7672 if (dli != lastLine && dli.Line != 0)
7673 outs() << "\t## " << dli.FileName << ':' << dli.Line << ':'
7674 << dli.Column;
7675 lastLine = dli;
7676 }
7677 outs() << "\n";
7678 } else {
7679 if (MachOOF->getArchTriple().isX86()) {
7680 outs() << format("\t.byte 0x%02x #bad opcode\n",
7681 *(Bytes.data() + Index) & 0xff);
7682 Size = 1; // skip exactly one illegible byte and move on.
7683 } else if (Arch == Triple::aarch64 ||
7684 (Arch == Triple::arm && !IsThumb)) {
7685 uint32_t opcode = (*(Bytes.data() + Index) & 0xff) |
7686 (*(Bytes.data() + Index + 1) & 0xff) << 8 |
7687 (*(Bytes.data() + Index + 2) & 0xff) << 16 |
7688 (*(Bytes.data() + Index + 3) & 0xff) << 24;
7689 outs() << format("\t.long\t0x%08x\n", opcode);
7690 Size = 4;
7691 } else if (Arch == Triple::arm) {
7692 assert(IsThumb && "ARM mode should have been dealt with above")(static_cast <bool> (IsThumb && "ARM mode should have been dealt with above"
) ? void (0) : __assert_fail ("IsThumb && \"ARM mode should have been dealt with above\""
, "llvm/tools/llvm-objdump/MachODump.cpp", 7692, __extension__
__PRETTY_FUNCTION__))
;
7693 uint32_t opcode = (*(Bytes.data() + Index) & 0xff) |
7694 (*(Bytes.data() + Index + 1) & 0xff) << 8;
7695 outs() << format("\t.short\t0x%04x\n", opcode);
7696 Size = 2;
7697 } else{
7698 WithColor::warning(errs(), "llvm-objdump")
7699 << "invalid instruction encoding\n";
7700 if (Size == 0)
7701 Size = 1; // skip illegible bytes
7702 }
7703 }
7704 }
7705 // Now that we are done disassembled the first symbol set the bool that
7706 // were doing this to false.
7707 FirstSymbol = false;
7708 }
7709 if (!symbolTableWorked) {
7710 // Reading the symbol table didn't work, disassemble the whole section.
7711 uint64_t SectAddress = Sections[SectIdx].getAddress();
7712 uint64_t SectSize = Sections[SectIdx].getSize();
7713 uint64_t InstSize;
7714 for (uint64_t Index = 0; Index < SectSize; Index += InstSize) {
7715 MCInst Inst;
7716
7717 uint64_t PC = SectAddress + Index;
7718
7719 if (DumpAndSkipDataInCode(PC, Bytes.data() + Index, Dices, InstSize))
7720 continue;
7721
7722 SmallVector<char, 64> AnnotationsBytes;
7723 raw_svector_ostream Annotations(AnnotationsBytes);
7724 if (DisAsm->getInstruction(Inst, InstSize, Bytes.slice(Index), PC,
7725 Annotations)) {
7726 if (LeadingAddr) {
7727 if (FullLeadingAddr) {
7728 if (MachOOF->is64Bit())
7729 outs() << format("%016" PRIx64"l" "x", PC);
7730 else
7731 outs() << format("%08" PRIx64"l" "x", PC);
7732 } else {
7733 outs() << format("%8" PRIx64"l" "x" ":", PC);
7734 }
7735 }
7736 if (ShowRawInsn || Arch == Triple::arm) {
7737 outs() << "\t";
7738 dumpBytes(makeArrayRef(Bytes.data() + Index, InstSize), outs());
7739 }
7740 StringRef AnnotationsStr = Annotations.str();
7741 IP->printInst(&Inst, PC, AnnotationsStr, *STI, outs());
7742 outs() << "\n";
7743 } else {
7744 if (MachOOF->getArchTriple().isX86()) {
7745 outs() << format("\t.byte 0x%02x #bad opcode\n",
7746 *(Bytes.data() + Index) & 0xff);
7747 InstSize = 1; // skip exactly one illegible byte and move on.
7748 } else {
7749 WithColor::warning(errs(), "llvm-objdump")
7750 << "invalid instruction encoding\n";
7751 if (InstSize == 0)
7752 InstSize = 1; // skip illegible bytes
7753 }
7754 }
7755 }
7756 }
7757 // The TripleName's need to be reset if we are called again for a different
7758 // architecture.
7759 TripleName = "";
7760 ThumbTripleName = "";
7761
7762 if (SymbolizerInfo.demangled_name != nullptr)
7763 free(SymbolizerInfo.demangled_name);
7764 if (ThumbSymbolizerInfo.demangled_name != nullptr)
7765 free(ThumbSymbolizerInfo.demangled_name);
7766 }
7767}
7768
7769//===----------------------------------------------------------------------===//
7770// __compact_unwind section dumping
7771//===----------------------------------------------------------------------===//
7772
7773namespace {
7774
7775template <typename T>
7776static uint64_t read(StringRef Contents, ptrdiff_t Offset) {
7777 using llvm::support::little;
7778 using llvm::support::unaligned;
7779
7780 if (Offset + sizeof(T) > Contents.size()) {
7781 outs() << "warning: attempt to read past end of buffer\n";
7782 return T();
7783 }
7784
7785 uint64_t Val =
7786 support::endian::read<T, little, unaligned>(Contents.data() + Offset);
7787 return Val;
7788}
7789
7790template <typename T>
7791static uint64_t readNext(StringRef Contents, ptrdiff_t &Offset) {
7792 T Val = read<T>(Contents, Offset);
7793 Offset += sizeof(T);
7794 return Val;
7795}
7796
7797struct CompactUnwindEntry {
7798 uint32_t OffsetInSection;
7799
7800 uint64_t FunctionAddr;
7801 uint32_t Length;
7802 uint32_t CompactEncoding;
7803 uint64_t PersonalityAddr;
7804 uint64_t LSDAAddr;
7805
7806 RelocationRef FunctionReloc;
7807 RelocationRef PersonalityReloc;
7808 RelocationRef LSDAReloc;
7809
7810 CompactUnwindEntry(StringRef Contents, unsigned Offset, bool Is64)
7811 : OffsetInSection(Offset) {
7812 if (Is64)
7813 read<uint64_t>(Contents, Offset);
7814 else
7815 read<uint32_t>(Contents, Offset);
7816 }
7817
7818private:
7819 template <typename UIntPtr> void read(StringRef Contents, ptrdiff_t Offset) {
7820 FunctionAddr = readNext<UIntPtr>(Contents, Offset);
7821 Length = readNext<uint32_t>(Contents, Offset);
7822 CompactEncoding = readNext<uint32_t>(Contents, Offset);
7823 PersonalityAddr = readNext<UIntPtr>(Contents, Offset);
7824 LSDAAddr = readNext<UIntPtr>(Contents, Offset);
7825 }
7826};
7827}
7828
7829/// Given a relocation from __compact_unwind, consisting of the RelocationRef
7830/// and data being relocated, determine the best base Name and Addend to use for
7831/// display purposes.
7832///
7833/// 1. An Extern relocation will directly reference a symbol (and the data is
7834/// then already an addend), so use that.
7835/// 2. Otherwise the data is an offset in the object file's layout; try to find
7836// a symbol before it in the same section, and use the offset from there.
7837/// 3. Finally, if all that fails, fall back to an offset from the start of the
7838/// referenced section.
7839static void findUnwindRelocNameAddend(const MachOObjectFile *Obj,
7840 std::map<uint64_t, SymbolRef> &Symbols,
7841 const RelocationRef &Reloc, uint64_t Addr,
7842 StringRef &Name, uint64_t &Addend) {
7843 if (Reloc.getSymbol() != Obj->symbol_end()) {
7844 Name = unwrapOrError(Reloc.getSymbol()->getName(), Obj->getFileName());
7845 Addend = Addr;
7846 return;
7847 }
7848
7849 auto RE = Obj->getRelocation(Reloc.getRawDataRefImpl());
7850 SectionRef RelocSection = Obj->getAnyRelocationSection(RE);
7851
7852 uint64_t SectionAddr = RelocSection.getAddress();
7853
7854 auto Sym = Symbols.upper_bound(Addr);
7855 if (Sym == Symbols.begin()) {
7856 // The first symbol in the object is after this reference, the best we can
7857 // do is section-relative notation.
7858 if (Expected<StringRef> NameOrErr = RelocSection.getName())
7859 Name = *NameOrErr;
7860 else
7861 consumeError(NameOrErr.takeError());
7862
7863 Addend = Addr - SectionAddr;
7864 return;
7865 }
7866
7867 // Go back one so that SymbolAddress <= Addr.
7868 --Sym;
7869
7870 section_iterator SymSection =
7871 unwrapOrError(Sym->second.getSection(), Obj->getFileName());
7872 if (RelocSection == *SymSection) {
7873 // There's a valid symbol in the same section before this reference.
7874 Name = unwrapOrError(Sym->second.getName(), Obj->getFileName());
7875 Addend = Addr - Sym->first;
7876 return;
7877 }
7878
7879 // There is a symbol before this reference, but it's in a different
7880 // section. Probably not helpful to mention it, so use the section name.
7881 if (Expected<StringRef> NameOrErr = RelocSection.getName())
7882 Name = *NameOrErr;
7883 else
7884 consumeError(NameOrErr.takeError());
7885
7886 Addend = Addr - SectionAddr;
7887}
7888
7889static void printUnwindRelocDest(const MachOObjectFile *Obj,
7890 std::map<uint64_t, SymbolRef> &Symbols,
7891 const RelocationRef &Reloc, uint64_t Addr) {
7892 StringRef Name;
7893 uint64_t Addend;
7894
7895 if (!Reloc.getObject())
7896 return;
7897
7898 findUnwindRelocNameAddend(Obj, Symbols, Reloc, Addr, Name, Addend);
7899
7900 outs() << Name;
7901 if (Addend)
7902 outs() << " + " << format("0x%" PRIx64"l" "x", Addend);
7903}
7904
7905static void
7906printMachOCompactUnwindSection(const MachOObjectFile *Obj,
7907 std::map<uint64_t, SymbolRef> &Symbols,
7908 const SectionRef &CompactUnwind) {
7909
7910 if (!Obj->isLittleEndian()) {
7911 outs() << "Skipping big-endian __compact_unwind section\n";
7912 return;
7913 }
7914
7915 bool Is64 = Obj->is64Bit();
7916 uint32_t PointerSize = Is64 ? sizeof(uint64_t) : sizeof(uint32_t);
7917 uint32_t EntrySize = 3 * PointerSize + 2 * sizeof(uint32_t);
7918
7919 StringRef Contents =
7920 unwrapOrError(CompactUnwind.getContents(), Obj->getFileName());
7921 SmallVector<CompactUnwindEntry, 4> CompactUnwinds;
7922
7923 // First populate the initial raw offsets, encodings and so on from the entry.
7924 for (unsigned Offset = 0; Offset < Contents.size(); Offset += EntrySize) {
7925 CompactUnwindEntry Entry(Contents, Offset, Is64);
7926 CompactUnwinds.push_back(Entry);
7927 }
7928
7929 // Next we need to look at the relocations to find out what objects are
7930 // actually being referred to.
7931 for (const RelocationRef &Reloc : CompactUnwind.relocations()) {
7932 uint64_t RelocAddress = Reloc.getOffset();
7933
7934 uint32_t EntryIdx = RelocAddress / EntrySize;
7935 uint32_t OffsetInEntry = RelocAddress - EntryIdx * EntrySize;
7936 CompactUnwindEntry &Entry = CompactUnwinds[EntryIdx];
7937
7938 if (OffsetInEntry == 0)
7939 Entry.FunctionReloc = Reloc;
7940 else if (OffsetInEntry == PointerSize + 2 * sizeof(uint32_t))
7941 Entry.PersonalityReloc = Reloc;
7942 else if (OffsetInEntry == 2 * PointerSize + 2 * sizeof(uint32_t))
7943 Entry.LSDAReloc = Reloc;
7944 else {
7945 outs() << "Invalid relocation in __compact_unwind section\n";
7946 return;
7947 }
7948 }
7949
7950 // Finally, we're ready to print the data we've gathered.
7951 outs() << "Contents of __compact_unwind section:\n";
7952 for (auto &Entry : CompactUnwinds) {
7953 outs() << " Entry at offset "
7954 << format("0x%" PRIx32"x", Entry.OffsetInSection) << ":\n";
7955
7956 // 1. Start of the region this entry applies to.
7957 outs() << " start: " << format("0x%" PRIx64"l" "x",
7958 Entry.FunctionAddr) << ' ';
7959 printUnwindRelocDest(Obj, Symbols, Entry.FunctionReloc, Entry.FunctionAddr);
7960 outs() << '\n';
7961
7962 // 2. Length of the region this entry applies to.
7963 outs() << " length: " << format("0x%" PRIx32"x", Entry.Length)
7964 << '\n';
7965 // 3. The 32-bit compact encoding.
7966 outs() << " compact encoding: "
7967 << format("0x%08" PRIx32"x", Entry.CompactEncoding) << '\n';
7968
7969 // 4. The personality function, if present.
7970 if (Entry.PersonalityReloc.getObject()) {
7971 outs() << " personality function: "
7972 << format("0x%" PRIx64"l" "x", Entry.PersonalityAddr) << ' ';
7973 printUnwindRelocDest(Obj, Symbols, Entry.PersonalityReloc,
7974 Entry.PersonalityAddr);
7975 outs() << '\n';
7976 }
7977
7978 // 5. This entry's language-specific data area.
7979 if (Entry.LSDAReloc.getObject()) {
7980 outs() << " LSDA: " << format("0x%" PRIx64"l" "x",
7981 Entry.LSDAAddr) << ' ';
7982 printUnwindRelocDest(Obj, Symbols, Entry.LSDAReloc, Entry.LSDAAddr);
7983 outs() << '\n';
7984 }
7985 }
7986}
7987
7988//===----------------------------------------------------------------------===//
7989// __unwind_info section dumping
7990//===----------------------------------------------------------------------===//
7991
7992static void printRegularSecondLevelUnwindPage(StringRef PageData) {
7993 ptrdiff_t Pos = 0;
7994 uint32_t Kind = readNext<uint32_t>(PageData, Pos);
7995 (void)Kind;
7996 assert(Kind == 2 && "kind for a regular 2nd level index should be 2")(static_cast <bool> (Kind == 2 && "kind for a regular 2nd level index should be 2"
) ? void (0) : __assert_fail ("Kind == 2 && \"kind for a regular 2nd level index should be 2\""
, "llvm/tools/llvm-objdump/MachODump.cpp", 7996, __extension__
__PRETTY_FUNCTION__))
;
7997
7998 uint16_t EntriesStart = readNext<uint16_t>(PageData, Pos);
7999 uint16_t NumEntries = readNext<uint16_t>(PageData, Pos);
8000
8001 Pos = EntriesStart;
8002 for (unsigned i = 0; i < NumEntries; ++i) {
8003 uint32_t FunctionOffset = readNext<uint32_t>(PageData, Pos);
8004 uint32_t Encoding = readNext<uint32_t>(PageData, Pos);
8005
8006 outs() << " [" << i << "]: "
8007 << "function offset=" << format("0x%08" PRIx32"x", FunctionOffset)
8008 << ", "
8009 << "encoding=" << format("0x%08" PRIx32"x", Encoding) << '\n';
8010 }
8011}
8012
8013static void printCompressedSecondLevelUnwindPage(
8014 StringRef PageData, uint32_t FunctionBase,
8015 const SmallVectorImpl<uint32_t> &CommonEncodings) {
8016 ptrdiff_t Pos = 0;
8017 uint32_t Kind = readNext<uint32_t>(PageData, Pos);
8018 (void)Kind;
8019 assert(Kind == 3 && "kind for a compressed 2nd level index should be 3")(static_cast <bool> (Kind == 3 && "kind for a compressed 2nd level index should be 3"
) ? void (0) : __assert_fail ("Kind == 3 && \"kind for a compressed 2nd level index should be 3\""
, "llvm/tools/llvm-objdump/MachODump.cpp", 8019, __extension__
__PRETTY_FUNCTION__))
;
8020
8021 uint32_t NumCommonEncodings = CommonEncodings.size();
8022 uint16_t EntriesStart = readNext<uint16_t>(PageData, Pos);
8023 uint16_t NumEntries = readNext<uint16_t>(PageData, Pos);
8024
8025 uint16_t PageEncodingsStart = readNext<uint16_t>(PageData, Pos);
8026 uint16_t NumPageEncodings = readNext<uint16_t>(PageData, Pos);
8027 SmallVector<uint32_t, 64> PageEncodings;
8028 if (NumPageEncodings) {
8029 outs() << " Page encodings: (count = " << NumPageEncodings << ")\n";
8030 Pos = PageEncodingsStart;
8031 for (unsigned i = 0; i < NumPageEncodings; ++i) {
8032 uint32_t Encoding = readNext<uint32_t>(PageData, Pos);
8033 PageEncodings.push_back(Encoding);
8034 outs() << " encoding[" << (i + NumCommonEncodings)
8035 << "]: " << format("0x%08" PRIx32"x", Encoding) << '\n';
8036 }
8037 }
8038
8039 Pos = EntriesStart;
8040 for (unsigned i = 0; i < NumEntries; ++i) {
8041 uint32_t Entry = readNext<uint32_t>(PageData, Pos);
8042 uint32_t FunctionOffset = FunctionBase + (Entry & 0xffffff);
8043 uint32_t EncodingIdx = Entry >> 24;
8044
8045 uint32_t Encoding;
8046 if (EncodingIdx < NumCommonEncodings)
8047 Encoding = CommonEncodings[EncodingIdx];
8048 else
8049 Encoding = PageEncodings[EncodingIdx - NumCommonEncodings];
8050
8051 outs() << " [" << i << "]: "
8052 << "function offset=" << format("0x%08" PRIx32"x", FunctionOffset)
8053 << ", "
8054 << "encoding[" << EncodingIdx
8055 << "]=" << format("0x%08" PRIx32"x", Encoding) << '\n';
8056 }
8057}
8058
8059static void printMachOUnwindInfoSection(const MachOObjectFile *Obj,
8060 std::map<uint64_t, SymbolRef> &Symbols,
8061 const SectionRef &UnwindInfo) {
8062
8063 if (!Obj->isLittleEndian()) {
8064 outs() << "Skipping big-endian __unwind_info section\n";
8065 return;
8066 }
8067
8068 outs() << "Contents of __unwind_info section:\n";
8069
8070 StringRef Contents =
8071 unwrapOrError(UnwindInfo.getContents(), Obj->getFileName());
8072 ptrdiff_t Pos = 0;
8073
8074 //===----------------------------------
8075 // Section header
8076 //===----------------------------------
8077
8078 uint32_t Version = readNext<uint32_t>(Contents, Pos);
8079 outs() << " Version: "
8080 << format("0x%" PRIx32"x", Version) << '\n';
8081 if (Version != 1) {
8082 outs() << " Skipping section with unknown version\n";
8083 return;
8084 }
8085
8086 uint32_t CommonEncodingsStart = readNext<uint32_t>(Contents, Pos);
8087 outs() << " Common encodings array section offset: "
8088 << format("0x%" PRIx32"x", CommonEncodingsStart) << '\n';
8089 uint32_t NumCommonEncodings = readNext<uint32_t>(Contents, Pos);
8090 outs() << " Number of common encodings in array: "
8091 << format("0x%" PRIx32"x", NumCommonEncodings) << '\n';
8092
8093 uint32_t PersonalitiesStart = readNext<uint32_t>(Contents, Pos);
8094 outs() << " Personality function array section offset: "
8095 << format("0x%" PRIx32"x", PersonalitiesStart) << '\n';
8096 uint32_t NumPersonalities = readNext<uint32_t>(Contents, Pos);
8097 outs() << " Number of personality functions in array: "
8098 << format("0x%" PRIx32"x", NumPersonalities) << '\n';
8099
8100 uint32_t IndicesStart = readNext<uint32_t>(Contents, Pos);
8101 outs() << " Index array section offset: "
8102 << format("0x%" PRIx32"x", IndicesStart) << '\n';
8103 uint32_t NumIndices = readNext<uint32_t>(Contents, Pos);
8104 outs() << " Number of indices in array: "
8105 << format("0x%" PRIx32"x", NumIndices) << '\n';
8106
8107 //===----------------------------------
8108 // A shared list of common encodings
8109 //===----------------------------------
8110
8111 // These occupy indices in the range [0, N] whenever an encoding is referenced
8112 // from a compressed 2nd level index table. In practice the linker only
8113 // creates ~128 of these, so that indices are available to embed encodings in
8114 // the 2nd level index.
8115
8116 SmallVector<uint32_t, 64> CommonEncodings;
8117 outs() << " Common encodings: (count = " << NumCommonEncodings << ")\n";
8118 Pos = CommonEncodingsStart;
8119 for (unsigned i = 0; i < NumCommonEncodings; ++i) {
8120 uint32_t Encoding = readNext<uint32_t>(Contents, Pos);
8121 CommonEncodings.push_back(Encoding);
8122
8123 outs() << " encoding[" << i << "]: " << format("0x%08" PRIx32"x", Encoding)
8124 << '\n';
8125 }
8126
8127 //===----------------------------------
8128 // Personality functions used in this executable
8129 //===----------------------------------
8130
8131 // There should be only a handful of these (one per source language,
8132 // roughly). Particularly since they only get 2 bits in the compact encoding.
8133
8134 outs() << " Personality functions: (count = " << NumPersonalities << ")\n";
8135 Pos = PersonalitiesStart;
8136 for (unsigned i = 0; i < NumPersonalities; ++i) {
8137 uint32_t PersonalityFn = readNext<uint32_t>(Contents, Pos);
8138 outs() << " personality[" << i + 1
8139 << "]: " << format("0x%08" PRIx32"x", PersonalityFn) << '\n';
8140 }
8141
8142 //===----------------------------------
8143 // The level 1 index entries
8144 //===----------------------------------
8145
8146 // These specify an approximate place to start searching for the more detailed
8147 // information, sorted by PC.
8148
8149 struct IndexEntry {
8150 uint32_t FunctionOffset;
8151 uint32_t SecondLevelPageStart;
8152 uint32_t LSDAStart;
8153 };
8154
8155 SmallVector<IndexEntry, 4> IndexEntries;
8156
8157 outs() << " Top level indices: (count = " << NumIndices << ")\n";
8158 Pos = IndicesStart;
8159 for (unsigned i = 0; i < NumIndices; ++i) {
8160 IndexEntry Entry;
8161
8162 Entry.FunctionOffset = readNext<uint32_t>(Contents, Pos);
8163 Entry.SecondLevelPageStart = readNext<uint32_t>(Contents, Pos);
8164 Entry.LSDAStart = readNext<uint32_t>(Contents, Pos);
8165 IndexEntries.push_back(Entry);
8166
8167 outs() << " [" << i << "]: "
8168 << "function offset=" << format("0x%08" PRIx32"x", Entry.FunctionOffset)
8169 << ", "
8170 << "2nd level page offset="
8171 << format("0x%08" PRIx32"x", Entry.SecondLevelPageStart) << ", "
8172 << "LSDA offset=" << format("0x%08" PRIx32"x", Entry.LSDAStart) << '\n';
8173 }
8174
8175 //===----------------------------------
8176 // Next come the LSDA tables
8177 //===----------------------------------
8178
8179 // The LSDA layout is rather implicit: it's a contiguous array of entries from
8180 // the first top-level index's LSDAOffset to the last (sentinel).
8181
8182 outs() << " LSDA descriptors:\n";
8183 Pos = IndexEntries[0].LSDAStart;
8184 const uint32_t LSDASize = 2 * sizeof(uint32_t);
8185 int NumLSDAs =
8186 (IndexEntries.back().LSDAStart - IndexEntries[0].LSDAStart) / LSDASize;
8187
8188 for (int i = 0; i < NumLSDAs; ++i) {
8189 uint32_t FunctionOffset = readNext<uint32_t>(Contents, Pos);
8190 uint32_t LSDAOffset = readNext<uint32_t>(Contents, Pos);
8191 outs() << " [" << i << "]: "
8192 << "function offset=" << format("0x%08" PRIx32"x", FunctionOffset)
8193 << ", "
8194 << "LSDA offset=" << format("0x%08" PRIx32"x", LSDAOffset) << '\n';
8195 }
8196
8197 //===----------------------------------
8198 // Finally, the 2nd level indices
8199 //===----------------------------------
8200
8201 // Generally these are 4K in size, and have 2 possible forms:
8202 // + Regular stores up to 511 entries with disparate encodings
8203 // + Compressed stores up to 1021 entries if few enough compact encoding
8204 // values are used.
8205 outs() << " Second level indices:\n";
8206 for (unsigned i = 0; i < IndexEntries.size() - 1; ++i) {
8207 // The final sentinel top-level index has no associated 2nd level page
8208 if (IndexEntries[i].SecondLevelPageStart == 0)
8209 break;
8210
8211 outs() << " Second level index[" << i << "]: "
8212 << "offset in section="
8213 << format("0x%08" PRIx32"x", IndexEntries[i].SecondLevelPageStart)
8214 << ", "
8215 << "base function offset="
8216 << format("0x%08" PRIx32"x", IndexEntries[i].FunctionOffset) << '\n';
8217
8218 Pos = IndexEntries[i].SecondLevelPageStart;
8219 if (Pos + sizeof(uint32_t) > Contents.size()) {
8220 outs() << "warning: invalid offset for second level page: " << Pos << '\n';
8221 continue;
8222 }
8223
8224 uint32_t Kind =
8225 *reinterpret_cast<const support::ulittle32_t *>(Contents.data() + Pos);
8226 if (Kind == 2)
8227 printRegularSecondLevelUnwindPage(Contents.substr(Pos, 4096));
8228 else if (Kind == 3)
8229 printCompressedSecondLevelUnwindPage(Contents.substr(Pos, 4096),
8230 IndexEntries[i].FunctionOffset,
8231 CommonEncodings);
8232 else
8233 outs() << " Skipping 2nd level page with unknown kind " << Kind
8234 << '\n';
8235 }
8236}
8237
8238void objdump::printMachOUnwindInfo(const MachOObjectFile *Obj) {
8239 std::map<uint64_t, SymbolRef> Symbols;
8240 for (const SymbolRef &SymRef : Obj->symbols()) {
8241 // Discard any undefined or absolute symbols. They're not going to take part
8242 // in the convenience lookup for unwind info and just take up resources.
8243 auto SectOrErr = SymRef.getSection();
8244 if (!SectOrErr) {
8245 // TODO: Actually report errors helpfully.
8246 consumeError(SectOrErr.takeError());
8247 continue;
8248 }
8249 section_iterator Section = *SectOrErr;
8250 if (Section == Obj->section_end())
8251 continue;
8252
8253 uint64_t Addr = cantFail(SymRef.getValue());
8254 Symbols.insert(std::make_pair(Addr, SymRef));
8255 }
8256
8257 for (const SectionRef &Section : Obj->sections()) {
8258 StringRef SectName;
8259 if (Expected<StringRef> NameOrErr = Section.getName())
8260 SectName = *NameOrErr;
8261 else
8262 consumeError(NameOrErr.takeError());
8263
8264 if (SectName == "__compact_unwind")
8265 printMachOCompactUnwindSection(Obj, Symbols, Section);
8266 else if (SectName == "__unwind_info")
8267 printMachOUnwindInfoSection(Obj, Symbols, Section);
8268 }
8269}
8270
8271static void PrintMachHeader(uint32_t magic, uint32_t cputype,
8272 uint32_t cpusubtype, uint32_t filetype,
8273 uint32_t ncmds, uint32_t sizeofcmds, uint32_t flags,
8274 bool verbose) {
8275 outs() << "Mach header\n";
8276 outs() << " magic cputype cpusubtype caps filetype ncmds "
8277 "sizeofcmds flags\n";
8278 if (verbose) {
8279 if (magic == MachO::MH_MAGIC)
8280 outs() << " MH_MAGIC";
8281 else if (magic == MachO::MH_MAGIC_64)
8282 outs() << "MH_MAGIC_64";
8283 else
8284 outs() << format(" 0x%08" PRIx32"x", magic);
8285 switch (cputype) {
8286 case MachO::CPU_TYPE_I386:
8287 outs() << " I386";
8288 switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
8289 case MachO::CPU_SUBTYPE_I386_ALL:
8290 outs() << " ALL";
8291 break;
8292 default:
8293 outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
8294 break;
8295 }
8296 break;
8297 case MachO::CPU_TYPE_X86_64:
8298 outs() << " X86_64";
8299 switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
8300 case MachO::CPU_SUBTYPE_X86_64_ALL:
8301 outs() << " ALL";
8302 break;
8303 case MachO::CPU_SUBTYPE_X86_64_H:
8304 outs() << " Haswell";
8305 break;
8306 default:
8307 outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
8308 break;
8309 }
8310 break;
8311 case MachO::CPU_TYPE_ARM:
8312 outs() << " ARM";
8313 switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
8314 case MachO::CPU_SUBTYPE_ARM_ALL:
8315 outs() << " ALL";
8316 break;
8317 case MachO::CPU_SUBTYPE_ARM_V4T:
8318 outs() << " V4T";
8319 break;
8320 case MachO::CPU_SUBTYPE_ARM_V5TEJ:
8321 outs() << " V5TEJ";
8322 break;
8323 case MachO::CPU_SUBTYPE_ARM_XSCALE:
8324 outs() << " XSCALE";
8325 break;
8326 case MachO::CPU_SUBTYPE_ARM_V6:
8327 outs() << " V6";
8328 break;
8329 case MachO::CPU_SUBTYPE_ARM_V6M:
8330 outs() << " V6M";
8331 break;
8332 case MachO::CPU_SUBTYPE_ARM_V7:
8333 outs() << " V7";
8334 break;
8335 case MachO::CPU_SUBTYPE_ARM_V7EM:
8336 outs() << " V7EM";
8337 break;
8338 case MachO::CPU_SUBTYPE_ARM_V7K:
8339 outs() << " V7K";
8340 break;
8341 case MachO::CPU_SUBTYPE_ARM_V7M:
8342 outs() << " V7M";
8343 break;
8344 case MachO::CPU_SUBTYPE_ARM_V7S:
8345 outs() << " V7S";
8346 break;
8347 default:
8348 outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
8349 break;
8350 }
8351 break;
8352 case MachO::CPU_TYPE_ARM64:
8353 outs() << " ARM64";
8354 switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
8355 case MachO::CPU_SUBTYPE_ARM64_ALL:
8356 outs() << " ALL";
8357 break;
8358 case MachO::CPU_SUBTYPE_ARM64_V8:
8359 outs() << " V8";
8360 break;
8361 case MachO::CPU_SUBTYPE_ARM64E:
8362 outs() << " E";
8363 break;
8364 default:
8365 outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
8366 break;
8367 }
8368 break;
8369 case MachO::CPU_TYPE_ARM64_32:
8370 outs() << " ARM64_32";
8371 switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
8372 case MachO::CPU_SUBTYPE_ARM64_32_V8:
8373 outs() << " V8";
8374 break;
8375 default:
8376 outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
8377 break;
8378 }
8379 break;
8380 case MachO::CPU_TYPE_POWERPC:
8381 outs() << " PPC";
8382 switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
8383 case MachO::CPU_SUBTYPE_POWERPC_ALL:
8384 outs() << " ALL";
8385 break;
8386 default:
8387 outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
8388 break;
8389 }
8390 break;
8391 case MachO::CPU_TYPE_POWERPC64:
8392 outs() << " PPC64";
8393 switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) {
8394 case MachO::CPU_SUBTYPE_POWERPC_ALL:
8395 outs() << " ALL";
8396 break;
8397 default:
8398 outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
8399 break;
8400 }
8401 break;
8402 default:
8403 outs() << format(" %7d", cputype);
8404 outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
8405 break;
8406 }
8407 if ((cpusubtype & MachO::CPU_SUBTYPE_MASK) == MachO::CPU_SUBTYPE_LIB64) {
8408 outs() << " LIB64";
8409 } else {
8410 outs() << format(" 0x%02" PRIx32"x",
8411 (cpusubtype & MachO::CPU_SUBTYPE_MASK) >> 24);
8412 }
8413 switch (filetype) {
8414 case MachO::MH_OBJECT:
8415 outs() << " OBJECT";
8416 break;
8417 case MachO::MH_EXECUTE:
8418 outs() << " EXECUTE";
8419 break;
8420 case MachO::MH_FVMLIB:
8421 outs() << " FVMLIB";
8422 break;
8423 case MachO::MH_CORE:
8424 outs() << " CORE";
8425 break;
8426 case MachO::MH_PRELOAD:
8427 outs() << " PRELOAD";
8428 break;
8429 case MachO::MH_DYLIB:
8430 outs() << " DYLIB";
8431 break;
8432 case MachO::MH_DYLIB_STUB:
8433 outs() << " DYLIB_STUB";
8434 break;
8435 case MachO::MH_DYLINKER:
8436 outs() << " DYLINKER";
8437 break;
8438 case MachO::MH_BUNDLE:
8439 outs() << " BUNDLE";
8440 break;
8441 case MachO::MH_DSYM:
8442 outs() << " DSYM";
8443 break;
8444 case MachO::MH_KEXT_BUNDLE:
8445 outs() << " KEXTBUNDLE";
8446 break;
8447 default:
8448 outs() << format(" %10u", filetype);
8449 break;
8450 }
8451 outs() << format(" %5u", ncmds);
8452 outs() << format(" %10u", sizeofcmds);
8453 uint32_t f = flags;
8454 if (f & MachO::MH_NOUNDEFS) {
8455 outs() << " NOUNDEFS";
8456 f &= ~MachO::MH_NOUNDEFS;
8457 }
8458 if (f & MachO::MH_INCRLINK) {
8459 outs() << " INCRLINK";
8460 f &= ~MachO::MH_INCRLINK;
8461 }
8462 if (f & MachO::MH_DYLDLINK) {
8463 outs() << " DYLDLINK";
8464 f &= ~MachO::MH_DYLDLINK;
8465 }
8466 if (f & MachO::MH_BINDATLOAD) {
8467 outs() << " BINDATLOAD";
8468 f &= ~MachO::MH_BINDATLOAD;
8469 }
8470 if (f & MachO::MH_PREBOUND) {
8471 outs() << " PREBOUND";
8472 f &= ~MachO::MH_PREBOUND;
8473 }
8474 if (f & MachO::MH_SPLIT_SEGS) {
8475 outs() << " SPLIT_SEGS";
8476 f &= ~MachO::MH_SPLIT_SEGS;
8477 }
8478 if (f & MachO::MH_LAZY_INIT) {
8479 outs() << " LAZY_INIT";
8480 f &= ~MachO::MH_LAZY_INIT;
8481 }
8482 if (f & MachO::MH_TWOLEVEL) {
8483 outs() << " TWOLEVEL";
8484 f &= ~MachO::MH_TWOLEVEL;
8485 }
8486 if (f & MachO::MH_FORCE_FLAT) {
8487 outs() << " FORCE_FLAT";
8488 f &= ~MachO::MH_FORCE_FLAT;
8489 }
8490 if (f & MachO::MH_NOMULTIDEFS) {
8491 outs() << " NOMULTIDEFS";
8492 f &= ~MachO::MH_NOMULTIDEFS;
8493 }
8494 if (f & MachO::MH_NOFIXPREBINDING) {
8495 outs() << " NOFIXPREBINDING";
8496 f &= ~MachO::MH_NOFIXPREBINDING;
8497 }
8498 if (f & MachO::MH_PREBINDABLE) {
8499 outs() << " PREBINDABLE";
8500 f &= ~MachO::MH_PREBINDABLE;
8501 }
8502 if (f & MachO::MH_ALLMODSBOUND) {
8503 outs() << " ALLMODSBOUND";
8504 f &= ~MachO::MH_ALLMODSBOUND;
8505 }
8506 if (f & MachO::MH_SUBSECTIONS_VIA_SYMBOLS) {
8507 outs() << " SUBSECTIONS_VIA_SYMBOLS";
8508 f &= ~MachO::MH_SUBSECTIONS_VIA_SYMBOLS;
8509 }
8510 if (f & MachO::MH_CANONICAL) {
8511 outs() << " CANONICAL";
8512 f &= ~MachO::MH_CANONICAL;
8513 }
8514 if (f & MachO::MH_WEAK_DEFINES) {
8515 outs() << " WEAK_DEFINES";
8516 f &= ~MachO::MH_WEAK_DEFINES;
8517 }
8518 if (f & MachO::MH_BINDS_TO_WEAK) {
8519 outs() << " BINDS_TO_WEAK";
8520 f &= ~MachO::MH_BINDS_TO_WEAK;
8521 }
8522 if (f & MachO::MH_ALLOW_STACK_EXECUTION) {
8523 outs() << " ALLOW_STACK_EXECUTION";
8524 f &= ~MachO::MH_ALLOW_STACK_EXECUTION;
8525 }
8526 if (f & MachO::MH_DEAD_STRIPPABLE_DYLIB) {
8527 outs() << " DEAD_STRIPPABLE_DYLIB";
8528 f &= ~MachO::MH_DEAD_STRIPPABLE_DYLIB;
8529 }
8530 if (f & MachO::MH_PIE) {
8531 outs() << " PIE";
8532 f &= ~MachO::MH_PIE;
8533 }
8534 if (f & MachO::MH_NO_REEXPORTED_DYLIBS) {
8535 outs() << " NO_REEXPORTED_DYLIBS";
8536 f &= ~MachO::MH_NO_REEXPORTED_DYLIBS;
8537 }
8538 if (f & MachO::MH_HAS_TLV_DESCRIPTORS) {
8539 outs() << " MH_HAS_TLV_DESCRIPTORS";
8540 f &= ~MachO::MH_HAS_TLV_DESCRIPTORS;
8541 }
8542 if (f & MachO::MH_NO_HEAP_EXECUTION) {
8543 outs() << " MH_NO_HEAP_EXECUTION";
8544 f &= ~MachO::MH_NO_HEAP_EXECUTION;
8545 }
8546 if (f & MachO::MH_APP_EXTENSION_SAFE) {
8547 outs() << " APP_EXTENSION_SAFE";
8548 f &= ~MachO::MH_APP_EXTENSION_SAFE;
8549 }
8550 if (f & MachO::MH_NLIST_OUTOFSYNC_WITH_DYLDINFO) {
8551 outs() << " NLIST_OUTOFSYNC_WITH_DYLDINFO";
8552 f &= ~MachO::MH_NLIST_OUTOFSYNC_WITH_DYLDINFO;
8553 }
8554 if (f != 0 || flags == 0)
8555 outs() << format(" 0x%08" PRIx32"x", f);
8556 } else {
8557 outs() << format(" 0x%08" PRIx32"x", magic);
8558 outs() << format(" %7d", cputype);
8559 outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK);
8560 outs() << format(" 0x%02" PRIx32"x",
8561 (cpusubtype & MachO::CPU_SUBTYPE_MASK) >> 24);
8562 outs() << format(" %10u", filetype);
8563 outs() << format(" %5u", ncmds);
8564 outs() << format(" %10u", sizeofcmds);
8565 outs() << format(" 0x%08" PRIx32"x", flags);
8566 }
8567 outs() << "\n";
8568}
8569
8570static void PrintSegmentCommand(uint32_t cmd, uint32_t cmdsize,
8571 StringRef SegName, uint64_t vmaddr,
8572 uint64_t vmsize, uint64_t fileoff,
8573 uint64_t filesize, uint32_t maxprot,
8574 uint32_t initprot, uint32_t nsects,
8575 uint32_t flags, uint32_t object_size,
8576 bool verbose) {
8577 uint64_t expected_cmdsize;
8578 if (cmd == MachO::LC_SEGMENT) {
8579 outs() << " cmd LC_SEGMENT\n";
8580 expected_cmdsize = nsects;
8581 expected_cmdsize *= sizeof(struct MachO::section);
8582 expected_cmdsize += sizeof(struct MachO::segment_command);
8583 } else {
8584 outs() << " cmd LC_SEGMENT_64\n";
8585 expected_cmdsize = nsects;
8586 expected_cmdsize *= sizeof(struct MachO::section_64);
8587 expected_cmdsize += sizeof(struct MachO::segment_command_64);
8588 }
8589 outs() << " cmdsize " << cmdsize;
8590 if (cmdsize != expected_cmdsize)
8591 outs() << " Inconsistent size\n";
8592 else
8593 outs() << "\n";
8594 outs() << " segname " << SegName << "\n";
8595 if (cmd == MachO::LC_SEGMENT_64) {
8596 outs() << " vmaddr " << format("0x%016" PRIx64"l" "x", vmaddr) << "\n";
8597 outs() << " vmsize " << format("0x%016" PRIx64"l" "x", vmsize) << "\n";
8598 } else {
8599 outs() << " vmaddr " << format("0x%08" PRIx64"l" "x", vmaddr) << "\n";
8600 outs() << " vmsize " << format("0x%08" PRIx64"l" "x", vmsize) << "\n";
8601 }
8602 outs() << " fileoff " << fileoff;
8603 if (fileoff > object_size)
8604 outs() << " (past end of file)\n";
8605 else
8606 outs() << "\n";
8607 outs() << " filesize " << filesize;
8608 if (fileoff + filesize > object_size)
8609 outs() << " (past end of file)\n";
8610 else
8611 outs() << "\n";
8612 if (verbose) {
8613 if ((maxprot &
8614 ~(MachO::VM_PROT_READ | MachO::VM_PROT_WRITE |
8615 MachO::VM_PROT_EXECUTE)) != 0)
8616 outs() << " maxprot ?" << format("0x%08" PRIx32"x", maxprot) << "\n";
8617 else {
8618 outs() << " maxprot ";
8619 outs() << ((maxprot & MachO::VM_PROT_READ) ? "r" : "-");
8620 outs() << ((maxprot & MachO::VM_PROT_WRITE) ? "w" : "-");
8621 outs() << ((maxprot & MachO::VM_PROT_EXECUTE) ? "x\n" : "-\n");
8622 }
8623 if ((initprot &
8624 ~(MachO::VM_PROT_READ | MachO::VM_PROT_WRITE |
8625 MachO::VM_PROT_EXECUTE)) != 0)
8626 outs() << " initprot ?" << format("0x%08" PRIx32"x", initprot) << "\n";
8627 else {
8628 outs() << " initprot ";
8629 outs() << ((initprot & MachO::VM_PROT_READ) ? "r" : "-");
8630 outs() << ((initprot & MachO::VM_PROT_WRITE) ? "w" : "-");
8631 outs() << ((initprot & MachO::VM_PROT_EXECUTE) ? "x\n" : "-\n");
8632 }
8633 } else {
8634 outs() << " maxprot " << format("0x%08" PRIx32"x", maxprot) << "\n";
8635 outs() << " initprot " << format("0x%08" PRIx32"x", initprot) << "\n";
8636 }
8637 outs() << " nsects " << nsects << "\n";
8638 if (verbose) {
8639 outs() << " flags";
8640 if (flags == 0)
8641 outs() << " (none)\n";
8642 else {
8643 if (flags & MachO::SG_HIGHVM) {
8644 outs() << " HIGHVM";
8645 flags &= ~MachO::SG_HIGHVM;
8646 }
8647 if (flags & MachO::SG_FVMLIB) {
8648 outs() << " FVMLIB";
8649 flags &= ~MachO::SG_FVMLIB;
8650 }
8651 if (flags & MachO::SG_NORELOC) {
8652 outs() << " NORELOC";
8653 flags &= ~MachO::SG_NORELOC;
8654 }
8655 if (flags & MachO::SG_PROTECTED_VERSION_1) {
8656 outs() << " PROTECTED_VERSION_1";
8657 flags &= ~MachO::SG_PROTECTED_VERSION_1;
8658 }
8659 if (flags)
8660 outs() << format(" 0x%08" PRIx32"x", flags) << " (unknown flags)\n";
8661 else
8662 outs() << "\n";
8663 }
8664 } else {
8665 outs() << " flags " << format("0x%" PRIx32"x", flags) << "\n";
8666 }
8667}
8668
8669static void PrintSection(const char *sectname, const char *segname,
8670 uint64_t addr, uint64_t size, uint32_t offset,
8671 uint32_t align, uint32_t reloff, uint32_t nreloc,
8672 uint32_t flags, uint32_t reserved1, uint32_t reserved2,
8673 uint32_t cmd, const char *sg_segname,
8674 uint32_t filetype, uint32_t object_size,
8675 bool verbose) {
8676 outs() << "Section\n";
8677 outs() << " sectname " << format("%.16s\n", sectname);
8678 outs() << " segname " << format("%.16s", segname);
8679 if (filetype != MachO::MH_OBJECT && strncmp(sg_segname, segname, 16) != 0)
8680 outs() << " (does not match segment)\n";
8681 else
8682 outs() << "\n";
8683 if (cmd == MachO::LC_SEGMENT_64) {
8684 outs() << " addr " << format("0x%016" PRIx64"l" "x", addr) << "\n";
8685 outs() << " size " << format("0x%016" PRIx64"l" "x", size);
8686 } else {
8687 outs() << " addr " << format("0x%08" PRIx64"l" "x", addr) << "\n";
8688 outs() << " size " << format("0x%08" PRIx64"l" "x", size);
8689 }
8690 if ((flags & MachO::S_ZEROFILL) != 0 && offset + size > object_size)
8691 outs() << " (past end of file)\n";
8692 else
8693 outs() << "\n";
8694 outs() << " offset " << offset;
8695 if (offset > object_size)
8696 outs() << " (past end of file)\n";
8697 else
8698 outs() << "\n";
8699 uint32_t align_shifted = 1 << align;
8700 outs() << " align 2^" << align << " (" << align_shifted << ")\n";
8701 outs() << " reloff " << reloff;
8702 if (reloff > object_size)
8703 outs() << " (past end of file)\n";
8704 else
8705 outs() << "\n";
8706 outs() << " nreloc " << nreloc;
8707 if (reloff + nreloc * sizeof(struct MachO::relocation_info) > object_size)
8708 outs() << " (past end of file)\n";
8709 else
8710 outs() << "\n";
8711 uint32_t section_type = flags & MachO::SECTION_TYPE;
8712 if (verbose) {
8713 outs() << " type";
8714 if (section_type == MachO::S_REGULAR)
8715 outs() << " S_REGULAR\n";
8716 else if (section_type == MachO::S_ZEROFILL)
8717 outs() << " S_ZEROFILL\n";
8718 else if (section_type == MachO::S_CSTRING_LITERALS)
8719 outs() << " S_CSTRING_LITERALS\n";
8720 else if (section_type == MachO::S_4BYTE_LITERALS)
8721 outs() << " S_4BYTE_LITERALS\n";
8722 else if (section_type == MachO::S_8BYTE_LITERALS)
8723 outs() << " S_8BYTE_LITERALS\n";
8724 else if (section_type == MachO::S_16BYTE_LITERALS)
8725 outs() << " S_16BYTE_LITERALS\n";
8726 else if (section_type == MachO::S_LITERAL_POINTERS)
8727 outs() << " S_LITERAL_POINTERS\n";
8728 else if (section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS)
8729 outs() << " S_NON_LAZY_SYMBOL_POINTERS\n";
8730 else if (section_type == MachO::S_LAZY_SYMBOL_POINTERS)
8731 outs() << " S_LAZY_SYMBOL_POINTERS\n";
8732 else if (section_type == MachO::S_SYMBOL_STUBS)
8733 outs() << " S_SYMBOL_STUBS\n";
8734 else if (section_type == MachO::S_MOD_INIT_FUNC_POINTERS)
8735 outs() << " S_MOD_INIT_FUNC_POINTERS\n";
8736 else if (section_type == MachO::S_MOD_TERM_FUNC_POINTERS)
8737 outs() << " S_MOD_TERM_FUNC_POINTERS\n";
8738 else if (section_type == MachO::S_COALESCED)
8739 outs() << " S_COALESCED\n";
8740 else if (section_type == MachO::S_INTERPOSING)
8741 outs() << " S_INTERPOSING\n";
8742 else if (section_type == MachO::S_DTRACE_DOF)
8743 outs() << " S_DTRACE_DOF\n";
8744 else if (section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS)
8745 outs() << " S_LAZY_DYLIB_SYMBOL_POINTERS\n";
8746 else if (section_type == MachO::S_THREAD_LOCAL_REGULAR)
8747 outs() << " S_THREAD_LOCAL_REGULAR\n";
8748 else if (section_type == MachO::S_THREAD_LOCAL_ZEROFILL)
8749 outs() << " S_THREAD_LOCAL_ZEROFILL\n";
8750 else if (section_type == MachO::S_THREAD_LOCAL_VARIABLES)
8751 outs() << " S_THREAD_LOCAL_VARIABLES\n";
8752 else if (section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS)
8753 outs() << " S_THREAD_LOCAL_VARIABLE_POINTERS\n";
8754 else if (section_type == MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS)
8755 outs() << " S_THREAD_LOCAL_INIT_FUNCTION_POINTERS\n";
8756 else
8757 outs() << format("0x%08" PRIx32"x", section_type) << "\n";
8758 outs() << "attributes";
8759 uint32_t section_attributes = flags & MachO::SECTION_ATTRIBUTES;
8760 if (section_attributes & MachO::S_ATTR_PURE_INSTRUCTIONS)
8761 outs() << " PURE_INSTRUCTIONS";
8762 if (section_attributes & MachO::S_ATTR_NO_TOC)
8763 outs() << " NO_TOC";
8764 if (section_attributes & MachO::S_ATTR_STRIP_STATIC_SYMS)
8765 outs() << " STRIP_STATIC_SYMS";
8766 if (section_attributes & MachO::S_ATTR_NO_DEAD_STRIP)
8767 outs() << " NO_DEAD_STRIP";
8768 if (section_attributes & MachO::S_ATTR_LIVE_SUPPORT)
8769 outs() << " LIVE_SUPPORT";
8770 if (section_attributes & MachO::S_ATTR_SELF_MODIFYING_CODE)
8771 outs() << " SELF_MODIFYING_CODE";
8772 if (section_attributes & MachO::S_ATTR_DEBUG)
8773 outs() << " DEBUG";
8774 if (section_attributes & MachO::S_ATTR_SOME_INSTRUCTIONS)
8775 outs() << " SOME_INSTRUCTIONS";
8776 if (section_attributes & MachO::S_ATTR_EXT_RELOC)
8777 outs() << " EXT_RELOC";
8778 if (section_attributes & MachO::S_ATTR_LOC_RELOC)
8779 outs() << " LOC_RELOC";
8780 if (section_attributes == 0)
8781 outs() << " (none)";
8782 outs() << "\n";
8783 } else
8784 outs() << " flags " << format("0x%08" PRIx32"x", flags) << "\n";
8785 outs() << " reserved1 " << reserved1;
8786 if (section_type == MachO::S_SYMBOL_STUBS ||
8787 section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
8788 section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
8789 section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
8790 section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS)
8791 outs() << " (index into indirect symbol table)\n";
8792 else
8793 outs() << "\n";
8794 outs() << " reserved2 " << reserved2;
8795 if (section_type == MachO::S_SYMBOL_STUBS)
8796 outs() << " (size of stubs)\n";
8797 else
8798 outs() << "\n";
8799}
8800
8801static void PrintSymtabLoadCommand(MachO::symtab_command st, bool Is64Bit,
8802 uint32_t object_size) {
8803 outs() << " cmd LC_SYMTAB\n";
8804 outs() << " cmdsize " << st.cmdsize;
8805 if (st.cmdsize != sizeof(struct MachO::symtab_command))
8806 outs() << " Incorrect size\n";
8807 else
8808 outs() << "\n";
8809 outs() << " symoff " << st.symoff;
8810 if (st.symoff > object_size)
8811 outs() << " (past end of file)\n";
8812 else
8813 outs() << "\n";
8814 outs() << " nsyms " << st.nsyms;
8815 uint64_t big_size;
8816 if (Is64Bit) {
8817 big_size = st.nsyms;
8818 big_size *= sizeof(struct MachO::nlist_64);
8819 big_size += st.symoff;
8820 if (big_size > object_size)
8821 outs() << " (past end of file)\n";
8822 else
8823 outs() << "\n";
8824 } else {
8825 big_size = st.nsyms;
8826 big_size *= sizeof(struct MachO::nlist);
8827 big_size += st.symoff;
8828 if (big_size > object_size)
8829 outs() << " (past end of file)\n";
8830 else
8831 outs() << "\n";
8832 }
8833 outs() << " stroff " << st.stroff;
8834 if (st.stroff > object_size)
8835 outs() << " (past end of file)\n";
8836 else
8837 outs() << "\n";
8838 outs() << " strsize " << st.strsize;
8839 big_size = st.stroff;
8840 big_size += st.strsize;
8841 if (big_size > object_size)
8842 outs() << " (past end of file)\n";
8843 else
8844 outs() << "\n";
8845}
8846
8847static void PrintDysymtabLoadCommand(MachO::dysymtab_command dyst,
8848 uint32_t nsyms, uint32_t object_size,
8849 bool Is64Bit) {
8850 outs() << " cmd LC_DYSYMTAB\n";
8851 outs() << " cmdsize " << dyst.cmdsize;
8852 if (dyst.cmdsize != sizeof(struct MachO::dysymtab_command))
8853 outs() << " Incorrect size\n";
8854 else
8855 outs() << "\n";
8856 outs() << " ilocalsym " << dyst.ilocalsym;
8857 if (dyst.ilocalsym > nsyms)
8858 outs() << " (greater than the number of symbols)\n";
8859 else
8860 outs() << "\n";
8861 outs() << " nlocalsym " << dyst.nlocalsym;
8862 uint64_t big_size;
8863 big_size = dyst.ilocalsym;
8864 big_size += dyst.nlocalsym;
8865 if (big_size > nsyms)
8866 outs() << " (past the end of the symbol table)\n";
8867 else
8868 outs() << "\n";
8869 outs() << " iextdefsym " << dyst.iextdefsym;
8870 if (dyst.iextdefsym > nsyms)
8871 outs() << " (greater than the number of symbols)\n";
8872 else
8873 outs() << "\n";
8874 outs() << " nextdefsym " << dyst.nextdefsym;
8875 big_size = dyst.iextdefsym;
8876 big_size += dyst.nextdefsym;
8877 if (big_size > nsyms)
8878 outs() << " (past the end of the symbol table)\n";
8879 else
8880 outs() << "\n";
8881 outs() << " iundefsym " << dyst.iundefsym;
8882 if (dyst.iundefsym > nsyms)
8883 outs() << " (greater than the number of symbols)\n";
8884 else
8885 outs() << "\n";
8886 outs() << " nundefsym " << dyst.nundefsym;
8887 big_size = dyst.iundefsym;
8888 big_size += dyst.nundefsym;
8889 if (big_size > nsyms)
8890 outs() << " (past the end of the symbol table)\n";
8891 else
8892 outs() << "\n";
8893 outs() << " tocoff " << dyst.tocoff;
8894 if (dyst.tocoff > object_size)
8895 outs() << " (past end of file)\n";
8896 else
8897 outs() << "\n";
8898 outs() << " ntoc " << dyst.ntoc;
8899 big_size = dyst.ntoc;
8900 big_size *= sizeof(struct MachO::dylib_table_of_contents);
8901 big_size += dyst.tocoff;
8902 if (big_size > object_size)
8903 outs() << " (past end of file)\n";
8904 else
8905 outs() << "\n";
8906 outs() << " modtaboff " << dyst.modtaboff;
8907 if (dyst.modtaboff > object_size)
8908 outs() << " (past end of file)\n";
8909 else
8910 outs() << "\n";
8911 outs() << " nmodtab " << dyst.nmodtab;
8912 uint64_t modtabend;
8913 if (Is64Bit) {
8914 modtabend = dyst.nmodtab;
8915 modtabend *= sizeof(struct MachO::dylib_module_64);
8916 modtabend += dyst.modtaboff;
8917 } else {
8918 modtabend = dyst.nmodtab;
8919 modtabend *= sizeof(struct MachO::dylib_module);
8920 modtabend += dyst.modtaboff;
8921 }
8922 if (modtabend > object_size)
8923 outs() << " (past end of file)\n";
8924 else
8925 outs() << "\n";
8926 outs() << " extrefsymoff " << dyst.extrefsymoff;
8927 if (dyst.extrefsymoff > object_size)
8928 outs() << " (past end of file)\n";
8929 else
8930 outs() << "\n";
8931 outs() << " nextrefsyms " << dyst.nextrefsyms;
8932 big_size = dyst.nextrefsyms;
8933 big_size *= sizeof(struct MachO::dylib_reference);
8934 big_size += dyst.extrefsymoff;
8935 if (big_size > object_size)
8936 outs() << " (past end of file)\n";
8937 else
8938 outs() << "\n";
8939 outs() << " indirectsymoff " << dyst.indirectsymoff;
8940 if (dyst.indirectsymoff > object_size)
8941 outs() << " (past end of file)\n";
8942 else
8943 outs() << "\n";
8944 outs() << " nindirectsyms " << dyst.nindirectsyms;
8945 big_size = dyst.nindirectsyms;
8946 big_size *= sizeof(uint32_t);
8947 big_size += dyst.indirectsymoff;
8948 if (big_size > object_size)
8949 outs() << " (past end of file)\n";
8950 else
8951 outs() << "\n";
8952 outs() << " extreloff " << dyst.extreloff;
8953 if (dyst.extreloff > object_size)
8954 outs() << " (past end of file)\n";
8955 else
8956 outs() << "\n";
8957 outs() << " nextrel " << dyst.nextrel;
8958 big_size = dyst.nextrel;
8959 big_size *= sizeof(struct MachO::relocation_info);
8960 big_size += dyst.extreloff;
8961 if (big_size > object_size)
8962 outs() << " (past end of file)\n";
8963 else
8964 outs() << "\n";
8965 outs() << " locreloff " << dyst.locreloff;
8966 if (dyst.locreloff > object_size)
8967 outs() << " (past end of file)\n";
8968 else
8969 outs() << "\n";
8970 outs() << " nlocrel " << dyst.nlocrel;
8971 big_size = dyst.nlocrel;
8972 big_size *= sizeof(struct MachO::relocation_info);
8973 big_size += dyst.locreloff;
8974 if (big_size > object_size)
8975 outs() << " (past end of file)\n";
8976 else
8977 outs() << "\n";
8978}
8979
8980static void PrintDyldInfoLoadCommand(MachO::dyld_info_command dc,
8981 uint32_t object_size) {
8982 if (dc.cmd == MachO::LC_DYLD_INFO)
8983 outs() << " cmd LC_DYLD_INFO\n";
8984 else
8985 outs() << " cmd LC_DYLD_INFO_ONLY\n";
8986 outs() << " cmdsize " << dc.cmdsize;
8987 if (dc.cmdsize != sizeof(struct MachO::dyld_info_command))
8988 outs() << " Incorrect size\n";
8989 else
8990 outs() << "\n";
8991 outs() << " rebase_off " << dc.rebase_off;
8992 if (dc.rebase_off > object_size)
8993 outs() << " (past end of file)\n";
8994 else
8995 outs() << "\n";
8996 outs() << " rebase_size " << dc.rebase_size;
8997 uint64_t big_size;
8998 big_size = dc.rebase_off;
8999 big_size += dc.rebase_size;
9000 if (big_size > object_size)
9001 outs() << " (past end of file)\n";
9002 else
9003 outs() << "\n";
9004 outs() << " bind_off " << dc.bind_off;
9005 if (dc.bind_off > object_size)
9006 outs() << " (past end of file)\n";
9007 else
9008 outs() << "\n";
9009 outs() << " bind_size " << dc.bind_size;
9010 big_size = dc.bind_off;
9011 big_size += dc.bind_size;
9012 if (big_size > object_size)
9013 outs() << " (past end of file)\n";
9014 else
9015 outs() << "\n";
9016 outs() << " weak_bind_off " << dc.weak_bind_off;
9017 if (dc.weak_bind_off > object_size)
9018 outs() << " (past end of file)\n";
9019 else
9020 outs() << "\n";
9021 outs() << " weak_bind_size " << dc.weak_bind_size;
9022 big_size = dc.weak_bind_off;
9023 big_size += dc.weak_bind_size;
9024 if (big_size > object_size)
9025 outs() << " (past end of file)\n";
9026 else
9027 outs() << "\n";
9028 outs() << " lazy_bind_off " << dc.lazy_bind_off;
9029 if (dc.lazy_bind_off > object_size)
9030 outs() << " (past end of file)\n";
9031 else
9032 outs() << "\n";
9033 outs() << " lazy_bind_size " << dc.lazy_bind_size;
9034 big_size = dc.lazy_bind_off;
9035 big_size += dc.lazy_bind_size;
9036 if (big_size > object_size)
9037 outs() << " (past end of file)\n";
9038 else
9039 outs() << "\n";
9040 outs() << " export_off " << dc.export_off;
9041 if (dc.export_off > object_size)
9042 outs() << " (past end of file)\n";
9043 else
9044 outs() << "\n";
9045 outs() << " export_size " << dc.export_size;
9046 big_size = dc.export_off;
9047 big_size += dc.export_size;
9048 if (big_size > object_size)
9049 outs() << " (past end of file)\n";
9050 else
9051 outs() << "\n";
9052}
9053
9054static void PrintDyldLoadCommand(MachO::dylinker_command dyld,
9055 const char *Ptr) {
9056 if (dyld.cmd == MachO::LC_ID_DYLINKER)
9057 outs() << " cmd LC_ID_DYLINKER\n";
9058 else if (dyld.cmd == MachO::LC_LOAD_DYLINKER)
9059 outs() << " cmd LC_LOAD_DYLINKER\n";
9060 else if (dyld.cmd == MachO::LC_DYLD_ENVIRONMENT)
9061 outs() << " cmd LC_DYLD_ENVIRONMENT\n";
9062 else
9063 outs() << " cmd ?(" << dyld.cmd << ")\n";
9064 outs() << " cmdsize " << dyld.cmdsize;
9065 if (dyld.cmdsize < sizeof(struct MachO::dylinker_command))
9066 outs() << " Incorrect size\n";
9067 else
9068 outs() << "\n";
9069 if (dyld.name >= dyld.cmdsize)
9070 outs() << " name ?(bad offset " << dyld.name << ")\n";
9071 else {
9072 const char *P = (const char *)(Ptr) + dyld.name;
9073 outs() << " name " << P << " (offset " << dyld.name << ")\n";
9074 }
9075}
9076
9077static void PrintUuidLoadCommand(MachO::uuid_command uuid) {
9078 outs() << " cmd LC_UUID\n";
9079 outs() << " cmdsize " << uuid.cmdsize;
9080 if (uuid.cmdsize != sizeof(struct MachO::uuid_command))
9081 outs() << " Incorrect size\n";
9082 else
9083 outs() << "\n";
9084 outs() << " uuid ";
9085 for (int i = 0; i < 16; ++i) {
9086 outs() << format("%02" PRIX32"X", uuid.uuid[i]);
9087 if (i == 3 || i == 5 || i == 7 || i == 9)
9088 outs() << "-";
9089 }
9090 outs() << "\n";
9091}
9092
9093static void PrintRpathLoadCommand(MachO::rpath_command rpath, const char *Ptr) {
9094 outs() << " cmd LC_RPATH\n";
9095 outs() << " cmdsize " << rpath.cmdsize;
9096 if (rpath.cmdsize < sizeof(struct MachO::rpath_command))
9097 outs() << " Incorrect size\n";
9098 else
9099 outs() << "\n";
9100 if (rpath.path >= rpath.cmdsize)
9101 outs() << " path ?(bad offset " << rpath.path << ")\n";
9102 else {
9103 const char *P = (const char *)(Ptr) + rpath.path;
9104 outs() << " path " << P << " (offset " << rpath.path << ")\n";
9105 }
9106}
9107
9108static void PrintVersionMinLoadCommand(MachO::version_min_command vd) {
9109 StringRef LoadCmdName;
9110 switch (vd.cmd) {
9111 case MachO::LC_VERSION_MIN_MACOSX:
9112 LoadCmdName = "LC_VERSION_MIN_MACOSX";
9113 break;
9114 case MachO::LC_VERSION_MIN_IPHONEOS:
9115 LoadCmdName = "LC_VERSION_MIN_IPHONEOS";
9116 break;
9117 case MachO::LC_VERSION_MIN_TVOS:
9118 LoadCmdName = "LC_VERSION_MIN_TVOS";
9119 break;
9120 case MachO::LC_VERSION_MIN_WATCHOS:
9121 LoadCmdName = "LC_VERSION_MIN_WATCHOS";
9122 break;
9123 default:
9124 llvm_unreachable("Unknown version min load command")::llvm::llvm_unreachable_internal("Unknown version min load command"
, "llvm/tools/llvm-objdump/MachODump.cpp", 9124)
;
9125 }
9126
9127 outs() << " cmd " << LoadCmdName << '\n';
9128 outs() << " cmdsize " << vd.cmdsize;
9129 if (vd.cmdsize != sizeof(struct MachO::version_min_command))
9130 outs() << " Incorrect size\n";
9131 else
9132 outs() << "\n";
9133 outs() << " version "
9134 << MachOObjectFile::getVersionMinMajor(vd, false) << "."
9135 << MachOObjectFile::getVersionMinMinor(vd, false);
9136 uint32_t Update = MachOObjectFile::getVersionMinUpdate(vd, false);
9137 if (Update != 0)
9138 outs() << "." << Update;
9139 outs() << "\n";
9140 if (vd.sdk == 0)
9141 outs() << " sdk n/a";
9142 else {
9143 outs() << " sdk "
9144 << MachOObjectFile::getVersionMinMajor(vd, true) << "."
9145 << MachOObjectFile::getVersionMinMinor(vd, true);
9146 }
9147 Update = MachOObjectFile::getVersionMinUpdate(vd, true);
9148 if (Update != 0)
9149 outs() << "." << Update;
9150 outs() << "\n";
9151}
9152
9153static void PrintNoteLoadCommand(MachO::note_command Nt) {
9154 outs() << " cmd LC_NOTE\n";
9155 outs() << " cmdsize " << Nt.cmdsize;
9156 if (Nt.cmdsize != sizeof(struct MachO::note_command))
9157 outs() << " Incorrect size\n";
9158 else
9159 outs() << "\n";
9160 const char *d = Nt.data_owner;
9161 outs() << "data_owner " << format("%.16s\n", d);
9162 outs() << " offset " << Nt.offset << "\n";
9163 outs() << " size " << Nt.size << "\n";
9164}
9165
9166static void PrintBuildToolVersion(MachO::build_tool_version bv) {
9167 outs() << " tool " << MachOObjectFile::getBuildTool(bv.tool) << "\n";
9168 outs() << " version " << MachOObjectFile::getVersionString(bv.version)
9169 << "\n";
9170}
9171
9172static void PrintBuildVersionLoadCommand(const MachOObjectFile *obj,
9173 MachO::build_version_command bd) {
9174 outs() << " cmd LC_BUILD_VERSION\n";
9175 outs() << " cmdsize " << bd.cmdsize;
9176 if (bd.cmdsize !=
9177 sizeof(struct MachO::build_version_command) +
9178 bd.ntools * sizeof(struct MachO::build_tool_version))
9179 outs() << " Incorrect size\n";
9180 else
9181 outs() << "\n";
9182 outs() << " platform " << MachOObjectFile::getBuildPlatform(bd.platform)
9183 << "\n";
9184 if (bd.sdk)
9185 outs() << " sdk " << MachOObjectFile::getVersionString(bd.sdk)
9186 << "\n";
9187 else
9188 outs() << " sdk n/a\n";
9189 outs() << " minos " << MachOObjectFile::getVersionString(bd.minos)
9190 << "\n";
9191 outs() << " ntools " << bd.ntools << "\n";
9192 for (unsigned i = 0; i < bd.ntools; ++i) {
9193 MachO::build_tool_version bv = obj->getBuildToolVersion(i);
9194 PrintBuildToolVersion(bv);
9195 }
9196}
9197
9198static void PrintSourceVersionCommand(MachO::source_version_command sd) {
9199 outs() << " cmd LC_SOURCE_VERSION\n";
9200 outs() << " cmdsize " << sd.cmdsize;
9201 if (sd.cmdsize != sizeof(struct MachO::source_version_command))
9202 outs() << " Incorrect size\n";
9203 else
9204 outs() << "\n";
9205 uint64_t a = (sd.version >> 40) & 0xffffff;
9206 uint64_t b = (sd.version >> 30) & 0x3ff;
9207 uint64_t c = (sd.version >> 20) & 0x3ff;
9208 uint64_t d = (sd.version >> 10) & 0x3ff;
9209 uint64_t e = sd.version & 0x3ff;
9210 outs() << " version " << a << "." << b;
9211 if (e != 0)
9212 outs() << "." << c << "." << d << "." << e;
9213 else if (d != 0)
9214 outs() << "." << c << "." << d;
9215 else if (c != 0)
9216 outs() << "." << c;
9217 outs() << "\n";
9218}
9219
9220static void PrintEntryPointCommand(MachO::entry_point_command ep) {
9221 outs() << " cmd LC_MAIN\n";
9222 outs() << " cmdsize " << ep.cmdsize;
9223 if (ep.cmdsize != sizeof(struct MachO::entry_point_command))
9224 outs() << " Incorrect size\n";
9225 else
9226 outs() << "\n";
9227 outs() << " entryoff " << ep.entryoff << "\n";
9228 outs() << " stacksize " << ep.stacksize << "\n";
9229}
9230
9231static void PrintEncryptionInfoCommand(MachO::encryption_info_command ec,
9232 uint32_t object_size) {
9233 outs() << " cmd LC_ENCRYPTION_INFO\n";
9234 outs() << " cmdsize " << ec.cmdsize;
9235 if (ec.cmdsize != sizeof(struct MachO::encryption_info_command))
9236 outs() << " Incorrect size\n";
9237 else
9238 outs() << "\n";
9239 outs() << " cryptoff " << ec.cryptoff;
9240 if (ec.cryptoff > object_size)
9241 outs() << " (past end of file)\n";
9242 else
9243 outs() << "\n";
9244 outs() << " cryptsize " << ec.cryptsize;
9245 if (ec.cryptsize > object_size)
9246 outs() << " (past end of file)\n";
9247 else
9248 outs() << "\n";
9249 outs() << " cryptid " << ec.cryptid << "\n";
9250}
9251
9252static void PrintEncryptionInfoCommand64(MachO::encryption_info_command_64 ec,
9253 uint32_t object_size) {
9254 outs() << " cmd LC_ENCRYPTION_INFO_64\n";
9255 outs() << " cmdsize " << ec.cmdsize;
9256 if (ec.cmdsize != sizeof(struct MachO::encryption_info_command_64))
9257 outs() << " Incorrect size\n";
9258 else
9259 outs() << "\n";
9260 outs() << " cryptoff " << ec.cryptoff;
9261 if (ec.cryptoff > object_size)
9262 outs() << " (past end of file)\n";
9263 else
9264 outs() << "\n";
9265 outs() << " cryptsize " << ec.cryptsize;
9266 if (ec.cryptsize > object_size)
9267 outs() << " (past end of file)\n";
9268 else
9269 outs() << "\n";
9270 outs() << " cryptid " << ec.cryptid << "\n";
9271 outs() << " pad " << ec.pad << "\n";
9272}
9273
9274static void PrintLinkerOptionCommand(MachO::linker_option_command lo,
9275 const char *Ptr) {
9276 outs() << " cmd LC_LINKER_OPTION\n";
9277 outs() << " cmdsize " << lo.cmdsize;
9278 if (lo.cmdsize < sizeof(struct MachO::linker_option_command))
9279 outs() << " Incorrect size\n";
9280 else
9281 outs() << "\n";
9282 outs() << " count " << lo.count << "\n";
9283 const char *string = Ptr + sizeof(struct MachO::linker_option_command);
9284 uint32_t left = lo.cmdsize - sizeof(struct MachO::linker_option_command);
9285 uint32_t i = 0;
9286 while (left > 0) {
9287 while (*string == '\0' && left > 0) {
9288 string++;
9289 left--;
9290 }
9291 if (left > 0) {
9292 i++;
9293 outs() << " string #" << i << " " << format("%.*s\n", left, string);
9294 uint32_t NullPos = StringRef(string, left).find('\0');
9295 uint32_t len = std::min(NullPos, left) + 1;
9296 string += len;
9297 left -= len;
9298 }
9299 }
9300 if (lo.count != i)
9301 outs() << " count " << lo.count << " does not match number of strings "
9302 << i << "\n";
9303}
9304
9305static void PrintSubFrameworkCommand(MachO::sub_framework_command sub,
9306 const char *Ptr) {
9307 outs() << " cmd LC_SUB_FRAMEWORK\n";
9308 outs() << " cmdsize " << sub.cmdsize;
9309 if (sub.cmdsize < sizeof(struct MachO::sub_framework_command))
9310 outs() << " Incorrect size\n";
9311 else
9312 outs() << "\n";
9313 if (sub.umbrella < sub.cmdsize) {
9314 const char *P = Ptr + sub.umbrella;
9315 outs() << " umbrella " << P << " (offset " << sub.umbrella << ")\n";
9316 } else {
9317 outs() << " umbrella ?(bad offset " << sub.umbrella << ")\n";
9318 }
9319}
9320
9321static void PrintSubUmbrellaCommand(MachO::sub_umbrella_command sub,
9322 const char *Ptr) {
9323 outs() << " cmd LC_SUB_UMBRELLA\n";
9324 outs() << " cmdsize " << sub.cmdsize;
9325 if (sub.cmdsize < sizeof(struct MachO::sub_umbrella_command))
9326 outs() << " Incorrect size\n";
9327 else
9328 outs() << "\n";
9329 if (sub.sub_umbrella < sub.cmdsize) {
9330 const char *P = Ptr + sub.sub_umbrella;
9331 outs() << " sub_umbrella " << P << " (offset " << sub.sub_umbrella << ")\n";
9332 } else {
9333 outs() << " sub_umbrella ?(bad offset " << sub.sub_umbrella << ")\n";
9334 }
9335}
9336
9337static void PrintSubLibraryCommand(MachO::sub_library_command sub,
9338 const char *Ptr) {
9339 outs() << " cmd LC_SUB_LIBRARY\n";
9340 outs() << " cmdsize " << sub.cmdsize;
9341 if (sub.cmdsize < sizeof(struct MachO::sub_library_command))
9342 outs() << " Incorrect size\n";
9343 else
9344 outs() << "\n";
9345 if (sub.sub_library < sub.cmdsize) {
9346 const char *P = Ptr + sub.sub_library;
9347 outs() << " sub_library " << P << " (offset " << sub.sub_library << ")\n";
9348 } else {
9349 outs() << " sub_library ?(bad offset " << sub.sub_library << ")\n";
9350 }
9351}
9352
9353static void PrintSubClientCommand(MachO::sub_client_command sub,
9354 const char *Ptr) {
9355 outs() << " cmd LC_SUB_CLIENT\n";
9356 outs() << " cmdsize " << sub.cmdsize;
9357 if (sub.cmdsize < sizeof(struct MachO::sub_client_command))
9358 outs() << " Incorrect size\n";
9359 else
9360 outs() << "\n";
9361 if (sub.client < sub.cmdsize) {
9362 const char *P = Ptr + sub.client;
9363 outs() << " client " << P << " (offset " << sub.client << ")\n";
9364 } else {
9365 outs() << " client ?(bad offset " << sub.client << ")\n";
9366 }
9367}
9368
9369static void PrintRoutinesCommand(MachO::routines_command r) {
9370 outs() << " cmd LC_ROUTINES\n";
9371 outs() << " cmdsize " << r.cmdsize;
9372 if (r.cmdsize != sizeof(struct MachO::routines_command))
9373 outs() << " Incorrect size\n";
9374 else
9375 outs() << "\n";
9376 outs() << " init_address " << format("0x%08" PRIx32"x", r.init_address) << "\n";
9377 outs() << " init_module " << r.init_module << "\n";
9378 outs() << " reserved1 " << r.reserved1 << "\n";
9379 outs() << " reserved2 " << r.reserved2 << "\n";
9380 outs() << " reserved3 " << r.reserved3 << "\n";
9381 outs() << " reserved4 " << r.reserved4 << "\n";
9382 outs() << " reserved5 " << r.reserved5 << "\n";
9383 outs() << " reserved6 " << r.reserved6 << "\n";
9384}
9385
9386static void PrintRoutinesCommand64(MachO::routines_command_64 r) {
9387 outs() << " cmd LC_ROUTINES_64\n";
9388 outs() << " cmdsize " << r.cmdsize;
9389 if (r.cmdsize != sizeof(struct MachO::routines_command_64))
9390 outs() << " Incorrect size\n";
9391 else
9392 outs() << "\n";
9393 outs() << " init_address " << format("0x%016" PRIx64"l" "x", r.init_address) << "\n";
9394 outs() << " init_module " << r.init_module << "\n";
9395 outs() << " reserved1 " << r.reserved1 << "\n";
9396 outs() << " reserved2 " << r.reserved2 << "\n";
9397 outs() << " reserved3 " << r.reserved3 << "\n";
9398 outs() << " reserved4 " << r.reserved4 << "\n";
9399 outs() << " reserved5 " << r.reserved5 << "\n";
9400 outs() << " reserved6 " << r.reserved6 << "\n";
9401}
9402
9403static void Print_x86_thread_state32_t(MachO::x86_thread_state32_t &cpu32) {
9404 outs() << "\t eax " << format("0x%08" PRIx32"x", cpu32.eax);
9405 outs() << " ebx " << format("0x%08" PRIx32"x", cpu32.ebx);
9406 outs() << " ecx " << format("0x%08" PRIx32"x", cpu32.ecx);
9407 outs() << " edx " << format("0x%08" PRIx32"x", cpu32.edx) << "\n";
9408 outs() << "\t edi " << format("0x%08" PRIx32"x", cpu32.edi);
9409 outs() << " esi " << format("0x%08" PRIx32"x", cpu32.esi);
9410 outs() << " ebp " << format("0x%08" PRIx32"x", cpu32.ebp);
9411 outs() << " esp " << format("0x%08" PRIx32"x", cpu32.esp) << "\n";
9412 outs() << "\t ss " << format("0x%08" PRIx32"x", cpu32.ss);
9413 outs() << " eflags " << format("0x%08" PRIx32"x", cpu32.eflags);
9414 outs() << " eip " << format("0x%08" PRIx32"x", cpu32.eip);
9415 outs() << " cs " << format("0x%08" PRIx32"x", cpu32.cs) << "\n";
9416 outs() << "\t ds " << format("0x%08" PRIx32"x", cpu32.ds);
9417 outs() << " es " << format("0x%08" PRIx32"x", cpu32.es);
9418 outs() << " fs " << format("0x%08" PRIx32"x", cpu32.fs);
9419 outs() << " gs " << format("0x%08" PRIx32"x", cpu32.gs) << "\n";
9420}
9421
9422static void Print_x86_thread_state64_t(MachO::x86_thread_state64_t &cpu64) {
9423 outs() << " rax " << format("0x%016" PRIx64"l" "x", cpu64.rax);
9424 outs() << " rbx " << format("0x%016" PRIx64"l" "x", cpu64.rbx);
9425 outs() << " rcx " << format("0x%016" PRIx64"l" "x", cpu64.rcx) << "\n";
9426 outs() << " rdx " << format("0x%016" PRIx64"l" "x", cpu64.rdx);
9427 outs() << " rdi " << format("0x%016" PRIx64"l" "x", cpu64.rdi);
9428 outs() << " rsi " << format("0x%016" PRIx64"l" "x", cpu64.rsi) << "\n";
9429 outs() << " rbp " << format("0x%016" PRIx64"l" "x", cpu64.rbp);
9430 outs() << " rsp " << format("0x%016" PRIx64"l" "x", cpu64.rsp);
9431 outs() << " r8 " << format("0x%016" PRIx64"l" "x", cpu64.r8) << "\n";
9432 outs() << " r9 " << format("0x%016" PRIx64"l" "x", cpu64.r9);
9433 outs() << " r10 " << format("0x%016" PRIx64"l" "x", cpu64.r10);
9434 outs() << " r11 " << format("0x%016" PRIx64"l" "x", cpu64.r11) << "\n";
9435 outs() << " r12 " << format("0x%016" PRIx64"l" "x", cpu64.r12);
9436 outs() << " r13 " << format("0x%016" PRIx64"l" "x", cpu64.r13);
9437 outs() << " r14 " << format("0x%016" PRIx64"l" "x", cpu64.r14) << "\n";
9438 outs() << " r15 " << format("0x%016" PRIx64"l" "x", cpu64.r15);
9439 outs() << " rip " << format("0x%016" PRIx64"l" "x", cpu64.rip) << "\n";
9440 outs() << "rflags " << format("0x%016" PRIx64"l" "x", cpu64.rflags);
9441 outs() << " cs " << format("0x%016" PRIx64"l" "x", cpu64.cs);
9442 outs() << " fs " << format("0x%016" PRIx64"l" "x", cpu64.fs) << "\n";
9443 outs() << " gs " << format("0x%016" PRIx64"l" "x", cpu64.gs) << "\n";
9444}
9445
9446static void Print_mmst_reg(MachO::mmst_reg_t &r) {
9447 uint32_t f;
9448 outs() << "\t mmst_reg ";
9449 for (f = 0; f < 10; f++)
9450 outs() << format("%02" PRIx32"x", (r.mmst_reg[f] & 0xff)) << " ";
9451 outs() << "\n";
9452 outs() << "\t mmst_rsrv ";
9453 for (f = 0; f < 6; f++)
9454 outs() << format("%02" PRIx32"x", (r.mmst_rsrv[f] & 0xff)) << " ";
9455 outs() << "\n";
9456}
9457
9458static void Print_xmm_reg(MachO::xmm_reg_t &r) {
9459 uint32_t f;
9460 outs() << "\t xmm_reg ";
9461 for (f = 0; f < 16; f++)
9462 outs() << format("%02" PRIx32"x", (r.xmm_reg[f] & 0xff)) << " ";
9463 outs() << "\n";
9464}
9465
9466static void Print_x86_float_state_t(MachO::x86_float_state64_t &fpu) {
9467 outs() << "\t fpu_reserved[0] " << fpu.fpu_reserved[0];
9468 outs() << " fpu_reserved[1] " << fpu.fpu_reserved[1] << "\n";
9469 outs() << "\t control: invalid " << fpu.fpu_fcw.invalid;
9470 outs() << " denorm " << fpu.fpu_fcw.denorm;
9471 outs() << " zdiv " << fpu.fpu_fcw.zdiv;
9472 outs() << " ovrfl " << fpu.fpu_fcw.ovrfl;
9473 outs() << " undfl " << fpu.fpu_fcw.undfl;
9474 outs() << " precis " << fpu.fpu_fcw.precis << "\n";
9475 outs() << "\t\t pc ";
9476 if (fpu.fpu_fcw.pc == MachO::x86_FP_PREC_24B)
9477 outs() << "FP_PREC_24B ";
9478 else if (fpu.fpu_fcw.pc == MachO::x86_FP_PREC_53B)
9479 outs() << "FP_PREC_53B ";
9480 else if (fpu.fpu_fcw.pc == MachO::x86_FP_PREC_64B)
9481 outs() << "FP_PREC_64B ";
9482 else
9483 outs() << fpu.fpu_fcw.pc << " ";
9484 outs() << "rc ";
9485 if (fpu.fpu_fcw.rc == MachO::x86_FP_RND_NEAR)
9486 outs() << "FP_RND_NEAR ";
9487 else if (fpu.fpu_fcw.rc == MachO::x86_FP_RND_DOWN)
9488 outs() << "FP_RND_DOWN ";
9489 else if (fpu.fpu_fcw.rc == MachO::x86_FP_RND_UP)
9490 outs() << "FP_RND_UP ";
9491 else if (fpu.fpu_fcw.rc == MachO::x86_FP_CHOP)
9492 outs() << "FP_CHOP ";
9493 outs() << "\n";
9494 outs() << "\t status: invalid " << fpu.fpu_fsw.invalid;
9495 outs() << " denorm " << fpu.fpu_fsw.denorm;
9496 outs() << " zdiv " << fpu.fpu_fsw.zdiv;
9497 outs() << " ovrfl " << fpu.fpu_fsw.ovrfl;
9498 outs() << " undfl " << fpu.fpu_fsw.undfl;
9499 outs() << " precis " << fpu.fpu_fsw.precis;
9500 outs() << " stkflt " << fpu.fpu_fsw.stkflt << "\n";
9501 outs() << "\t errsumm " << fpu.fpu_fsw.errsumm;
9502 outs() << " c0 " << fpu.fpu_fsw.c0;
9503 outs() << " c1 " << fpu.fpu_fsw.c1;
9504 outs() << " c2 " << fpu.fpu_fsw.c2;
9505 outs() << " tos " << fpu.fpu_fsw.tos;
9506 outs() << " c3 " << fpu.fpu_fsw.c3;
9507 outs() << " busy " << fpu.fpu_fsw.busy << "\n";
9508 outs() << "\t fpu_ftw " << format("0x%02" PRIx32"x", fpu.fpu_ftw);
9509 outs() << " fpu_rsrv1 " << format("0x%02" PRIx32"x", fpu.fpu_rsrv1);
9510 outs() << " fpu_fop " << format("0x%04" PRIx32"x", fpu.fpu_fop);
9511 outs() << " fpu_ip " << format("0x%08" PRIx32"x", fpu.fpu_ip) << "\n";
9512 outs() << "\t fpu_cs " << format("0x%04" PRIx32"x", fpu.fpu_cs);
9513 outs() << " fpu_rsrv2 " << format("0x%04" PRIx32"x", fpu.fpu_rsrv2);
9514 outs() << " fpu_dp " << format("0x%08" PRIx32"x", fpu.fpu_dp);
9515 outs() << " fpu_ds " << format("0x%04" PRIx32"x", fpu.fpu_ds) << "\n";
9516 outs() << "\t fpu_rsrv3 " << format("0x%04" PRIx32"x", fpu.fpu_rsrv3);
9517 outs() << " fpu_mxcsr " << format("0x%08" PRIx32"x", fpu.fpu_mxcsr);
9518 outs() << " fpu_mxcsrmask " << format("0x%08" PRIx32"x", fpu.fpu_mxcsrmask);
9519 outs() << "\n";
9520 outs() << "\t fpu_stmm0:\n";
9521 Print_mmst_reg(fpu.fpu_stmm0);
9522 outs() << "\t fpu_stmm1:\n";
9523 Print_mmst_reg(fpu.fpu_stmm1);
9524 outs() << "\t fpu_stmm2:\n";
9525 Print_mmst_reg(fpu.fpu_stmm2);
9526 outs() << "\t fpu_stmm3:\n";
9527 Print_mmst_reg(fpu.fpu_stmm3);
9528 outs() << "\t fpu_stmm4:\n";
9529 Print_mmst_reg(fpu.fpu_stmm4);
9530 outs() << "\t fpu_stmm5:\n";
9531 Print_mmst_reg(fpu.fpu_stmm5);
9532 outs() << "\t fpu_stmm6:\n";
9533 Print_mmst_reg(fpu.fpu_stmm6);
9534 outs() << "\t fpu_stmm7:\n";
9535 Print_mmst_reg(fpu.fpu_stmm7);
9536 outs() << "\t fpu_xmm0:\n";
9537 Print_xmm_reg(fpu.fpu_xmm0);
9538 outs() << "\t fpu_xmm1:\n";
9539 Print_xmm_reg(fpu.fpu_xmm1);
9540 outs() << "\t fpu_xmm2:\n";
9541 Print_xmm_reg(fpu.fpu_xmm2);
9542 outs() << "\t fpu_xmm3:\n";
9543 Print_xmm_reg(fpu.fpu_xmm3);
9544 outs() << "\t fpu_xmm4:\n";
9545 Print_xmm_reg(fpu.fpu_xmm4);
9546 outs() << "\t fpu_xmm5:\n";
9547 Print_xmm_reg(fpu.fpu_xmm5);
9548 outs() << "\t fpu_xmm6:\n";
9549 Print_xmm_reg(fpu.fpu_xmm6);
9550 outs() << "\t fpu_xmm7:\n";
9551 Print_xmm_reg(fpu.fpu_xmm7);
9552 outs() << "\t fpu_xmm8:\n";
9553 Print_xmm_reg(fpu.fpu_xmm8);
9554 outs() << "\t fpu_xmm9:\n";
9555 Print_xmm_reg(fpu.fpu_xmm9);
9556 outs() << "\t fpu_xmm10:\n";
9557 Print_xmm_reg(fpu.fpu_xmm10);
9558 outs() << "\t fpu_xmm11:\n";
9559 Print_xmm_reg(fpu.fpu_xmm11);
9560 outs() << "\t fpu_xmm12:\n";
9561 Print_xmm_reg(fpu.fpu_xmm12);
9562 outs() << "\t fpu_xmm13:\n";
9563 Print_xmm_reg(fpu.fpu_xmm13);
9564 outs() << "\t fpu_xmm14:\n";
9565 Print_xmm_reg(fpu.fpu_xmm14);
9566 outs() << "\t fpu_xmm15:\n";
9567 Print_xmm_reg(fpu.fpu_xmm15);
9568 outs() << "\t fpu_rsrv4:\n";
9569 for (uint32_t f = 0; f < 6; f++) {
9570 outs() << "\t ";
9571 for (uint32_t g = 0; g < 16; g++)
9572 outs() << format("%02" PRIx32"x", fpu.fpu_rsrv4[f * g]) << " ";
9573 outs() << "\n";
9574 }
9575 outs() << "\t fpu_reserved1 " << format("0x%08" PRIx32"x", fpu.fpu_reserved1);
9576 outs() << "\n";
9577}
9578
9579static void Print_x86_exception_state_t(MachO::x86_exception_state64_t &exc64) {
9580 outs() << "\t trapno " << format("0x%08" PRIx32"x", exc64.trapno);
9581 outs() << " err " << format("0x%08" PRIx32"x", exc64.err);
9582 outs() << " faultvaddr " << format("0x%016" PRIx64"l" "x", exc64.faultvaddr) << "\n";
9583}
9584
9585static void Print_arm_thread_state32_t(MachO::arm_thread_state32_t &cpu32) {
9586 outs() << "\t r0 " << format("0x%08" PRIx32"x", cpu32.r[0]);
9587 outs() << " r1 " << format("0x%08" PRIx32"x", cpu32.r[1]);
9588 outs() << " r2 " << format("0x%08" PRIx32"x", cpu32.r[2]);
9589 outs() << " r3 " << format("0x%08" PRIx32"x", cpu32.r[3]) << "\n";
9590 outs() << "\t r4 " << format("0x%08" PRIx32"x", cpu32.r[4]);
9591 outs() << " r5 " << format("0x%08" PRIx32"x", cpu32.r[5]);
9592 outs() << " r6 " << format("0x%08" PRIx32"x", cpu32.r[6]);
9593 outs() << " r7 " << format("0x%08" PRIx32"x", cpu32.r[7]) << "\n";
9594 outs() << "\t r8 " << format("0x%08" PRIx32"x", cpu32.r[8]);
9595 outs() << " r9 " << format("0x%08" PRIx32"x", cpu32.r[9]);
9596 outs() << " r10 " << format("0x%08" PRIx32"x", cpu32.r[10]);
9597 outs() << " r11 " << format("0x%08" PRIx32"x", cpu32.r[11]) << "\n";
9598 outs() << "\t r12 " << format("0x%08" PRIx32"x", cpu32.r[12]);
9599 outs() << " sp " << format("0x%08" PRIx32"x", cpu32.sp);
9600 outs() << " lr " << format("0x%08" PRIx32"x", cpu32.lr);
9601 outs() << " pc " << format("0x%08" PRIx32"x", cpu32.pc) << "\n";
9602 outs() << "\t cpsr " << format("0x%08" PRIx32"x", cpu32.cpsr) << "\n";
9603}
9604
9605static void Print_arm_thread_state64_t(MachO::arm_thread_state64_t &cpu64) {
9606 outs() << "\t x0 " << format("0x%016" PRIx64"l" "x", cpu64.x[0]);
9607 outs() << " x1 " << format("0x%016" PRIx64"l" "x", cpu64.x[1]);
9608 outs() << " x2 " << format("0x%016" PRIx64"l" "x", cpu64.x[2]) << "\n";
9609 outs() << "\t x3 " << format("0x%016" PRIx64"l" "x", cpu64.x[3]);
9610 outs() << " x4 " << format("0x%016" PRIx64"l" "x", cpu64.x[4]);
9611 outs() << " x5 " << format("0x%016" PRIx64"l" "x", cpu64.x[5]) << "\n";
9612 outs() << "\t x6 " << format("0x%016" PRIx64"l" "x", cpu64.x[6]);
9613 outs() << " x7 " << format("0x%016" PRIx64"l" "x", cpu64.x[7]);
9614 outs() << " x8 " << format("0x%016" PRIx64"l" "x", cpu64.x[8]) << "\n";
9615 outs() << "\t x9 " << format("0x%016" PRIx64"l" "x", cpu64.x[9]);
9616 outs() << " x10 " << format("0x%016" PRIx64"l" "x", cpu64.x[10]);
9617 outs() << " x11 " << format("0x%016" PRIx64"l" "x", cpu64.x[11]) << "\n";
9618 outs() << "\t x12 " << format("0x%016" PRIx64"l" "x", cpu64.x[12]);
9619 outs() << " x13 " << format("0x%016" PRIx64"l" "x", cpu64.x[13]);
9620 outs() << " x14 " << format("0x%016" PRIx64"l" "x", cpu64.x[14]) << "\n";
9621 outs() << "\t x15 " << format("0x%016" PRIx64"l" "x", cpu64.x[15]);
9622 outs() << " x16 " << format("0x%016" PRIx64"l" "x", cpu64.x[16]);
9623 outs() << " x17 " << format("0x%016" PRIx64"l" "x", cpu64.x[17]) << "\n";
9624 outs() << "\t x18 " << format("0x%016" PRIx64"l" "x", cpu64.x[18]);
9625 outs() << " x19 " << format("0x%016" PRIx64"l" "x", cpu64.x[19]);
9626 outs() << " x20 " << format("0x%016" PRIx64"l" "x", cpu64.x[20]) << "\n";
9627 outs() << "\t x21 " << format("0x%016" PRIx64"l" "x", cpu64.x[21]);
9628 outs() << " x22 " << format("0x%016" PRIx64"l" "x", cpu64.x[22]);
9629 outs() << " x23 " << format("0x%016" PRIx64"l" "x", cpu64.x[23]) << "\n";
9630 outs() << "\t x24 " << format("0x%016" PRIx64"l" "x", cpu64.x[24]);
9631 outs() << " x25 " << format("0x%016" PRIx64"l" "x", cpu64.x[25]);
9632 outs() << " x26 " << format("0x%016" PRIx64"l" "x", cpu64.x[26]) << "\n";
9633 outs() << "\t x27 " << format("0x%016" PRIx64"l" "x", cpu64.x[27]);
9634 outs() << " x28 " << format("0x%016" PRIx64"l" "x", cpu64.x[28]);
9635 outs() << " fp " << format("0x%016" PRIx64"l" "x", cpu64.fp) << "\n";
9636 outs() << "\t lr " << format("0x%016" PRIx64"l" "x", cpu64.lr);
9637 outs() << " sp " << format("0x%016" PRIx64"l" "x", cpu64.sp);
9638 outs() << " pc " << format("0x%016" PRIx64"l" "x", cpu64.pc) << "\n";
9639 outs() << "\t cpsr " << format("0x%08" PRIx32"x", cpu64.cpsr) << "\n";
9640}
9641
9642static void PrintThreadCommand(MachO::thread_command t, const char *Ptr,
9643 bool isLittleEndian, uint32_t cputype) {
9644 if (t.cmd == MachO::LC_THREAD)
9645 outs() << " cmd LC_THREAD\n";
9646 else if (t.cmd == MachO::LC_UNIXTHREAD)
9647 outs() << " cmd LC_UNIXTHREAD\n";
9648 else
9649 outs() << " cmd " << t.cmd << " (unknown)\n";
9650 outs() << " cmdsize " << t.cmdsize;
9651 if (t.cmdsize < sizeof(struct MachO::thread_command) + 2 * sizeof(uint32_t))
9652 outs() << " Incorrect size\n";
9653 else
9654 outs() << "\n";
9655
9656 const char *begin = Ptr + sizeof(struct MachO::thread_command);
9657 const char *end = Ptr + t.cmdsize;
9658 uint32_t flavor, count, left;
9659 if (cputype == MachO::CPU_TYPE_I386) {
9660 while (begin < end) {
9661 if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
9662 memcpy((char *)&flavor, begin, sizeof(uint32_t));
9663 begin += sizeof(uint32_t);
9664 } else {
9665 flavor = 0;
9666 begin = end;
9667 }
9668 if (isLittleEndian != sys::IsLittleEndianHost)
9669 sys::swapByteOrder(flavor);
9670 if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
9671 memcpy((char *)&count, begin, sizeof(uint32_t));
9672 begin += sizeof(uint32_t);
9673 } else {
9674 count = 0;
9675 begin = end;
9676 }
9677 if (isLittleEndian != sys::IsLittleEndianHost)
9678 sys::swapByteOrder(count);
9679 if (flavor == MachO::x86_THREAD_STATE32) {
9680 outs() << " flavor i386_THREAD_STATE\n";
9681 if (count == MachO::x86_THREAD_STATE32_COUNT)
9682 outs() << " count i386_THREAD_STATE_COUNT\n";
9683 else
9684 outs() << " count " << count
9685 << " (not x86_THREAD_STATE32_COUNT)\n";
9686 MachO::x86_thread_state32_t cpu32;
9687 left = end - begin;
9688 if (left >= sizeof(MachO::x86_thread_state32_t)) {
9689 memcpy(&cpu32, begin, sizeof(MachO::x86_thread_state32_t));
9690 begin += sizeof(MachO::x86_thread_state32_t);
9691 } else {
9692 memset(&cpu32, '\0', sizeof(MachO::x86_thread_state32_t));
9693 memcpy(&cpu32, begin, left);
9694 begin += left;
9695 }
9696 if (isLittleEndian != sys::IsLittleEndianHost)
9697 swapStruct(cpu32);
9698 Print_x86_thread_state32_t(cpu32);
9699 } else if (flavor == MachO::x86_THREAD_STATE) {
9700 outs() << " flavor x86_THREAD_STATE\n";
9701 if (count == MachO::x86_THREAD_STATE_COUNT)
9702 outs() << " count x86_THREAD_STATE_COUNT\n";
9703 else
9704 outs() << " count " << count
9705 << " (not x86_THREAD_STATE_COUNT)\n";
9706 struct MachO::x86_thread_state_t ts;
9707 left = end - begin;
9708 if (left >= sizeof(MachO::x86_thread_state_t)) {
9709 memcpy(&ts, begin, sizeof(MachO::x86_thread_state_t));
9710 begin += sizeof(MachO::x86_thread_state_t);
9711 } else {
9712 memset(&ts, '\0', sizeof(MachO::x86_thread_state_t));
9713 memcpy(&ts, begin, left);
9714 begin += left;
9715 }
9716 if (isLittleEndian != sys::IsLittleEndianHost)
9717 swapStruct(ts);
9718 if (ts.tsh.flavor == MachO::x86_THREAD_STATE32) {
9719 outs() << "\t tsh.flavor x86_THREAD_STATE32 ";
9720 if (ts.tsh.count == MachO::x86_THREAD_STATE32_COUNT)
9721 outs() << "tsh.count x86_THREAD_STATE32_COUNT\n";
9722 else
9723 outs() << "tsh.count " << ts.tsh.count
9724 << " (not x86_THREAD_STATE32_COUNT\n";
9725 Print_x86_thread_state32_t(ts.uts.ts32);
9726 } else {
9727 outs() << "\t tsh.flavor " << ts.tsh.flavor << " tsh.count "
9728 << ts.tsh.count << "\n";
9729 }
9730 } else {
9731 outs() << " flavor " << flavor << " (unknown)\n";
9732 outs() << " count " << count << "\n";
9733 outs() << " state (unknown)\n";
9734 begin += count * sizeof(uint32_t);
9735 }
9736 }
9737 } else if (cputype == MachO::CPU_TYPE_X86_64) {
9738 while (begin < end) {
9739 if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
9740 memcpy((char *)&flavor, begin, sizeof(uint32_t));
9741 begin += sizeof(uint32_t);
9742 } else {
9743 flavor = 0;
9744 begin = end;
9745 }
9746 if (isLittleEndian != sys::IsLittleEndianHost)
9747 sys::swapByteOrder(flavor);
9748 if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
9749 memcpy((char *)&count, begin, sizeof(uint32_t));
9750 begin += sizeof(uint32_t);
9751 } else {
9752 count = 0;
9753 begin = end;
9754 }
9755 if (isLittleEndian != sys::IsLittleEndianHost)
9756 sys::swapByteOrder(count);
9757 if (flavor == MachO::x86_THREAD_STATE64) {
9758 outs() << " flavor x86_THREAD_STATE64\n";
9759 if (count == MachO::x86_THREAD_STATE64_COUNT)
9760 outs() << " count x86_THREAD_STATE64_COUNT\n";
9761 else
9762 outs() << " count " << count
9763 << " (not x86_THREAD_STATE64_COUNT)\n";
9764 MachO::x86_thread_state64_t cpu64;
9765 left = end - begin;
9766 if (left >= sizeof(MachO::x86_thread_state64_t)) {
9767 memcpy(&cpu64, begin, sizeof(MachO::x86_thread_state64_t));
9768 begin += sizeof(MachO::x86_thread_state64_t);
9769 } else {
9770 memset(&cpu64, '\0', sizeof(MachO::x86_thread_state64_t));
9771 memcpy(&cpu64, begin, left);
9772 begin += left;
9773 }
9774 if (isLittleEndian != sys::IsLittleEndianHost)
9775 swapStruct(cpu64);
9776 Print_x86_thread_state64_t(cpu64);
9777 } else if (flavor == MachO::x86_THREAD_STATE) {
9778 outs() << " flavor x86_THREAD_STATE\n";
9779 if (count == MachO::x86_THREAD_STATE_COUNT)
9780 outs() << " count x86_THREAD_STATE_COUNT\n";
9781 else
9782 outs() << " count " << count
9783 << " (not x86_THREAD_STATE_COUNT)\n";
9784 struct MachO::x86_thread_state_t ts;
9785 left = end - begin;
9786 if (left >= sizeof(MachO::x86_thread_state_t)) {
9787 memcpy(&ts, begin, sizeof(MachO::x86_thread_state_t));
9788 begin += sizeof(MachO::x86_thread_state_t);
9789 } else {
9790 memset(&ts, '\0', sizeof(MachO::x86_thread_state_t));
9791 memcpy(&ts, begin, left);
9792 begin += left;
9793 }
9794 if (isLittleEndian != sys::IsLittleEndianHost)
9795 swapStruct(ts);
9796 if (ts.tsh.flavor == MachO::x86_THREAD_STATE64) {
9797 outs() << "\t tsh.flavor x86_THREAD_STATE64 ";
9798 if (ts.tsh.count == MachO::x86_THREAD_STATE64_COUNT)
9799 outs() << "tsh.count x86_THREAD_STATE64_COUNT\n";
9800 else
9801 outs() << "tsh.count " << ts.tsh.count
9802 << " (not x86_THREAD_STATE64_COUNT\n";
9803 Print_x86_thread_state64_t(ts.uts.ts64);
9804 } else {
9805 outs() << "\t tsh.flavor " << ts.tsh.flavor << " tsh.count "
9806 << ts.tsh.count << "\n";
9807 }
9808 } else if (flavor == MachO::x86_FLOAT_STATE) {
9809 outs() << " flavor x86_FLOAT_STATE\n";
9810 if (count == MachO::x86_FLOAT_STATE_COUNT)
9811 outs() << " count x86_FLOAT_STATE_COUNT\n";
9812 else
9813 outs() << " count " << count << " (not x86_FLOAT_STATE_COUNT)\n";
9814 struct MachO::x86_float_state_t fs;
9815 left = end - begin;
9816 if (left >= sizeof(MachO::x86_float_state_t)) {
9817 memcpy(&fs, begin, sizeof(MachO::x86_float_state_t));
9818 begin += sizeof(MachO::x86_float_state_t);
9819 } else {
9820 memset(&fs, '\0', sizeof(MachO::x86_float_state_t));
9821 memcpy(&fs, begin, left);
9822 begin += left;
9823 }
9824 if (isLittleEndian != sys::IsLittleEndianHost)
9825 swapStruct(fs);
9826 if (fs.fsh.flavor == MachO::x86_FLOAT_STATE64) {
9827 outs() << "\t fsh.flavor x86_FLOAT_STATE64 ";
9828 if (fs.fsh.count == MachO::x86_FLOAT_STATE64_COUNT)
9829 outs() << "fsh.count x86_FLOAT_STATE64_COUNT\n";
9830 else
9831 outs() << "fsh.count " << fs.fsh.count
9832 << " (not x86_FLOAT_STATE64_COUNT\n";
9833 Print_x86_float_state_t(fs.ufs.fs64);
9834 } else {
9835 outs() << "\t fsh.flavor " << fs.fsh.flavor << " fsh.count "
9836 << fs.fsh.count << "\n";
9837 }
9838 } else if (flavor == MachO::x86_EXCEPTION_STATE) {
9839 outs() << " flavor x86_EXCEPTION_STATE\n";
9840 if (count == MachO::x86_EXCEPTION_STATE_COUNT)
9841 outs() << " count x86_EXCEPTION_STATE_COUNT\n";
9842 else
9843 outs() << " count " << count
9844 << " (not x86_EXCEPTION_STATE_COUNT)\n";
9845 struct MachO::x86_exception_state_t es;
9846 left = end - begin;
9847 if (left >= sizeof(MachO::x86_exception_state_t)) {
9848 memcpy(&es, begin, sizeof(MachO::x86_exception_state_t));
9849 begin += sizeof(MachO::x86_exception_state_t);
9850 } else {
9851 memset(&es, '\0', sizeof(MachO::x86_exception_state_t));
9852 memcpy(&es, begin, left);
9853 begin += left;
9854 }
9855 if (isLittleEndian != sys::IsLittleEndianHost)
9856 swapStruct(es);
9857 if (es.esh.flavor == MachO::x86_EXCEPTION_STATE64) {
9858 outs() << "\t esh.flavor x86_EXCEPTION_STATE64\n";
9859 if (es.esh.count == MachO::x86_EXCEPTION_STATE64_COUNT)
9860 outs() << "\t esh.count x86_EXCEPTION_STATE64_COUNT\n";
9861 else
9862 outs() << "\t esh.count " << es.esh.count
9863 << " (not x86_EXCEPTION_STATE64_COUNT\n";
9864 Print_x86_exception_state_t(es.ues.es64);
9865 } else {
9866 outs() << "\t esh.flavor " << es.esh.flavor << " esh.count "
9867 << es.esh.count << "\n";
9868 }
9869 } else if (flavor == MachO::x86_EXCEPTION_STATE64) {
9870 outs() << " flavor x86_EXCEPTION_STATE64\n";
9871 if (count == MachO::x86_EXCEPTION_STATE64_COUNT)
9872 outs() << " count x86_EXCEPTION_STATE64_COUNT\n";
9873 else
9874 outs() << " count " << count
9875 << " (not x86_EXCEPTION_STATE64_COUNT)\n";
9876 struct MachO::x86_exception_state64_t es64;
9877 left = end - begin;
9878 if (left >= sizeof(MachO::x86_exception_state64_t)) {
9879 memcpy(&es64, begin, sizeof(MachO::x86_exception_state64_t));
9880 begin += sizeof(MachO::x86_exception_state64_t);
9881 } else {
9882 memset(&es64, '\0', sizeof(MachO::x86_exception_state64_t));
9883 memcpy(&es64, begin, left);
9884 begin += left;
9885 }
9886 if (isLittleEndian != sys::IsLittleEndianHost)
9887 swapStruct(es64);
9888 Print_x86_exception_state_t(es64);
9889 } else {
9890 outs() << " flavor " << flavor << " (unknown)\n";
9891 outs() << " count " << count << "\n";
9892 outs() << " state (unknown)\n";
9893 begin += count * sizeof(uint32_t);
9894 }
9895 }
9896 } else if (cputype == MachO::CPU_TYPE_ARM) {
9897 while (begin < end) {
9898 if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
9899 memcpy((char *)&flavor, begin, sizeof(uint32_t));
9900 begin += sizeof(uint32_t);
9901 } else {
9902 flavor = 0;
9903 begin = end;
9904 }
9905 if (isLittleEndian != sys::IsLittleEndianHost)
9906 sys::swapByteOrder(flavor);
9907 if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
9908 memcpy((char *)&count, begin, sizeof(uint32_t));
9909 begin += sizeof(uint32_t);
9910 } else {
9911 count = 0;
9912 begin = end;
9913 }
9914 if (isLittleEndian != sys::IsLittleEndianHost)
9915 sys::swapByteOrder(count);
9916 if (flavor == MachO::ARM_THREAD_STATE) {
9917 outs() << " flavor ARM_THREAD_STATE\n";
9918 if (count == MachO::ARM_THREAD_STATE_COUNT)
9919 outs() << " count ARM_THREAD_STATE_COUNT\n";
9920 else
9921 outs() << " count " << count
9922 << " (not ARM_THREAD_STATE_COUNT)\n";
9923 MachO::arm_thread_state32_t cpu32;
9924 left = end - begin;
9925 if (left >= sizeof(MachO::arm_thread_state32_t)) {
9926 memcpy(&cpu32, begin, sizeof(MachO::arm_thread_state32_t));
9927 begin += sizeof(MachO::arm_thread_state32_t);
9928 } else {
9929 memset(&cpu32, '\0', sizeof(MachO::arm_thread_state32_t));
9930 memcpy(&cpu32, begin, left);
9931 begin += left;
9932 }
9933 if (isLittleEndian != sys::IsLittleEndianHost)
9934 swapStruct(cpu32);
9935 Print_arm_thread_state32_t(cpu32);
9936 } else {
9937 outs() << " flavor " << flavor << " (unknown)\n";
9938 outs() << " count " << count << "\n";
9939 outs() << " state (unknown)\n";
9940 begin += count * sizeof(uint32_t);
9941 }
9942 }
9943 } else if (cputype == MachO::CPU_TYPE_ARM64 ||
9944 cputype == MachO::CPU_TYPE_ARM64_32) {
9945 while (begin < end) {
9946 if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
9947 memcpy((char *)&flavor, begin, sizeof(uint32_t));
9948 begin += sizeof(uint32_t);
9949 } else {
9950 flavor = 0;
9951 begin = end;
9952 }
9953 if (isLittleEndian != sys::IsLittleEndianHost)
9954 sys::swapByteOrder(flavor);
9955 if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
9956 memcpy((char *)&count, begin, sizeof(uint32_t));
9957 begin += sizeof(uint32_t);
9958 } else {
9959 count = 0;
9960 begin = end;
9961 }
9962 if (isLittleEndian != sys::IsLittleEndianHost)
9963 sys::swapByteOrder(count);
9964 if (flavor == MachO::ARM_THREAD_STATE64) {
9965 outs() << " flavor ARM_THREAD_STATE64\n";
9966 if (count == MachO::ARM_THREAD_STATE64_COUNT)
9967 outs() << " count ARM_THREAD_STATE64_COUNT\n";
9968 else
9969 outs() << " count " << count
9970 << " (not ARM_THREAD_STATE64_COUNT)\n";
9971 MachO::arm_thread_state64_t cpu64;
9972 left = end - begin;
9973 if (left >= sizeof(MachO::arm_thread_state64_t)) {
9974 memcpy(&cpu64, begin, sizeof(MachO::arm_thread_state64_t));
9975 begin += sizeof(MachO::arm_thread_state64_t);
9976 } else {
9977 memset(&cpu64, '\0', sizeof(MachO::arm_thread_state64_t));
9978 memcpy(&cpu64, begin, left);
9979 begin += left;
9980 }
9981 if (isLittleEndian != sys::IsLittleEndianHost)
9982 swapStruct(cpu64);
9983 Print_arm_thread_state64_t(cpu64);
9984 } else {
9985 outs() << " flavor " << flavor << " (unknown)\n";
9986 outs() << " count " << count << "\n";
9987 outs() << " state (unknown)\n";
9988 begin += count * sizeof(uint32_t);
9989 }
9990 }
9991 } else {
9992 while (begin < end) {
9993 if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
9994 memcpy((char *)&flavor, begin, sizeof(uint32_t));
9995 begin += sizeof(uint32_t);
9996 } else {
9997 flavor = 0;
9998 begin = end;
9999 }
10000 if (isLittleEndian != sys::IsLittleEndianHost)
10001 sys::swapByteOrder(flavor);
10002 if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
10003 memcpy((char *)&count, begin, sizeof(uint32_t));
10004 begin += sizeof(uint32_t);
10005 } else {
10006 count = 0;
10007 begin = end;
10008 }
10009 if (isLittleEndian != sys::IsLittleEndianHost)
10010 sys::swapByteOrder(count);
10011 outs() << " flavor " << flavor << "\n";
10012 outs() << " count " << count << "\n";
10013 outs() << " state (Unknown cputype/cpusubtype)\n";
10014 begin += count * sizeof(uint32_t);
10015 }
10016 }
10017}
10018
10019static void PrintDylibCommand(MachO::dylib_command dl, const char *Ptr) {
10020 if (dl.cmd == MachO::LC_ID_DYLIB)
10021 outs() << " cmd LC_ID_DYLIB\n";
10022 else if (dl.cmd == MachO::LC_LOAD_DYLIB)
10023 outs() << " cmd LC_LOAD_DYLIB\n";
10024 else if (dl.cmd == MachO::LC_LOAD_WEAK_DYLIB)
10025 outs() << " cmd LC_LOAD_WEAK_DYLIB\n";
10026 else if (dl.cmd == MachO::LC_REEXPORT_DYLIB)
10027 outs() << " cmd LC_REEXPORT_DYLIB\n";
10028 else if (dl.cmd == MachO::LC_LAZY_LOAD_DYLIB)
10029 outs() << " cmd LC_LAZY_LOAD_DYLIB\n";
10030 else if (dl.cmd == MachO::LC_LOAD_UPWARD_DYLIB)
10031 outs() << " cmd LC_LOAD_UPWARD_DYLIB\n";
10032 else
10033 outs() << " cmd " << dl.cmd << " (unknown)\n";
10034 outs() << " cmdsize " << dl.cmdsize;
10035 if (dl.cmdsize < sizeof(struct MachO::dylib_command))
10036 outs() << " Incorrect size\n";
10037 else
10038 outs() << "\n";
10039 if (dl.dylib.name < dl.cmdsize) {
10040 const char *P = (const char *)(Ptr) + dl.dylib.name;
10041 outs() << " name " << P << " (offset " << dl.dylib.name << ")\n";
10042 } else {
10043 outs() << " name ?(bad offset " << dl.dylib.name << ")\n";
10044 }
10045 outs() << " time stamp " << dl.dylib.timestamp << " ";
10046 time_t t = dl.dylib.timestamp;
10047 outs() << ctime(&t);
10048 outs() << " current version ";
10049 if (dl.dylib.current_version == 0xffffffff)
10050 outs() << "n/a\n";
10051 else
10052 outs() << ((dl.dylib.current_version >> 16) & 0xffff) << "."
10053 << ((dl.dylib.current_version >> 8) & 0xff) << "."
10054 << (dl.dylib.current_version & 0xff) << "\n";
10055 outs() << "compatibility version ";
10056 if (dl.dylib.compatibility_version == 0xffffffff)
10057 outs() << "n/a\n";
10058 else
10059 outs() << ((dl.dylib.compatibility_version >> 16) & 0xffff) << "."
10060 << ((dl.dylib.compatibility_version >> 8) & 0xff) << "."
10061 << (dl.dylib.compatibility_version & 0xff) << "\n";
10062}
10063
10064static void PrintLinkEditDataCommand(MachO::linkedit_data_command ld,
10065 uint32_t object_size) {
10066 if (ld.cmd == MachO::LC_CODE_SIGNATURE)
10067 outs() << " cmd LC_CODE_SIGNATURE\n";
10068 else if (ld.cmd == MachO::LC_SEGMENT_SPLIT_INFO)
10069 outs() << " cmd LC_SEGMENT_SPLIT_INFO\n";
10070 else if (ld.cmd == MachO::LC_FUNCTION_STARTS)
10071 outs() << " cmd LC_FUNCTION_STARTS\n";
10072 else if (ld.cmd == MachO::LC_DATA_IN_CODE)
10073 outs() << " cmd LC_DATA_IN_CODE\n";
10074 else if (ld.cmd == MachO::LC_DYLIB_CODE_SIGN_DRS)
10075 outs() << " cmd LC_DYLIB_CODE_SIGN_DRS\n";
10076 else if (ld.cmd == MachO::LC_LINKER_OPTIMIZATION_HINT)
10077 outs() << " cmd LC_LINKER_OPTIMIZATION_HINT\n";
10078 else if (ld.cmd == MachO::LC_DYLD_EXPORTS_TRIE)
10079 outs() << " cmd LC_DYLD_EXPORTS_TRIE\n";
10080 else if (ld.cmd == MachO::LC_DYLD_CHAINED_FIXUPS)
10081 outs() << " cmd LC_DYLD_CHAINED_FIXUPS\n";
10082 else
10083 outs() << " cmd " << ld.cmd << " (?)\n";
10084 outs() << " cmdsize " << ld.cmdsize;
10085 if (ld.cmdsize != sizeof(struct MachO::linkedit_data_command))
10086 outs() << " Incorrect size\n";
10087 else
10088 outs() << "\n";
10089 outs() << " dataoff " << ld.dataoff;
10090 if (ld.dataoff > object_size)
10091 outs() << " (past end of file)\n";
10092 else
10093 outs() << "\n";
10094 outs() << " datasize " << ld.datasize;
10095 uint64_t big_size = ld.dataoff;
10096 big_size += ld.datasize;
10097 if (big_size > object_size)
10098 outs() << " (past end of file)\n";
10099 else
10100 outs() << "\n";
10101}
10102
10103static void PrintLoadCommands(const MachOObjectFile *Obj, uint32_t filetype,
10104 uint32_t cputype, bool verbose) {
10105 StringRef Buf = Obj->getData();
10106 unsigned Index = 0;
10107 for (const auto &Command : Obj->load_commands()) {
10108 outs() << "Load command " << Index++ << "\n";
10109 if (Command.C.cmd == MachO::LC_SEGMENT) {
10110 MachO::segment_command SLC = Obj->getSegmentLoadCommand(Command);
10111 const char *sg_segname = SLC.segname;
10112 PrintSegmentCommand(SLC.cmd, SLC.cmdsize, SLC.segname, SLC.vmaddr,
10113 SLC.vmsize, SLC.fileoff, SLC.filesize, SLC.maxprot,
10114 SLC.initprot, SLC.nsects, SLC.flags, Buf.size(),
10115 verbose);
10116 for (unsigned j = 0; j < SLC.nsects; j++) {
10117 MachO::section S = Obj->getSection(Command, j);
10118 PrintSection(S.sectname, S.segname, S.addr, S.size, S.offset, S.align,
10119 S.reloff, S.nreloc, S.flags, S.reserved1, S.reserved2,
10120 SLC.cmd, sg_segname, filetype, Buf.size(), verbose);
10121 }
10122 } else if (Command.C.cmd == MachO::LC_SEGMENT_64) {
10123 MachO::segment_command_64 SLC_64 = Obj->getSegment64LoadCommand(Command);
10124 const char *sg_segname = SLC_64.segname;
10125 PrintSegmentCommand(SLC_64.cmd, SLC_64.cmdsize, SLC_64.segname,
10126 SLC_64.vmaddr, SLC_64.vmsize, SLC_64.fileoff,
10127 SLC_64.filesize, SLC_64.maxprot, SLC_64.initprot,
10128 SLC_64.nsects, SLC_64.flags, Buf.size(), verbose);
10129 for (unsigned j = 0; j < SLC_64.nsects; j++) {
10130 MachO::section_64 S_64 = Obj->getSection64(Command, j);
10131 PrintSection(S_64.sectname, S_64.segname, S_64.addr, S_64.size,
10132 S_64.offset, S_64.align, S_64.reloff, S_64.nreloc,
10133 S_64.flags, S_64.reserved1, S_64.reserved2, SLC_64.cmd,
10134 sg_segname, filetype, Buf.size(), verbose);
10135 }
10136 } else if (Command.C.cmd == MachO::LC_SYMTAB) {
10137 MachO::symtab_command Symtab = Obj->getSymtabLoadCommand();
10138 PrintSymtabLoadCommand(Symtab, Obj->is64Bit(), Buf.size());
10139 } else if (Command.C.cmd == MachO::LC_DYSYMTAB) {
10140 MachO::dysymtab_command Dysymtab = Obj->getDysymtabLoadCommand();
10141 MachO::symtab_command Symtab = Obj->getSymtabLoadCommand();
10142 PrintDysymtabLoadCommand(Dysymtab, Symtab.nsyms, Buf.size(),
10143 Obj->is64Bit());
10144 } else if (Command.C.cmd == MachO::LC_DYLD_INFO ||
10145 Command.C.cmd == MachO::LC_DYLD_INFO_ONLY) {
10146 MachO::dyld_info_command DyldInfo = Obj->getDyldInfoLoadCommand(Command);
10147 PrintDyldInfoLoadCommand(DyldInfo, Buf.size());
10148 } else if (Command.C.cmd == MachO::LC_LOAD_DYLINKER ||
10149 Command.C.cmd == MachO::LC_ID_DYLINKER ||
10150 Command.C.cmd == MachO::LC_DYLD_ENVIRONMENT) {
10151 MachO::dylinker_command Dyld = Obj->getDylinkerCommand(Command);
10152 PrintDyldLoadCommand(Dyld, Command.Ptr);
10153 } else if (Command.C.cmd == MachO::LC_UUID) {
10154 MachO::uuid_command Uuid = Obj->getUuidCommand(Command);
10155 PrintUuidLoadCommand(Uuid);
10156 } else if (Command.C.cmd == MachO::LC_RPATH) {
10157 MachO::rpath_command Rpath = Obj->getRpathCommand(Command);
10158 PrintRpathLoadCommand(Rpath, Command.Ptr);
10159 } else if (Command.C.cmd == MachO::LC_VERSION_MIN_MACOSX ||
10160 Command.C.cmd == MachO::LC_VERSION_MIN_IPHONEOS ||
10161 Command.C.cmd == MachO::LC_VERSION_MIN_TVOS ||
10162 Command.C.cmd == MachO::LC_VERSION_MIN_WATCHOS) {
10163 MachO::version_min_command Vd = Obj->getVersionMinLoadCommand(Command);
10164 PrintVersionMinLoadCommand(Vd);
10165 } else if (Command.C.cmd == MachO::LC_NOTE) {
10166 MachO::note_command Nt = Obj->getNoteLoadCommand(Command);
10167 PrintNoteLoadCommand(Nt);
10168 } else if (Command.C.cmd == MachO::LC_BUILD_VERSION) {
10169 MachO::build_version_command Bv =
10170 Obj->getBuildVersionLoadCommand(Command);
10171 PrintBuildVersionLoadCommand(Obj, Bv);
10172 } else if (Command.C.cmd == MachO::LC_SOURCE_VERSION) {
10173 MachO::source_version_command Sd = Obj->getSourceVersionCommand(Command);
10174 PrintSourceVersionCommand(Sd);
10175 } else if (Command.C.cmd == MachO::LC_MAIN) {
10176 MachO::entry_point_command Ep = Obj->getEntryPointCommand(Command);
10177 PrintEntryPointCommand(Ep);
10178 } else if (Command.C.cmd == MachO::LC_ENCRYPTION_INFO) {
10179 MachO::encryption_info_command Ei =
10180 Obj->getEncryptionInfoCommand(Command);
10181 PrintEncryptionInfoCommand(Ei, Buf.size());
10182 } else if (Command.C.cmd == MachO::LC_ENCRYPTION_INFO_64) {
10183 MachO::encryption_info_command_64 Ei =
10184 Obj->getEncryptionInfoCommand64(Command);
10185 PrintEncryptionInfoCommand64(Ei, Buf.size());
10186 } else if (Command.C.cmd == MachO::LC_LINKER_OPTION) {
10187 MachO::linker_option_command Lo =
10188 Obj->getLinkerOptionLoadCommand(Command);
10189 PrintLinkerOptionCommand(Lo, Command.Ptr);
10190 } else if (Command.C.cmd == MachO::LC_SUB_FRAMEWORK) {
10191 MachO::sub_framework_command Sf = Obj->getSubFrameworkCommand(Command);
10192 PrintSubFrameworkCommand(Sf, Command.Ptr);
10193 } else if (Command.C.cmd == MachO::LC_SUB_UMBRELLA) {
10194 MachO::sub_umbrella_command Sf = Obj->getSubUmbrellaCommand(Command);
10195 PrintSubUmbrellaCommand(Sf, Command.Ptr);
10196 } else if (Command.C.cmd == MachO::LC_SUB_LIBRARY) {
10197 MachO::sub_library_command Sl = Obj->getSubLibraryCommand(Command);
10198 PrintSubLibraryCommand(Sl, Command.Ptr);
10199 } else if (Command.C.cmd == MachO::LC_SUB_CLIENT) {
10200 MachO::sub_client_command Sc = Obj->getSubClientCommand(Command);
10201 PrintSubClientCommand(Sc, Command.Ptr);
10202 } else if (Command.C.cmd == MachO::LC_ROUTINES) {
10203 MachO::routines_command Rc = Obj->getRoutinesCommand(Command);
10204 PrintRoutinesCommand(Rc);
10205 } else if (Command.C.cmd == MachO::LC_ROUTINES_64) {
10206 MachO::routines_command_64 Rc = Obj->getRoutinesCommand64(Command);
10207 PrintRoutinesCommand64(Rc);
10208 } else if (Command.C.cmd == MachO::LC_THREAD ||
10209 Command.C.cmd == MachO::LC_UNIXTHREAD) {
10210 MachO::thread_command Tc = Obj->getThreadCommand(Command);
10211 PrintThreadCommand(Tc, Command.Ptr, Obj->isLittleEndian(), cputype);
10212 } else if (Command.C.cmd == MachO::LC_LOAD_DYLIB ||
10213 Command.C.cmd == MachO::LC_ID_DYLIB ||
10214 Command.C.cmd == MachO::LC_LOAD_WEAK_DYLIB ||
10215 Command.C.cmd == MachO::LC_REEXPORT_DYLIB ||
10216 Command.C.cmd == MachO::LC_LAZY_LOAD_DYLIB ||
10217 Command.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) {
10218 MachO::dylib_command Dl = Obj->getDylibIDLoadCommand(Command);
10219 PrintDylibCommand(Dl, Command.Ptr);
10220 } else if (Command.C.cmd == MachO::LC_CODE_SIGNATURE ||
10221 Command.C.cmd == MachO::LC_SEGMENT_SPLIT_INFO ||
10222 Command.C.cmd == MachO::LC_FUNCTION_STARTS ||
10223 Command.C.cmd == MachO::LC_DATA_IN_CODE ||
10224 Command.C.cmd == MachO::LC_DYLIB_CODE_SIGN_DRS ||
10225 Command.C.cmd == MachO::LC_LINKER_OPTIMIZATION_HINT ||
10226 Command.C.cmd == MachO::LC_DYLD_EXPORTS_TRIE ||
10227 Command.C.cmd == MachO::LC_DYLD_CHAINED_FIXUPS) {
10228 MachO::linkedit_data_command Ld =
10229 Obj->getLinkeditDataLoadCommand(Command);
10230 PrintLinkEditDataCommand(Ld, Buf.size());
10231 } else {
10232 outs() << " cmd ?(" << format("0x%08" PRIx32"x", Command.C.cmd)
10233 << ")\n";
10234 outs() << " cmdsize " << Command.C.cmdsize << "\n";
10235 // TODO: get and print the raw bytes of the load command.
10236 }
10237 // TODO: print all the other kinds of load commands.
10238 }
10239}
10240
10241static void PrintMachHeader(const MachOObjectFile *Obj, bool verbose) {
10242 if (Obj->is64Bit()) {
10243 MachO::mach_header_64 H_64;
10244 H_64 = Obj->getHeader64();
10245 PrintMachHeader(H_64.magic, H_64.cputype, H_64.cpusubtype, H_64.filetype,
10246 H_64.ncmds, H_64.sizeofcmds, H_64.flags, verbose);
10247 } else {
10248 MachO::mach_header H;
10249 H = Obj->getHeader();
10250 PrintMachHeader(H.magic, H.cputype, H.cpusubtype, H.filetype, H.ncmds,
10251 H.sizeofcmds, H.flags, verbose);
10252 }
10253}
10254
10255void objdump::printMachOFileHeader(const object::ObjectFile *Obj) {
10256 const MachOObjectFile *file = cast<const MachOObjectFile>(Obj);
10257 PrintMachHeader(file, Verbose);
10258}
10259
10260void objdump::printMachOLoadCommands(const object::ObjectFile *Obj) {
10261 const MachOObjectFile *file = cast<const MachOObjectFile>(Obj);
10262 uint32_t filetype = 0;
10263 uint32_t cputype = 0;
10264 if (file->is64Bit()) {
10265 MachO::mach_header_64 H_64;
10266 H_64 = file->getHeader64();
10267 filetype = H_64.filetype;
10268 cputype = H_64.cputype;
10269 } else {
10270 MachO::mach_header H;
10271 H = file->getHeader();
10272 filetype = H.filetype;
10273 cputype = H.cputype;
10274 }
10275 PrintLoadCommands(file, filetype, cputype, Verbose);
10276}
10277
10278//===----------------------------------------------------------------------===//
10279// export trie dumping
10280//===----------------------------------------------------------------------===//
10281
10282static void printMachOExportsTrie(const object::MachOObjectFile *Obj) {
10283 uint64_t BaseSegmentAddress = 0;
10284 for (const auto &Command : Obj->load_commands()) {
10285 if (Command.C.cmd == MachO::LC_SEGMENT) {
10286 MachO::segment_command Seg = Obj->getSegmentLoadCommand(Command);
10287 if (Seg.fileoff == 0 && Seg.filesize != 0) {
10288 BaseSegmentAddress = Seg.vmaddr;
10289 break;
10290 }
10291 } else if (Command.C.cmd == MachO::LC_SEGMENT_64) {
10292 MachO::segment_command_64 Seg = Obj->getSegment64LoadCommand(Command);
10293 if (Seg.fileoff == 0 && Seg.filesize != 0) {
10294 BaseSegmentAddress = Seg.vmaddr;
10295 break;
10296 }
10297 }
10298 }
10299 Error Err = Error::success();
10300 for (const object::ExportEntry &Entry : Obj->exports(Err)) {
10301 uint64_t Flags = Entry.flags();
10302 bool ReExport = (Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT);
10303 bool WeakDef = (Flags & MachO::EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION);
10304 bool ThreadLocal = ((Flags & MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK) ==
10305 MachO::EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL);
10306 bool Abs = ((Flags & MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK) ==
10307 MachO::EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE);
10308 bool Resolver = (Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER);
10309 if (ReExport)
10310 outs() << "[re-export] ";
10311 else
10312 outs() << format("0x%08llX ",
10313 Entry.address() + BaseSegmentAddress);
10314 outs() << Entry.name();
10315 if (WeakDef || ThreadLocal || Resolver || Abs) {
10316 ListSeparator LS;
10317 outs() << " [";
10318 if (WeakDef)
10319 outs() << LS << "weak_def";
10320 if (ThreadLocal)
10321 outs() << LS << "per-thread";
10322 if (Abs)
10323 outs() << LS << "absolute";
10324 if (Resolver)
10325 outs() << LS << format("resolver=0x%08llX", Entry.other());
10326 outs() << "]";
10327 }
10328 if (ReExport) {
10329 StringRef DylibName = "unknown";
10330 int Ordinal = Entry.other() - 1;
10331 Obj->getLibraryShortNameByIndex(Ordinal, DylibName);
10332 if (Entry.otherName().empty())
10333 outs() << " (from " << DylibName << ")";
10334 else
10335 outs() << " (" << Entry.otherName() << " from " << DylibName << ")";
10336 }
10337 outs() << "\n";
10338 }
10339 if (Err)
10340 reportError(std::move(Err), Obj->getFileName());
10341}
10342
10343//===----------------------------------------------------------------------===//
10344// rebase table dumping
10345//===----------------------------------------------------------------------===//
10346
10347static void printMachORebaseTable(object::MachOObjectFile *Obj) {
10348 outs() << "segment section address type\n";
10349 Error Err = Error::success();
10350 for (const object::MachORebaseEntry &Entry : Obj->rebaseTable(Err)) {
10351 StringRef SegmentName = Entry.segmentName();
10352 StringRef SectionName = Entry.sectionName();
10353 uint64_t Address = Entry.address();
10354
10355 // Table lines look like: __DATA __nl_symbol_ptr 0x0000F00C pointer
10356 outs() << format("%-8s %-18s 0x%08" PRIX64"l" "X" " %s\n",
10357 SegmentName.str().c_str(), SectionName.str().c_str(),
10358 Address, Entry.typeName().str().c_str());
10359 }
10360 if (Err)
10361 reportError(std::move(Err), Obj->getFileName());
10362}
10363
10364static StringRef ordinalName(const object::MachOObjectFile *Obj, int Ordinal) {
10365 StringRef DylibName;
10366 switch (Ordinal) {
10367 case MachO::BIND_SPECIAL_DYLIB_SELF:
10368 return "this-image";
10369 case MachO::BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE:
10370 return "main-executable";
10371 case MachO::BIND_SPECIAL_DYLIB_FLAT_LOOKUP:
10372 return "flat-namespace";
10373 default:
10374 if (Ordinal > 0) {
10375 std::error_code EC =
10376 Obj->getLibraryShortNameByIndex(Ordinal - 1, DylibName);
10377 if (EC)
10378 return "<<bad library ordinal>>";
10379 return DylibName;
10380 }
10381 }
10382 return "<<unknown special ordinal>>";
10383}
10384
10385//===----------------------------------------------------------------------===//
10386// bind table dumping
10387//===----------------------------------------------------------------------===//
10388
10389static void printMachOBindTable(object::MachOObjectFile *Obj) {
10390 // Build table of sections so names can used in final output.
10391 outs() << "segment section address type "
10392 "addend dylib symbol\n";
10393 Error Err = Error::success();
10394 for (const object::MachOBindEntry &Entry : Obj->bindTable(Err)) {
10395 StringRef SegmentName = Entry.segmentName();
10396 StringRef SectionName = Entry.sectionName();
10397 uint64_t Address = Entry.address();
10398
10399 // Table lines look like:
10400 // __DATA __got 0x00012010 pointer 0 libSystem ___stack_chk_guard
10401 StringRef Attr;
10402 if (Entry.flags() & MachO::BIND_SYMBOL_FLAGS_WEAK_IMPORT)
10403 Attr = " (weak_import)";
10404 outs() << left_justify(SegmentName, 8) << " "
10405 << left_justify(SectionName, 18) << " "
10406 << format_hex(Address, 10, true) << " "
10407 << left_justify(Entry.typeName(), 8) << " "
10408 << format_decimal(Entry.addend(), 8) << " "
10409 << left_justify(ordinalName(Obj, Entry.ordinal()), 16) << " "
10410 << Entry.symbolName() << Attr << "\n";
10411 }
10412 if (Err)
10413 reportError(std::move(Err), Obj->getFileName());
10414}
10415
10416//===----------------------------------------------------------------------===//
10417// lazy bind table dumping
10418//===----------------------------------------------------------------------===//
10419
10420static void printMachOLazyBindTable(object::MachOObjectFile *Obj) {
10421 outs() << "segment section address "
10422 "dylib symbol\n";
10423 Error Err = Error::success();
10424 for (const object::MachOBindEntry &Entry : Obj->lazyBindTable(Err)) {
10425 StringRef SegmentName = Entry.segmentName();
10426 StringRef SectionName = Entry.sectionName();
10427 uint64_t Address = Entry.address();
10428
10429 // Table lines look like:
10430 // __DATA __got 0x00012010 libSystem ___stack_chk_guard
10431 outs() << left_justify(SegmentName, 8) << " "
10432 << left_justify(SectionName, 18) << " "
10433 << format_hex(Address, 10, true) << " "
10434 << left_justify(ordinalName(Obj, Entry.ordinal()), 16) << " "
10435 << Entry.symbolName() << "\n";
10436 }
10437 if (Err)
10438 reportError(std::move(Err), Obj->getFileName());
10439}
10440
10441//===----------------------------------------------------------------------===//
10442// weak bind table dumping
10443//===----------------------------------------------------------------------===//
10444
10445static void printMachOWeakBindTable(object::MachOObjectFile *Obj) {
10446 outs() << "segment section address "
10447 "type addend symbol\n";
10448 Error Err = Error::success();
10449 for (const object::MachOBindEntry &Entry : Obj->weakBindTable(Err)) {
10450 // Strong symbols don't have a location to update.
10451 if (Entry.flags() & MachO::BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION) {
10452 outs() << " strong "
10453 << Entry.symbolName() << "\n";
10454 continue;
10455 }
10456 StringRef SegmentName = Entry.segmentName();
10457 StringRef SectionName = Entry.sectionName();
10458 uint64_t Address = Entry.address();
10459
10460 // Table lines look like:
10461 // __DATA __data 0x00001000 pointer 0 _foo
10462 outs() << left_justify(SegmentName, 8) << " "
10463 << left_justify(SectionName, 18) << " "
10464 << format_hex(Address, 10, true) << " "
10465 << left_justify(Entry.typeName(), 8) << " "
10466 << format_decimal(Entry.addend(), 8) << " " << Entry.symbolName()
10467 << "\n";
10468 }
10469 if (Err)
10470 reportError(std::move(Err), Obj->getFileName());
10471}
10472
10473// get_dyld_bind_info_symbolname() is used for disassembly and passed an
10474// address, ReferenceValue, in the Mach-O file and looks in the dyld bind
10475// information for that address. If the address is found its binding symbol
10476// name is returned. If not nullptr is returned.
10477static const char *get_dyld_bind_info_symbolname(uint64_t ReferenceValue,
10478 struct DisassembleInfo *info) {
10479 if (info->bindtable == nullptr) {
10480 info->bindtable = std::make_unique<SymbolAddressMap>();
10481 Error Err = Error::success();
10482 for (const object::MachOBindEntry &Entry : info->O->bindTable(Err)) {
10483 uint64_t Address = Entry.address();
10484 StringRef name = Entry.symbolName();
10485 if (!name.empty())
10486 (*info->bindtable)[Address] = name;
10487 }
10488 if (Err)
10489 reportError(std::move(Err), info->O->getFileName());
10490 }
10491 auto name = info->bindtable->lookup(ReferenceValue);
10492 return !name.empty() ? name.data() : nullptr;
10493}
10494
10495void objdump::printLazyBindTable(ObjectFile *o) {
10496 outs() << "\nLazy bind table:\n";
10497 if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
10498 printMachOLazyBindTable(MachO);
10499 else
10500 WithColor::error()
10501 << "This operation is only currently supported "
10502 "for Mach-O executable files.\n";
10503}
10504
10505void objdump::printWeakBindTable(ObjectFile *o) {
10506 outs() << "\nWeak bind table:\n";
10507 if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
10508 printMachOWeakBindTable(MachO);
10509 else
10510 WithColor::error()
10511 << "This operation is only currently supported "
10512 "for Mach-O executable files.\n";
10513}
10514
10515void objdump::printExportsTrie(const ObjectFile *o) {
10516 outs() << "\nExports trie:\n";
10517 if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
10518 printMachOExportsTrie(MachO);
10519 else
10520 WithColor::error()
10521 << "This operation is only currently supported "
10522 "for Mach-O executable files.\n";
10523}
10524
10525void objdump::printRebaseTable(ObjectFile *o) {
10526 outs() << "\nRebase table:\n";
10527 if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
10528 printMachORebaseTable(MachO);
10529 else
10530 WithColor::error()
10531 << "This operation is only currently supported "
10532 "for Mach-O executable files.\n";
10533}
10534
10535void objdump::printBindTable(ObjectFile *o) {
10536 outs() << "\nBind table:\n";
10537 if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o))
10538 printMachOBindTable(MachO);
10539 else
10540 WithColor::error()
10541 << "This operation is only currently supported "
10542 "for Mach-O executable files.\n";
10543}