1 //===-- MachODump.cpp - Object file dumping utility for llvm --------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the MachO-specific dumper for llvm-readobj.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm-readobj.h"
15 #include "Error.h"
16 #include "ObjDumper.h"
17 #include "StreamWriter.h"
18 #include "llvm/ADT/SmallString.h"
19 #include "llvm/ADT/StringExtras.h"
20 #include "llvm/Object/MachO.h"
21 #include "llvm/Support/Casting.h"
22 
23 using namespace llvm;
24 using namespace object;
25 
26 namespace {
27 
28 class MachODumper : public ObjDumper {
29 public:
30   MachODumper(const MachOObjectFile *Obj, StreamWriter& Writer)
31     : ObjDumper(Writer)
32     , Obj(Obj) { }
33 
34   void printFileHeaders() override;
35   void printSections() override;
36   void printRelocations() override;
37   void printSymbols() override;
38   void printDynamicSymbols() override;
39   void printUnwindInfo() override;
40 
41 private:
42   template<class MachHeader>
43   void printFileHeaders(const MachHeader &Header);
44 
45   void printSymbol(const SymbolRef &Symbol);
46 
47   void printRelocation(const RelocationRef &Reloc);
48 
49   void printRelocation(const MachOObjectFile *Obj, const RelocationRef &Reloc);
50 
51   void printSections(const MachOObjectFile *Obj);
52 
53   const MachOObjectFile *Obj;
54 };
55 
56 } // namespace
57 
58 
59 namespace llvm {
60 
61 std::error_code createMachODumper(const object::ObjectFile *Obj,
62                                   StreamWriter &Writer,
63                                   std::unique_ptr<ObjDumper> &Result) {
64   const MachOObjectFile *MachOObj = dyn_cast<MachOObjectFile>(Obj);
65   if (!MachOObj)
66     return readobj_error::unsupported_obj_file_format;
67 
68   Result.reset(new MachODumper(MachOObj, Writer));
69   return readobj_error::success;
70 }
71 
72 } // namespace llvm
73 
74 static const EnumEntry<uint32_t> MachOMagics[] = {
75   { "Magic",      MachO::MH_MAGIC    },
76   { "Cigam",      MachO::MH_CIGAM    },
77   { "Magic64",    MachO::MH_MAGIC_64 },
78   { "Cigam64",    MachO::MH_CIGAM_64 },
79   { "FatMagic",   MachO::FAT_MAGIC   },
80   { "FatCigam",   MachO::FAT_CIGAM   },
81 };
82 
83 static const EnumEntry<uint32_t> MachOHeaderFileTypes[] = {
84   { "Relocatable",          MachO::MH_OBJECT      },
85   { "Executable",           MachO::MH_EXECUTE     },
86   { "FixedVMLibrary",       MachO::MH_FVMLIB      },
87   { "Core",                 MachO::MH_CORE        },
88   { "PreloadedExecutable",  MachO::MH_PRELOAD     },
89   { "DynamicLibrary",       MachO::MH_DYLIB       },
90   { "DynamicLinker",        MachO::MH_DYLINKER    },
91   { "Bundle",               MachO::MH_BUNDLE      },
92   { "DynamicLibraryStub",   MachO::MH_DYLIB_STUB  },
93   { "DWARFSymbol",          MachO::MH_DSYM        },
94   { "KextBundle",           MachO::MH_KEXT_BUNDLE },
95 };
96 
97 static const EnumEntry<uint32_t> MachOHeaderCpuTypes[] = {
98   { "Any"       , static_cast<uint32_t>(MachO::CPU_TYPE_ANY) },
99   { "X86"       , MachO::CPU_TYPE_X86       },
100   { "X86-64"    , MachO::CPU_TYPE_X86_64    },
101   { "Mc98000"   , MachO::CPU_TYPE_MC98000   },
102   { "Arm"       , MachO::CPU_TYPE_ARM       },
103   { "Arm64"     , MachO::CPU_TYPE_ARM64     },
104   { "Sparc"     , MachO::CPU_TYPE_SPARC     },
105   { "PowerPC"   , MachO::CPU_TYPE_POWERPC   },
106   { "PowerPC64" , MachO::CPU_TYPE_POWERPC64 },
107 };
108 
109 static const EnumEntry<uint32_t> MachOHeaderCpuSubtypesX86[] = {
110   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_I386_ALL),
111   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_386),
112   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_486),
113   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_486SX),
114   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_586),
115   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTPRO),
116   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTII_M3),
117   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTII_M5),
118   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_CELERON),
119   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_CELERON_MOBILE),
120   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_3),
121   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_3_M),
122   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_3_XEON),
123   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_M),
124   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_4),
125   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_4_M),
126   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ITANIUM),
127   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ITANIUM_2),
128   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_XEON),
129   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_XEON_MP),
130 };
131 
132 static const EnumEntry<uint32_t> MachOHeaderCpuSubtypesX64[] = {
133   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_X86_64_ALL),
134   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_X86_ARCH1),
135   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_X86_64_H),
136 };
137 
138 static const EnumEntry<uint32_t> MachOHeaderCpuSubtypesARM[] = {
139   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_ALL),
140   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V4T),
141   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V6),
142   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V5),
143   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V5TEJ),
144   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_XSCALE),
145   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7),
146   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7S),
147   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7K),
148   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V6M),
149   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7M),
150   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7EM),
151 };
152 
153 static const EnumEntry<uint32_t> MachOHeaderCpuSubtypesARM64[] = {
154   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM64_ALL),
155 };
156 
157 static const EnumEntry<uint32_t> MachOHeaderCpuSubtypesSPARC[] = {
158   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_SPARC_ALL),
159 };
160 
161 static const EnumEntry<uint32_t> MachOHeaderCpuSubtypesPPC[] = {
162   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_ALL),
163   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_601),
164   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_602),
165   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_603),
166   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_603e),
167   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_603ev),
168   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_604),
169   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_604e),
170   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_620),
171   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_750),
172   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_7400),
173   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_7450),
174   LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_970),
175 };
176 
177 static const EnumEntry<uint32_t> MachOHeaderFlags[] = {
178   LLVM_READOBJ_ENUM_ENT(MachO, MH_NOUNDEFS),
179   LLVM_READOBJ_ENUM_ENT(MachO, MH_INCRLINK),
180   LLVM_READOBJ_ENUM_ENT(MachO, MH_DYLDLINK),
181   LLVM_READOBJ_ENUM_ENT(MachO, MH_BINDATLOAD),
182   LLVM_READOBJ_ENUM_ENT(MachO, MH_PREBOUND),
183   LLVM_READOBJ_ENUM_ENT(MachO, MH_SPLIT_SEGS),
184   LLVM_READOBJ_ENUM_ENT(MachO, MH_LAZY_INIT),
185   LLVM_READOBJ_ENUM_ENT(MachO, MH_TWOLEVEL),
186   LLVM_READOBJ_ENUM_ENT(MachO, MH_FORCE_FLAT),
187   LLVM_READOBJ_ENUM_ENT(MachO, MH_NOMULTIDEFS),
188   LLVM_READOBJ_ENUM_ENT(MachO, MH_NOFIXPREBINDING),
189   LLVM_READOBJ_ENUM_ENT(MachO, MH_PREBINDABLE),
190   LLVM_READOBJ_ENUM_ENT(MachO, MH_ALLMODSBOUND),
191   LLVM_READOBJ_ENUM_ENT(MachO, MH_SUBSECTIONS_VIA_SYMBOLS),
192   LLVM_READOBJ_ENUM_ENT(MachO, MH_CANONICAL),
193   LLVM_READOBJ_ENUM_ENT(MachO, MH_WEAK_DEFINES),
194   LLVM_READOBJ_ENUM_ENT(MachO, MH_BINDS_TO_WEAK),
195   LLVM_READOBJ_ENUM_ENT(MachO, MH_ALLOW_STACK_EXECUTION),
196   LLVM_READOBJ_ENUM_ENT(MachO, MH_ROOT_SAFE),
197   LLVM_READOBJ_ENUM_ENT(MachO, MH_SETUID_SAFE),
198   LLVM_READOBJ_ENUM_ENT(MachO, MH_NO_REEXPORTED_DYLIBS),
199   LLVM_READOBJ_ENUM_ENT(MachO, MH_PIE),
200   LLVM_READOBJ_ENUM_ENT(MachO, MH_DEAD_STRIPPABLE_DYLIB),
201   LLVM_READOBJ_ENUM_ENT(MachO, MH_HAS_TLV_DESCRIPTORS),
202   LLVM_READOBJ_ENUM_ENT(MachO, MH_NO_HEAP_EXECUTION),
203   LLVM_READOBJ_ENUM_ENT(MachO, MH_APP_EXTENSION_SAFE),
204 };
205 
206 static const EnumEntry<unsigned> MachOSectionAttributes[] = {
207   { "LocReloc"         , 1 <<  0 /*S_ATTR_LOC_RELOC          */ },
208   { "ExtReloc"         , 1 <<  1 /*S_ATTR_EXT_RELOC          */ },
209   { "SomeInstructions" , 1 <<  2 /*S_ATTR_SOME_INSTRUCTIONS  */ },
210   { "Debug"            , 1 << 17 /*S_ATTR_DEBUG              */ },
211   { "SelfModifyingCode", 1 << 18 /*S_ATTR_SELF_MODIFYING_CODE*/ },
212   { "LiveSupport"      , 1 << 19 /*S_ATTR_LIVE_SUPPORT       */ },
213   { "NoDeadStrip"      , 1 << 20 /*S_ATTR_NO_DEAD_STRIP      */ },
214   { "StripStaticSyms"  , 1 << 21 /*S_ATTR_STRIP_STATIC_SYMS  */ },
215   { "NoTOC"            , 1 << 22 /*S_ATTR_NO_TOC             */ },
216   { "PureInstructions" , 1 << 23 /*S_ATTR_PURE_INSTRUCTIONS  */ },
217 };
218 
219 static const EnumEntry<unsigned> MachOSymbolRefTypes[] = {
220   { "UndefinedNonLazy",                     0 },
221   { "ReferenceFlagUndefinedLazy",           1 },
222   { "ReferenceFlagDefined",                 2 },
223   { "ReferenceFlagPrivateDefined",          3 },
224   { "ReferenceFlagPrivateUndefinedNonLazy", 4 },
225   { "ReferenceFlagPrivateUndefinedLazy",    5 }
226 };
227 
228 static const EnumEntry<unsigned> MachOSymbolFlags[] = {
229   { "ReferencedDynamically", 0x10 },
230   { "NoDeadStrip",           0x20 },
231   { "WeakRef",               0x40 },
232   { "WeakDef",               0x80 }
233 };
234 
235 static const EnumEntry<unsigned> MachOSymbolTypes[] = {
236   { "Undef",           0x0 },
237   { "Abs",             0x2 },
238   { "Indirect",        0xA },
239   { "PreboundUndef",   0xC },
240   { "Section",         0xE }
241 };
242 
243 namespace {
244   struct MachOSection {
245     ArrayRef<char> Name;
246     ArrayRef<char> SegmentName;
247     uint64_t Address;
248     uint64_t Size;
249     uint32_t Offset;
250     uint32_t Alignment;
251     uint32_t RelocationTableOffset;
252     uint32_t NumRelocationTableEntries;
253     uint32_t Flags;
254     uint32_t Reserved1;
255     uint32_t Reserved2;
256   };
257 
258   struct MachOSymbol {
259     uint32_t StringIndex;
260     uint8_t Type;
261     uint8_t SectionIndex;
262     uint16_t Flags;
263     uint64_t Value;
264   };
265 }
266 
267 static void getSection(const MachOObjectFile *Obj,
268                        DataRefImpl Sec,
269                        MachOSection &Section) {
270   if (!Obj->is64Bit()) {
271     MachO::section Sect = Obj->getSection(Sec);
272     Section.Address     = Sect.addr;
273     Section.Size        = Sect.size;
274     Section.Offset      = Sect.offset;
275     Section.Alignment   = Sect.align;
276     Section.RelocationTableOffset = Sect.reloff;
277     Section.NumRelocationTableEntries = Sect.nreloc;
278     Section.Flags       = Sect.flags;
279     Section.Reserved1   = Sect.reserved1;
280     Section.Reserved2   = Sect.reserved2;
281     return;
282   }
283   MachO::section_64 Sect = Obj->getSection64(Sec);
284   Section.Address     = Sect.addr;
285   Section.Size        = Sect.size;
286   Section.Offset      = Sect.offset;
287   Section.Alignment   = Sect.align;
288   Section.RelocationTableOffset = Sect.reloff;
289   Section.NumRelocationTableEntries = Sect.nreloc;
290   Section.Flags       = Sect.flags;
291   Section.Reserved1   = Sect.reserved1;
292   Section.Reserved2   = Sect.reserved2;
293 }
294 
295 
296 static void getSymbol(const MachOObjectFile *Obj,
297                       DataRefImpl DRI,
298                       MachOSymbol &Symbol) {
299   if (!Obj->is64Bit()) {
300     MachO::nlist Entry = Obj->getSymbolTableEntry(DRI);
301     Symbol.StringIndex  = Entry.n_strx;
302     Symbol.Type         = Entry.n_type;
303     Symbol.SectionIndex = Entry.n_sect;
304     Symbol.Flags        = Entry.n_desc;
305     Symbol.Value        = Entry.n_value;
306     return;
307   }
308   MachO::nlist_64 Entry = Obj->getSymbol64TableEntry(DRI);
309   Symbol.StringIndex  = Entry.n_strx;
310   Symbol.Type         = Entry.n_type;
311   Symbol.SectionIndex = Entry.n_sect;
312   Symbol.Flags        = Entry.n_desc;
313   Symbol.Value        = Entry.n_value;
314 }
315 
316 void MachODumper::printFileHeaders() {
317   DictScope H(W, "MachHeader");
318   if (!Obj->is64Bit()) {
319     printFileHeaders(Obj->getHeader());
320   } else {
321     printFileHeaders(Obj->getHeader64());
322     W.printHex("Reserved", Obj->getHeader64().reserved);
323   }
324 }
325 
326 template<class MachHeader>
327 void MachODumper::printFileHeaders(const MachHeader &Header) {
328   W.printEnum("Magic", Header.magic, makeArrayRef(MachOMagics));
329   W.printEnum("CpuType", Header.cputype, makeArrayRef(MachOHeaderCpuTypes));
330   uint32_t subtype = Header.cpusubtype & ~MachO::CPU_SUBTYPE_MASK;
331   switch (Header.cputype) {
332   case MachO::CPU_TYPE_X86:
333     W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesX86));
334     break;
335   case MachO::CPU_TYPE_X86_64:
336     W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesX64));
337     break;
338   case MachO::CPU_TYPE_ARM:
339     W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesARM));
340     break;
341   case MachO::CPU_TYPE_POWERPC:
342     W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesPPC));
343     break;
344   case MachO::CPU_TYPE_SPARC:
345     W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesSPARC));
346     break;
347   case MachO::CPU_TYPE_ARM64:
348     W.printEnum("CpuSubType", subtype, makeArrayRef(MachOHeaderCpuSubtypesARM64));
349     break;
350   case MachO::CPU_TYPE_POWERPC64:
351   default:
352     W.printHex("CpuSubtype", subtype);
353   }
354   W.printEnum("FileType", Header.filetype, makeArrayRef(MachOHeaderFileTypes));
355   W.printNumber("NumOfLoadCommands", Header.ncmds);
356   W.printNumber("SizeOfLoadCommands", Header.sizeofcmds);
357   W.printFlags("Flags", Header.flags, makeArrayRef(MachOHeaderFlags));
358 }
359 
360 void MachODumper::printSections() {
361   return printSections(Obj);
362 }
363 
364 void MachODumper::printSections(const MachOObjectFile *Obj) {
365   ListScope Group(W, "Sections");
366 
367   int SectionIndex = -1;
368   for (const SectionRef &Section : Obj->sections()) {
369     ++SectionIndex;
370 
371     MachOSection MOSection;
372     getSection(Obj, Section.getRawDataRefImpl(), MOSection);
373     DataRefImpl DR = Section.getRawDataRefImpl();
374 
375     StringRef Name;
376     if (error(Section.getName(Name)))
377       Name = "";
378 
379     ArrayRef<char> RawName = Obj->getSectionRawName(DR);
380     StringRef SegmentName = Obj->getSectionFinalSegmentName(DR);
381     ArrayRef<char> RawSegmentName = Obj->getSectionRawFinalSegmentName(DR);
382 
383     DictScope SectionD(W, "Section");
384     W.printNumber("Index", SectionIndex);
385     W.printBinary("Name", Name, RawName);
386     W.printBinary("Segment", SegmentName, RawSegmentName);
387     W.printHex("Address", MOSection.Address);
388     W.printHex("Size", MOSection.Size);
389     W.printNumber("Offset", MOSection.Offset);
390     W.printNumber("Alignment", MOSection.Alignment);
391     W.printHex("RelocationOffset", MOSection.RelocationTableOffset);
392     W.printNumber("RelocationCount", MOSection.NumRelocationTableEntries);
393     W.printEnum("Type", MOSection.Flags & 0xFF,
394                 makeArrayRef(MachOSectionAttributes));
395     W.printFlags("Attributes", MOSection.Flags >> 8,
396                  makeArrayRef(MachOSectionAttributes));
397     W.printHex("Reserved1", MOSection.Reserved1);
398     W.printHex("Reserved2", MOSection.Reserved2);
399 
400     if (opts::SectionRelocations) {
401       ListScope D(W, "Relocations");
402       for (const RelocationRef &Reloc : Section.relocations())
403         printRelocation(Reloc);
404     }
405 
406     if (opts::SectionSymbols) {
407       ListScope D(W, "Symbols");
408       for (const SymbolRef &Symbol : Obj->symbols()) {
409         if (!Section.containsSymbol(Symbol))
410           continue;
411 
412         printSymbol(Symbol);
413       }
414     }
415 
416     if (opts::SectionData) {
417       bool IsBSS = Section.isBSS();
418       if (!IsBSS) {
419         StringRef Data;
420         if (error(Section.getContents(Data)))
421           break;
422 
423         W.printBinaryBlock("SectionData", Data);
424       }
425     }
426   }
427 }
428 
429 void MachODumper::printRelocations() {
430   ListScope D(W, "Relocations");
431 
432   std::error_code EC;
433   for (const SectionRef &Section : Obj->sections()) {
434     StringRef Name;
435     if (error(Section.getName(Name)))
436       continue;
437 
438     bool PrintedGroup = false;
439     for (const RelocationRef &Reloc : Section.relocations()) {
440       if (!PrintedGroup) {
441         W.startLine() << "Section " << Name << " {\n";
442         W.indent();
443         PrintedGroup = true;
444       }
445 
446       printRelocation(Reloc);
447     }
448 
449     if (PrintedGroup) {
450       W.unindent();
451       W.startLine() << "}\n";
452     }
453   }
454 }
455 
456 void MachODumper::printRelocation(const RelocationRef &Reloc) {
457   return printRelocation(Obj, Reloc);
458 }
459 
460 void MachODumper::printRelocation(const MachOObjectFile *Obj,
461                                   const RelocationRef &Reloc) {
462   uint64_t Offset;
463   SmallString<32> RelocName;
464   if (error(Reloc.getOffset(Offset)))
465     return;
466   if (error(Reloc.getTypeName(RelocName)))
467     return;
468 
469   DataRefImpl DR = Reloc.getRawDataRefImpl();
470   MachO::any_relocation_info RE = Obj->getRelocation(DR);
471   bool IsScattered = Obj->isRelocationScattered(RE);
472   SmallString<32> SymbolNameOrOffset("0x");
473   if (IsScattered) {
474     // Scattered relocations don't really have an associated symbol
475     // for some reason, even if one exists in the symtab at the correct address.
476     SymbolNameOrOffset += utohexstr(Obj->getScatteredRelocationValue(RE));
477   } else {
478     symbol_iterator Symbol = Reloc.getSymbol();
479     if (Symbol != Obj->symbol_end()) {
480       StringRef SymbolName;
481       if (error(Symbol->getName(SymbolName)))
482         return;
483       SymbolNameOrOffset = SymbolName;
484     } else
485       SymbolNameOrOffset += utohexstr(Obj->getPlainRelocationSymbolNum(RE));
486   }
487 
488   if (opts::ExpandRelocs) {
489     DictScope Group(W, "Relocation");
490     W.printHex("Offset", Offset);
491     W.printNumber("PCRel", Obj->getAnyRelocationPCRel(RE));
492     W.printNumber("Length", Obj->getAnyRelocationLength(RE));
493     if (IsScattered)
494       W.printString("Extern", StringRef("N/A"));
495     else
496       W.printNumber("Extern", Obj->getPlainRelocationExternal(RE));
497     W.printNumber("Type", RelocName, Obj->getAnyRelocationType(RE));
498     W.printString("Symbol", SymbolNameOrOffset);
499     W.printNumber("Scattered", IsScattered);
500   } else {
501     raw_ostream& OS = W.startLine();
502     OS << W.hex(Offset)
503        << " " << Obj->getAnyRelocationPCRel(RE)
504        << " " << Obj->getAnyRelocationLength(RE);
505     if (IsScattered)
506       OS << " n/a";
507     else
508       OS << " " << Obj->getPlainRelocationExternal(RE);
509     OS << " " << RelocName
510        << " " << IsScattered
511        << " " << SymbolNameOrOffset
512        << "\n";
513   }
514 }
515 
516 void MachODumper::printSymbols() {
517   ListScope Group(W, "Symbols");
518 
519   for (const SymbolRef &Symbol : Obj->symbols()) {
520     printSymbol(Symbol);
521   }
522 }
523 
524 void MachODumper::printDynamicSymbols() {
525   ListScope Group(W, "DynamicSymbols");
526 }
527 
528 void MachODumper::printSymbol(const SymbolRef &Symbol) {
529   StringRef SymbolName;
530   if (Symbol.getName(SymbolName))
531     SymbolName = "";
532 
533   MachOSymbol MOSymbol;
534   getSymbol(Obj, Symbol.getRawDataRefImpl(), MOSymbol);
535 
536   StringRef SectionName = "";
537   section_iterator SecI(Obj->section_begin());
538   if (!error(Symbol.getSection(SecI)) && SecI != Obj->section_end())
539     error(SecI->getName(SectionName));
540 
541   DictScope D(W, "Symbol");
542   W.printNumber("Name", SymbolName, MOSymbol.StringIndex);
543   if (MOSymbol.Type & MachO::N_STAB) {
544     W.printHex("Type", "SymDebugTable", MOSymbol.Type);
545   } else {
546     if (MOSymbol.Type & MachO::N_PEXT)
547       W.startLine() << "PrivateExtern\n";
548     if (MOSymbol.Type & MachO::N_EXT)
549       W.startLine() << "Extern\n";
550     W.printEnum("Type", uint8_t(MOSymbol.Type & MachO::N_TYPE),
551                 makeArrayRef(MachOSymbolTypes));
552   }
553   W.printHex("Section", SectionName, MOSymbol.SectionIndex);
554   W.printEnum("RefType", static_cast<uint16_t>(MOSymbol.Flags & 0xF),
555               makeArrayRef(MachOSymbolRefTypes));
556   W.printFlags("Flags", static_cast<uint16_t>(MOSymbol.Flags & ~0xF),
557                makeArrayRef(MachOSymbolFlags));
558   W.printHex("Value", MOSymbol.Value);
559 }
560 
561 void MachODumper::printUnwindInfo() {
562   W.startLine() << "UnwindInfo not implemented.\n";
563 }
564