1//===- MachODumper.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-readobj.
10//
11//===----------------------------------------------------------------------===//
12
13#include "ObjDumper.h"
14#include "StackMapPrinter.h"
15#include "llvm-readobj.h"
16#include "llvm/ADT/SmallString.h"
17#include "llvm/ADT/StringExtras.h"
18#include "llvm/Object/MachO.h"
19#include "llvm/Support/BinaryStreamReader.h"
20#include "llvm/Support/ScopedPrinter.h"
21
22using namespace llvm;
23using namespace object;
24
25namespace {
26
27class MachODumper : public ObjDumper {
28public:
29 MachODumper(const MachOObjectFile *Obj, ScopedPrinter &Writer)
30 : ObjDumper(Writer, Obj->getFileName()), Obj(Obj) {}
31
32 void printFileHeaders() override;
33 void printSectionHeaders() override;
34 void printRelocations() override;
35 void printUnwindInfo() override;
36 void printStackMap() const override;
37 void printCGProfile() override;
38
39 void printNeededLibraries() override;
40
41 bool canCompareSymbols() const override { return true; }
42 bool compareSymbolsByName(object::SymbolRef LHS,
43 object::SymbolRef RHS) const override;
44 bool compareSymbolsByType(object::SymbolRef LHS,
45 object::SymbolRef RHS) const override;
46 // MachO-specific.
47 void printMachODataInCode() override;
48 void printMachOVersionMin() override;
49 void printMachOTargetTriple() override;
50 void printMachODysymtab() override;
51 void printMachOSegment() override;
52 void printMachOIndirectSymbols() override;
53 void printMachOLinkerOptions () override;
54
55private:
56 template<class MachHeader>
57 void printFileHeaders(const MachHeader &Header);
58
59 StringRef getSymbolName(const SymbolRef &Symbol) const;
60 uint8_t getSymbolType(const SymbolRef &Symbol) const;
61
62 void printSymbols(bool ExtraSymInfo) override;
63 void printSymbols(std::optional<SymbolComparator> SymComp) override;
64 void printDynamicSymbols() override;
65 void printDynamicSymbols(std::optional<SymbolComparator> SymComp) override;
66 void printSymbol(const SymbolRef &Symbol, ScopedPrinter &W);
67 void printSymbol(const SymbolRef &Symbol);
68
69 void printRelocation(const RelocationRef &Reloc);
70
71 void printRelocation(const MachOObjectFile *Obj, const RelocationRef &Reloc);
72
73 void printSectionHeaders(const MachOObjectFile *Obj);
74
75 const MachOObjectFile *Obj;
76};
77
78} // namespace
79
80
81namespace llvm {
82
83std::unique_ptr<ObjDumper> createMachODumper(const object::MachOObjectFile &Obj,
84 ScopedPrinter &Writer) {
85 return std::make_unique<MachODumper>(args: &Obj, args&: Writer);
86}
87
88} // namespace llvm
89
90constexpr EnumStringDef<uint32_t> MachOMagicsDefs[] = {
91 {.Names: {"Magic"}, .Value: MachO::MH_MAGIC}, {.Names: {"Cigam"}, .Value: MachO::MH_CIGAM},
92 {.Names: {"Magic64"}, .Value: MachO::MH_MAGIC_64}, {.Names: {"Cigam64"}, .Value: MachO::MH_CIGAM_64},
93 {.Names: {"FatMagic"}, .Value: MachO::FAT_MAGIC}, {.Names: {"FatCigam"}, .Value: MachO::FAT_CIGAM},
94};
95constexpr auto MachOMagics = BUILD_ENUM_STRINGS(MachOMagicsDefs);
96
97constexpr EnumStringDef<uint32_t> MachOHeaderFileTypesDefs[] = {
98 {.Names: {"Relocatable"}, .Value: MachO::MH_OBJECT},
99 {.Names: {"Executable"}, .Value: MachO::MH_EXECUTE},
100 {.Names: {"FixedVMLibrary"}, .Value: MachO::MH_FVMLIB},
101 {.Names: {"Core"}, .Value: MachO::MH_CORE},
102 {.Names: {"PreloadedExecutable"}, .Value: MachO::MH_PRELOAD},
103 {.Names: {"DynamicLibrary"}, .Value: MachO::MH_DYLIB},
104 {.Names: {"DynamicLinker"}, .Value: MachO::MH_DYLINKER},
105 {.Names: {"Bundle"}, .Value: MachO::MH_BUNDLE},
106 {.Names: {"DynamicLibraryStub"}, .Value: MachO::MH_DYLIB_STUB},
107 {.Names: {"DWARFSymbol"}, .Value: MachO::MH_DSYM},
108 {.Names: {"KextBundle"}, .Value: MachO::MH_KEXT_BUNDLE},
109};
110constexpr auto MachOHeaderFileTypes =
111 BUILD_ENUM_STRINGS(MachOHeaderFileTypesDefs);
112
113// clang-format off
114constexpr EnumStringDef<uint32_t> MachOHeaderCpuTypesDefs[] = {
115 { .Names: {"Any"} , .Value: static_cast<uint32_t>(MachO::CPU_TYPE_ANY) },
116 { .Names: {"X86"} , .Value: MachO::CPU_TYPE_X86 },
117 { .Names: {"X86-64"} , .Value: MachO::CPU_TYPE_X86_64 },
118 { .Names: {"Mc98000"} , .Value: MachO::CPU_TYPE_MC98000 },
119 { .Names: {"Arm"} , .Value: MachO::CPU_TYPE_ARM },
120 { .Names: {"Arm64"} , .Value: MachO::CPU_TYPE_ARM64 },
121 { .Names: {"Arm64 (ILP32)"}, .Value: MachO::CPU_TYPE_ARM64_32 },
122 { .Names: {"Sparc"} , .Value: MachO::CPU_TYPE_SPARC },
123 { .Names: {"PowerPC"} , .Value: MachO::CPU_TYPE_POWERPC },
124 { .Names: {"PowerPC64"} , .Value: MachO::CPU_TYPE_POWERPC64 },
125};
126constexpr auto MachOHeaderCpuTypes = BUILD_ENUM_STRINGS(MachOHeaderCpuTypesDefs);
127// clang-format on
128
129constexpr EnumStringDef<uint32_t> MachOHeaderCpuSubtypesX86Defs[] = {
130 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_I386_ALL),
131 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_386),
132 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_486),
133 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_486SX),
134 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_586),
135 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTPRO),
136 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTII_M3),
137 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTII_M5),
138 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_CELERON),
139 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_CELERON_MOBILE),
140 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_3),
141 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_3_M),
142 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_3_XEON),
143 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_M),
144 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_4),
145 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_4_M),
146 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ITANIUM),
147 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ITANIUM_2),
148 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_XEON),
149 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_XEON_MP),
150};
151constexpr auto MachOHeaderCpuSubtypesX86 =
152 BUILD_ENUM_STRINGS(MachOHeaderCpuSubtypesX86Defs);
153
154constexpr EnumStringDef<uint32_t> MachOHeaderCpuSubtypesX64Defs[] = {
155 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_X86_64_ALL),
156 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_X86_ARCH1),
157 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_X86_64_H),
158};
159constexpr auto MachOHeaderCpuSubtypesX64 =
160 BUILD_ENUM_STRINGS(MachOHeaderCpuSubtypesX64Defs);
161
162constexpr EnumStringDef<uint32_t> MachOHeaderCpuSubtypesARMDefs[] = {
163 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_ALL),
164 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V4T),
165 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V6),
166 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V5),
167 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V5TEJ),
168 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_XSCALE),
169 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7),
170 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7S),
171 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7K),
172 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V6M),
173 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7M),
174 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7EM),
175 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V8M_MAIN),
176 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V8M_BASE),
177 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V8_1M_MAIN),
178};
179constexpr auto MachOHeaderCpuSubtypesARM =
180 BUILD_ENUM_STRINGS(MachOHeaderCpuSubtypesARMDefs);
181
182constexpr EnumStringDef<uint32_t> MachOHeaderCpuSubtypesARM64_32Defs[] = {
183 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM64_32_V8),
184};
185constexpr auto MachOHeaderCpuSubtypesARM64_32 =
186 BUILD_ENUM_STRINGS(MachOHeaderCpuSubtypesARM64_32Defs);
187
188constexpr EnumStringDef<uint32_t> MachOHeaderCpuSubtypesARM64Defs[] = {
189 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM64_ALL),
190 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM64_V8),
191 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM64E),
192 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM64E_X1),
193};
194constexpr auto MachOHeaderCpuSubtypesARM64 =
195 BUILD_ENUM_STRINGS(MachOHeaderCpuSubtypesARM64Defs);
196
197constexpr EnumStringDef<uint32_t> MachOHeaderCpuSubtypesSPARCDefs[] = {
198 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_SPARC_ALL),
199};
200constexpr auto MachOHeaderCpuSubtypesSPARC =
201 BUILD_ENUM_STRINGS(MachOHeaderCpuSubtypesSPARCDefs);
202
203constexpr EnumStringDef<uint32_t> MachOHeaderCpuSubtypesPPCDefs[] = {
204 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_ALL),
205 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_601),
206 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_602),
207 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_603),
208 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_603e),
209 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_603ev),
210 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_604),
211 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_604e),
212 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_620),
213 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_750),
214 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_7400),
215 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_7450),
216 LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_970),
217};
218constexpr auto MachOHeaderCpuSubtypesPPC =
219 BUILD_ENUM_STRINGS(MachOHeaderCpuSubtypesPPCDefs);
220
221constexpr EnumStringDef<uint32_t> MachOHeaderFlagsDefs[] = {
222 LLVM_READOBJ_ENUM_ENT(MachO, MH_NOUNDEFS),
223 LLVM_READOBJ_ENUM_ENT(MachO, MH_INCRLINK),
224 LLVM_READOBJ_ENUM_ENT(MachO, MH_DYLDLINK),
225 LLVM_READOBJ_ENUM_ENT(MachO, MH_BINDATLOAD),
226 LLVM_READOBJ_ENUM_ENT(MachO, MH_PREBOUND),
227 LLVM_READOBJ_ENUM_ENT(MachO, MH_SPLIT_SEGS),
228 LLVM_READOBJ_ENUM_ENT(MachO, MH_LAZY_INIT),
229 LLVM_READOBJ_ENUM_ENT(MachO, MH_TWOLEVEL),
230 LLVM_READOBJ_ENUM_ENT(MachO, MH_FORCE_FLAT),
231 LLVM_READOBJ_ENUM_ENT(MachO, MH_NOMULTIDEFS),
232 LLVM_READOBJ_ENUM_ENT(MachO, MH_NOFIXPREBINDING),
233 LLVM_READOBJ_ENUM_ENT(MachO, MH_PREBINDABLE),
234 LLVM_READOBJ_ENUM_ENT(MachO, MH_ALLMODSBOUND),
235 LLVM_READOBJ_ENUM_ENT(MachO, MH_SUBSECTIONS_VIA_SYMBOLS),
236 LLVM_READOBJ_ENUM_ENT(MachO, MH_CANONICAL),
237 LLVM_READOBJ_ENUM_ENT(MachO, MH_WEAK_DEFINES),
238 LLVM_READOBJ_ENUM_ENT(MachO, MH_BINDS_TO_WEAK),
239 LLVM_READOBJ_ENUM_ENT(MachO, MH_ALLOW_STACK_EXECUTION),
240 LLVM_READOBJ_ENUM_ENT(MachO, MH_ROOT_SAFE),
241 LLVM_READOBJ_ENUM_ENT(MachO, MH_SETUID_SAFE),
242 LLVM_READOBJ_ENUM_ENT(MachO, MH_NO_REEXPORTED_DYLIBS),
243 LLVM_READOBJ_ENUM_ENT(MachO, MH_PIE),
244 LLVM_READOBJ_ENUM_ENT(MachO, MH_DEAD_STRIPPABLE_DYLIB),
245 LLVM_READOBJ_ENUM_ENT(MachO, MH_HAS_TLV_DESCRIPTORS),
246 LLVM_READOBJ_ENUM_ENT(MachO, MH_NO_HEAP_EXECUTION),
247 LLVM_READOBJ_ENUM_ENT(MachO, MH_APP_EXTENSION_SAFE),
248};
249constexpr auto MachOHeaderFlags = BUILD_ENUM_STRINGS(MachOHeaderFlagsDefs);
250
251constexpr EnumStringDef<unsigned> MachOSectionTypesDefs[] = {
252 {.Names: {"Regular"}, .Value: MachO::S_REGULAR},
253 {.Names: {"ZeroFill"}, .Value: MachO::S_ZEROFILL},
254 {.Names: {"CStringLiterals"}, .Value: MachO::S_CSTRING_LITERALS},
255 {.Names: {"4ByteLiterals"}, .Value: MachO::S_4BYTE_LITERALS},
256 {.Names: {"8ByteLiterals"}, .Value: MachO::S_8BYTE_LITERALS},
257 {.Names: {"LiteralPointers"}, .Value: MachO::S_LITERAL_POINTERS},
258 {.Names: {"NonLazySymbolPointers"}, .Value: MachO::S_NON_LAZY_SYMBOL_POINTERS},
259 {.Names: {"LazySymbolPointers"}, .Value: MachO::S_LAZY_SYMBOL_POINTERS},
260 {.Names: {"SymbolStubs"}, .Value: MachO::S_SYMBOL_STUBS},
261 {.Names: {"ModInitFuncPointers"}, .Value: MachO::S_MOD_INIT_FUNC_POINTERS},
262 {.Names: {"ModTermFuncPointers"}, .Value: MachO::S_MOD_TERM_FUNC_POINTERS},
263 {.Names: {"Coalesced"}, .Value: MachO::S_COALESCED},
264 {.Names: {"GBZeroFill"}, .Value: MachO::S_GB_ZEROFILL},
265 {.Names: {"Interposing"}, .Value: MachO::S_INTERPOSING},
266 {.Names: {"16ByteLiterals"}, .Value: MachO::S_16BYTE_LITERALS},
267 {.Names: {"DTraceDOF"}, .Value: MachO::S_DTRACE_DOF},
268 {.Names: {"LazyDylibSymbolPointers"}, .Value: MachO::S_LAZY_DYLIB_SYMBOL_POINTERS},
269 {.Names: {"ThreadLocalRegular"}, .Value: MachO::S_THREAD_LOCAL_REGULAR},
270 {.Names: {"ThreadLocalZerofill"}, .Value: MachO::S_THREAD_LOCAL_ZEROFILL},
271 {.Names: {"ThreadLocalVariables"}, .Value: MachO::S_THREAD_LOCAL_VARIABLES},
272 {.Names: {"ThreadLocalVariablePointers"}, .Value: MachO::S_THREAD_LOCAL_VARIABLE_POINTERS},
273 {.Names: {"ThreadLocalInitFunctionPointers"},
274 .Value: MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS}};
275constexpr auto MachOSectionTypes = BUILD_ENUM_STRINGS(MachOSectionTypesDefs);
276
277constexpr EnumStringDef<unsigned> MachOSectionAttributesDefs[] = {
278 {.Names: {"LocReloc"}, .Value: 1 << 0 /*S_ATTR_LOC_RELOC*/},
279 {.Names: {"ExtReloc"}, .Value: 1 << 1 /*S_ATTR_EXT_RELOC*/},
280 {.Names: {"SomeInstructions"}, .Value: 1 << 2 /*S_ATTR_SOME_INSTRUCTIONS*/},
281 {.Names: {"Debug"}, .Value: 1 << 17 /*S_ATTR_DEBUG*/},
282 {.Names: {"SelfModifyingCode"}, .Value: 1 << 18 /*S_ATTR_SELF_MODIFYING_CODE*/},
283 {.Names: {"LiveSupport"}, .Value: 1 << 19 /*S_ATTR_LIVE_SUPPORT*/},
284 {.Names: {"NoDeadStrip"}, .Value: 1 << 20 /*S_ATTR_NO_DEAD_STRIP*/},
285 {.Names: {"StripStaticSyms"}, .Value: 1 << 21 /*S_ATTR_STRIP_STATIC_SYMS*/},
286 {.Names: {"NoTOC"}, .Value: 1 << 22 /*S_ATTR_NO_TOC*/},
287 {.Names: {"PureInstructions"}, .Value: 1 << 23 /*S_ATTR_PURE_INSTRUCTIONS*/},
288};
289constexpr auto MachOSectionAttributes =
290 BUILD_ENUM_STRINGS(MachOSectionAttributesDefs);
291
292constexpr EnumStringDef<unsigned> MachOSymbolRefTypesDefs[] = {
293 {.Names: {"UndefinedNonLazy"}, .Value: 0},
294 {.Names: {"ReferenceFlagUndefinedLazy"}, .Value: 1},
295 {.Names: {"ReferenceFlagDefined"}, .Value: 2},
296 {.Names: {"ReferenceFlagPrivateDefined"}, .Value: 3},
297 {.Names: {"ReferenceFlagPrivateUndefinedNonLazy"}, .Value: 4},
298 {.Names: {"ReferenceFlagPrivateUndefinedLazy"}, .Value: 5}};
299constexpr auto MachOSymbolRefTypes =
300 BUILD_ENUM_STRINGS(MachOSymbolRefTypesDefs);
301
302constexpr EnumStringDef<unsigned> MachOSymbolFlagsDefs[] = {
303 {.Names: {"ThumbDef"}, .Value: 0x8}, {.Names: {"ReferencedDynamically"}, .Value: 0x10},
304 {.Names: {"NoDeadStrip"}, .Value: 0x20}, {.Names: {"WeakRef"}, .Value: 0x40},
305 {.Names: {"WeakDef"}, .Value: 0x80}, {.Names: {"SymbolResolver"}, .Value: 0x100},
306 {.Names: {"AltEntry"}, .Value: 0x200}, {.Names: {"ColdFunc"}, .Value: 0x400},
307};
308constexpr auto MachOSymbolFlags = BUILD_ENUM_STRINGS(MachOSymbolFlagsDefs);
309
310constexpr EnumStringDef<unsigned> MachOSymbolTypesDefs[] = {
311 {.Names: {"Undef"}, .Value: 0x0},
312 {.Names: {"Abs"}, .Value: 0x2},
313 {.Names: {"Indirect"}, .Value: 0xA},
314 {.Names: {"PreboundUndef"}, .Value: 0xC},
315 {.Names: {"Section"}, .Value: 0xE}};
316constexpr auto MachOSymbolTypes = BUILD_ENUM_STRINGS(MachOSymbolTypesDefs);
317
318namespace {
319 struct MachOSection {
320 ArrayRef<char> Name;
321 ArrayRef<char> SegmentName;
322 uint64_t Address;
323 uint64_t Size;
324 uint32_t Offset;
325 uint32_t Alignment;
326 uint32_t RelocationTableOffset;
327 uint32_t NumRelocationTableEntries;
328 uint32_t Flags;
329 uint32_t Reserved1;
330 uint32_t Reserved2;
331 uint32_t Reserved3;
332 };
333
334 struct MachOSegment {
335 std::string CmdName;
336 std::string SegName;
337 uint64_t cmdsize;
338 uint64_t vmaddr;
339 uint64_t vmsize;
340 uint64_t fileoff;
341 uint64_t filesize;
342 uint32_t maxprot;
343 uint32_t initprot;
344 uint32_t nsects;
345 uint32_t flags;
346 };
347
348 struct MachOSymbol {
349 uint32_t StringIndex;
350 uint8_t Type;
351 uint8_t SectionIndex;
352 uint16_t Flags;
353 uint64_t Value;
354 };
355}
356
357static std::string getMask(uint32_t prot)
358{
359 // TODO (davide): This always assumes prot is valid.
360 // Catch mistakes and report if needed.
361 std::string Prot;
362 Prot = "";
363 Prot += (prot & MachO::VM_PROT_READ) ? "r" : "-";
364 Prot += (prot & MachO::VM_PROT_WRITE) ? "w" : "-";
365 Prot += (prot & MachO::VM_PROT_EXECUTE) ? "x" : "-";
366 return Prot;
367}
368
369static void getSection(const MachOObjectFile *Obj,
370 DataRefImpl Sec,
371 MachOSection &Section) {
372 if (!Obj->is64Bit()) {
373 MachO::section Sect = Obj->getSection(DRI: Sec);
374 Section.Address = Sect.addr;
375 Section.Size = Sect.size;
376 Section.Offset = Sect.offset;
377 Section.Alignment = Sect.align;
378 Section.RelocationTableOffset = Sect.reloff;
379 Section.NumRelocationTableEntries = Sect.nreloc;
380 Section.Flags = Sect.flags;
381 Section.Reserved1 = Sect.reserved1;
382 Section.Reserved2 = Sect.reserved2;
383 return;
384 }
385 MachO::section_64 Sect = Obj->getSection64(DRI: Sec);
386 Section.Address = Sect.addr;
387 Section.Size = Sect.size;
388 Section.Offset = Sect.offset;
389 Section.Alignment = Sect.align;
390 Section.RelocationTableOffset = Sect.reloff;
391 Section.NumRelocationTableEntries = Sect.nreloc;
392 Section.Flags = Sect.flags;
393 Section.Reserved1 = Sect.reserved1;
394 Section.Reserved2 = Sect.reserved2;
395 Section.Reserved3 = Sect.reserved3;
396}
397
398static void getSegment(const MachOObjectFile *Obj,
399 const MachOObjectFile::LoadCommandInfo &L,
400 MachOSegment &Segment) {
401 if (!Obj->is64Bit()) {
402 MachO::segment_command SC = Obj->getSegmentLoadCommand(L);
403 Segment.CmdName = "LC_SEGMENT";
404 Segment.SegName = SC.segname;
405 Segment.cmdsize = SC.cmdsize;
406 Segment.vmaddr = SC.vmaddr;
407 Segment.vmsize = SC.vmsize;
408 Segment.fileoff = SC.fileoff;
409 Segment.filesize = SC.filesize;
410 Segment.maxprot = SC.maxprot;
411 Segment.initprot = SC.initprot;
412 Segment.nsects = SC.nsects;
413 Segment.flags = SC.flags;
414 return;
415 }
416 MachO::segment_command_64 SC = Obj->getSegment64LoadCommand(L);
417 Segment.CmdName = "LC_SEGMENT_64";
418 Segment.SegName = SC.segname;
419 Segment.cmdsize = SC.cmdsize;
420 Segment.vmaddr = SC.vmaddr;
421 Segment.vmsize = SC.vmsize;
422 Segment.fileoff = SC.fileoff;
423 Segment.filesize = SC.filesize;
424 Segment.maxprot = SC.maxprot;
425 Segment.initprot = SC.initprot;
426 Segment.nsects = SC.nsects;
427 Segment.flags = SC.flags;
428}
429
430static void getSymbol(const MachOObjectFile *Obj,
431 DataRefImpl DRI,
432 MachOSymbol &Symbol) {
433 if (!Obj->is64Bit()) {
434 MachO::nlist Entry = Obj->getSymbolTableEntry(DRI);
435 Symbol.StringIndex = Entry.n_strx;
436 Symbol.Type = Entry.n_type;
437 Symbol.SectionIndex = Entry.n_sect;
438 Symbol.Flags = Entry.n_desc;
439 Symbol.Value = Entry.n_value;
440 return;
441 }
442 MachO::nlist_64 Entry = Obj->getSymbol64TableEntry(DRI);
443 Symbol.StringIndex = Entry.n_strx;
444 Symbol.Type = Entry.n_type;
445 Symbol.SectionIndex = Entry.n_sect;
446 Symbol.Flags = Entry.n_desc;
447 Symbol.Value = Entry.n_value;
448}
449
450void MachODumper::printFileHeaders() {
451 DictScope H(W, "MachHeader");
452 if (!Obj->is64Bit()) {
453 printFileHeaders(Header: Obj->getHeader());
454 } else {
455 printFileHeaders(Header: Obj->getHeader64());
456 W.printHex(Label: "Reserved", Value: Obj->getHeader64().reserved);
457 }
458}
459
460template<class MachHeader>
461void MachODumper::printFileHeaders(const MachHeader &Header) {
462 W.printEnum("Magic", Header.magic, EnumStrings(MachOMagics));
463 W.printEnum("CpuType", Header.cputype, EnumStrings(MachOHeaderCpuTypes));
464 uint32_t subtype = Header.cpusubtype & ~MachO::CPU_SUBTYPE_MASK;
465 switch (Header.cputype) {
466 case MachO::CPU_TYPE_X86:
467 W.printEnum(Label: "CpuSubType", Value: subtype, EnumValues: EnumStrings(MachOHeaderCpuSubtypesX86));
468 break;
469 case MachO::CPU_TYPE_X86_64:
470 W.printEnum(Label: "CpuSubType", Value: subtype, EnumValues: EnumStrings(MachOHeaderCpuSubtypesX64));
471 break;
472 case MachO::CPU_TYPE_ARM:
473 W.printEnum(Label: "CpuSubType", Value: subtype, EnumValues: EnumStrings(MachOHeaderCpuSubtypesARM));
474 break;
475 case MachO::CPU_TYPE_POWERPC:
476 W.printEnum(Label: "CpuSubType", Value: subtype, EnumValues: EnumStrings(MachOHeaderCpuSubtypesPPC));
477 break;
478 case MachO::CPU_TYPE_SPARC:
479 W.printEnum(Label: "CpuSubType", Value: subtype,
480 EnumValues: EnumStrings(MachOHeaderCpuSubtypesSPARC));
481 break;
482 case MachO::CPU_TYPE_ARM64:
483 W.printEnum(Label: "CpuSubType", Value: subtype,
484 EnumValues: EnumStrings(MachOHeaderCpuSubtypesARM64));
485 break;
486 case MachO::CPU_TYPE_ARM64_32:
487 W.printEnum(Label: "CpuSubType", Value: subtype,
488 EnumValues: EnumStrings(MachOHeaderCpuSubtypesARM64_32));
489 break;
490 case MachO::CPU_TYPE_POWERPC64:
491 default:
492 W.printHex(Label: "CpuSubType", Value: subtype);
493 }
494 W.printHex("CpuCapabilities",
495 (Header.cpusubtype & MachO::CPU_SUBTYPE_MASK) >> 24);
496 W.printEnum("FileType", Header.filetype, EnumStrings(MachOHeaderFileTypes));
497 W.printNumber("NumOfLoadCommands", Header.ncmds);
498 W.printNumber("SizeOfLoadCommands", Header.sizeofcmds);
499 W.printFlags("Flags", Header.flags, EnumStrings(MachOHeaderFlags));
500}
501
502void MachODumper::printSectionHeaders() { return printSectionHeaders(Obj); }
503
504void MachODumper::printSectionHeaders(const MachOObjectFile *Obj) {
505 ListScope Group(W, "Sections");
506
507 int SectionIndex = -1;
508 for (const SectionRef &Section : Obj->sections()) {
509 ++SectionIndex;
510
511 MachOSection MOSection;
512 getSection(Obj, Sec: Section.getRawDataRefImpl(), Section&: MOSection);
513 DataRefImpl DR = Section.getRawDataRefImpl();
514 StringRef Name = unwrapOrError(Input: Obj->getFileName(), EO: Section.getName());
515 ArrayRef<char> RawName = Obj->getSectionRawName(Sec: DR);
516 StringRef SegmentName = Obj->getSectionFinalSegmentName(Sec: DR);
517 ArrayRef<char> RawSegmentName = Obj->getSectionRawFinalSegmentName(Sec: DR);
518
519 DictScope SectionD(W, "Section");
520 W.printNumber(Label: "Index", Value: SectionIndex);
521 W.printBinary(Label: "Name", Str: Name, Value: RawName);
522 W.printBinary(Label: "Segment", Str: SegmentName, Value: RawSegmentName);
523 W.printHex(Label: "Address", Value: MOSection.Address);
524 W.printHex(Label: "Size", Value: MOSection.Size);
525 W.printNumber(Label: "Offset", Value: MOSection.Offset);
526 W.printNumber(Label: "Alignment", Value: MOSection.Alignment);
527 W.printHex(Label: "RelocationOffset", Value: MOSection.RelocationTableOffset);
528 W.printNumber(Label: "RelocationCount", Value: MOSection.NumRelocationTableEntries);
529 W.printEnum(Label: "Type", Value: MOSection.Flags & 0xFF, EnumValues: EnumStrings(MachOSectionTypes));
530 W.printFlags(Label: "Attributes", Value: MOSection.Flags >> 8,
531 Flags: EnumStrings(MachOSectionAttributes));
532 W.printHex(Label: "Reserved1", Value: MOSection.Reserved1);
533 W.printHex(Label: "Reserved2", Value: MOSection.Reserved2);
534 if (Obj->is64Bit())
535 W.printHex(Label: "Reserved3", Value: MOSection.Reserved3);
536
537 if (opts::SectionRelocations) {
538 ListScope D(W, "Relocations");
539 for (const RelocationRef &Reloc : Section.relocations())
540 printRelocation(Reloc);
541 }
542
543 if (opts::SectionSymbols) {
544 ListScope D(W, "Symbols");
545 for (const SymbolRef &Symbol : Obj->symbols()) {
546 if (!Section.containsSymbol(S: Symbol))
547 continue;
548
549 printSymbol(Symbol);
550 }
551 }
552
553 if (opts::SectionData && !Section.isBSS())
554 W.printBinaryBlock(Label: "SectionData", Value: unwrapOrError(Input: Obj->getFileName(),
555 EO: Section.getContents()));
556 }
557}
558
559void MachODumper::printRelocations() {
560 ListScope D(W, "Relocations");
561
562 std::error_code EC;
563 for (const SectionRef &Section : Obj->sections()) {
564 StringRef Name = unwrapOrError(Input: Obj->getFileName(), EO: Section.getName());
565 bool PrintedGroup = false;
566 for (const RelocationRef &Reloc : Section.relocations()) {
567 if (!PrintedGroup) {
568 W.startLine() << "Section " << Name << " {\n";
569 W.indent();
570 PrintedGroup = true;
571 }
572
573 printRelocation(Reloc);
574 }
575
576 if (PrintedGroup) {
577 W.unindent();
578 W.startLine() << "}\n";
579 }
580 }
581}
582
583void MachODumper::printRelocation(const RelocationRef &Reloc) {
584 return printRelocation(Obj, Reloc);
585}
586
587void MachODumper::printRelocation(const MachOObjectFile *Obj,
588 const RelocationRef &Reloc) {
589 uint64_t Offset = Reloc.getOffset();
590 SmallString<32> RelocName;
591 Reloc.getTypeName(Result&: RelocName);
592
593 DataRefImpl DR = Reloc.getRawDataRefImpl();
594 MachO::any_relocation_info RE = Obj->getRelocation(Rel: DR);
595 bool IsScattered = Obj->isRelocationScattered(RE);
596 bool IsExtern = !IsScattered && Obj->getPlainRelocationExternal(RE);
597
598 StringRef TargetName;
599 if (IsExtern) {
600 symbol_iterator Symbol = Reloc.getSymbol();
601 if (Symbol != Obj->symbol_end()) {
602 TargetName = getSymbolName(Symbol: *Symbol);
603 }
604 } else if (!IsScattered) {
605 section_iterator SecI = Obj->getRelocationSection(Rel: DR);
606 if (SecI != Obj->section_end())
607 TargetName = unwrapOrError(Input: Obj->getFileName(), EO: SecI->getName());
608 }
609 if (TargetName.empty())
610 TargetName = "-";
611
612 if (opts::ExpandRelocs) {
613 DictScope Group(W, "Relocation");
614 W.printHex(Label: "Offset", Value: Offset);
615 W.printNumber(Label: "PCRel", Value: Obj->getAnyRelocationPCRel(RE));
616 W.printNumber(Label: "Length", Value: Obj->getAnyRelocationLength(RE));
617 W.printNumber(Label: "Type", Str: RelocName, Value: Obj->getAnyRelocationType(RE));
618 if (IsScattered) {
619 W.printHex(Label: "Value", Value: Obj->getScatteredRelocationValue(RE));
620 } else {
621 const char *Kind = IsExtern ? "Symbol" : "Section";
622 W.printNumber(Label: Kind, Str: TargetName, Value: Obj->getPlainRelocationSymbolNum(RE));
623 }
624 } else {
625 SmallString<32> SymbolNameOrOffset("0x");
626 if (IsScattered) {
627 // Scattered relocations don't really have an associated symbol for some
628 // reason, even if one exists in the symtab at the correct address.
629 SymbolNameOrOffset += utohexstr(X: Obj->getScatteredRelocationValue(RE));
630 } else {
631 SymbolNameOrOffset = TargetName;
632 }
633
634 raw_ostream& OS = W.startLine();
635 OS << W.hex(Value: Offset)
636 << " " << Obj->getAnyRelocationPCRel(RE)
637 << " " << Obj->getAnyRelocationLength(RE);
638 if (IsScattered)
639 OS << " n/a";
640 else
641 OS << " " << Obj->getPlainRelocationExternal(RE);
642 OS << " " << RelocName
643 << " " << IsScattered
644 << " " << SymbolNameOrOffset
645 << "\n";
646 }
647}
648
649StringRef MachODumper::getSymbolName(const SymbolRef &Symbol) const {
650 Expected<StringRef> SymbolNameOrErr = Symbol.getName();
651 if (!SymbolNameOrErr) {
652 reportError(Err: SymbolNameOrErr.takeError(), Input: Obj->getFileName());
653 }
654 return *SymbolNameOrErr;
655}
656
657uint8_t MachODumper::getSymbolType(const SymbolRef &Symbol) const {
658 return Obj->is64Bit()
659 ? Obj->getSymbol64TableEntry(DRI: Symbol.getRawDataRefImpl()).n_type
660 : Obj->getSymbolTableEntry(DRI: Symbol.getRawDataRefImpl()).n_type;
661}
662
663bool MachODumper::compareSymbolsByName(SymbolRef LHS, SymbolRef RHS) const {
664 return getSymbolName(Symbol: LHS).str().compare(str: getSymbolName(Symbol: RHS).str()) < 0;
665}
666
667bool MachODumper::compareSymbolsByType(SymbolRef LHS, SymbolRef RHS) const {
668 return getSymbolType(Symbol: LHS) < getSymbolType(Symbol: RHS);
669}
670
671void MachODumper::printSymbols(bool /*ExtraSymInfo*/) {
672 printSymbols(SymComp: std::nullopt);
673}
674
675void MachODumper::printSymbols(std::optional<SymbolComparator> SymComp) {
676 ListScope Group(W, "Symbols");
677 if (SymComp) {
678 auto SymbolRange = Obj->symbols();
679 std::vector<SymbolRef> SortedSymbols(SymbolRange.begin(),
680 SymbolRange.end());
681 llvm::stable_sort(Range&: SortedSymbols, C: *SymComp);
682 for (SymbolRef Symbol : SortedSymbols)
683 printSymbol(Symbol);
684 } else {
685 for (const SymbolRef &Symbol : Obj->symbols()) {
686 printSymbol(Symbol);
687 }
688 }
689}
690
691void MachODumper::printDynamicSymbols() {
692 ListScope Group(W, "DynamicSymbols");
693}
694void MachODumper::printDynamicSymbols(std::optional<SymbolComparator> SymComp) {
695 ListScope Group(W, "DynamicSymbols");
696}
697
698void MachODumper::printSymbol(const SymbolRef &Symbol) {
699 printSymbol(Symbol, W);
700}
701
702void MachODumper::printSymbol(const SymbolRef &Symbol, ScopedPrinter &W) {
703 StringRef SymbolName = getSymbolName(Symbol);
704
705 MachOSymbol MOSymbol;
706 getSymbol(Obj, DRI: Symbol.getRawDataRefImpl(), Symbol&: MOSymbol);
707
708 StringRef SectionName = "";
709 // Don't ask a Mach-O STABS symbol for its section unless we know that
710 // STAB symbol's section field refers to a valid section index. Otherwise
711 // the symbol may error trying to load a section that does not exist.
712 // TODO: Add a whitelist of STABS symbol types that contain valid section
713 // indices.
714 if (!(MOSymbol.Type & MachO::N_STAB)) {
715 Expected<section_iterator> SecIOrErr = Symbol.getSection();
716 if (!SecIOrErr)
717 reportError(Err: SecIOrErr.takeError(), Input: Obj->getFileName());
718
719 section_iterator SecI = *SecIOrErr;
720 if (SecI != Obj->section_end())
721 SectionName = unwrapOrError(Input: Obj->getFileName(), EO: SecI->getName());
722 }
723
724 DictScope D(W, "Symbol");
725 W.printNumber(Label: "Name", Str: SymbolName, Value: MOSymbol.StringIndex);
726 if (MOSymbol.Type & MachO::N_STAB) {
727 W.printHex(Label: "Type", Str: "SymDebugTable", Value: MOSymbol.Type);
728 } else {
729 if (MOSymbol.Type & MachO::N_PEXT)
730 W.startLine() << "PrivateExtern\n";
731 if (MOSymbol.Type & MachO::N_EXT)
732 W.startLine() << "Extern\n";
733 W.printEnum(Label: "Type", Value: uint8_t(MOSymbol.Type & MachO::N_TYPE),
734 EnumValues: EnumStrings(MachOSymbolTypes));
735 }
736 W.printHex(Label: "Section", Str: SectionName, Value: MOSymbol.SectionIndex);
737 W.printEnum(Label: "RefType", Value: static_cast<uint16_t>(MOSymbol.Flags & 0x7),
738 EnumValues: EnumStrings(MachOSymbolRefTypes));
739 W.printFlags(Label: "Flags", Value: static_cast<uint16_t>(MOSymbol.Flags & ~0x7),
740 Flags: EnumStrings(MachOSymbolFlags));
741 W.printHex(Label: "Value", Value: MOSymbol.Value);
742}
743
744void MachODumper::printUnwindInfo() {
745 W.startLine() << "UnwindInfo not implemented.\n";
746}
747
748void MachODumper::printStackMap() const {
749 object::SectionRef StackMapSection;
750 for (auto Sec : Obj->sections()) {
751 StringRef Name;
752 if (Expected<StringRef> NameOrErr = Sec.getName())
753 Name = *NameOrErr;
754 else
755 consumeError(Err: NameOrErr.takeError());
756
757 if (Name == "__llvm_stackmaps") {
758 StackMapSection = Sec;
759 break;
760 }
761 }
762
763 if (StackMapSection == object::SectionRef())
764 return;
765
766 StringRef StackMapContents =
767 unwrapOrError(Input: Obj->getFileName(), EO: StackMapSection.getContents());
768 ArrayRef<uint8_t> StackMapContentsArray =
769 arrayRefFromStringRef(Input: StackMapContents);
770
771 if (Obj->isLittleEndian())
772 prettyPrintStackMap(
773 W, SMP: StackMapParser<llvm::endianness::little>(StackMapContentsArray));
774 else
775 prettyPrintStackMap(
776 W, SMP: StackMapParser<llvm::endianness::big>(StackMapContentsArray));
777}
778
779void MachODumper::printCGProfile() {
780 object::SectionRef CGProfileSection;
781 for (auto Sec : Obj->sections()) {
782 StringRef Name;
783 if (Expected<StringRef> NameOrErr = Sec.getName())
784 Name = *NameOrErr;
785 else
786 consumeError(Err: NameOrErr.takeError());
787
788 if (Name == "__cg_profile") {
789 CGProfileSection = Sec;
790 break;
791 }
792 }
793 if (CGProfileSection == object::SectionRef())
794 return;
795
796 StringRef CGProfileContents =
797 unwrapOrError(Input: Obj->getFileName(), EO: CGProfileSection.getContents());
798 BinaryStreamReader Reader(CGProfileContents, Obj->isLittleEndian()
799 ? llvm::endianness::little
800 : llvm::endianness::big);
801
802 ListScope L(W, "CGProfile");
803 while (!Reader.empty()) {
804 uint32_t FromIndex, ToIndex;
805 uint64_t Count;
806 if (Error Err = Reader.readInteger(Dest&: FromIndex))
807 reportError(Err: std::move(Err), Input: Obj->getFileName());
808 if (Error Err = Reader.readInteger(Dest&: ToIndex))
809 reportError(Err: std::move(Err), Input: Obj->getFileName());
810 if (Error Err = Reader.readInteger(Dest&: Count))
811 reportError(Err: std::move(Err), Input: Obj->getFileName());
812 DictScope D(W, "CGProfileEntry");
813 W.printNumber(Label: "From", Str: getSymbolName(Symbol: *Obj->getSymbolByIndex(Index: FromIndex)),
814 Value: FromIndex);
815 W.printNumber(Label: "To", Str: getSymbolName(Symbol: *Obj->getSymbolByIndex(Index: ToIndex)),
816 Value: ToIndex);
817 W.printNumber(Label: "Weight", Value: Count);
818 }
819}
820
821void MachODumper::printNeededLibraries() {
822 ListScope D(W, "NeededLibraries");
823
824 using LibsTy = std::vector<StringRef>;
825 LibsTy Libs;
826
827 for (const auto &Command : Obj->load_commands()) {
828 if (Command.C.cmd == MachO::LC_LOAD_DYLIB ||
829 Command.C.cmd == MachO::LC_LOAD_WEAK_DYLIB ||
830 Command.C.cmd == MachO::LC_REEXPORT_DYLIB ||
831 Command.C.cmd == MachO::LC_LAZY_LOAD_DYLIB ||
832 Command.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) {
833 MachO::dylib_command Dl = Obj->getDylibIDLoadCommand(L: Command);
834 if (Dl.dylib.name < Dl.cmdsize) {
835 auto *P = static_cast<const char*>(Command.Ptr) + Dl.dylib.name;
836 Libs.push_back(x: P);
837 }
838 }
839 }
840
841 llvm::stable_sort(Range&: Libs);
842
843 for (const auto &L : Libs) {
844 W.startLine() << L << "\n";
845 }
846}
847
848void MachODumper::printMachODataInCode() {
849 for (const auto &Load : Obj->load_commands()) {
850 if (Load.C.cmd == MachO::LC_DATA_IN_CODE) {
851 MachO::linkedit_data_command LLC = Obj->getLinkeditDataLoadCommand(L: Load);
852 DictScope Group(W, "DataInCode");
853 W.printNumber(Label: "Data offset", Value: LLC.dataoff);
854 W.printNumber(Label: "Data size", Value: LLC.datasize);
855 ListScope D(W, "Data entries");
856 unsigned NumRegions = LLC.datasize / sizeof(MachO::data_in_code_entry);
857 for (unsigned i = 0; i < NumRegions; ++i) {
858 MachO::data_in_code_entry DICE = Obj->getDataInCodeTableEntry(
859 DataOffset: LLC.dataoff, Index: i);
860 DictScope Group(W, "Entry");
861 W.printNumber(Label: "Index", Value: i);
862 W.printNumber(Label: "Offset", Value: DICE.offset);
863 W.printNumber(Label: "Length", Value: DICE.length);
864 W.printNumber(Label: "Kind", Value: DICE.kind);
865 }
866 }
867 }
868}
869
870void MachODumper::printMachOVersionMin() {
871 for (const auto &Load : Obj->load_commands()) {
872 StringRef Cmd;
873 switch (Load.C.cmd) {
874 case MachO::LC_VERSION_MIN_MACOSX:
875 Cmd = "LC_VERSION_MIN_MACOSX";
876 break;
877 case MachO::LC_VERSION_MIN_IPHONEOS:
878 Cmd = "LC_VERSION_MIN_IPHONEOS";
879 break;
880 case MachO::LC_VERSION_MIN_TVOS:
881 Cmd = "LC_VERSION_MIN_TVOS";
882 break;
883 case MachO::LC_VERSION_MIN_WATCHOS:
884 Cmd = "LC_VERSION_MIN_WATCHOS";
885 break;
886 case MachO::LC_BUILD_VERSION:
887 Cmd = "LC_BUILD_VERSION";
888 break;
889 default:
890 continue;
891 }
892
893 DictScope Group(W, "MinVersion");
894 // Handle LC_BUILD_VERSION.
895 if (Load.C.cmd == MachO::LC_BUILD_VERSION) {
896 MachO::build_version_command BVC = Obj->getBuildVersionLoadCommand(L: Load);
897 W.printString(Label: "Cmd", Value: Cmd);
898 W.printNumber(Label: "Size", Value: BVC.cmdsize);
899 W.printString(Label: "Platform",
900 Value: MachOObjectFile::getBuildPlatform(platform: BVC.platform));
901 W.printString(Label: "Version", Value: MachOObjectFile::getVersionString(version: BVC.minos));
902 if (BVC.sdk)
903 W.printString(Label: "SDK", Value: MachOObjectFile::getVersionString(version: BVC.sdk));
904 else
905 W.printString(Label: "SDK", Value: StringRef("n/a"));
906 continue;
907 }
908
909 MachO::version_min_command VMC = Obj->getVersionMinLoadCommand(L: Load);
910 W.printString(Label: "Cmd", Value: Cmd);
911 W.printNumber(Label: "Size", Value: VMC.cmdsize);
912 SmallString<32> Version;
913 Version = utostr(X: MachOObjectFile::getVersionMinMajor(C&: VMC, SDK: false)) + "." +
914 utostr(X: MachOObjectFile::getVersionMinMinor(C&: VMC, SDK: false));
915 uint32_t Update = MachOObjectFile::getVersionMinUpdate(C&: VMC, SDK: false);
916 if (Update != 0)
917 Version += "." + utostr(X: MachOObjectFile::getVersionMinUpdate(C&: VMC, SDK: false));
918 W.printString(Label: "Version", Value: Version);
919 SmallString<32> SDK;
920 if (VMC.sdk == 0)
921 SDK = "n/a";
922 else {
923 SDK = utostr(X: MachOObjectFile::getVersionMinMajor(C&: VMC, SDK: true)) + "." +
924 utostr(X: MachOObjectFile::getVersionMinMinor(C&: VMC, SDK: true));
925 uint32_t Update = MachOObjectFile::getVersionMinUpdate(C&: VMC, SDK: true);
926 if (Update != 0)
927 SDK += "." + utostr(X: MachOObjectFile::getVersionMinUpdate(C&: VMC, SDK: true));
928 }
929 W.printString(Label: "SDK", Value: SDK);
930 }
931}
932
933void MachODumper::printMachOTargetTriple() {
934 for (const auto &Load : Obj->load_commands()) {
935 if (Load.C.cmd == MachO::LC_TARGET_TRIPLE) {
936 DictScope Group(W, "TargetTriple");
937 MachO::target_triple_command TTC = Obj->getTargetTripleLoadCommand(L: Load);
938 W.printString(Label: "Cmd", Value: "LC_TARGET_TRIPLE");
939 W.printNumber(Label: "Size", Value: TTC.cmdsize);
940 if (TTC.triple < TTC.cmdsize)
941 W.printString(Label: "Triple", Value: Load.Ptr + TTC.triple);
942 else
943 W.printNumber(Label: "Triple ?(bad offset)", Value: TTC.triple);
944 }
945 }
946}
947
948void MachODumper::printMachODysymtab() {
949 for (const auto &Load : Obj->load_commands()) {
950 if (Load.C.cmd == MachO::LC_DYSYMTAB) {
951 MachO::dysymtab_command DLC = Obj->getDysymtabLoadCommand();
952 DictScope Group(W, "Dysymtab");
953 W.printNumber(Label: "ilocalsym", Value: DLC.ilocalsym);
954 W.printNumber(Label: "nlocalsym", Value: DLC.nlocalsym);
955 W.printNumber(Label: "iextdefsym", Value: DLC.iextdefsym);
956 W.printNumber(Label: "nextdefsym", Value: DLC.nextdefsym);
957 W.printNumber(Label: "iundefsym", Value: DLC.iundefsym);
958 W.printNumber(Label: "nundefsym", Value: DLC.nundefsym);
959 W.printNumber(Label: "tocoff", Value: DLC.tocoff);
960 W.printNumber(Label: "ntoc", Value: DLC.ntoc);
961 W.printNumber(Label: "modtaboff", Value: DLC.modtaboff);
962 W.printNumber(Label: "nmodtab", Value: DLC.nmodtab);
963 W.printNumber(Label: "extrefsymoff", Value: DLC.extrefsymoff);
964 W.printNumber(Label: "nextrefsyms", Value: DLC.nextrefsyms);
965 W.printNumber(Label: "indirectsymoff", Value: DLC.indirectsymoff);
966 W.printNumber(Label: "nindirectsyms", Value: DLC.nindirectsyms);
967 W.printNumber(Label: "extreloff", Value: DLC.extreloff);
968 W.printNumber(Label: "nextrel", Value: DLC.nextrel);
969 W.printNumber(Label: "locreloff", Value: DLC.locreloff);
970 W.printNumber(Label: "nlocrel", Value: DLC.nlocrel);
971 }
972 }
973}
974
975void MachODumper::printMachOSegment() {
976 for (const auto &Load : Obj->load_commands()) {
977 if (Load.C.cmd == MachO::LC_SEGMENT || Load.C.cmd == MachO::LC_SEGMENT_64) {
978 MachOSegment MOSegment;
979 getSegment(Obj, L: Load, Segment&: MOSegment);
980 DictScope Group(W, "Segment");
981 W.printString(Label: "Cmd", Value: MOSegment.CmdName);
982 W.printString(Label: "Name", Value: MOSegment.SegName);
983 W.printNumber(Label: "Size", Value: MOSegment.cmdsize);
984 W.printHex(Label: "vmaddr", Value: MOSegment.vmaddr);
985 W.printHex(Label: "vmsize", Value: MOSegment.vmsize);
986 W.printNumber(Label: "fileoff", Value: MOSegment.fileoff);
987 W.printNumber(Label: "filesize", Value: MOSegment.filesize);
988 W.printString(Label: "maxprot", Value: getMask(prot: MOSegment.maxprot));
989 W.printString(Label: "initprot", Value: getMask(prot: MOSegment.initprot));
990 W.printNumber(Label: "nsects", Value: MOSegment.nsects);
991 W.printHex(Label: "flags", Value: MOSegment.flags);
992 }
993 }
994}
995
996void MachODumper::printMachOIndirectSymbols() {
997 for (const auto &Load : Obj->load_commands()) {
998 if (Load.C.cmd == MachO::LC_DYSYMTAB) {
999 MachO::dysymtab_command DLC = Obj->getDysymtabLoadCommand();
1000 DictScope Group(W, "Indirect Symbols");
1001 W.printNumber(Label: "Number", Value: DLC.nindirectsyms);
1002 ListScope D(W, "Symbols");
1003 for (unsigned i = 0; i < DLC.nindirectsyms; ++i) {
1004 DictScope Group(W, "Entry");
1005 W.printNumber(Label: "Entry Index", Value: i);
1006 W.printHex(Label: "Symbol Index", Value: Obj->getIndirectSymbolTableEntry(DLC, Index: i));
1007 }
1008 }
1009 }
1010}
1011
1012void MachODumper::printMachOLinkerOptions() {
1013 for (const auto &Load : Obj->load_commands()) {
1014 if (Load.C.cmd == MachO::LC_LINKER_OPTION) {
1015 MachO::linker_option_command LOLC = Obj->getLinkerOptionLoadCommand(L: Load);
1016 DictScope Group(W, "Linker Options");
1017 W.printNumber(Label: "Size", Value: LOLC.cmdsize);
1018 ListScope D(W, "Strings");
1019 uint64_t DataSize = LOLC.cmdsize - sizeof(MachO::linker_option_command);
1020 const char *P = Load.Ptr + sizeof(MachO::linker_option_command);
1021 StringRef Data(P, DataSize);
1022 for (unsigned i = 0; i < LOLC.count; ++i) {
1023 std::pair<StringRef,StringRef> Split = Data.split(Separator: '\0');
1024 W.printString(Label: "Value", Value: Split.first);
1025 Data = Split.second;
1026 }
1027 }
1028 }
1029}
1030