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