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 §ion) { 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