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
