Home | History | Annotate | Download | only in Object 
      1 //===- MachOObject.cpp - Mach-O Object File Wrapper -----------------------===//
      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 #include "llvm/Object/MachOObject.h"
     11 #include "llvm/ADT/StringRef.h"
     12 #include "llvm/ADT/SmallVector.h"
     13 #include "llvm/Support/MemoryBuffer.h"
     14 #include "llvm/Support/Host.h"
     15 #include "llvm/Support/SwapByteOrder.h"
     16 #include "llvm/Support/raw_ostream.h"
     17 #include "llvm/Support/Debug.h"
     18 
     19 using namespace llvm;
     20 using namespace llvm::object;
     21 
     22 /* Translation Utilities */
     23 
     24 template<typename T>
     25 static void SwapValue(T &Value) {
     26   Value = sys::SwapByteOrder(Value);
     27 }
     28 
     29 template<typename T>
     30 static void SwapStruct(T &Value);
     31 
     32 template<typename T>
     33 static void ReadInMemoryStruct(const MachOObject &MOO,
     34                                StringRef Buffer, uint64_t Base,
     35                                InMemoryStruct<T> &Res) {
     36   typedef T struct_type;
     37   uint64_t Size = sizeof(struct_type);
     38 
     39   // Check that the buffer contains the expected data.
     40   if (Base + Size >  Buffer.size()) {
     41     Res = 0;
     42     return;
     43   }
     44 
     45   // Check whether we can return a direct pointer.
     46   struct_type *Ptr = (struct_type *) (Buffer.data() + Base);
     47   if (!MOO.isSwappedEndian()) {
     48     Res = Ptr;
     49     return;
     50   }
     51 
     52   // Otherwise, copy the struct and translate the values.
     53   Res = *Ptr;
     54   SwapStruct(*Res);
     55 }
     56 
     57 /* *** */
     58 
     59 MachOObject::MachOObject(MemoryBuffer *Buffer_, bool IsLittleEndian_,
     60                          bool Is64Bit_)
     61   : Buffer(Buffer_), IsLittleEndian(IsLittleEndian_), Is64Bit(Is64Bit_),
     62     IsSwappedEndian(IsLittleEndian != sys::isLittleEndianHost()),
     63     HasStringTable(false), LoadCommands(0), NumLoadedCommands(0) {
     64   // Load the common header.
     65   memcpy(&Header, Buffer->getBuffer().data(), sizeof(Header));
     66   if (IsSwappedEndian) {
     67     SwapValue(Header.Magic);
     68     SwapValue(Header.CPUType);
     69     SwapValue(Header.CPUSubtype);
     70     SwapValue(Header.FileType);
     71     SwapValue(Header.NumLoadCommands);
     72     SwapValue(Header.SizeOfLoadCommands);
     73     SwapValue(Header.Flags);
     74   }
     75 
     76   if (is64Bit()) {
     77     memcpy(&Header64Ext, Buffer->getBuffer().data() + sizeof(Header),
     78            sizeof(Header64Ext));
     79     if (IsSwappedEndian) {
     80       SwapValue(Header64Ext.Reserved);
     81     }
     82   }
     83 
     84   // Create the load command array if sane.
     85   if (getHeader().NumLoadCommands < (1 << 20))
     86     LoadCommands = new LoadCommandInfo[getHeader().NumLoadCommands];
     87 }
     88 
     89 MachOObject::~MachOObject() {
     90   delete [] LoadCommands;
     91 }
     92 
     93 MachOObject *MachOObject::LoadFromBuffer(MemoryBuffer *Buffer,
     94                                          std::string *ErrorStr) {
     95   // First, check the magic value and initialize the basic object info.
     96   bool IsLittleEndian = false, Is64Bit = false;
     97   StringRef Magic = Buffer->getBuffer().slice(0, 4);
     98   if (Magic == "\xFE\xED\xFA\xCE") {
     99   }  else if (Magic == "\xCE\xFA\xED\xFE") {
    100     IsLittleEndian = true;
    101   } else if (Magic == "\xFE\xED\xFA\xCF") {
    102     Is64Bit = true;
    103   } else if (Magic == "\xCF\xFA\xED\xFE") {
    104     IsLittleEndian = true;
    105     Is64Bit = true;
    106   } else {
    107     if (ErrorStr) *ErrorStr = "not a Mach object file (invalid magic)";
    108     return 0;
    109   }
    110 
    111   // Ensure that the at least the full header is present.
    112   unsigned HeaderSize = Is64Bit ? macho::Header64Size : macho::Header32Size;
    113   if (Buffer->getBufferSize() < HeaderSize) {
    114     if (ErrorStr) *ErrorStr = "not a Mach object file (invalid header)";
    115     return 0;
    116   }
    117 
    118   OwningPtr<MachOObject> Object(new MachOObject(Buffer, IsLittleEndian,
    119                                                 Is64Bit));
    120 
    121   // Check for bogus number of load commands.
    122   if (Object->getHeader().NumLoadCommands >= (1 << 20)) {
    123     if (ErrorStr) *ErrorStr = "not a Mach object file (unreasonable header)";
    124     return 0;
    125   }
    126 
    127   if (ErrorStr) *ErrorStr = "";
    128   return Object.take();
    129 }
    130 
    131 StringRef MachOObject::getData(size_t Offset, size_t Size) const {
    132   return Buffer->getBuffer().substr(Offset,Size);
    133 }
    134 
    135 void MachOObject::RegisterStringTable(macho::SymtabLoadCommand &SLC) {
    136   HasStringTable = true;
    137   StringTable = Buffer->getBuffer().substr(SLC.StringTableOffset,
    138                                            SLC.StringTableSize);
    139 }
    140 
    141 const MachOObject::LoadCommandInfo &
    142 MachOObject::getLoadCommandInfo(unsigned Index) const {
    143   assert(Index < getHeader().NumLoadCommands && "Invalid index!");
    144 
    145   // Load the command, if necessary.
    146   if (Index >= NumLoadedCommands) {
    147     uint64_t Offset;
    148     if (Index == 0) {
    149       Offset = getHeaderSize();
    150     } else {
    151       const LoadCommandInfo &Prev = getLoadCommandInfo(Index - 1);
    152       Offset = Prev.Offset + Prev.Command.Size;
    153     }
    154 
    155     LoadCommandInfo &Info = LoadCommands[Index];
    156     memcpy(&Info.Command, Buffer->getBuffer().data() + Offset,
    157            sizeof(macho::LoadCommand));
    158     if (IsSwappedEndian) {
    159       SwapValue(Info.Command.Type);
    160       SwapValue(Info.Command.Size);
    161     }
    162     Info.Offset = Offset;
    163     NumLoadedCommands = Index + 1;
    164   }
    165 
    166   return LoadCommands[Index];
    167 }
    168 
    169 template<>
    170 void SwapStruct(macho::SegmentLoadCommand &Value) {
    171   SwapValue(Value.Type);
    172   SwapValue(Value.Size);
    173   SwapValue(Value.VMAddress);
    174   SwapValue(Value.VMSize);
    175   SwapValue(Value.FileOffset);
    176   SwapValue(Value.FileSize);
    177   SwapValue(Value.MaxVMProtection);
    178   SwapValue(Value.InitialVMProtection);
    179   SwapValue(Value.NumSections);
    180   SwapValue(Value.Flags);
    181 }
    182 void MachOObject::ReadSegmentLoadCommand(const LoadCommandInfo &LCI,
    183                          InMemoryStruct<macho::SegmentLoadCommand> &Res) const {
    184   ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
    185 }
    186 
    187 template<>
    188 void SwapStruct(macho::Segment64LoadCommand &Value) {
    189   SwapValue(Value.Type);
    190   SwapValue(Value.Size);
    191   SwapValue(Value.VMAddress);
    192   SwapValue(Value.VMSize);
    193   SwapValue(Value.FileOffset);
    194   SwapValue(Value.FileSize);
    195   SwapValue(Value.MaxVMProtection);
    196   SwapValue(Value.InitialVMProtection);
    197   SwapValue(Value.NumSections);
    198   SwapValue(Value.Flags);
    199 }
    200 void MachOObject::ReadSegment64LoadCommand(const LoadCommandInfo &LCI,
    201                        InMemoryStruct<macho::Segment64LoadCommand> &Res) const {
    202   ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
    203 }
    204 
    205 template<>
    206 void SwapStruct(macho::SymtabLoadCommand &Value) {
    207   SwapValue(Value.Type);
    208   SwapValue(Value.Size);
    209   SwapValue(Value.SymbolTableOffset);
    210   SwapValue(Value.NumSymbolTableEntries);
    211   SwapValue(Value.StringTableOffset);
    212   SwapValue(Value.StringTableSize);
    213 }
    214 void MachOObject::ReadSymtabLoadCommand(const LoadCommandInfo &LCI,
    215                           InMemoryStruct<macho::SymtabLoadCommand> &Res) const {
    216   ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
    217 }
    218 
    219 template<>
    220 void SwapStruct(macho::DysymtabLoadCommand &Value) {
    221   SwapValue(Value.Type);
    222   SwapValue(Value.Size);
    223   SwapValue(Value.LocalSymbolsIndex);
    224   SwapValue(Value.NumLocalSymbols);
    225   SwapValue(Value.ExternalSymbolsIndex);
    226   SwapValue(Value.NumExternalSymbols);
    227   SwapValue(Value.UndefinedSymbolsIndex);
    228   SwapValue(Value.NumUndefinedSymbols);
    229   SwapValue(Value.TOCOffset);
    230   SwapValue(Value.NumTOCEntries);
    231   SwapValue(Value.ModuleTableOffset);
    232   SwapValue(Value.NumModuleTableEntries);
    233   SwapValue(Value.ReferenceSymbolTableOffset);
    234   SwapValue(Value.NumReferencedSymbolTableEntries);
    235   SwapValue(Value.IndirectSymbolTableOffset);
    236   SwapValue(Value.NumIndirectSymbolTableEntries);
    237   SwapValue(Value.ExternalRelocationTableOffset);
    238   SwapValue(Value.NumExternalRelocationTableEntries);
    239   SwapValue(Value.LocalRelocationTableOffset);
    240   SwapValue(Value.NumLocalRelocationTableEntries);
    241 }
    242 void MachOObject::ReadDysymtabLoadCommand(const LoadCommandInfo &LCI,
    243                         InMemoryStruct<macho::DysymtabLoadCommand> &Res) const {
    244   ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
    245 }
    246 
    247 template<>
    248 void SwapStruct(macho::LinkeditDataLoadCommand &Value) {
    249   SwapValue(Value.Type);
    250   SwapValue(Value.Size);
    251   SwapValue(Value.DataOffset);
    252   SwapValue(Value.DataSize);
    253 }
    254 void MachOObject::ReadLinkeditDataLoadCommand(const LoadCommandInfo &LCI,
    255                     InMemoryStruct<macho::LinkeditDataLoadCommand> &Res) const {
    256   ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
    257 }
    258 
    259 template<>
    260 void SwapStruct(macho::IndirectSymbolTableEntry &Value) {
    261   SwapValue(Value.Index);
    262 }
    263 void
    264 MachOObject::ReadIndirectSymbolTableEntry(const macho::DysymtabLoadCommand &DLC,
    265                                           unsigned Index,
    266                    InMemoryStruct<macho::IndirectSymbolTableEntry> &Res) const {
    267   uint64_t Offset = (DLC.IndirectSymbolTableOffset +
    268                      Index * sizeof(macho::IndirectSymbolTableEntry));
    269   ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
    270 }
    271 
    272 
    273 template<>
    274 void SwapStruct(macho::Section &Value) {
    275   SwapValue(Value.Address);
    276   SwapValue(Value.Size);
    277   SwapValue(Value.Offset);
    278   SwapValue(Value.Align);
    279   SwapValue(Value.RelocationTableOffset);
    280   SwapValue(Value.NumRelocationTableEntries);
    281   SwapValue(Value.Flags);
    282   SwapValue(Value.Reserved1);
    283   SwapValue(Value.Reserved2);
    284 }
    285 void MachOObject::ReadSection(const LoadCommandInfo &LCI,
    286                               unsigned Index,
    287                               InMemoryStruct<macho::Section> &Res) const {
    288   assert(LCI.Command.Type == macho::LCT_Segment &&
    289          "Unexpected load command info!");
    290   uint64_t Offset = (LCI.Offset + sizeof(macho::SegmentLoadCommand) +
    291                      Index * sizeof(macho::Section));
    292   ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
    293 }
    294 
    295 template<>
    296 void SwapStruct(macho::Section64 &Value) {
    297   SwapValue(Value.Address);
    298   SwapValue(Value.Size);
    299   SwapValue(Value.Offset);
    300   SwapValue(Value.Align);
    301   SwapValue(Value.RelocationTableOffset);
    302   SwapValue(Value.NumRelocationTableEntries);
    303   SwapValue(Value.Flags);
    304   SwapValue(Value.Reserved1);
    305   SwapValue(Value.Reserved2);
    306   SwapValue(Value.Reserved3);
    307 }
    308 void MachOObject::ReadSection64(const LoadCommandInfo &LCI,
    309                                 unsigned Index,
    310                                 InMemoryStruct<macho::Section64> &Res) const {
    311   assert(LCI.Command.Type == macho::LCT_Segment64 &&
    312          "Unexpected load command info!");
    313   uint64_t Offset = (LCI.Offset + sizeof(macho::Segment64LoadCommand) +
    314                      Index * sizeof(macho::Section64));
    315   ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
    316 }
    317 
    318 template<>
    319 void SwapStruct(macho::RelocationEntry &Value) {
    320   SwapValue(Value.Word0);
    321   SwapValue(Value.Word1);
    322 }
    323 void MachOObject::ReadRelocationEntry(uint64_t RelocationTableOffset,
    324                                       unsigned Index,
    325                             InMemoryStruct<macho::RelocationEntry> &Res) const {
    326   uint64_t Offset = (RelocationTableOffset +
    327                      Index * sizeof(macho::RelocationEntry));
    328   ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
    329 }
    330 
    331 template<>
    332 void SwapStruct(macho::SymbolTableEntry &Value) {
    333   SwapValue(Value.StringIndex);
    334   SwapValue(Value.Flags);
    335   SwapValue(Value.Value);
    336 }
    337 void MachOObject::ReadSymbolTableEntry(uint64_t SymbolTableOffset,
    338                                        unsigned Index,
    339                            InMemoryStruct<macho::SymbolTableEntry> &Res) const {
    340   uint64_t Offset = (SymbolTableOffset +
    341                      Index * sizeof(macho::SymbolTableEntry));
    342   ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
    343 }
    344 
    345 template<>
    346 void SwapStruct(macho::Symbol64TableEntry &Value) {
    347   SwapValue(Value.StringIndex);
    348   SwapValue(Value.Flags);
    349   SwapValue(Value.Value);
    350 }
    351 void MachOObject::ReadSymbol64TableEntry(uint64_t SymbolTableOffset,
    352                                        unsigned Index,
    353                          InMemoryStruct<macho::Symbol64TableEntry> &Res) const {
    354   uint64_t Offset = (SymbolTableOffset +
    355                      Index * sizeof(macho::Symbol64TableEntry));
    356   ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
    357 }
    358 
    359 
    360 void MachOObject::ReadULEB128s(uint64_t Index,
    361                                SmallVectorImpl<uint64_t> &Out) const {
    362   const char *ptr = Buffer->getBufferStart() + Index;
    363   uint64_t data = 0;
    364   uint64_t delta = 0;
    365   uint32_t shift = 0;
    366   while (true) {
    367     assert(ptr < Buffer->getBufferEnd() && "index out of bounds");
    368     assert(shift < 64 && "too big for uint64_t");
    369 
    370     uint8_t byte = *ptr++;
    371     delta |= ((byte & 0x7F) << shift);
    372     shift += 7;
    373     if (byte < 0x80) {
    374       if (delta == 0)
    375         break;
    376       data += delta;
    377       Out.push_back(data);
    378       delta = 0;
    379       shift = 0;
    380     }
    381   }
    382 }
    383 
    384 /* ** */
    385 // Object Dumping Facilities
    386 void MachOObject::dump() const { print(dbgs()); dbgs() << '\n'; }
    387 void MachOObject::dumpHeader() const { printHeader(dbgs()); dbgs() << '\n'; }
    388 
    389 void MachOObject::printHeader(raw_ostream &O) const {
    390   O << "('cputype', " << Header.CPUType << ")\n";
    391   O << "('cpusubtype', " << Header.CPUSubtype << ")\n";
    392   O << "('filetype', " << Header.FileType << ")\n";
    393   O << "('num_load_commands', " << Header.NumLoadCommands << ")\n";
    394   O << "('load_commands_size', " << Header.SizeOfLoadCommands << ")\n";
    395   O << "('flag', " << Header.Flags << ")\n";
    396 
    397   // Print extended header if 64-bit.
    398   if (is64Bit())
    399     O << "('reserved', " << Header64Ext.Reserved << ")\n";
    400 }
    401 
    402 void MachOObject::print(raw_ostream &O) const {
    403   O << "Header:\n";
    404   printHeader(O);
    405   O << "Load Commands:\n";
    406 
    407   O << "Buffer:\n";
    408 }
    409