| // Copyright 2013 The Goma Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| |
| #include "mach_o_parser.h" |
| |
| #include <sys/mman.h> |
| |
| // expect followings would be executed in Mac OS X, or provide headers. |
| #include <mach-o/fat.h> |
| #include <mach-o/loader.h> |
| |
| #include <glog/logging.h> |
| |
| #include "scoped_fd.h" |
| |
| namespace { |
| |
| static void SwapFatArchByteOrder(fat_arch* arch) { |
| arch->cputype = OSSwapInt32(arch->cputype); |
| arch->cpusubtype = OSSwapInt32(arch->cpusubtype); |
| arch->offset = OSSwapInt32(arch->offset); |
| arch->size = OSSwapInt32(arch->size); |
| arch->align = OSSwapInt32(arch->align); |
| } |
| |
| static const string GetArchName(cpu_type_t type, cpu_subtype_t subtype) { |
| if (type == CPU_TYPE_I386 && subtype == CPU_SUBTYPE_I386_ALL) { |
| return "i386"; |
| } else if (type == CPU_TYPE_X86_64 && subtype == CPU_SUBTYPE_X86_64_ALL) { |
| return "x86_64"; |
| } else if (type == CPU_TYPE_POWERPC) { |
| return "powerpc"; |
| } else { |
| LOG(ERROR) << "unknown CPU type or subtype found:" |
| << " cpu_type=" << type |
| << " cpu_subtype=" << subtype; |
| return ""; |
| } |
| } |
| |
| bool GetFatArchs( |
| const devtools_goma::ScopedFd& fd, |
| std::vector<fat_arch>* archs, |
| string* raw) { |
| DCHECK(archs); |
| // Parse fat header. |
| if (fd.Seek(0, devtools_goma::ScopedFd::SeekAbsolute) |
| == static_cast<off_t>(-1)) { |
| PLOG(WARNING) << "seek 0: fd=" << fd; |
| return false; |
| } |
| |
| fat_header header; |
| if (fd.Read(&header, sizeof(header)) != sizeof(header)) { |
| PLOG(WARNING) << "read fat header:" << fd; |
| return false; |
| } |
| if (raw != nullptr) |
| raw->assign(reinterpret_cast<char*>(&header), sizeof(header)); |
| bool reversed; |
| if (header.magic == FAT_MAGIC) { |
| reversed = false; |
| } else if (header.magic == FAT_CIGAM) { |
| reversed = true; |
| } else { |
| // Since we may ask GetFatArch to read the file, it won't be error. |
| VLOG(1) << "not a FAT file magic: " |
| << " fd=" << fd |
| << " magic=" << std::hex << header.magic; |
| return false; |
| } |
| |
| // Parse fat arch. |
| if (reversed) { |
| header.nfat_arch = OSSwapInt32(header.nfat_arch); |
| } |
| for (uint32_t i = 0; i < header.nfat_arch; ++i) { |
| fat_arch arch; |
| if (fd.Read(&arch, sizeof(arch)) != sizeof(arch)) { |
| PLOG(WARNING) << "read fat arch:" |
| << " entry_id=" << i |
| << " fd=" << fd; |
| return false; |
| } |
| if (raw != nullptr) |
| raw->append(reinterpret_cast<char*>(&arch), sizeof(arch)); |
| if (reversed) { |
| SwapFatArchByteOrder(&arch); |
| } |
| archs->push_back(arch); |
| } |
| return true; |
| } |
| |
| } // namespace |
| |
| namespace devtools_goma { |
| |
| bool GetFatHeader(const ScopedFd& fd, MacFatHeader* fheader) { |
| std::vector<fat_arch> archs; |
| if (!GetFatArchs(fd, &archs, &fheader->raw)) |
| return false; |
| |
| for (std::vector<fat_arch>::iterator it = archs.begin(); |
| it != archs.end(); ++it) { |
| MacFatArch arch; |
| arch.arch_name = GetArchName(it->cputype, it->cpusubtype); |
| arch.offset = it->offset; |
| arch.size = it->size; |
| fheader->archs.push_back(arch); |
| VLOG(1) << "fat:" |
| << " arch=" << arch.arch_name |
| << " offset=" << arch.offset |
| << " size=" << arch.size; |
| } |
| |
| return true; |
| } |
| |
| MachO::MachO(const string& filename) |
| : filename_(filename) { |
| fd_.reset(ScopedFd::OpenForRead(filename)); |
| // TODO: support non-fat mach object if needed. |
| std::vector<fat_arch> archs; |
| if (!GetFatArchs(fd_, &archs, nullptr)) { |
| LOG(WARNING) << "Cannot read FAT header:" |
| << " filename=" << filename |
| << " fd=" << fd_; |
| } |
| for (std::vector<fat_arch>::iterator it = archs.begin(); |
| it != archs.end(); ++it) { |
| archs_.insert(make_pair( |
| GetArchName(it->cputype, it->cpusubtype), |
| *it)); |
| } |
| } |
| |
| MachO::~MachO() { |
| } |
| |
| bool MachO::GetDylibs(const string& cpu_type, std::vector<DylibEntry>* dylibs) { |
| std::map<string, fat_arch>::const_iterator found = archs_.find(cpu_type); |
| if (found == archs_.end()) { |
| LOG(WARNING) << "unknown cpu type: " << cpu_type; |
| return false; |
| } |
| |
| const size_t offset = found->second.offset; |
| const size_t len = found->second.size; |
| VLOG(1) << "mmap " |
| << " len=" << len |
| << " offset=" << offset; |
| char* mmapped = reinterpret_cast<char*>( |
| mmap(nullptr, len, PROT_READ, MAP_PRIVATE, fd_.fd(), offset)); |
| if (mmapped == MAP_FAILED) { |
| LOG(ERROR) << "mmap failed:" |
| << " filename=" << filename_ |
| << " fd=" << fd_.fd() |
| << " len=" << len |
| << " offset=" << offset; |
| return false; |
| } |
| const mach_header* header = reinterpret_cast<const mach_header*>(mmapped); |
| load_command* command; |
| if (header->magic == MH_MAGIC) { |
| command = reinterpret_cast<load_command*>(mmapped + sizeof(mach_header)); |
| } else if (header->magic == MH_MAGIC_64) { |
| command = reinterpret_cast<load_command*>(mmapped + sizeof(mach_header_64)); |
| } else { |
| // We might not see the different endian mach object. |
| if (header->magic == MH_CIGAM || header->magic == MH_CIGAM_64) { |
| LOG(WARNING) << "Mach object with non-supported endian."; |
| } |
| LOG(WARNING) << "strange magic: " |
| << " filename=" << filename_ |
| << " magic=" << std::hex << header->magic; |
| munmap(mmapped, len); |
| return false; |
| } |
| VLOG(1) << "mach header info:" |
| << " magic=" << header->magic |
| << " cputype=" << header->cputype |
| << " cpusubtype=" << header->cpusubtype |
| << " filetype=" << header->filetype |
| << " ncmds=" << header->ncmds |
| << " sizeofcmds=" << header->sizeofcmds |
| << " flags=" << header->flags; |
| CHECK_EQ(header->cputype, found->second.cputype); |
| CHECK_EQ(header->cpusubtype, found->second.cpusubtype); |
| |
| for (uint32_t i = 0; i < header->ncmds; ++i) { |
| // Since we do not support different endian, we do not convert |command|. |
| // If we support different endian, we should also convert data structures |
| // used in this loop. |
| VLOG(2) << "cmd:" |
| << " type=" << std::hex << command->cmd |
| << " size=" << command->cmdsize; |
| switch (command->cmd) { |
| case LC_IDFVMLIB: |
| FALLTHROUGH_INTENDED; |
| case LC_LOADFVMLIB: |
| LOG(ERROR) << "Sorry, FVMLIB support is not implemented yet."; |
| break; |
| case LC_LOAD_DYLIB: |
| FALLTHROUGH_INTENDED; |
| case LC_LOAD_WEAK_DYLIB: |
| FALLTHROUGH_INTENDED; |
| case LC_REEXPORT_DYLIB: |
| { |
| dylib_command* dycom = reinterpret_cast<dylib_command*>(command); |
| if (dycom->dylib.name.offset < command->cmdsize) { |
| DylibEntry entry; |
| entry.name = string(reinterpret_cast<char*>(command) + |
| dycom->dylib.name.offset); |
| entry.timestamp = dycom->dylib.timestamp; |
| entry.current_version = dycom->dylib.current_version; |
| entry.compatibility_version = dycom->dylib.compatibility_version; |
| dylibs->push_back(entry); |
| } else { |
| LOG(WARNING) << "dylib command broken:" |
| << " cmd=" << command->cmd |
| << " cmdsize=" << command->cmdsize |
| << " dylib.name.offset=" << dycom->dylib.name.offset; |
| } |
| } |
| break; |
| default: |
| VLOG(2) << "command is skipped:" |
| << " type=" << std::hex << command->cmd |
| << " size=" << command->cmdsize; |
| break; |
| } |
| command = reinterpret_cast<load_command*>( |
| reinterpret_cast<char*>(command) + command->cmdsize); |
| CHECK_GT(reinterpret_cast<char*>(command), mmapped); |
| CHECK_LT(reinterpret_cast<char*>(command), mmapped + len); |
| } |
| |
| munmap(mmapped, len); |
| return true; |
| } |
| |
| bool MachO::valid() const { |
| return fd_.valid(); |
| } |
| |
| } // namespace devtools_goma |
