1//===-- macho-dump.cpp - Mach Object Dumping Tool -------------------------===//
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 is a testing tool for use with the MC/Mach-O LLVM components.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/Object/MachO.h"
15#include "llvm/ADT/StringExtras.h"
16#include "llvm/ADT/Twine.h"
17#include "llvm/Support/Casting.h"
18#include "llvm/Support/CommandLine.h"
19#include "llvm/Support/Format.h"
20#include "llvm/Support/ManagedStatic.h"
21#include "llvm/Support/MemoryBuffer.h"
22#include "llvm/Support/raw_ostream.h"
23#include <system_error>
24using namespace llvm;
25using namespace llvm::object;
26
27static cl::opt<std::string>
28InputFile(cl::Positional, cl::desc("<input file>"), cl::init("-"));
29
30static cl::opt<bool>
31ShowSectionData("dump-section-data", cl::desc("Dump the contents of sections"),
32                cl::init(false));
33
34///
35
36static const char *ProgramName;
37
38static void Message(const char *Type, const Twine &Msg) {
39  errs() << ProgramName << ": " << Type << ": " << Msg << "\n";
40}
41
42static int Error(const Twine &Msg) {
43  Message("error", Msg);
44  return 1;
45}
46
47static void Warning(const Twine &Msg) {
48  Message("warning", Msg);
49}
50
51///
52
53static void DumpSegmentCommandData(StringRef Name,
54                                   uint64_t VMAddr, uint64_t VMSize,
55                                   uint64_t FileOffset, uint64_t FileSize,
56                                   uint32_t MaxProt, uint32_t InitProt,
57                                   uint32_t NumSections, uint32_t Flags) {
58  outs() << "  ('segment_name', '";
59  outs().write_escaped(Name, /*UseHexEscapes=*/true) << "')\n";
60  outs() << "  ('vm_addr', " << VMAddr << ")\n";
61  outs() << "  ('vm_size', " << VMSize << ")\n";
62  outs() << "  ('file_offset', " << FileOffset << ")\n";
63  outs() << "  ('file_size', " << FileSize << ")\n";
64  outs() << "  ('maxprot', " << MaxProt << ")\n";
65  outs() << "  ('initprot', " << InitProt << ")\n";
66  outs() << "  ('num_sections', " << NumSections << ")\n";
67  outs() << "  ('flags', " << Flags << ")\n";
68}
69
70static int DumpSectionData(const MachOObjectFile &Obj, unsigned Index,
71                           StringRef Name,
72                           StringRef SegmentName, uint64_t Address,
73                           uint64_t Size, uint32_t Offset,
74                           uint32_t Align, uint32_t RelocationTableOffset,
75                           uint32_t NumRelocationTableEntries,
76                           uint32_t Flags, uint32_t Reserved1,
77                           uint32_t Reserved2, uint64_t Reserved3 = ~0ULL) {
78  outs() << "    # Section " << Index << "\n";
79  outs() << "   (('section_name', '";
80  outs().write_escaped(Name, /*UseHexEscapes=*/true) << "')\n";
81  outs() << "    ('segment_name', '";
82  outs().write_escaped(SegmentName, /*UseHexEscapes=*/true) << "')\n";
83  outs() << "    ('address', " << Address << ")\n";
84  outs() << "    ('size', " << Size << ")\n";
85  outs() << "    ('offset', " << Offset << ")\n";
86  outs() << "    ('alignment', " << Align << ")\n";
87  outs() << "    ('reloc_offset', " << RelocationTableOffset << ")\n";
88  outs() << "    ('num_reloc', " << NumRelocationTableEntries << ")\n";
89  outs() << "    ('flags', " << format("0x%x", Flags) << ")\n";
90  outs() << "    ('reserved1', " << Reserved1 << ")\n";
91  outs() << "    ('reserved2', " << Reserved2 << ")\n";
92  if (Reserved3 != ~0ULL)
93    outs() << "    ('reserved3', " << Reserved3 << ")\n";
94  outs() << "   ),\n";
95
96  // Dump the relocation entries.
97  outs() << "  ('_relocations', [\n";
98  unsigned RelNum = 0;
99  for (relocation_iterator I = Obj.section_rel_begin(Index),
100                           E = Obj.section_rel_end(Index);
101       I != E; ++I, ++RelNum) {
102    MachO::any_relocation_info RE = Obj.getRelocation(I->getRawDataRefImpl());
103    outs() << "    # Relocation " << RelNum << "\n";
104    outs() << "    (('word-0', " << format("0x%x", RE.r_word0) << "),\n";
105    outs() << "     ('word-1', " << format("0x%x", RE.r_word1) << ")),\n";
106  }
107  outs() << "  ])\n";
108
109  // Dump the section data, if requested.
110  if (ShowSectionData) {
111    outs() << "  ('_section_data', '";
112    StringRef Data = Obj.getData().substr(Offset, Size);
113    for (unsigned i = 0; i != Data.size(); ++i) {
114      if (i && (i % 4) == 0)
115        outs() << ' ';
116      outs() << hexdigit((Data[i] >> 4) & 0xF, /*LowerCase=*/true);
117      outs() << hexdigit((Data[i] >> 0) & 0xF, /*LowerCase=*/true);
118    }
119    outs() << "')\n";
120  }
121
122  return 0;
123}
124
125static int DumpSegmentCommand(const MachOObjectFile &Obj,
126                              const MachOObjectFile::LoadCommandInfo &LCI) {
127  MachO::segment_command SLC = Obj.getSegmentLoadCommand(LCI);
128
129  DumpSegmentCommandData(StringRef(SLC.segname, 16), SLC.vmaddr,
130                         SLC.vmsize, SLC.fileoff, SLC.filesize,
131                         SLC.maxprot, SLC.initprot, SLC.nsects, SLC.flags);
132
133  // Dump the sections.
134  outs() << "  ('sections', [\n";
135  for (unsigned i = 0; i != SLC.nsects; ++i) {
136    MachO::section Sect = Obj.getSection(LCI, i);
137    DumpSectionData(Obj, i, StringRef(Sect.sectname, 16),
138                    StringRef(Sect.segname, 16), Sect.addr,
139                    Sect.size, Sect.offset, Sect.align,
140                    Sect.reloff, Sect.nreloc, Sect.flags,
141                    Sect.reserved1, Sect.reserved2);
142  }
143  outs() << "  ])\n";
144
145  return 0;
146}
147
148static int DumpSegment64Command(const MachOObjectFile &Obj,
149                                const MachOObjectFile::LoadCommandInfo &LCI) {
150  MachO::segment_command_64 SLC = Obj.getSegment64LoadCommand(LCI);
151  DumpSegmentCommandData(StringRef(SLC.segname, 16), SLC.vmaddr,
152                         SLC.vmsize, SLC.fileoff, SLC.filesize,
153                         SLC.maxprot, SLC.initprot, SLC.nsects, SLC.flags);
154
155  // Dump the sections.
156  outs() << "  ('sections', [\n";
157  for (unsigned i = 0; i != SLC.nsects; ++i) {
158    MachO::section_64 Sect = Obj.getSection64(LCI, i);
159
160    DumpSectionData(Obj, i, StringRef(Sect.sectname, 16),
161                    StringRef(Sect.segname, 16), Sect.addr,
162                    Sect.size, Sect.offset, Sect.align,
163                    Sect.reloff, Sect.nreloc, Sect.flags,
164                    Sect.reserved1, Sect.reserved2,
165                    Sect.reserved3);
166  }
167  outs() << "  ])\n";
168
169  return 0;
170}
171
172static void DumpSymbolTableEntryData(const MachOObjectFile &Obj,
173                                     unsigned Index, uint32_t StringIndex,
174                                     uint8_t Type, uint8_t SectionIndex,
175                                     uint16_t Flags, uint64_t Value,
176                                     StringRef StringTable) {
177  const char *Name = &StringTable.data()[StringIndex];
178  outs() << "    # Symbol " << Index << "\n";
179  outs() << "   (('n_strx', " << StringIndex << ")\n";
180  outs() << "    ('n_type', " << format("0x%x", Type) << ")\n";
181  outs() << "    ('n_sect', " << uint32_t(SectionIndex) << ")\n";
182  outs() << "    ('n_desc', " << Flags << ")\n";
183  outs() << "    ('n_value', " << Value << ")\n";
184  outs() << "    ('_string', '" << Name << "')\n";
185  outs() << "   ),\n";
186}
187
188static int DumpSymtabCommand(const MachOObjectFile &Obj) {
189  MachO::symtab_command SLC = Obj.getSymtabLoadCommand();
190
191  outs() << "  ('symoff', " << SLC.symoff << ")\n";
192  outs() << "  ('nsyms', " << SLC.nsyms << ")\n";
193  outs() << "  ('stroff', " << SLC.stroff << ")\n";
194  outs() << "  ('strsize', " << SLC.strsize << ")\n";
195
196  // Dump the string data.
197  outs() << "  ('_string_data', '";
198  StringRef StringTable = Obj.getStringTableData();
199  outs().write_escaped(StringTable,
200                       /*UseHexEscapes=*/true) << "')\n";
201
202  // Dump the symbol table.
203  outs() << "  ('_symbols', [\n";
204  unsigned SymNum = 0;
205  for (const SymbolRef &Symbol : Obj.symbols()) {
206    DataRefImpl DRI = Symbol.getRawDataRefImpl();
207    if (Obj.is64Bit()) {
208      MachO::nlist_64 STE = Obj.getSymbol64TableEntry(DRI);
209      DumpSymbolTableEntryData(Obj, SymNum, STE.n_strx, STE.n_type,
210                               STE.n_sect, STE.n_desc, STE.n_value,
211                               StringTable);
212    } else {
213      MachO::nlist STE = Obj.getSymbolTableEntry(DRI);
214      DumpSymbolTableEntryData(Obj, SymNum, STE.n_strx, STE.n_type,
215                               STE.n_sect, STE.n_desc, STE.n_value,
216                               StringTable);
217    }
218    SymNum++;
219  }
220  outs() << "  ])\n";
221
222  return 0;
223}
224
225static int DumpDysymtabCommand(const MachOObjectFile &Obj) {
226  MachO::dysymtab_command DLC = Obj.getDysymtabLoadCommand();
227
228  outs() << "  ('ilocalsym', " << DLC.ilocalsym << ")\n";
229  outs() << "  ('nlocalsym', " << DLC.nlocalsym << ")\n";
230  outs() << "  ('iextdefsym', " << DLC.iextdefsym << ")\n";
231  outs() << "  ('nextdefsym', " << DLC.nextdefsym << ")\n";
232  outs() << "  ('iundefsym', " << DLC.iundefsym << ")\n";
233  outs() << "  ('nundefsym', " << DLC.nundefsym << ")\n";
234  outs() << "  ('tocoff', " << DLC.tocoff << ")\n";
235  outs() << "  ('ntoc', " << DLC.ntoc << ")\n";
236  outs() << "  ('modtaboff', " << DLC.modtaboff << ")\n";
237  outs() << "  ('nmodtab', " << DLC.nmodtab << ")\n";
238  outs() << "  ('extrefsymoff', " << DLC.extrefsymoff << ")\n";
239  outs() << "  ('nextrefsyms', " << DLC.nextrefsyms << ")\n";
240  outs() << "  ('indirectsymoff', " << DLC.indirectsymoff << ")\n";
241  outs() << "  ('nindirectsyms', " << DLC.nindirectsyms << ")\n";
242  outs() << "  ('extreloff', " << DLC.extreloff << ")\n";
243  outs() << "  ('nextrel', " << DLC.nextrel << ")\n";
244  outs() << "  ('locreloff', " << DLC.locreloff << ")\n";
245  outs() << "  ('nlocrel', " << DLC.nlocrel << ")\n";
246
247  // Dump the indirect symbol table.
248  outs() << "  ('_indirect_symbols', [\n";
249  for (unsigned i = 0; i != DLC.nindirectsyms; ++i) {
250    uint32_t ISTE = Obj.getIndirectSymbolTableEntry(DLC, i);
251    outs() << "    # Indirect Symbol " << i << "\n";
252    outs() << "    (('symbol_index', " << format("0x%x", ISTE) << "),),\n";
253  }
254  outs() << "  ])\n";
255
256  return 0;
257}
258
259static int
260DumpLinkeditDataCommand(const MachOObjectFile &Obj,
261                        const MachOObjectFile::LoadCommandInfo &LCI) {
262  MachO::linkedit_data_command LLC = Obj.getLinkeditDataLoadCommand(LCI);
263  outs() << "  ('dataoff', " << LLC.dataoff << ")\n"
264         << "  ('datasize', " << LLC.datasize << ")\n"
265         << "  ('_addresses', [\n";
266
267  SmallVector<uint64_t, 8> Addresses;
268  Obj.ReadULEB128s(LLC.dataoff, Addresses);
269  for (unsigned i = 0, e = Addresses.size(); i != e; ++i)
270    outs() << "    # Address " << i << '\n'
271           << "    ('address', " << format("0x%x", Addresses[i]) << "),\n";
272
273  outs() << "  ])\n";
274
275  return 0;
276}
277
278static int
279DumpDataInCodeDataCommand(const MachOObjectFile &Obj,
280                          const MachOObjectFile::LoadCommandInfo &LCI) {
281  MachO::linkedit_data_command LLC = Obj.getLinkeditDataLoadCommand(LCI);
282  outs() << "  ('dataoff', " << LLC.dataoff << ")\n"
283         << "  ('datasize', " << LLC.datasize << ")\n"
284         << "  ('_data_regions', [\n";
285
286  unsigned NumRegions = LLC.datasize / sizeof(MachO::data_in_code_entry);
287  for (unsigned i = 0; i < NumRegions; ++i) {
288    MachO::data_in_code_entry DICE= Obj.getDataInCodeTableEntry(LLC.dataoff, i);
289    outs() << "    # DICE " << i << "\n"
290           << "    ('offset', " << DICE.offset << ")\n"
291           << "    ('length', " << DICE.length << ")\n"
292           << "    ('kind', " << DICE.kind << ")\n";
293  }
294
295  outs() <<"  ])\n";
296
297  return 0;
298}
299
300static int
301DumpLinkerOptionsCommand(const MachOObjectFile &Obj,
302                         const MachOObjectFile::LoadCommandInfo &LCI) {
303  MachO::linker_options_command LOLC = Obj.getLinkerOptionsLoadCommand(LCI);
304  outs() << "  ('count', " << LOLC.count << ")\n"
305         << "  ('_strings', [\n";
306
307  uint64_t DataSize = LOLC.cmdsize - sizeof(MachO::linker_options_command);
308  const char *P = LCI.Ptr + sizeof(MachO::linker_options_command);
309  StringRef Data(P, DataSize);
310  for (unsigned i = 0; i != LOLC.count; ++i) {
311    std::pair<StringRef,StringRef> Split = Data.split('\0');
312    outs() << "\t\"";
313    outs().write_escaped(Split.first);
314    outs() << "\",\n";
315    Data = Split.second;
316  }
317  outs() <<"  ])\n";
318
319  return 0;
320}
321
322static int
323DumpVersionMin(const MachOObjectFile &Obj,
324               const MachOObjectFile::LoadCommandInfo &LCI) {
325  MachO::version_min_command VMLC = Obj.getVersionMinLoadCommand(LCI);
326  outs() << "  ('version, " << VMLC.version << ")\n"
327         << "  ('reserved, " << VMLC.reserved << ")\n";
328  return 0;
329}
330
331static int
332DumpDylibID(const MachOObjectFile &Obj,
333            const MachOObjectFile::LoadCommandInfo &LCI) {
334  MachO::dylib_command DLLC = Obj.getDylibIDLoadCommand(LCI);
335  outs() << "  ('install_name', '" << LCI.Ptr + DLLC.dylib.name << "')\n"
336         << "  ('timestamp, " << DLLC.dylib.timestamp << ")\n"
337         << "  ('cur_version, " << DLLC.dylib.current_version << ")\n"
338         << "  ('compat_version, " << DLLC.dylib.compatibility_version << ")\n";
339  return 0;
340}
341
342static int DumpLoadCommand(const MachOObjectFile &Obj,
343                           MachOObjectFile::LoadCommandInfo &LCI) {
344  switch (LCI.C.cmd) {
345  case MachO::LC_SEGMENT:
346    return DumpSegmentCommand(Obj, LCI);
347  case MachO::LC_SEGMENT_64:
348    return DumpSegment64Command(Obj, LCI);
349  case MachO::LC_SYMTAB:
350    return DumpSymtabCommand(Obj);
351  case MachO::LC_DYSYMTAB:
352    return DumpDysymtabCommand(Obj);
353  case MachO::LC_CODE_SIGNATURE:
354  case MachO::LC_SEGMENT_SPLIT_INFO:
355  case MachO::LC_FUNCTION_STARTS:
356    return DumpLinkeditDataCommand(Obj, LCI);
357  case MachO::LC_DATA_IN_CODE:
358    return DumpDataInCodeDataCommand(Obj, LCI);
359  case MachO::LC_LINKER_OPTIONS:
360    return DumpLinkerOptionsCommand(Obj, LCI);
361  case MachO::LC_VERSION_MIN_IPHONEOS:
362  case MachO::LC_VERSION_MIN_MACOSX:
363    return DumpVersionMin(Obj, LCI);
364  case MachO::LC_ID_DYLIB:
365    return DumpDylibID(Obj, LCI);
366  default:
367    Warning("unknown load command: " + Twine(LCI.C.cmd));
368    return 0;
369  }
370}
371
372
373static int DumpLoadCommand(const MachOObjectFile &Obj, unsigned Index,
374                           MachOObjectFile::LoadCommandInfo &LCI) {
375  outs() << "  # Load Command " << Index << "\n"
376         << " (('command', " << LCI.C.cmd << ")\n"
377         << "  ('size', " << LCI.C.cmdsize << ")\n";
378  int Res = DumpLoadCommand(Obj, LCI);
379  outs() << " ),\n";
380  return Res;
381}
382
383static void printHeader(const MachOObjectFile *Obj,
384                        const MachO::mach_header &Header) {
385  outs() << "('cputype', " << Header.cputype << ")\n";
386  outs() << "('cpusubtype', " << Header.cpusubtype << ")\n";
387  outs() << "('filetype', " << Header.filetype << ")\n";
388  outs() << "('num_load_commands', " << Header.ncmds << ")\n";
389  outs() << "('load_commands_size', " << Header.sizeofcmds << ")\n";
390  outs() << "('flag', " << Header.flags << ")\n";
391
392  // Print extended header if 64-bit.
393  if (Obj->is64Bit()) {
394    const MachO::mach_header_64 *Header64 =
395      reinterpret_cast<const MachO::mach_header_64 *>(&Header);
396    outs() << "('reserved', " << Header64->reserved << ")\n";
397  }
398}
399
400int main(int argc, char **argv) {
401  ProgramName = argv[0];
402  llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
403
404  cl::ParseCommandLineOptions(argc, argv, "llvm Mach-O dumping tool\n");
405
406  ErrorOr<Binary *> BinaryOrErr = createBinary(InputFile);
407  if (std::error_code EC = BinaryOrErr.getError())
408    return Error("unable to read input: '" + EC.message() + "'");
409  std::unique_ptr<Binary> Binary(BinaryOrErr.get());
410
411  const MachOObjectFile *InputObject = dyn_cast<MachOObjectFile>(Binary.get());
412  if (!InputObject)
413    return Error("Not a MachO object");
414
415  // Print the header
416  MachO::mach_header_64 Header64;
417  MachO::mach_header *Header = reinterpret_cast<MachO::mach_header*>(&Header64);
418  if (InputObject->is64Bit())
419    Header64 = InputObject->getHeader64();
420  else
421    *Header = InputObject->getHeader();
422  printHeader(InputObject, *Header);
423
424  // Print the load commands.
425  int Res = 0;
426  MachOObjectFile::LoadCommandInfo Command =
427    InputObject->getFirstLoadCommandInfo();
428  outs() << "('load_commands', [\n";
429  for (unsigned i = 0; ; ++i) {
430    if (DumpLoadCommand(*InputObject, i, Command))
431      break;
432
433    if (i == Header->ncmds - 1)
434      break;
435    Command = InputObject->getNextLoadCommandInfo(Command);
436  }
437  outs() << "])\n";
438
439  return Res;
440}
441