MachOUniversal.cpp revision 36b56886974eae4f9c5ebc96befd3e7bfe5de338
1//===- MachOUniversal.cpp - Mach-O universal binary -------------*- C++ -*-===// 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 file defines the MachOUniversalBinary class. 11// 12//===----------------------------------------------------------------------===// 13 14#include "llvm/Object/MachOUniversal.h" 15#include "llvm/Object/MachO.h" 16#include "llvm/Object/ObjectFile.h" 17#include "llvm/Support/Casting.h" 18#include "llvm/Support/Host.h" 19#include "llvm/Support/MemoryBuffer.h" 20 21using namespace llvm; 22using namespace object; 23 24template<typename T> 25static void SwapValue(T &Value) { 26 Value = sys::SwapByteOrder(Value); 27} 28 29template<typename T> 30static void SwapStruct(T &Value); 31 32template<> 33void SwapStruct(MachO::fat_header &H) { 34 SwapValue(H.magic); 35 SwapValue(H.nfat_arch); 36} 37 38template<> 39void SwapStruct(MachO::fat_arch &H) { 40 SwapValue(H.cputype); 41 SwapValue(H.cpusubtype); 42 SwapValue(H.offset); 43 SwapValue(H.size); 44 SwapValue(H.align); 45} 46 47template<typename T> 48static T getUniversalBinaryStruct(const char *Ptr) { 49 T Res; 50 memcpy(&Res, Ptr, sizeof(T)); 51 // Universal binary headers have big-endian byte order. 52 if (sys::IsLittleEndianHost) 53 SwapStruct(Res); 54 return Res; 55} 56 57MachOUniversalBinary::ObjectForArch::ObjectForArch( 58 const MachOUniversalBinary *Parent, uint32_t Index) 59 : Parent(Parent), Index(Index) { 60 if (Parent == 0 || Index > Parent->getNumberOfObjects()) { 61 clear(); 62 } else { 63 // Parse object header. 64 StringRef ParentData = Parent->getData(); 65 const char *HeaderPos = ParentData.begin() + sizeof(MachO::fat_header) + 66 Index * sizeof(MachO::fat_arch); 67 Header = getUniversalBinaryStruct<MachO::fat_arch>(HeaderPos); 68 if (ParentData.size() < Header.offset + Header.size) { 69 clear(); 70 } 71 } 72} 73 74error_code MachOUniversalBinary::ObjectForArch::getAsObjectFile( 75 std::unique_ptr<ObjectFile> &Result) const { 76 if (Parent) { 77 StringRef ParentData = Parent->getData(); 78 StringRef ObjectData = ParentData.substr(Header.offset, Header.size); 79 std::string ObjectName = 80 Parent->getFileName().str() + ":" + 81 Triple::getArchTypeName(MachOObjectFile::getArch(Header.cputype)); 82 MemoryBuffer *ObjBuffer = MemoryBuffer::getMemBuffer( 83 ObjectData, ObjectName, false); 84 ErrorOr<ObjectFile *> Obj = ObjectFile::createMachOObjectFile(ObjBuffer); 85 if (error_code EC = Obj.getError()) 86 return EC; 87 Result.reset(Obj.get()); 88 return object_error::success; 89 } 90 return object_error::parse_failed; 91} 92 93void MachOUniversalBinary::anchor() { } 94 95ErrorOr<MachOUniversalBinary *> 96MachOUniversalBinary::create(MemoryBuffer *Source) { 97 error_code EC; 98 std::unique_ptr<MachOUniversalBinary> Ret( 99 new MachOUniversalBinary(Source, EC)); 100 if (EC) 101 return EC; 102 return Ret.release(); 103} 104 105MachOUniversalBinary::MachOUniversalBinary(MemoryBuffer *Source, 106 error_code &ec) 107 : Binary(Binary::ID_MachOUniversalBinary, Source), 108 NumberOfObjects(0) { 109 if (Source->getBufferSize() < sizeof(MachO::fat_header)) { 110 ec = object_error::invalid_file_type; 111 return; 112 } 113 // Check for magic value and sufficient header size. 114 StringRef Buf = getData(); 115 MachO::fat_header H= getUniversalBinaryStruct<MachO::fat_header>(Buf.begin()); 116 NumberOfObjects = H.nfat_arch; 117 uint32_t MinSize = sizeof(MachO::fat_header) + 118 sizeof(MachO::fat_arch) * NumberOfObjects; 119 if (H.magic != MachO::FAT_MAGIC || Buf.size() < MinSize) { 120 ec = object_error::parse_failed; 121 return; 122 } 123 ec = object_error::success; 124} 125 126static bool getCTMForArch(Triple::ArchType Arch, MachO::CPUType &CTM) { 127 switch (Arch) { 128 case Triple::x86: CTM = MachO::CPU_TYPE_I386; return true; 129 case Triple::x86_64: CTM = MachO::CPU_TYPE_X86_64; return true; 130 case Triple::arm: CTM = MachO::CPU_TYPE_ARM; return true; 131 case Triple::sparc: CTM = MachO::CPU_TYPE_SPARC; return true; 132 case Triple::ppc: CTM = MachO::CPU_TYPE_POWERPC; return true; 133 case Triple::ppc64: CTM = MachO::CPU_TYPE_POWERPC64; return true; 134 default: return false; 135 } 136} 137 138error_code MachOUniversalBinary::getObjectForArch( 139 Triple::ArchType Arch, std::unique_ptr<ObjectFile> &Result) const { 140 MachO::CPUType CTM; 141 if (!getCTMForArch(Arch, CTM)) 142 return object_error::arch_not_found; 143 for (object_iterator I = begin_objects(), E = end_objects(); I != E; ++I) { 144 if (I->getCPUType() == static_cast<uint32_t>(CTM)) 145 return I->getAsObjectFile(Result); 146 } 147 return object_error::arch_not_found; 148} 149