tools/macho-dump/macho-dump.cpp

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