Home | History | Annotate | Download | only in macho-dump 
      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 
     27 static cl::opt<std::string>
     28 InputFile(cl::Positional, cl::desc("<input file>"), cl::init("-"));
     29 
     30 static cl::opt<bool>
     31 ShowSectionData("dump-section-data", cl::desc("Dump the contents of sections"),
     32                 cl::init(false));
     33 
     34 ///
     35 
     36 static const char *ProgramName;
     37 
     38 static void Message(const char *Type, const Twine &Msg) {
     39   errs() << ProgramName << ": " << Type << ": " << Msg << "\n";
     40 }
     41 
     42 static int Error(const Twine &Msg) {
     43   Message("error", Msg);
     44   return 1;
     45 }
     46 
     47 static void Warning(const Twine &Msg) {
     48   Message("warning", Msg);
     49 }
     50 
     51 ///
     52 
     53 static 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 
     70 static 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 
    125 static 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 
    148 static 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 
    172 static 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 
    188 static 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 
    225 static 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 
    259 static int
    260 DumpLinkeditDataCommand(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 
    278 static int
    279 DumpDataInCodeDataCommand(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 
    300 static int
    301 DumpLinkerOptionsCommand(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 
    322 static int
    323 DumpVersionMin(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 
    331 static int
    332 DumpDylibID(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 
    342 static 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 
    373 static 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 
    383 static 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 
    400 int 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