contrib/llvm/lib/Object/MachOObject.cpp

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