1// Copyright (c) 2010, Google Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8//     * Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10//     * Redistributions in binary form must reproduce the above
11// copyright notice, this list of conditions and the following disclaimer
12// in the documentation and/or other materials provided with the
13// distribution.
14//     * Neither the name of Google Inc. nor the names of its
15// contributors may be used to endorse or promote products derived from
16// this software without specific prior written permission.
17//
18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
31
32// macho_dump.cc: Dump the contents of a Mach-O file. This is mostly
33// a test program for the Mach_O::FatReader and Mach_O::Reader classes.
34
35#include <errno.h>
36#include <fcntl.h>
37#include <libgen.h>
38#include <mach-o/arch.h>
39#include <sys/mman.h>
40#include <stdint.h>
41#include <string.h>
42#include <sys/stat.h>
43#include <unistd.h>
44
45#include <sstream>
46#include <string>
47#include <vector>
48
49#include "common/byte_cursor.h"
50#include "common/mac/arch_utilities.h"
51#include "common/mac/macho_reader.h"
52
53using google_breakpad::ByteBuffer;
54using std::ostringstream;
55using std::string;
56using std::vector;
57
58namespace {
59namespace mach_o = google_breakpad::mach_o;
60
61string program_name;
62
63int check_syscall(int result, const char *operation, const char *filename) {
64  if (result < 0) {
65    fprintf(stderr, "%s: %s '%s': %s\n",
66            program_name.c_str(), operation,
67            filename, strerror(errno));
68    exit(1);
69  }
70  return result;
71}
72
73class DumpSection: public mach_o::Reader::SectionHandler {
74 public:
75  DumpSection() : index_(0) { }
76  bool HandleSection(const mach_o::Section &section) {
77    printf("        section %d '%s' in segment '%s'\n"
78           "          address: 0x%llx\n"
79           "          alignment: 1 << %d B\n"
80           "          flags: %d\n"
81           "          size: %ld\n",
82           index_++, section.section_name.c_str(), section.segment_name.c_str(),
83           section.address, section.align,
84           mach_o::SectionFlags(section.flags),
85           section.contents.Size());
86    return true;
87  }
88
89 private:
90  int index_;
91};
92
93class DumpCommand: public mach_o::Reader::LoadCommandHandler {
94 public:
95  DumpCommand(mach_o::Reader *reader) : reader_(reader), index_(0) { }
96  bool UnknownCommand(mach_o::LoadCommandType type,
97                      const ByteBuffer &contents) {
98    printf("      load command %d: %d", index_++, type);
99    return true;
100  }
101  bool SegmentCommand(const mach_o::Segment &segment) {
102    printf("      load command %d: %s-bit segment '%s'\n"
103           "        address: 0x%llx\n"
104           "        memory size: 0x%llx\n"
105           "        maximum protection: 0x%x\n"
106           "        initial protection: 0x%x\n"
107           "        flags: %d\n"
108           "        section_list size: %ld B\n",
109           index_++, (segment.bits_64 ? "64" : "32"), segment.name.c_str(),
110           segment.vmaddr, segment.vmsize, segment.maxprot,
111           segment.initprot, mach_o::SegmentFlags(segment.flags),
112           segment.section_list.Size());
113
114    DumpSection dump_section;
115    return reader_->WalkSegmentSections(segment, &dump_section);
116  }
117 private:
118  mach_o::Reader *reader_;
119  int index_;
120};
121
122void DumpFile(const char *filename) {
123  int fd = check_syscall(open(filename, O_RDONLY), "opening", filename);
124  struct stat attributes;
125  check_syscall(fstat(fd, &attributes),
126                "getting file attributes for", filename);
127  void *mapping = mmap(NULL, attributes.st_size, PROT_READ,
128                       MAP_PRIVATE, fd, 0);
129  close(fd);
130  check_syscall(mapping == (void *)-1 ? -1 : 0,
131                "mapping contents of", filename);
132
133  mach_o::FatReader::Reporter fat_reporter(filename);
134  mach_o::FatReader fat_reader(&fat_reporter);
135  if (!fat_reader.Read(reinterpret_cast<uint8_t *>(mapping),
136                       attributes.st_size)) {
137    exit(1);
138  }
139  printf("filename: %s\n", filename);
140  size_t object_files_size;
141  const struct fat_arch *object_files
142    = fat_reader.object_files(&object_files_size);
143  printf("  object file count: %ld\n", object_files_size);
144  for (size_t i = 0; i < object_files_size; i++) {
145    const struct fat_arch &file = object_files[i];
146    const NXArchInfo *fat_arch_info =
147        google_breakpad::BreakpadGetArchInfoFromCpuType(
148            file.cputype, file.cpusubtype);
149    printf("\n  object file %ld:\n"
150           "    fat header:\n:"
151           "      CPU type: %s (%s)\n"
152           "      size: %d B\n"
153           "      alignment: 1<<%d B\n",
154           i, fat_arch_info->name, fat_arch_info->description,
155           file.size, file.align);
156
157    ostringstream name;
158    name << filename;
159    if (object_files_size > 1)
160      name << ", object file #" << i;
161    ByteBuffer file_contents(reinterpret_cast<uint8_t *>(mapping)
162                             + file.offset, file.size);
163    mach_o::Reader::Reporter reporter(name.str());
164    mach_o::Reader reader(&reporter);
165    if (!reader.Read(file_contents, file.cputype, file.cpusubtype)) {
166      exit(1);
167    }
168
169    const NXArchInfo *macho_arch_info =
170      NXGetArchInfoFromCpuType(reader.cpu_type(),
171                               reader.cpu_subtype());
172    printf("    Mach-O header:\n"
173           "      word size: %s\n"
174           "      CPU type: %s (%s)\n"
175           "      File type: %d\n"
176           "      flags: %x\n",
177           (reader.bits_64() ? "64 bits" : "32 bits"),
178           macho_arch_info->name, macho_arch_info->description,
179           reader.file_type(), reader.flags());
180
181    DumpCommand dump_command(&reader);
182    reader.WalkLoadCommands(&dump_command);
183  }
184  munmap(mapping, attributes.st_size);
185}
186
187}  // namespace
188
189int main(int argc, char **argv) {
190  program_name = basename(argv[0]);
191  if (argc == 1) {
192    fprintf(stderr, "Usage: %s FILE ...\n"
193            "Dump the contents of the Mach-O or fat binary files "
194            "'FILE ...'.\n", program_name.c_str());
195  }
196  for (int i = 1; i < argc; i++) {
197    DumpFile(argv[i]);
198  }
199}
200