1 //===- MachOObjectFile.cpp - Mach-O object file binding ---------*- 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 MachOObjectFile class, which binds the MachOObject 11 // class to the generic ObjectFile wrapper. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "llvm/Object/MachO.h" 16 #include "llvm/ADT/STLExtras.h" 17 #include "llvm/ADT/StringSwitch.h" 18 #include "llvm/ADT/Triple.h" 19 #include "llvm/Support/DataExtractor.h" 20 #include "llvm/Support/Debug.h" 21 #include "llvm/Support/Format.h" 22 #include "llvm/Support/Host.h" 23 #include "llvm/Support/LEB128.h" 24 #include "llvm/Support/MachO.h" 25 #include "llvm/Support/MemoryBuffer.h" 26 #include "llvm/Support/raw_ostream.h" 27 #include <cctype> 28 #include <cstring> 29 #include <limits> 30 31 using namespace llvm; 32 using namespace object; 33 34 namespace { 35 struct section_base { 36 char sectname[16]; 37 char segname[16]; 38 }; 39 } 40 41 static Error 42 malformedError(Twine Msg) { 43 std::string StringMsg = "truncated or malformed object (" + Msg.str() + ")"; 44 return make_error<GenericBinaryError>(std::move(StringMsg), 45 object_error::parse_failed); 46 } 47 48 // FIXME: Replace all uses of this function with getStructOrErr. 49 template <typename T> 50 static T getStruct(const MachOObjectFile *O, const char *P) { 51 // Don't read before the beginning or past the end of the file 52 if (P < O->getData().begin() || P + sizeof(T) > O->getData().end()) 53 report_fatal_error("Malformed MachO file."); 54 55 T Cmd; 56 memcpy(&Cmd, P, sizeof(T)); 57 if (O->isLittleEndian() != sys::IsLittleEndianHost) 58 MachO::swapStruct(Cmd); 59 return Cmd; 60 } 61 62 template <typename T> 63 static Expected<T> getStructOrErr(const MachOObjectFile *O, const char *P) { 64 // Don't read before the beginning or past the end of the file 65 if (P < O->getData().begin() || P + sizeof(T) > O->getData().end()) 66 return malformedError("Structure read out-of-range"); 67 68 T Cmd; 69 memcpy(&Cmd, P, sizeof(T)); 70 if (O->isLittleEndian() != sys::IsLittleEndianHost) 71 MachO::swapStruct(Cmd); 72 return Cmd; 73 } 74 75 static const char * 76 getSectionPtr(const MachOObjectFile *O, MachOObjectFile::LoadCommandInfo L, 77 unsigned Sec) { 78 uintptr_t CommandAddr = reinterpret_cast<uintptr_t>(L.Ptr); 79 80 bool Is64 = O->is64Bit(); 81 unsigned SegmentLoadSize = Is64 ? sizeof(MachO::segment_command_64) : 82 sizeof(MachO::segment_command); 83 unsigned SectionSize = Is64 ? sizeof(MachO::section_64) : 84 sizeof(MachO::section); 85 86 uintptr_t SectionAddr = CommandAddr + SegmentLoadSize + Sec * SectionSize; 87 return reinterpret_cast<const char*>(SectionAddr); 88 } 89 90 static const char *getPtr(const MachOObjectFile *O, size_t Offset) { 91 return O->getData().substr(Offset, 1).data(); 92 } 93 94 static MachO::nlist_base 95 getSymbolTableEntryBase(const MachOObjectFile *O, DataRefImpl DRI) { 96 const char *P = reinterpret_cast<const char *>(DRI.p); 97 return getStruct<MachO::nlist_base>(O, P); 98 } 99 100 static StringRef parseSegmentOrSectionName(const char *P) { 101 if (P[15] == 0) 102 // Null terminated. 103 return P; 104 // Not null terminated, so this is a 16 char string. 105 return StringRef(P, 16); 106 } 107 108 // Helper to advance a section or symbol iterator multiple increments at a time. 109 template<class T> 110 static void advance(T &it, size_t Val) { 111 while (Val--) 112 ++it; 113 } 114 115 static unsigned getCPUType(const MachOObjectFile *O) { 116 return O->getHeader().cputype; 117 } 118 119 static uint32_t 120 getPlainRelocationAddress(const MachO::any_relocation_info &RE) { 121 return RE.r_word0; 122 } 123 124 static unsigned 125 getScatteredRelocationAddress(const MachO::any_relocation_info &RE) { 126 return RE.r_word0 & 0xffffff; 127 } 128 129 static bool getPlainRelocationPCRel(const MachOObjectFile *O, 130 const MachO::any_relocation_info &RE) { 131 if (O->isLittleEndian()) 132 return (RE.r_word1 >> 24) & 1; 133 return (RE.r_word1 >> 7) & 1; 134 } 135 136 static bool 137 getScatteredRelocationPCRel(const MachOObjectFile *O, 138 const MachO::any_relocation_info &RE) { 139 return (RE.r_word0 >> 30) & 1; 140 } 141 142 static unsigned getPlainRelocationLength(const MachOObjectFile *O, 143 const MachO::any_relocation_info &RE) { 144 if (O->isLittleEndian()) 145 return (RE.r_word1 >> 25) & 3; 146 return (RE.r_word1 >> 5) & 3; 147 } 148 149 static unsigned 150 getScatteredRelocationLength(const MachO::any_relocation_info &RE) { 151 return (RE.r_word0 >> 28) & 3; 152 } 153 154 static unsigned getPlainRelocationType(const MachOObjectFile *O, 155 const MachO::any_relocation_info &RE) { 156 if (O->isLittleEndian()) 157 return RE.r_word1 >> 28; 158 return RE.r_word1 & 0xf; 159 } 160 161 static uint32_t getSectionFlags(const MachOObjectFile *O, 162 DataRefImpl Sec) { 163 if (O->is64Bit()) { 164 MachO::section_64 Sect = O->getSection64(Sec); 165 return Sect.flags; 166 } 167 MachO::section Sect = O->getSection(Sec); 168 return Sect.flags; 169 } 170 171 static Expected<MachOObjectFile::LoadCommandInfo> 172 getLoadCommandInfo(const MachOObjectFile *Obj, const char *Ptr, 173 uint32_t LoadCommandIndex) { 174 if (auto CmdOrErr = getStructOrErr<MachO::load_command>(Obj, Ptr)) { 175 if (CmdOrErr->cmdsize < 8) 176 return malformedError("load command " + Twine(LoadCommandIndex) + 177 " with size less than 8 bytes"); 178 return MachOObjectFile::LoadCommandInfo({Ptr, *CmdOrErr}); 179 } else 180 return CmdOrErr.takeError(); 181 } 182 183 static Expected<MachOObjectFile::LoadCommandInfo> 184 getFirstLoadCommandInfo(const MachOObjectFile *Obj) { 185 unsigned HeaderSize = Obj->is64Bit() ? sizeof(MachO::mach_header_64) 186 : sizeof(MachO::mach_header); 187 if (sizeof(MachOObjectFile::LoadCommandInfo) > Obj->getHeader().sizeofcmds) 188 return malformedError("load command 0 extends past the end all load " 189 "commands in the file"); 190 return getLoadCommandInfo(Obj, getPtr(Obj, HeaderSize), 0); 191 } 192 193 static Expected<MachOObjectFile::LoadCommandInfo> 194 getNextLoadCommandInfo(const MachOObjectFile *Obj, uint32_t LoadCommandIndex, 195 const MachOObjectFile::LoadCommandInfo &L) { 196 unsigned HeaderSize = Obj->is64Bit() ? sizeof(MachO::mach_header_64) 197 : sizeof(MachO::mach_header); 198 if (L.Ptr + L.C.cmdsize + sizeof(MachOObjectFile::LoadCommandInfo) > 199 Obj->getData().data() + HeaderSize + Obj->getHeader().sizeofcmds) 200 return malformedError("load command " + Twine(LoadCommandIndex + 1) + 201 " extends past the end all load commands in the file"); 202 return getLoadCommandInfo(Obj, L.Ptr + L.C.cmdsize, LoadCommandIndex + 1); 203 } 204 205 template <typename T> 206 static void parseHeader(const MachOObjectFile *Obj, T &Header, 207 Error &Err) { 208 if (sizeof(T) > Obj->getData().size()) { 209 Err = malformedError("the mach header extends past the end of the " 210 "file"); 211 return; 212 } 213 if (auto HeaderOrErr = getStructOrErr<T>(Obj, getPtr(Obj, 0))) 214 Header = *HeaderOrErr; 215 else 216 Err = HeaderOrErr.takeError(); 217 } 218 219 // Parses LC_SEGMENT or LC_SEGMENT_64 load command, adds addresses of all 220 // sections to \param Sections, and optionally sets 221 // \param IsPageZeroSegment to true. 222 template <typename SegmentCmd> 223 static Error parseSegmentLoadCommand( 224 const MachOObjectFile *Obj, const MachOObjectFile::LoadCommandInfo &Load, 225 SmallVectorImpl<const char *> &Sections, bool &IsPageZeroSegment, 226 uint32_t LoadCommandIndex, const char *CmdName) { 227 const unsigned SegmentLoadSize = sizeof(SegmentCmd); 228 if (Load.C.cmdsize < SegmentLoadSize) 229 return malformedError("load command " + Twine(LoadCommandIndex) + 230 " " + CmdName + " cmdsize too small"); 231 if (auto SegOrErr = getStructOrErr<SegmentCmd>(Obj, Load.Ptr)) { 232 SegmentCmd S = SegOrErr.get(); 233 const unsigned SectionSize = 234 Obj->is64Bit() ? sizeof(MachO::section_64) : sizeof(MachO::section); 235 if (S.nsects > std::numeric_limits<uint32_t>::max() / SectionSize || 236 S.nsects * SectionSize > Load.C.cmdsize - SegmentLoadSize) 237 return malformedError("load command " + Twine(LoadCommandIndex) + 238 " inconsistent cmdsize in " + CmdName + 239 " for the number of sections"); 240 for (unsigned J = 0; J < S.nsects; ++J) { 241 const char *Sec = getSectionPtr(Obj, Load, J); 242 Sections.push_back(Sec); 243 } 244 IsPageZeroSegment |= StringRef("__PAGEZERO").equals(S.segname); 245 } else 246 return SegOrErr.takeError(); 247 248 return Error::success(); 249 } 250 251 Expected<std::unique_ptr<MachOObjectFile>> 252 MachOObjectFile::create(MemoryBufferRef Object, bool IsLittleEndian, 253 bool Is64Bits) { 254 Error Err; 255 std::unique_ptr<MachOObjectFile> Obj( 256 new MachOObjectFile(std::move(Object), IsLittleEndian, 257 Is64Bits, Err)); 258 if (Err) 259 return std::move(Err); 260 return std::move(Obj); 261 } 262 263 MachOObjectFile::MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian, 264 bool Is64bits, Error &Err) 265 : ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object), 266 SymtabLoadCmd(nullptr), DysymtabLoadCmd(nullptr), 267 DataInCodeLoadCmd(nullptr), LinkOptHintsLoadCmd(nullptr), 268 DyldInfoLoadCmd(nullptr), UuidLoadCmd(nullptr), 269 HasPageZeroSegment(false) { 270 ErrorAsOutParameter ErrAsOutParam(Err); 271 uint64_t BigSize; 272 if (is64Bit()) { 273 parseHeader(this, Header64, Err); 274 BigSize = sizeof(MachO::mach_header_64); 275 } else { 276 parseHeader(this, Header, Err); 277 BigSize = sizeof(MachO::mach_header); 278 } 279 if (Err) 280 return; 281 BigSize += getHeader().sizeofcmds; 282 if (getData().data() + BigSize > getData().end()) { 283 Err = malformedError("load commands extend past the end of the file"); 284 return; 285 } 286 287 uint32_t LoadCommandCount = getHeader().ncmds; 288 if (LoadCommandCount == 0) 289 return; 290 291 LoadCommandInfo Load; 292 if (auto LoadOrErr = getFirstLoadCommandInfo(this)) 293 Load = *LoadOrErr; 294 else { 295 Err = LoadOrErr.takeError(); 296 return; 297 } 298 299 for (unsigned I = 0; I < LoadCommandCount; ++I) { 300 if (is64Bit()) { 301 if (Load.C.cmdsize % 8 != 0) { 302 // We have a hack here to allow 64-bit Mach-O core files to have 303 // LC_THREAD commands that are only a multiple of 4 and not 8 to be 304 // allowed since the macOS kernel produces them. 305 if (getHeader().filetype != MachO::MH_CORE || 306 Load.C.cmd != MachO::LC_THREAD || Load.C.cmdsize % 4) { 307 Err = malformedError("load command " + Twine(I) + " cmdsize not a " 308 "multiple of 8"); 309 return; 310 } 311 } 312 } else { 313 if (Load.C.cmdsize % 4 != 0) { 314 Err = malformedError("load command " + Twine(I) + " cmdsize not a " 315 "multiple of 4"); 316 return; 317 } 318 } 319 LoadCommands.push_back(Load); 320 if (Load.C.cmd == MachO::LC_SYMTAB) { 321 // Multiple symbol tables 322 if (SymtabLoadCmd) { 323 Err = malformedError("Multiple symbol tables"); 324 return; 325 } 326 SymtabLoadCmd = Load.Ptr; 327 } else if (Load.C.cmd == MachO::LC_DYSYMTAB) { 328 // Multiple dynamic symbol tables 329 if (DysymtabLoadCmd) { 330 Err = malformedError("Multiple dynamic symbol tables"); 331 return; 332 } 333 DysymtabLoadCmd = Load.Ptr; 334 } else if (Load.C.cmd == MachO::LC_DATA_IN_CODE) { 335 // Multiple data in code tables 336 if (DataInCodeLoadCmd) { 337 Err = malformedError("Multiple data-in-code tables"); 338 return; 339 } 340 DataInCodeLoadCmd = Load.Ptr; 341 } else if (Load.C.cmd == MachO::LC_LINKER_OPTIMIZATION_HINT) { 342 // Multiple linker optimization hint tables 343 if (LinkOptHintsLoadCmd) { 344 Err = malformedError("Multiple linker optimization hint tables"); 345 return; 346 } 347 LinkOptHintsLoadCmd = Load.Ptr; 348 } else if (Load.C.cmd == MachO::LC_DYLD_INFO || 349 Load.C.cmd == MachO::LC_DYLD_INFO_ONLY) { 350 // Multiple dyldinfo load commands 351 if (DyldInfoLoadCmd) { 352 Err = malformedError("Multiple dyldinfo load commands"); 353 return; 354 } 355 DyldInfoLoadCmd = Load.Ptr; 356 } else if (Load.C.cmd == MachO::LC_UUID) { 357 // Multiple UUID load commands 358 if (UuidLoadCmd) { 359 Err = malformedError("Multiple UUID load commands"); 360 return; 361 } 362 UuidLoadCmd = Load.Ptr; 363 } else if (Load.C.cmd == MachO::LC_SEGMENT_64) { 364 if ((Err = parseSegmentLoadCommand<MachO::segment_command_64>( 365 this, Load, Sections, HasPageZeroSegment, I, 366 "LC_SEGMENT_64"))) 367 return; 368 } else if (Load.C.cmd == MachO::LC_SEGMENT) { 369 if ((Err = parseSegmentLoadCommand<MachO::segment_command>( 370 this, Load, Sections, HasPageZeroSegment, I, "LC_SEGMENT"))) 371 return; 372 } else if (Load.C.cmd == MachO::LC_LOAD_DYLIB || 373 Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB || 374 Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB || 375 Load.C.cmd == MachO::LC_REEXPORT_DYLIB || 376 Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) { 377 Libraries.push_back(Load.Ptr); 378 } 379 if (I < LoadCommandCount - 1) { 380 if (auto LoadOrErr = getNextLoadCommandInfo(this, I, Load)) 381 Load = *LoadOrErr; 382 else { 383 Err = LoadOrErr.takeError(); 384 return; 385 } 386 } 387 } 388 if (!SymtabLoadCmd) { 389 if (DysymtabLoadCmd) { 390 Err = malformedError("contains LC_DYSYMTAB load command without a " 391 "LC_SYMTAB load command"); 392 return; 393 } 394 } else if (DysymtabLoadCmd) { 395 MachO::symtab_command Symtab = 396 getStruct<MachO::symtab_command>(this, SymtabLoadCmd); 397 MachO::dysymtab_command Dysymtab = 398 getStruct<MachO::dysymtab_command>(this, DysymtabLoadCmd); 399 if (Dysymtab.nlocalsym != 0 && Dysymtab.ilocalsym > Symtab.nsyms) { 400 Err = malformedError("ilocalsym in LC_DYSYMTAB load command " 401 "extends past the end of the symbol table"); 402 return; 403 } 404 uint64_t BigSize = Dysymtab.ilocalsym; 405 BigSize += Dysymtab.nlocalsym; 406 if (Dysymtab.nlocalsym != 0 && BigSize > Symtab.nsyms) { 407 Err = malformedError("ilocalsym plus nlocalsym in LC_DYSYMTAB load " 408 "command extends past the end of the symbol table"); 409 return; 410 } 411 if (Dysymtab.nextdefsym != 0 && Dysymtab.ilocalsym > Symtab.nsyms) { 412 Err = malformedError("nextdefsym in LC_DYSYMTAB load command " 413 "extends past the end of the symbol table"); 414 return; 415 } 416 BigSize = Dysymtab.iextdefsym; 417 BigSize += Dysymtab.nextdefsym; 418 if (Dysymtab.nextdefsym != 0 && BigSize > Symtab.nsyms) { 419 Err = malformedError("iextdefsym plus nextdefsym in LC_DYSYMTAB " 420 "load command extends past the end of the symbol " 421 "table"); 422 return; 423 } 424 if (Dysymtab.nundefsym != 0 && Dysymtab.iundefsym > Symtab.nsyms) { 425 Err = malformedError("nundefsym in LC_DYSYMTAB load command " 426 "extends past the end of the symbol table"); 427 return; 428 } 429 BigSize = Dysymtab.iundefsym; 430 BigSize += Dysymtab.nundefsym; 431 if (Dysymtab.nundefsym != 0 && BigSize > Symtab.nsyms) { 432 Err = malformedError("iundefsym plus nundefsym in LC_DYSYMTAB load " 433 " command extends past the end of the symbol table"); 434 return; 435 } 436 } 437 assert(LoadCommands.size() == LoadCommandCount); 438 439 Err = Error::success(); 440 } 441 442 void MachOObjectFile::moveSymbolNext(DataRefImpl &Symb) const { 443 unsigned SymbolTableEntrySize = is64Bit() ? 444 sizeof(MachO::nlist_64) : 445 sizeof(MachO::nlist); 446 Symb.p += SymbolTableEntrySize; 447 } 448 449 Expected<StringRef> MachOObjectFile::getSymbolName(DataRefImpl Symb) const { 450 StringRef StringTable = getStringTableData(); 451 MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb); 452 const char *Start = &StringTable.data()[Entry.n_strx]; 453 if (Start < getData().begin() || Start >= getData().end()) { 454 return malformedError("bad string index: " + Twine(Entry.n_strx) + 455 " for symbol at index " + Twine(getSymbolIndex(Symb))); 456 } 457 return StringRef(Start); 458 } 459 460 unsigned MachOObjectFile::getSectionType(SectionRef Sec) const { 461 DataRefImpl DRI = Sec.getRawDataRefImpl(); 462 uint32_t Flags = getSectionFlags(this, DRI); 463 return Flags & MachO::SECTION_TYPE; 464 } 465 466 uint64_t MachOObjectFile::getNValue(DataRefImpl Sym) const { 467 if (is64Bit()) { 468 MachO::nlist_64 Entry = getSymbol64TableEntry(Sym); 469 return Entry.n_value; 470 } 471 MachO::nlist Entry = getSymbolTableEntry(Sym); 472 return Entry.n_value; 473 } 474 475 // getIndirectName() returns the name of the alias'ed symbol who's string table 476 // index is in the n_value field. 477 std::error_code MachOObjectFile::getIndirectName(DataRefImpl Symb, 478 StringRef &Res) const { 479 StringRef StringTable = getStringTableData(); 480 MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb); 481 if ((Entry.n_type & MachO::N_TYPE) != MachO::N_INDR) 482 return object_error::parse_failed; 483 uint64_t NValue = getNValue(Symb); 484 if (NValue >= StringTable.size()) 485 return object_error::parse_failed; 486 const char *Start = &StringTable.data()[NValue]; 487 Res = StringRef(Start); 488 return std::error_code(); 489 } 490 491 uint64_t MachOObjectFile::getSymbolValueImpl(DataRefImpl Sym) const { 492 return getNValue(Sym); 493 } 494 495 Expected<uint64_t> MachOObjectFile::getSymbolAddress(DataRefImpl Sym) const { 496 return getSymbolValue(Sym); 497 } 498 499 uint32_t MachOObjectFile::getSymbolAlignment(DataRefImpl DRI) const { 500 uint32_t flags = getSymbolFlags(DRI); 501 if (flags & SymbolRef::SF_Common) { 502 MachO::nlist_base Entry = getSymbolTableEntryBase(this, DRI); 503 return 1 << MachO::GET_COMM_ALIGN(Entry.n_desc); 504 } 505 return 0; 506 } 507 508 uint64_t MachOObjectFile::getCommonSymbolSizeImpl(DataRefImpl DRI) const { 509 return getNValue(DRI); 510 } 511 512 Expected<SymbolRef::Type> 513 MachOObjectFile::getSymbolType(DataRefImpl Symb) const { 514 MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb); 515 uint8_t n_type = Entry.n_type; 516 517 // If this is a STAB debugging symbol, we can do nothing more. 518 if (n_type & MachO::N_STAB) 519 return SymbolRef::ST_Debug; 520 521 switch (n_type & MachO::N_TYPE) { 522 case MachO::N_UNDF : 523 return SymbolRef::ST_Unknown; 524 case MachO::N_SECT : 525 Expected<section_iterator> SecOrError = getSymbolSection(Symb); 526 if (!SecOrError) 527 return SecOrError.takeError(); 528 section_iterator Sec = *SecOrError; 529 if (Sec->isData() || Sec->isBSS()) 530 return SymbolRef::ST_Data; 531 return SymbolRef::ST_Function; 532 } 533 return SymbolRef::ST_Other; 534 } 535 536 uint32_t MachOObjectFile::getSymbolFlags(DataRefImpl DRI) const { 537 MachO::nlist_base Entry = getSymbolTableEntryBase(this, DRI); 538 539 uint8_t MachOType = Entry.n_type; 540 uint16_t MachOFlags = Entry.n_desc; 541 542 uint32_t Result = SymbolRef::SF_None; 543 544 if ((MachOType & MachO::N_TYPE) == MachO::N_INDR) 545 Result |= SymbolRef::SF_Indirect; 546 547 if (MachOType & MachO::N_STAB) 548 Result |= SymbolRef::SF_FormatSpecific; 549 550 if (MachOType & MachO::N_EXT) { 551 Result |= SymbolRef::SF_Global; 552 if ((MachOType & MachO::N_TYPE) == MachO::N_UNDF) { 553 if (getNValue(DRI)) 554 Result |= SymbolRef::SF_Common; 555 else 556 Result |= SymbolRef::SF_Undefined; 557 } 558 559 if (!(MachOType & MachO::N_PEXT)) 560 Result |= SymbolRef::SF_Exported; 561 } 562 563 if (MachOFlags & (MachO::N_WEAK_REF | MachO::N_WEAK_DEF)) 564 Result |= SymbolRef::SF_Weak; 565 566 if (MachOFlags & (MachO::N_ARM_THUMB_DEF)) 567 Result |= SymbolRef::SF_Thumb; 568 569 if ((MachOType & MachO::N_TYPE) == MachO::N_ABS) 570 Result |= SymbolRef::SF_Absolute; 571 572 return Result; 573 } 574 575 Expected<section_iterator> 576 MachOObjectFile::getSymbolSection(DataRefImpl Symb) const { 577 MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb); 578 uint8_t index = Entry.n_sect; 579 580 if (index == 0) 581 return section_end(); 582 DataRefImpl DRI; 583 DRI.d.a = index - 1; 584 if (DRI.d.a >= Sections.size()){ 585 return malformedError("bad section index: " + Twine((int)index) + 586 " for symbol at index " + Twine(getSymbolIndex(Symb))); 587 } 588 return section_iterator(SectionRef(DRI, this)); 589 } 590 591 unsigned MachOObjectFile::getSymbolSectionID(SymbolRef Sym) const { 592 MachO::nlist_base Entry = 593 getSymbolTableEntryBase(this, Sym.getRawDataRefImpl()); 594 return Entry.n_sect - 1; 595 } 596 597 void MachOObjectFile::moveSectionNext(DataRefImpl &Sec) const { 598 Sec.d.a++; 599 } 600 601 std::error_code MachOObjectFile::getSectionName(DataRefImpl Sec, 602 StringRef &Result) const { 603 ArrayRef<char> Raw = getSectionRawName(Sec); 604 Result = parseSegmentOrSectionName(Raw.data()); 605 return std::error_code(); 606 } 607 608 uint64_t MachOObjectFile::getSectionAddress(DataRefImpl Sec) const { 609 if (is64Bit()) 610 return getSection64(Sec).addr; 611 return getSection(Sec).addr; 612 } 613 614 uint64_t MachOObjectFile::getSectionSize(DataRefImpl Sec) const { 615 // In the case if a malformed Mach-O file where the section offset is past 616 // the end of the file or some part of the section size is past the end of 617 // the file return a size of zero or a size that covers the rest of the file 618 // but does not extend past the end of the file. 619 uint32_t SectOffset, SectType; 620 uint64_t SectSize; 621 622 if (is64Bit()) { 623 MachO::section_64 Sect = getSection64(Sec); 624 SectOffset = Sect.offset; 625 SectSize = Sect.size; 626 SectType = Sect.flags & MachO::SECTION_TYPE; 627 } else { 628 MachO::section Sect = getSection(Sec); 629 SectOffset = Sect.offset; 630 SectSize = Sect.size; 631 SectType = Sect.flags & MachO::SECTION_TYPE; 632 } 633 if (SectType == MachO::S_ZEROFILL || SectType == MachO::S_GB_ZEROFILL) 634 return SectSize; 635 uint64_t FileSize = getData().size(); 636 if (SectOffset > FileSize) 637 return 0; 638 if (FileSize - SectOffset < SectSize) 639 return FileSize - SectOffset; 640 return SectSize; 641 } 642 643 std::error_code MachOObjectFile::getSectionContents(DataRefImpl Sec, 644 StringRef &Res) const { 645 uint32_t Offset; 646 uint64_t Size; 647 648 if (is64Bit()) { 649 MachO::section_64 Sect = getSection64(Sec); 650 Offset = Sect.offset; 651 Size = Sect.size; 652 } else { 653 MachO::section Sect = getSection(Sec); 654 Offset = Sect.offset; 655 Size = Sect.size; 656 } 657 658 Res = this->getData().substr(Offset, Size); 659 return std::error_code(); 660 } 661 662 uint64_t MachOObjectFile::getSectionAlignment(DataRefImpl Sec) const { 663 uint32_t Align; 664 if (is64Bit()) { 665 MachO::section_64 Sect = getSection64(Sec); 666 Align = Sect.align; 667 } else { 668 MachO::section Sect = getSection(Sec); 669 Align = Sect.align; 670 } 671 672 return uint64_t(1) << Align; 673 } 674 675 bool MachOObjectFile::isSectionCompressed(DataRefImpl Sec) const { 676 return false; 677 } 678 679 bool MachOObjectFile::isSectionText(DataRefImpl Sec) const { 680 uint32_t Flags = getSectionFlags(this, Sec); 681 return Flags & MachO::S_ATTR_PURE_INSTRUCTIONS; 682 } 683 684 bool MachOObjectFile::isSectionData(DataRefImpl Sec) const { 685 uint32_t Flags = getSectionFlags(this, Sec); 686 unsigned SectionType = Flags & MachO::SECTION_TYPE; 687 return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) && 688 !(SectionType == MachO::S_ZEROFILL || 689 SectionType == MachO::S_GB_ZEROFILL); 690 } 691 692 bool MachOObjectFile::isSectionBSS(DataRefImpl Sec) const { 693 uint32_t Flags = getSectionFlags(this, Sec); 694 unsigned SectionType = Flags & MachO::SECTION_TYPE; 695 return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) && 696 (SectionType == MachO::S_ZEROFILL || 697 SectionType == MachO::S_GB_ZEROFILL); 698 } 699 700 unsigned MachOObjectFile::getSectionID(SectionRef Sec) const { 701 return Sec.getRawDataRefImpl().d.a; 702 } 703 704 bool MachOObjectFile::isSectionVirtual(DataRefImpl Sec) const { 705 // FIXME: Unimplemented. 706 return false; 707 } 708 709 bool MachOObjectFile::isSectionBitcode(DataRefImpl Sec) const { 710 StringRef SegmentName = getSectionFinalSegmentName(Sec); 711 StringRef SectName; 712 if (!getSectionName(Sec, SectName)) 713 return (SegmentName == "__LLVM" && SectName == "__bitcode"); 714 return false; 715 } 716 717 relocation_iterator MachOObjectFile::section_rel_begin(DataRefImpl Sec) const { 718 DataRefImpl Ret; 719 Ret.d.a = Sec.d.a; 720 Ret.d.b = 0; 721 return relocation_iterator(RelocationRef(Ret, this)); 722 } 723 724 relocation_iterator 725 MachOObjectFile::section_rel_end(DataRefImpl Sec) const { 726 uint32_t Num; 727 if (is64Bit()) { 728 MachO::section_64 Sect = getSection64(Sec); 729 Num = Sect.nreloc; 730 } else { 731 MachO::section Sect = getSection(Sec); 732 Num = Sect.nreloc; 733 } 734 735 DataRefImpl Ret; 736 Ret.d.a = Sec.d.a; 737 Ret.d.b = Num; 738 return relocation_iterator(RelocationRef(Ret, this)); 739 } 740 741 void MachOObjectFile::moveRelocationNext(DataRefImpl &Rel) const { 742 ++Rel.d.b; 743 } 744 745 uint64_t MachOObjectFile::getRelocationOffset(DataRefImpl Rel) const { 746 assert(getHeader().filetype == MachO::MH_OBJECT && 747 "Only implemented for MH_OBJECT"); 748 MachO::any_relocation_info RE = getRelocation(Rel); 749 return getAnyRelocationAddress(RE); 750 } 751 752 symbol_iterator 753 MachOObjectFile::getRelocationSymbol(DataRefImpl Rel) const { 754 MachO::any_relocation_info RE = getRelocation(Rel); 755 if (isRelocationScattered(RE)) 756 return symbol_end(); 757 758 uint32_t SymbolIdx = getPlainRelocationSymbolNum(RE); 759 bool isExtern = getPlainRelocationExternal(RE); 760 if (!isExtern) 761 return symbol_end(); 762 763 MachO::symtab_command S = getSymtabLoadCommand(); 764 unsigned SymbolTableEntrySize = is64Bit() ? 765 sizeof(MachO::nlist_64) : 766 sizeof(MachO::nlist); 767 uint64_t Offset = S.symoff + SymbolIdx * SymbolTableEntrySize; 768 DataRefImpl Sym; 769 Sym.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset)); 770 return symbol_iterator(SymbolRef(Sym, this)); 771 } 772 773 section_iterator 774 MachOObjectFile::getRelocationSection(DataRefImpl Rel) const { 775 return section_iterator(getAnyRelocationSection(getRelocation(Rel))); 776 } 777 778 uint64_t MachOObjectFile::getRelocationType(DataRefImpl Rel) const { 779 MachO::any_relocation_info RE = getRelocation(Rel); 780 return getAnyRelocationType(RE); 781 } 782 783 void MachOObjectFile::getRelocationTypeName( 784 DataRefImpl Rel, SmallVectorImpl<char> &Result) const { 785 StringRef res; 786 uint64_t RType = getRelocationType(Rel); 787 788 unsigned Arch = this->getArch(); 789 790 switch (Arch) { 791 case Triple::x86: { 792 static const char *const Table[] = { 793 "GENERIC_RELOC_VANILLA", 794 "GENERIC_RELOC_PAIR", 795 "GENERIC_RELOC_SECTDIFF", 796 "GENERIC_RELOC_PB_LA_PTR", 797 "GENERIC_RELOC_LOCAL_SECTDIFF", 798 "GENERIC_RELOC_TLV" }; 799 800 if (RType > 5) 801 res = "Unknown"; 802 else 803 res = Table[RType]; 804 break; 805 } 806 case Triple::x86_64: { 807 static const char *const Table[] = { 808 "X86_64_RELOC_UNSIGNED", 809 "X86_64_RELOC_SIGNED", 810 "X86_64_RELOC_BRANCH", 811 "X86_64_RELOC_GOT_LOAD", 812 "X86_64_RELOC_GOT", 813 "X86_64_RELOC_SUBTRACTOR", 814 "X86_64_RELOC_SIGNED_1", 815 "X86_64_RELOC_SIGNED_2", 816 "X86_64_RELOC_SIGNED_4", 817 "X86_64_RELOC_TLV" }; 818 819 if (RType > 9) 820 res = "Unknown"; 821 else 822 res = Table[RType]; 823 break; 824 } 825 case Triple::arm: { 826 static const char *const Table[] = { 827 "ARM_RELOC_VANILLA", 828 "ARM_RELOC_PAIR", 829 "ARM_RELOC_SECTDIFF", 830 "ARM_RELOC_LOCAL_SECTDIFF", 831 "ARM_RELOC_PB_LA_PTR", 832 "ARM_RELOC_BR24", 833 "ARM_THUMB_RELOC_BR22", 834 "ARM_THUMB_32BIT_BRANCH", 835 "ARM_RELOC_HALF", 836 "ARM_RELOC_HALF_SECTDIFF" }; 837 838 if (RType > 9) 839 res = "Unknown"; 840 else 841 res = Table[RType]; 842 break; 843 } 844 case Triple::aarch64: { 845 static const char *const Table[] = { 846 "ARM64_RELOC_UNSIGNED", "ARM64_RELOC_SUBTRACTOR", 847 "ARM64_RELOC_BRANCH26", "ARM64_RELOC_PAGE21", 848 "ARM64_RELOC_PAGEOFF12", "ARM64_RELOC_GOT_LOAD_PAGE21", 849 "ARM64_RELOC_GOT_LOAD_PAGEOFF12", "ARM64_RELOC_POINTER_TO_GOT", 850 "ARM64_RELOC_TLVP_LOAD_PAGE21", "ARM64_RELOC_TLVP_LOAD_PAGEOFF12", 851 "ARM64_RELOC_ADDEND" 852 }; 853 854 if (RType >= array_lengthof(Table)) 855 res = "Unknown"; 856 else 857 res = Table[RType]; 858 break; 859 } 860 case Triple::ppc: { 861 static const char *const Table[] = { 862 "PPC_RELOC_VANILLA", 863 "PPC_RELOC_PAIR", 864 "PPC_RELOC_BR14", 865 "PPC_RELOC_BR24", 866 "PPC_RELOC_HI16", 867 "PPC_RELOC_LO16", 868 "PPC_RELOC_HA16", 869 "PPC_RELOC_LO14", 870 "PPC_RELOC_SECTDIFF", 871 "PPC_RELOC_PB_LA_PTR", 872 "PPC_RELOC_HI16_SECTDIFF", 873 "PPC_RELOC_LO16_SECTDIFF", 874 "PPC_RELOC_HA16_SECTDIFF", 875 "PPC_RELOC_JBSR", 876 "PPC_RELOC_LO14_SECTDIFF", 877 "PPC_RELOC_LOCAL_SECTDIFF" }; 878 879 if (RType > 15) 880 res = "Unknown"; 881 else 882 res = Table[RType]; 883 break; 884 } 885 case Triple::UnknownArch: 886 res = "Unknown"; 887 break; 888 } 889 Result.append(res.begin(), res.end()); 890 } 891 892 uint8_t MachOObjectFile::getRelocationLength(DataRefImpl Rel) const { 893 MachO::any_relocation_info RE = getRelocation(Rel); 894 return getAnyRelocationLength(RE); 895 } 896 897 // 898 // guessLibraryShortName() is passed a name of a dynamic library and returns a 899 // guess on what the short name is. Then name is returned as a substring of the 900 // StringRef Name passed in. The name of the dynamic library is recognized as 901 // a framework if it has one of the two following forms: 902 // Foo.framework/Versions/A/Foo 903 // Foo.framework/Foo 904 // Where A and Foo can be any string. And may contain a trailing suffix 905 // starting with an underbar. If the Name is recognized as a framework then 906 // isFramework is set to true else it is set to false. If the Name has a 907 // suffix then Suffix is set to the substring in Name that contains the suffix 908 // else it is set to a NULL StringRef. 909 // 910 // The Name of the dynamic library is recognized as a library name if it has 911 // one of the two following forms: 912 // libFoo.A.dylib 913 // libFoo.dylib 914 // The library may have a suffix trailing the name Foo of the form: 915 // libFoo_profile.A.dylib 916 // libFoo_profile.dylib 917 // 918 // The Name of the dynamic library is also recognized as a library name if it 919 // has the following form: 920 // Foo.qtx 921 // 922 // If the Name of the dynamic library is none of the forms above then a NULL 923 // StringRef is returned. 924 // 925 StringRef MachOObjectFile::guessLibraryShortName(StringRef Name, 926 bool &isFramework, 927 StringRef &Suffix) { 928 StringRef Foo, F, DotFramework, V, Dylib, Lib, Dot, Qtx; 929 size_t a, b, c, d, Idx; 930 931 isFramework = false; 932 Suffix = StringRef(); 933 934 // Pull off the last component and make Foo point to it 935 a = Name.rfind('/'); 936 if (a == Name.npos || a == 0) 937 goto guess_library; 938 Foo = Name.slice(a+1, Name.npos); 939 940 // Look for a suffix starting with a '_' 941 Idx = Foo.rfind('_'); 942 if (Idx != Foo.npos && Foo.size() >= 2) { 943 Suffix = Foo.slice(Idx, Foo.npos); 944 Foo = Foo.slice(0, Idx); 945 } 946 947 // First look for the form Foo.framework/Foo 948 b = Name.rfind('/', a); 949 if (b == Name.npos) 950 Idx = 0; 951 else 952 Idx = b+1; 953 F = Name.slice(Idx, Idx + Foo.size()); 954 DotFramework = Name.slice(Idx + Foo.size(), 955 Idx + Foo.size() + sizeof(".framework/")-1); 956 if (F == Foo && DotFramework == ".framework/") { 957 isFramework = true; 958 return Foo; 959 } 960 961 // Next look for the form Foo.framework/Versions/A/Foo 962 if (b == Name.npos) 963 goto guess_library; 964 c = Name.rfind('/', b); 965 if (c == Name.npos || c == 0) 966 goto guess_library; 967 V = Name.slice(c+1, Name.npos); 968 if (!V.startswith("Versions/")) 969 goto guess_library; 970 d = Name.rfind('/', c); 971 if (d == Name.npos) 972 Idx = 0; 973 else 974 Idx = d+1; 975 F = Name.slice(Idx, Idx + Foo.size()); 976 DotFramework = Name.slice(Idx + Foo.size(), 977 Idx + Foo.size() + sizeof(".framework/")-1); 978 if (F == Foo && DotFramework == ".framework/") { 979 isFramework = true; 980 return Foo; 981 } 982 983 guess_library: 984 // pull off the suffix after the "." and make a point to it 985 a = Name.rfind('.'); 986 if (a == Name.npos || a == 0) 987 return StringRef(); 988 Dylib = Name.slice(a, Name.npos); 989 if (Dylib != ".dylib") 990 goto guess_qtx; 991 992 // First pull off the version letter for the form Foo.A.dylib if any. 993 if (a >= 3) { 994 Dot = Name.slice(a-2, a-1); 995 if (Dot == ".") 996 a = a - 2; 997 } 998 999 b = Name.rfind('/', a); 1000 if (b == Name.npos) 1001 b = 0; 1002 else 1003 b = b+1; 1004 // ignore any suffix after an underbar like Foo_profile.A.dylib 1005 Idx = Name.find('_', b); 1006 if (Idx != Name.npos && Idx != b) { 1007 Lib = Name.slice(b, Idx); 1008 Suffix = Name.slice(Idx, a); 1009 } 1010 else 1011 Lib = Name.slice(b, a); 1012 // There are incorrect library names of the form: 1013 // libATS.A_profile.dylib so check for these. 1014 if (Lib.size() >= 3) { 1015 Dot = Lib.slice(Lib.size()-2, Lib.size()-1); 1016 if (Dot == ".") 1017 Lib = Lib.slice(0, Lib.size()-2); 1018 } 1019 return Lib; 1020 1021 guess_qtx: 1022 Qtx = Name.slice(a, Name.npos); 1023 if (Qtx != ".qtx") 1024 return StringRef(); 1025 b = Name.rfind('/', a); 1026 if (b == Name.npos) 1027 Lib = Name.slice(0, a); 1028 else 1029 Lib = Name.slice(b+1, a); 1030 // There are library names of the form: QT.A.qtx so check for these. 1031 if (Lib.size() >= 3) { 1032 Dot = Lib.slice(Lib.size()-2, Lib.size()-1); 1033 if (Dot == ".") 1034 Lib = Lib.slice(0, Lib.size()-2); 1035 } 1036 return Lib; 1037 } 1038 1039 // getLibraryShortNameByIndex() is used to get the short name of the library 1040 // for an undefined symbol in a linked Mach-O binary that was linked with the 1041 // normal two-level namespace default (that is MH_TWOLEVEL in the header). 1042 // It is passed the index (0 - based) of the library as translated from 1043 // GET_LIBRARY_ORDINAL (1 - based). 1044 std::error_code MachOObjectFile::getLibraryShortNameByIndex(unsigned Index, 1045 StringRef &Res) const { 1046 if (Index >= Libraries.size()) 1047 return object_error::parse_failed; 1048 1049 // If the cache of LibrariesShortNames is not built up do that first for 1050 // all the Libraries. 1051 if (LibrariesShortNames.size() == 0) { 1052 for (unsigned i = 0; i < Libraries.size(); i++) { 1053 MachO::dylib_command D = 1054 getStruct<MachO::dylib_command>(this, Libraries[i]); 1055 if (D.dylib.name >= D.cmdsize) 1056 return object_error::parse_failed; 1057 const char *P = (const char *)(Libraries[i]) + D.dylib.name; 1058 StringRef Name = StringRef(P); 1059 if (D.dylib.name+Name.size() >= D.cmdsize) 1060 return object_error::parse_failed; 1061 StringRef Suffix; 1062 bool isFramework; 1063 StringRef shortName = guessLibraryShortName(Name, isFramework, Suffix); 1064 if (shortName.empty()) 1065 LibrariesShortNames.push_back(Name); 1066 else 1067 LibrariesShortNames.push_back(shortName); 1068 } 1069 } 1070 1071 Res = LibrariesShortNames[Index]; 1072 return std::error_code(); 1073 } 1074 1075 section_iterator 1076 MachOObjectFile::getRelocationRelocatedSection(relocation_iterator Rel) const { 1077 DataRefImpl Sec; 1078 Sec.d.a = Rel->getRawDataRefImpl().d.a; 1079 return section_iterator(SectionRef(Sec, this)); 1080 } 1081 1082 basic_symbol_iterator MachOObjectFile::symbol_begin_impl() const { 1083 DataRefImpl DRI; 1084 MachO::symtab_command Symtab = getSymtabLoadCommand(); 1085 if (!SymtabLoadCmd || Symtab.nsyms == 0) 1086 return basic_symbol_iterator(SymbolRef(DRI, this)); 1087 1088 return getSymbolByIndex(0); 1089 } 1090 1091 basic_symbol_iterator MachOObjectFile::symbol_end_impl() const { 1092 DataRefImpl DRI; 1093 MachO::symtab_command Symtab = getSymtabLoadCommand(); 1094 if (!SymtabLoadCmd || Symtab.nsyms == 0) 1095 return basic_symbol_iterator(SymbolRef(DRI, this)); 1096 1097 unsigned SymbolTableEntrySize = is64Bit() ? 1098 sizeof(MachO::nlist_64) : 1099 sizeof(MachO::nlist); 1100 unsigned Offset = Symtab.symoff + 1101 Symtab.nsyms * SymbolTableEntrySize; 1102 DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset)); 1103 return basic_symbol_iterator(SymbolRef(DRI, this)); 1104 } 1105 1106 basic_symbol_iterator MachOObjectFile::getSymbolByIndex(unsigned Index) const { 1107 MachO::symtab_command Symtab = getSymtabLoadCommand(); 1108 if (!SymtabLoadCmd || Index >= Symtab.nsyms) 1109 report_fatal_error("Requested symbol index is out of range."); 1110 unsigned SymbolTableEntrySize = 1111 is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist); 1112 DataRefImpl DRI; 1113 DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Symtab.symoff)); 1114 DRI.p += Index * SymbolTableEntrySize; 1115 return basic_symbol_iterator(SymbolRef(DRI, this)); 1116 } 1117 1118 uint64_t MachOObjectFile::getSymbolIndex(DataRefImpl Symb) const { 1119 MachO::symtab_command Symtab = getSymtabLoadCommand(); 1120 if (!SymtabLoadCmd) 1121 report_fatal_error("getSymbolIndex() called with no symbol table symbol"); 1122 unsigned SymbolTableEntrySize = 1123 is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist); 1124 DataRefImpl DRIstart; 1125 DRIstart.p = reinterpret_cast<uintptr_t>(getPtr(this, Symtab.symoff)); 1126 uint64_t Index = (Symb.p - DRIstart.p) / SymbolTableEntrySize; 1127 return Index; 1128 } 1129 1130 section_iterator MachOObjectFile::section_begin() const { 1131 DataRefImpl DRI; 1132 return section_iterator(SectionRef(DRI, this)); 1133 } 1134 1135 section_iterator MachOObjectFile::section_end() const { 1136 DataRefImpl DRI; 1137 DRI.d.a = Sections.size(); 1138 return section_iterator(SectionRef(DRI, this)); 1139 } 1140 1141 uint8_t MachOObjectFile::getBytesInAddress() const { 1142 return is64Bit() ? 8 : 4; 1143 } 1144 1145 StringRef MachOObjectFile::getFileFormatName() const { 1146 unsigned CPUType = getCPUType(this); 1147 if (!is64Bit()) { 1148 switch (CPUType) { 1149 case llvm::MachO::CPU_TYPE_I386: 1150 return "Mach-O 32-bit i386"; 1151 case llvm::MachO::CPU_TYPE_ARM: 1152 return "Mach-O arm"; 1153 case llvm::MachO::CPU_TYPE_POWERPC: 1154 return "Mach-O 32-bit ppc"; 1155 default: 1156 return "Mach-O 32-bit unknown"; 1157 } 1158 } 1159 1160 switch (CPUType) { 1161 case llvm::MachO::CPU_TYPE_X86_64: 1162 return "Mach-O 64-bit x86-64"; 1163 case llvm::MachO::CPU_TYPE_ARM64: 1164 return "Mach-O arm64"; 1165 case llvm::MachO::CPU_TYPE_POWERPC64: 1166 return "Mach-O 64-bit ppc64"; 1167 default: 1168 return "Mach-O 64-bit unknown"; 1169 } 1170 } 1171 1172 Triple::ArchType MachOObjectFile::getArch(uint32_t CPUType) { 1173 switch (CPUType) { 1174 case llvm::MachO::CPU_TYPE_I386: 1175 return Triple::x86; 1176 case llvm::MachO::CPU_TYPE_X86_64: 1177 return Triple::x86_64; 1178 case llvm::MachO::CPU_TYPE_ARM: 1179 return Triple::arm; 1180 case llvm::MachO::CPU_TYPE_ARM64: 1181 return Triple::aarch64; 1182 case llvm::MachO::CPU_TYPE_POWERPC: 1183 return Triple::ppc; 1184 case llvm::MachO::CPU_TYPE_POWERPC64: 1185 return Triple::ppc64; 1186 default: 1187 return Triple::UnknownArch; 1188 } 1189 } 1190 1191 Triple MachOObjectFile::getArchTriple(uint32_t CPUType, uint32_t CPUSubType, 1192 const char **McpuDefault) { 1193 if (McpuDefault) 1194 *McpuDefault = nullptr; 1195 1196 switch (CPUType) { 1197 case MachO::CPU_TYPE_I386: 1198 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) { 1199 case MachO::CPU_SUBTYPE_I386_ALL: 1200 return Triple("i386-apple-darwin"); 1201 default: 1202 return Triple(); 1203 } 1204 case MachO::CPU_TYPE_X86_64: 1205 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) { 1206 case MachO::CPU_SUBTYPE_X86_64_ALL: 1207 return Triple("x86_64-apple-darwin"); 1208 case MachO::CPU_SUBTYPE_X86_64_H: 1209 return Triple("x86_64h-apple-darwin"); 1210 default: 1211 return Triple(); 1212 } 1213 case MachO::CPU_TYPE_ARM: 1214 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) { 1215 case MachO::CPU_SUBTYPE_ARM_V4T: 1216 return Triple("armv4t-apple-darwin"); 1217 case MachO::CPU_SUBTYPE_ARM_V5TEJ: 1218 return Triple("armv5e-apple-darwin"); 1219 case MachO::CPU_SUBTYPE_ARM_XSCALE: 1220 return Triple("xscale-apple-darwin"); 1221 case MachO::CPU_SUBTYPE_ARM_V6: 1222 return Triple("armv6-apple-darwin"); 1223 case MachO::CPU_SUBTYPE_ARM_V6M: 1224 if (McpuDefault) 1225 *McpuDefault = "cortex-m0"; 1226 return Triple("armv6m-apple-darwin"); 1227 case MachO::CPU_SUBTYPE_ARM_V7: 1228 return Triple("armv7-apple-darwin"); 1229 case MachO::CPU_SUBTYPE_ARM_V7EM: 1230 if (McpuDefault) 1231 *McpuDefault = "cortex-m4"; 1232 return Triple("thumbv7em-apple-darwin"); 1233 case MachO::CPU_SUBTYPE_ARM_V7K: 1234 return Triple("armv7k-apple-darwin"); 1235 case MachO::CPU_SUBTYPE_ARM_V7M: 1236 if (McpuDefault) 1237 *McpuDefault = "cortex-m3"; 1238 return Triple("thumbv7m-apple-darwin"); 1239 case MachO::CPU_SUBTYPE_ARM_V7S: 1240 return Triple("armv7s-apple-darwin"); 1241 default: 1242 return Triple(); 1243 } 1244 case MachO::CPU_TYPE_ARM64: 1245 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) { 1246 case MachO::CPU_SUBTYPE_ARM64_ALL: 1247 return Triple("arm64-apple-darwin"); 1248 default: 1249 return Triple(); 1250 } 1251 case MachO::CPU_TYPE_POWERPC: 1252 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) { 1253 case MachO::CPU_SUBTYPE_POWERPC_ALL: 1254 return Triple("ppc-apple-darwin"); 1255 default: 1256 return Triple(); 1257 } 1258 case MachO::CPU_TYPE_POWERPC64: 1259 switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) { 1260 case MachO::CPU_SUBTYPE_POWERPC_ALL: 1261 return Triple("ppc64-apple-darwin"); 1262 default: 1263 return Triple(); 1264 } 1265 default: 1266 return Triple(); 1267 } 1268 } 1269 1270 Triple MachOObjectFile::getHostArch() { 1271 return Triple(sys::getDefaultTargetTriple()); 1272 } 1273 1274 bool MachOObjectFile::isValidArch(StringRef ArchFlag) { 1275 return StringSwitch<bool>(ArchFlag) 1276 .Case("i386", true) 1277 .Case("x86_64", true) 1278 .Case("x86_64h", true) 1279 .Case("armv4t", true) 1280 .Case("arm", true) 1281 .Case("armv5e", true) 1282 .Case("armv6", true) 1283 .Case("armv6m", true) 1284 .Case("armv7", true) 1285 .Case("armv7em", true) 1286 .Case("armv7k", true) 1287 .Case("armv7m", true) 1288 .Case("armv7s", true) 1289 .Case("arm64", true) 1290 .Case("ppc", true) 1291 .Case("ppc64", true) 1292 .Default(false); 1293 } 1294 1295 unsigned MachOObjectFile::getArch() const { 1296 return getArch(getCPUType(this)); 1297 } 1298 1299 Triple MachOObjectFile::getArchTriple(const char **McpuDefault) const { 1300 return getArchTriple(Header.cputype, Header.cpusubtype, McpuDefault); 1301 } 1302 1303 relocation_iterator MachOObjectFile::section_rel_begin(unsigned Index) const { 1304 DataRefImpl DRI; 1305 DRI.d.a = Index; 1306 return section_rel_begin(DRI); 1307 } 1308 1309 relocation_iterator MachOObjectFile::section_rel_end(unsigned Index) const { 1310 DataRefImpl DRI; 1311 DRI.d.a = Index; 1312 return section_rel_end(DRI); 1313 } 1314 1315 dice_iterator MachOObjectFile::begin_dices() const { 1316 DataRefImpl DRI; 1317 if (!DataInCodeLoadCmd) 1318 return dice_iterator(DiceRef(DRI, this)); 1319 1320 MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand(); 1321 DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, DicLC.dataoff)); 1322 return dice_iterator(DiceRef(DRI, this)); 1323 } 1324 1325 dice_iterator MachOObjectFile::end_dices() const { 1326 DataRefImpl DRI; 1327 if (!DataInCodeLoadCmd) 1328 return dice_iterator(DiceRef(DRI, this)); 1329 1330 MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand(); 1331 unsigned Offset = DicLC.dataoff + DicLC.datasize; 1332 DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset)); 1333 return dice_iterator(DiceRef(DRI, this)); 1334 } 1335 1336 ExportEntry::ExportEntry(ArrayRef<uint8_t> T) 1337 : Trie(T), Malformed(false), Done(false) {} 1338 1339 void ExportEntry::moveToFirst() { 1340 pushNode(0); 1341 pushDownUntilBottom(); 1342 } 1343 1344 void ExportEntry::moveToEnd() { 1345 Stack.clear(); 1346 Done = true; 1347 } 1348 1349 bool ExportEntry::operator==(const ExportEntry &Other) const { 1350 // Common case, one at end, other iterating from begin. 1351 if (Done || Other.Done) 1352 return (Done == Other.Done); 1353 // Not equal if different stack sizes. 1354 if (Stack.size() != Other.Stack.size()) 1355 return false; 1356 // Not equal if different cumulative strings. 1357 if (!CumulativeString.equals(Other.CumulativeString)) 1358 return false; 1359 // Equal if all nodes in both stacks match. 1360 for (unsigned i=0; i < Stack.size(); ++i) { 1361 if (Stack[i].Start != Other.Stack[i].Start) 1362 return false; 1363 } 1364 return true; 1365 } 1366 1367 uint64_t ExportEntry::readULEB128(const uint8_t *&Ptr) { 1368 unsigned Count; 1369 uint64_t Result = decodeULEB128(Ptr, &Count); 1370 Ptr += Count; 1371 if (Ptr > Trie.end()) { 1372 Ptr = Trie.end(); 1373 Malformed = true; 1374 } 1375 return Result; 1376 } 1377 1378 StringRef ExportEntry::name() const { 1379 return CumulativeString; 1380 } 1381 1382 uint64_t ExportEntry::flags() const { 1383 return Stack.back().Flags; 1384 } 1385 1386 uint64_t ExportEntry::address() const { 1387 return Stack.back().Address; 1388 } 1389 1390 uint64_t ExportEntry::other() const { 1391 return Stack.back().Other; 1392 } 1393 1394 StringRef ExportEntry::otherName() const { 1395 const char* ImportName = Stack.back().ImportName; 1396 if (ImportName) 1397 return StringRef(ImportName); 1398 return StringRef(); 1399 } 1400 1401 uint32_t ExportEntry::nodeOffset() const { 1402 return Stack.back().Start - Trie.begin(); 1403 } 1404 1405 ExportEntry::NodeState::NodeState(const uint8_t *Ptr) 1406 : Start(Ptr), Current(Ptr), Flags(0), Address(0), Other(0), 1407 ImportName(nullptr), ChildCount(0), NextChildIndex(0), 1408 ParentStringLength(0), IsExportNode(false) {} 1409 1410 void ExportEntry::pushNode(uint64_t offset) { 1411 const uint8_t *Ptr = Trie.begin() + offset; 1412 NodeState State(Ptr); 1413 uint64_t ExportInfoSize = readULEB128(State.Current); 1414 State.IsExportNode = (ExportInfoSize != 0); 1415 const uint8_t* Children = State.Current + ExportInfoSize; 1416 if (State.IsExportNode) { 1417 State.Flags = readULEB128(State.Current); 1418 if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT) { 1419 State.Address = 0; 1420 State.Other = readULEB128(State.Current); // dylib ordinal 1421 State.ImportName = reinterpret_cast<const char*>(State.Current); 1422 } else { 1423 State.Address = readULEB128(State.Current); 1424 if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER) 1425 State.Other = readULEB128(State.Current); 1426 } 1427 } 1428 State.ChildCount = *Children; 1429 State.Current = Children + 1; 1430 State.NextChildIndex = 0; 1431 State.ParentStringLength = CumulativeString.size(); 1432 Stack.push_back(State); 1433 } 1434 1435 void ExportEntry::pushDownUntilBottom() { 1436 while (Stack.back().NextChildIndex < Stack.back().ChildCount) { 1437 NodeState &Top = Stack.back(); 1438 CumulativeString.resize(Top.ParentStringLength); 1439 for (;*Top.Current != 0; Top.Current++) { 1440 char C = *Top.Current; 1441 CumulativeString.push_back(C); 1442 } 1443 Top.Current += 1; 1444 uint64_t childNodeIndex = readULEB128(Top.Current); 1445 Top.NextChildIndex += 1; 1446 pushNode(childNodeIndex); 1447 } 1448 if (!Stack.back().IsExportNode) { 1449 Malformed = true; 1450 moveToEnd(); 1451 } 1452 } 1453 1454 // We have a trie data structure and need a way to walk it that is compatible 1455 // with the C++ iterator model. The solution is a non-recursive depth first 1456 // traversal where the iterator contains a stack of parent nodes along with a 1457 // string that is the accumulation of all edge strings along the parent chain 1458 // to this point. 1459 // 1460 // There is one "export" node for each exported symbol. But because some 1461 // symbols may be a prefix of another symbol (e.g. _dup and _dup2), an export 1462 // node may have child nodes too. 1463 // 1464 // The algorithm for moveNext() is to keep moving down the leftmost unvisited 1465 // child until hitting a node with no children (which is an export node or 1466 // else the trie is malformed). On the way down, each node is pushed on the 1467 // stack ivar. If there is no more ways down, it pops up one and tries to go 1468 // down a sibling path until a childless node is reached. 1469 void ExportEntry::moveNext() { 1470 if (Stack.empty() || !Stack.back().IsExportNode) { 1471 Malformed = true; 1472 moveToEnd(); 1473 return; 1474 } 1475 1476 Stack.pop_back(); 1477 while (!Stack.empty()) { 1478 NodeState &Top = Stack.back(); 1479 if (Top.NextChildIndex < Top.ChildCount) { 1480 pushDownUntilBottom(); 1481 // Now at the next export node. 1482 return; 1483 } else { 1484 if (Top.IsExportNode) { 1485 // This node has no children but is itself an export node. 1486 CumulativeString.resize(Top.ParentStringLength); 1487 return; 1488 } 1489 Stack.pop_back(); 1490 } 1491 } 1492 Done = true; 1493 } 1494 1495 iterator_range<export_iterator> 1496 MachOObjectFile::exports(ArrayRef<uint8_t> Trie) { 1497 ExportEntry Start(Trie); 1498 if (Trie.size() == 0) 1499 Start.moveToEnd(); 1500 else 1501 Start.moveToFirst(); 1502 1503 ExportEntry Finish(Trie); 1504 Finish.moveToEnd(); 1505 1506 return make_range(export_iterator(Start), export_iterator(Finish)); 1507 } 1508 1509 iterator_range<export_iterator> MachOObjectFile::exports() const { 1510 return exports(getDyldInfoExportsTrie()); 1511 } 1512 1513 MachORebaseEntry::MachORebaseEntry(ArrayRef<uint8_t> Bytes, bool is64Bit) 1514 : Opcodes(Bytes), Ptr(Bytes.begin()), SegmentOffset(0), SegmentIndex(0), 1515 RemainingLoopCount(0), AdvanceAmount(0), RebaseType(0), 1516 PointerSize(is64Bit ? 8 : 4), Malformed(false), Done(false) {} 1517 1518 void MachORebaseEntry::moveToFirst() { 1519 Ptr = Opcodes.begin(); 1520 moveNext(); 1521 } 1522 1523 void MachORebaseEntry::moveToEnd() { 1524 Ptr = Opcodes.end(); 1525 RemainingLoopCount = 0; 1526 Done = true; 1527 } 1528 1529 void MachORebaseEntry::moveNext() { 1530 // If in the middle of some loop, move to next rebasing in loop. 1531 SegmentOffset += AdvanceAmount; 1532 if (RemainingLoopCount) { 1533 --RemainingLoopCount; 1534 return; 1535 } 1536 if (Ptr == Opcodes.end()) { 1537 Done = true; 1538 return; 1539 } 1540 bool More = true; 1541 while (More && !Malformed) { 1542 // Parse next opcode and set up next loop. 1543 uint8_t Byte = *Ptr++; 1544 uint8_t ImmValue = Byte & MachO::REBASE_IMMEDIATE_MASK; 1545 uint8_t Opcode = Byte & MachO::REBASE_OPCODE_MASK; 1546 switch (Opcode) { 1547 case MachO::REBASE_OPCODE_DONE: 1548 More = false; 1549 Done = true; 1550 moveToEnd(); 1551 DEBUG_WITH_TYPE("mach-o-rebase", llvm::dbgs() << "REBASE_OPCODE_DONE\n"); 1552 break; 1553 case MachO::REBASE_OPCODE_SET_TYPE_IMM: 1554 RebaseType = ImmValue; 1555 DEBUG_WITH_TYPE( 1556 "mach-o-rebase", 1557 llvm::dbgs() << "REBASE_OPCODE_SET_TYPE_IMM: " 1558 << "RebaseType=" << (int) RebaseType << "\n"); 1559 break; 1560 case MachO::REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: 1561 SegmentIndex = ImmValue; 1562 SegmentOffset = readULEB128(); 1563 DEBUG_WITH_TYPE( 1564 "mach-o-rebase", 1565 llvm::dbgs() << "REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: " 1566 << "SegmentIndex=" << SegmentIndex << ", " 1567 << format("SegmentOffset=0x%06X", SegmentOffset) 1568 << "\n"); 1569 break; 1570 case MachO::REBASE_OPCODE_ADD_ADDR_ULEB: 1571 SegmentOffset += readULEB128(); 1572 DEBUG_WITH_TYPE("mach-o-rebase", 1573 llvm::dbgs() << "REBASE_OPCODE_ADD_ADDR_ULEB: " 1574 << format("SegmentOffset=0x%06X", 1575 SegmentOffset) << "\n"); 1576 break; 1577 case MachO::REBASE_OPCODE_ADD_ADDR_IMM_SCALED: 1578 SegmentOffset += ImmValue * PointerSize; 1579 DEBUG_WITH_TYPE("mach-o-rebase", 1580 llvm::dbgs() << "REBASE_OPCODE_ADD_ADDR_IMM_SCALED: " 1581 << format("SegmentOffset=0x%06X", 1582 SegmentOffset) << "\n"); 1583 break; 1584 case MachO::REBASE_OPCODE_DO_REBASE_IMM_TIMES: 1585 AdvanceAmount = PointerSize; 1586 RemainingLoopCount = ImmValue - 1; 1587 DEBUG_WITH_TYPE( 1588 "mach-o-rebase", 1589 llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_IMM_TIMES: " 1590 << format("SegmentOffset=0x%06X", SegmentOffset) 1591 << ", AdvanceAmount=" << AdvanceAmount 1592 << ", RemainingLoopCount=" << RemainingLoopCount 1593 << "\n"); 1594 return; 1595 case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES: 1596 AdvanceAmount = PointerSize; 1597 RemainingLoopCount = readULEB128() - 1; 1598 DEBUG_WITH_TYPE( 1599 "mach-o-rebase", 1600 llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES: " 1601 << format("SegmentOffset=0x%06X", SegmentOffset) 1602 << ", AdvanceAmount=" << AdvanceAmount 1603 << ", RemainingLoopCount=" << RemainingLoopCount 1604 << "\n"); 1605 return; 1606 case MachO::REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: 1607 AdvanceAmount = readULEB128() + PointerSize; 1608 RemainingLoopCount = 0; 1609 DEBUG_WITH_TYPE( 1610 "mach-o-rebase", 1611 llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: " 1612 << format("SegmentOffset=0x%06X", SegmentOffset) 1613 << ", AdvanceAmount=" << AdvanceAmount 1614 << ", RemainingLoopCount=" << RemainingLoopCount 1615 << "\n"); 1616 return; 1617 case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: 1618 RemainingLoopCount = readULEB128() - 1; 1619 AdvanceAmount = readULEB128() + PointerSize; 1620 DEBUG_WITH_TYPE( 1621 "mach-o-rebase", 1622 llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: " 1623 << format("SegmentOffset=0x%06X", SegmentOffset) 1624 << ", AdvanceAmount=" << AdvanceAmount 1625 << ", RemainingLoopCount=" << RemainingLoopCount 1626 << "\n"); 1627 return; 1628 default: 1629 Malformed = true; 1630 } 1631 } 1632 } 1633 1634 uint64_t MachORebaseEntry::readULEB128() { 1635 unsigned Count; 1636 uint64_t Result = decodeULEB128(Ptr, &Count); 1637 Ptr += Count; 1638 if (Ptr > Opcodes.end()) { 1639 Ptr = Opcodes.end(); 1640 Malformed = true; 1641 } 1642 return Result; 1643 } 1644 1645 uint32_t MachORebaseEntry::segmentIndex() const { return SegmentIndex; } 1646 1647 uint64_t MachORebaseEntry::segmentOffset() const { return SegmentOffset; } 1648 1649 StringRef MachORebaseEntry::typeName() const { 1650 switch (RebaseType) { 1651 case MachO::REBASE_TYPE_POINTER: 1652 return "pointer"; 1653 case MachO::REBASE_TYPE_TEXT_ABSOLUTE32: 1654 return "text abs32"; 1655 case MachO::REBASE_TYPE_TEXT_PCREL32: 1656 return "text rel32"; 1657 } 1658 return "unknown"; 1659 } 1660 1661 bool MachORebaseEntry::operator==(const MachORebaseEntry &Other) const { 1662 assert(Opcodes == Other.Opcodes && "compare iterators of different files"); 1663 return (Ptr == Other.Ptr) && 1664 (RemainingLoopCount == Other.RemainingLoopCount) && 1665 (Done == Other.Done); 1666 } 1667 1668 iterator_range<rebase_iterator> 1669 MachOObjectFile::rebaseTable(ArrayRef<uint8_t> Opcodes, bool is64) { 1670 MachORebaseEntry Start(Opcodes, is64); 1671 Start.moveToFirst(); 1672 1673 MachORebaseEntry Finish(Opcodes, is64); 1674 Finish.moveToEnd(); 1675 1676 return make_range(rebase_iterator(Start), rebase_iterator(Finish)); 1677 } 1678 1679 iterator_range<rebase_iterator> MachOObjectFile::rebaseTable() const { 1680 return rebaseTable(getDyldInfoRebaseOpcodes(), is64Bit()); 1681 } 1682 1683 MachOBindEntry::MachOBindEntry(ArrayRef<uint8_t> Bytes, bool is64Bit, Kind BK) 1684 : Opcodes(Bytes), Ptr(Bytes.begin()), SegmentOffset(0), SegmentIndex(0), 1685 Ordinal(0), Flags(0), Addend(0), RemainingLoopCount(0), AdvanceAmount(0), 1686 BindType(0), PointerSize(is64Bit ? 8 : 4), 1687 TableKind(BK), Malformed(false), Done(false) {} 1688 1689 void MachOBindEntry::moveToFirst() { 1690 Ptr = Opcodes.begin(); 1691 moveNext(); 1692 } 1693 1694 void MachOBindEntry::moveToEnd() { 1695 Ptr = Opcodes.end(); 1696 RemainingLoopCount = 0; 1697 Done = true; 1698 } 1699 1700 void MachOBindEntry::moveNext() { 1701 // If in the middle of some loop, move to next binding in loop. 1702 SegmentOffset += AdvanceAmount; 1703 if (RemainingLoopCount) { 1704 --RemainingLoopCount; 1705 return; 1706 } 1707 if (Ptr == Opcodes.end()) { 1708 Done = true; 1709 return; 1710 } 1711 bool More = true; 1712 while (More && !Malformed) { 1713 // Parse next opcode and set up next loop. 1714 uint8_t Byte = *Ptr++; 1715 uint8_t ImmValue = Byte & MachO::BIND_IMMEDIATE_MASK; 1716 uint8_t Opcode = Byte & MachO::BIND_OPCODE_MASK; 1717 int8_t SignExtended; 1718 const uint8_t *SymStart; 1719 switch (Opcode) { 1720 case MachO::BIND_OPCODE_DONE: 1721 if (TableKind == Kind::Lazy) { 1722 // Lazying bindings have a DONE opcode between entries. Need to ignore 1723 // it to advance to next entry. But need not if this is last entry. 1724 bool NotLastEntry = false; 1725 for (const uint8_t *P = Ptr; P < Opcodes.end(); ++P) { 1726 if (*P) { 1727 NotLastEntry = true; 1728 } 1729 } 1730 if (NotLastEntry) 1731 break; 1732 } 1733 More = false; 1734 Done = true; 1735 moveToEnd(); 1736 DEBUG_WITH_TYPE("mach-o-bind", llvm::dbgs() << "BIND_OPCODE_DONE\n"); 1737 break; 1738 case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: 1739 Ordinal = ImmValue; 1740 DEBUG_WITH_TYPE( 1741 "mach-o-bind", 1742 llvm::dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: " 1743 << "Ordinal=" << Ordinal << "\n"); 1744 break; 1745 case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: 1746 Ordinal = readULEB128(); 1747 DEBUG_WITH_TYPE( 1748 "mach-o-bind", 1749 llvm::dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: " 1750 << "Ordinal=" << Ordinal << "\n"); 1751 break; 1752 case MachO::BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: 1753 if (ImmValue) { 1754 SignExtended = MachO::BIND_OPCODE_MASK | ImmValue; 1755 Ordinal = SignExtended; 1756 } else 1757 Ordinal = 0; 1758 DEBUG_WITH_TYPE( 1759 "mach-o-bind", 1760 llvm::dbgs() << "BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: " 1761 << "Ordinal=" << Ordinal << "\n"); 1762 break; 1763 case MachO::BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: 1764 Flags = ImmValue; 1765 SymStart = Ptr; 1766 while (*Ptr) { 1767 ++Ptr; 1768 } 1769 SymbolName = StringRef(reinterpret_cast<const char*>(SymStart), 1770 Ptr-SymStart); 1771 ++Ptr; 1772 DEBUG_WITH_TYPE( 1773 "mach-o-bind", 1774 llvm::dbgs() << "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: " 1775 << "SymbolName=" << SymbolName << "\n"); 1776 if (TableKind == Kind::Weak) { 1777 if (ImmValue & MachO::BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION) 1778 return; 1779 } 1780 break; 1781 case MachO::BIND_OPCODE_SET_TYPE_IMM: 1782 BindType = ImmValue; 1783 DEBUG_WITH_TYPE( 1784 "mach-o-bind", 1785 llvm::dbgs() << "BIND_OPCODE_SET_TYPE_IMM: " 1786 << "BindType=" << (int)BindType << "\n"); 1787 break; 1788 case MachO::BIND_OPCODE_SET_ADDEND_SLEB: 1789 Addend = readSLEB128(); 1790 if (TableKind == Kind::Lazy) 1791 Malformed = true; 1792 DEBUG_WITH_TYPE( 1793 "mach-o-bind", 1794 llvm::dbgs() << "BIND_OPCODE_SET_ADDEND_SLEB: " 1795 << "Addend=" << Addend << "\n"); 1796 break; 1797 case MachO::BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: 1798 SegmentIndex = ImmValue; 1799 SegmentOffset = readULEB128(); 1800 DEBUG_WITH_TYPE( 1801 "mach-o-bind", 1802 llvm::dbgs() << "BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: " 1803 << "SegmentIndex=" << SegmentIndex << ", " 1804 << format("SegmentOffset=0x%06X", SegmentOffset) 1805 << "\n"); 1806 break; 1807 case MachO::BIND_OPCODE_ADD_ADDR_ULEB: 1808 SegmentOffset += readULEB128(); 1809 DEBUG_WITH_TYPE("mach-o-bind", 1810 llvm::dbgs() << "BIND_OPCODE_ADD_ADDR_ULEB: " 1811 << format("SegmentOffset=0x%06X", 1812 SegmentOffset) << "\n"); 1813 break; 1814 case MachO::BIND_OPCODE_DO_BIND: 1815 AdvanceAmount = PointerSize; 1816 RemainingLoopCount = 0; 1817 DEBUG_WITH_TYPE("mach-o-bind", 1818 llvm::dbgs() << "BIND_OPCODE_DO_BIND: " 1819 << format("SegmentOffset=0x%06X", 1820 SegmentOffset) << "\n"); 1821 return; 1822 case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: 1823 AdvanceAmount = readULEB128() + PointerSize; 1824 RemainingLoopCount = 0; 1825 if (TableKind == Kind::Lazy) 1826 Malformed = true; 1827 DEBUG_WITH_TYPE( 1828 "mach-o-bind", 1829 llvm::dbgs() << "BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: " 1830 << format("SegmentOffset=0x%06X", SegmentOffset) 1831 << ", AdvanceAmount=" << AdvanceAmount 1832 << ", RemainingLoopCount=" << RemainingLoopCount 1833 << "\n"); 1834 return; 1835 case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: 1836 AdvanceAmount = ImmValue * PointerSize + PointerSize; 1837 RemainingLoopCount = 0; 1838 if (TableKind == Kind::Lazy) 1839 Malformed = true; 1840 DEBUG_WITH_TYPE("mach-o-bind", 1841 llvm::dbgs() 1842 << "BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: " 1843 << format("SegmentOffset=0x%06X", 1844 SegmentOffset) << "\n"); 1845 return; 1846 case MachO::BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: 1847 RemainingLoopCount = readULEB128() - 1; 1848 AdvanceAmount = readULEB128() + PointerSize; 1849 if (TableKind == Kind::Lazy) 1850 Malformed = true; 1851 DEBUG_WITH_TYPE( 1852 "mach-o-bind", 1853 llvm::dbgs() << "BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: " 1854 << format("SegmentOffset=0x%06X", SegmentOffset) 1855 << ", AdvanceAmount=" << AdvanceAmount 1856 << ", RemainingLoopCount=" << RemainingLoopCount 1857 << "\n"); 1858 return; 1859 default: 1860 Malformed = true; 1861 } 1862 } 1863 } 1864 1865 uint64_t MachOBindEntry::readULEB128() { 1866 unsigned Count; 1867 uint64_t Result = decodeULEB128(Ptr, &Count); 1868 Ptr += Count; 1869 if (Ptr > Opcodes.end()) { 1870 Ptr = Opcodes.end(); 1871 Malformed = true; 1872 } 1873 return Result; 1874 } 1875 1876 int64_t MachOBindEntry::readSLEB128() { 1877 unsigned Count; 1878 int64_t Result = decodeSLEB128(Ptr, &Count); 1879 Ptr += Count; 1880 if (Ptr > Opcodes.end()) { 1881 Ptr = Opcodes.end(); 1882 Malformed = true; 1883 } 1884 return Result; 1885 } 1886 1887 uint32_t MachOBindEntry::segmentIndex() const { return SegmentIndex; } 1888 1889 uint64_t MachOBindEntry::segmentOffset() const { return SegmentOffset; } 1890 1891 StringRef MachOBindEntry::typeName() const { 1892 switch (BindType) { 1893 case MachO::BIND_TYPE_POINTER: 1894 return "pointer"; 1895 case MachO::BIND_TYPE_TEXT_ABSOLUTE32: 1896 return "text abs32"; 1897 case MachO::BIND_TYPE_TEXT_PCREL32: 1898 return "text rel32"; 1899 } 1900 return "unknown"; 1901 } 1902 1903 StringRef MachOBindEntry::symbolName() const { return SymbolName; } 1904 1905 int64_t MachOBindEntry::addend() const { return Addend; } 1906 1907 uint32_t MachOBindEntry::flags() const { return Flags; } 1908 1909 int MachOBindEntry::ordinal() const { return Ordinal; } 1910 1911 bool MachOBindEntry::operator==(const MachOBindEntry &Other) const { 1912 assert(Opcodes == Other.Opcodes && "compare iterators of different files"); 1913 return (Ptr == Other.Ptr) && 1914 (RemainingLoopCount == Other.RemainingLoopCount) && 1915 (Done == Other.Done); 1916 } 1917 1918 iterator_range<bind_iterator> 1919 MachOObjectFile::bindTable(ArrayRef<uint8_t> Opcodes, bool is64, 1920 MachOBindEntry::Kind BKind) { 1921 MachOBindEntry Start(Opcodes, is64, BKind); 1922 Start.moveToFirst(); 1923 1924 MachOBindEntry Finish(Opcodes, is64, BKind); 1925 Finish.moveToEnd(); 1926 1927 return make_range(bind_iterator(Start), bind_iterator(Finish)); 1928 } 1929 1930 iterator_range<bind_iterator> MachOObjectFile::bindTable() const { 1931 return bindTable(getDyldInfoBindOpcodes(), is64Bit(), 1932 MachOBindEntry::Kind::Regular); 1933 } 1934 1935 iterator_range<bind_iterator> MachOObjectFile::lazyBindTable() const { 1936 return bindTable(getDyldInfoLazyBindOpcodes(), is64Bit(), 1937 MachOBindEntry::Kind::Lazy); 1938 } 1939 1940 iterator_range<bind_iterator> MachOObjectFile::weakBindTable() const { 1941 return bindTable(getDyldInfoWeakBindOpcodes(), is64Bit(), 1942 MachOBindEntry::Kind::Weak); 1943 } 1944 1945 MachOObjectFile::load_command_iterator 1946 MachOObjectFile::begin_load_commands() const { 1947 return LoadCommands.begin(); 1948 } 1949 1950 MachOObjectFile::load_command_iterator 1951 MachOObjectFile::end_load_commands() const { 1952 return LoadCommands.end(); 1953 } 1954 1955 iterator_range<MachOObjectFile::load_command_iterator> 1956 MachOObjectFile::load_commands() const { 1957 return make_range(begin_load_commands(), end_load_commands()); 1958 } 1959 1960 StringRef 1961 MachOObjectFile::getSectionFinalSegmentName(DataRefImpl Sec) const { 1962 ArrayRef<char> Raw = getSectionRawFinalSegmentName(Sec); 1963 return parseSegmentOrSectionName(Raw.data()); 1964 } 1965 1966 ArrayRef<char> 1967 MachOObjectFile::getSectionRawName(DataRefImpl Sec) const { 1968 assert(Sec.d.a < Sections.size() && "Should have detected this earlier"); 1969 const section_base *Base = 1970 reinterpret_cast<const section_base *>(Sections[Sec.d.a]); 1971 return makeArrayRef(Base->sectname); 1972 } 1973 1974 ArrayRef<char> 1975 MachOObjectFile::getSectionRawFinalSegmentName(DataRefImpl Sec) const { 1976 assert(Sec.d.a < Sections.size() && "Should have detected this earlier"); 1977 const section_base *Base = 1978 reinterpret_cast<const section_base *>(Sections[Sec.d.a]); 1979 return makeArrayRef(Base->segname); 1980 } 1981 1982 bool 1983 MachOObjectFile::isRelocationScattered(const MachO::any_relocation_info &RE) 1984 const { 1985 if (getCPUType(this) == MachO::CPU_TYPE_X86_64) 1986 return false; 1987 return getPlainRelocationAddress(RE) & MachO::R_SCATTERED; 1988 } 1989 1990 unsigned MachOObjectFile::getPlainRelocationSymbolNum( 1991 const MachO::any_relocation_info &RE) const { 1992 if (isLittleEndian()) 1993 return RE.r_word1 & 0xffffff; 1994 return RE.r_word1 >> 8; 1995 } 1996 1997 bool MachOObjectFile::getPlainRelocationExternal( 1998 const MachO::any_relocation_info &RE) const { 1999 if (isLittleEndian()) 2000 return (RE.r_word1 >> 27) & 1; 2001 return (RE.r_word1 >> 4) & 1; 2002 } 2003 2004 bool MachOObjectFile::getScatteredRelocationScattered( 2005 const MachO::any_relocation_info &RE) const { 2006 return RE.r_word0 >> 31; 2007 } 2008 2009 uint32_t MachOObjectFile::getScatteredRelocationValue( 2010 const MachO::any_relocation_info &RE) const { 2011 return RE.r_word1; 2012 } 2013 2014 uint32_t MachOObjectFile::getScatteredRelocationType( 2015 const MachO::any_relocation_info &RE) const { 2016 return (RE.r_word0 >> 24) & 0xf; 2017 } 2018 2019 unsigned MachOObjectFile::getAnyRelocationAddress( 2020 const MachO::any_relocation_info &RE) const { 2021 if (isRelocationScattered(RE)) 2022 return getScatteredRelocationAddress(RE); 2023 return getPlainRelocationAddress(RE); 2024 } 2025 2026 unsigned MachOObjectFile::getAnyRelocationPCRel( 2027 const MachO::any_relocation_info &RE) const { 2028 if (isRelocationScattered(RE)) 2029 return getScatteredRelocationPCRel(this, RE); 2030 return getPlainRelocationPCRel(this, RE); 2031 } 2032 2033 unsigned MachOObjectFile::getAnyRelocationLength( 2034 const MachO::any_relocation_info &RE) const { 2035 if (isRelocationScattered(RE)) 2036 return getScatteredRelocationLength(RE); 2037 return getPlainRelocationLength(this, RE); 2038 } 2039 2040 unsigned 2041 MachOObjectFile::getAnyRelocationType( 2042 const MachO::any_relocation_info &RE) const { 2043 if (isRelocationScattered(RE)) 2044 return getScatteredRelocationType(RE); 2045 return getPlainRelocationType(this, RE); 2046 } 2047 2048 SectionRef 2049 MachOObjectFile::getAnyRelocationSection( 2050 const MachO::any_relocation_info &RE) const { 2051 if (isRelocationScattered(RE) || getPlainRelocationExternal(RE)) 2052 return *section_end(); 2053 unsigned SecNum = getPlainRelocationSymbolNum(RE); 2054 if (SecNum == MachO::R_ABS || SecNum > Sections.size()) 2055 return *section_end(); 2056 DataRefImpl DRI; 2057 DRI.d.a = SecNum - 1; 2058 return SectionRef(DRI, this); 2059 } 2060 2061 MachO::section MachOObjectFile::getSection(DataRefImpl DRI) const { 2062 assert(DRI.d.a < Sections.size() && "Should have detected this earlier"); 2063 return getStruct<MachO::section>(this, Sections[DRI.d.a]); 2064 } 2065 2066 MachO::section_64 MachOObjectFile::getSection64(DataRefImpl DRI) const { 2067 assert(DRI.d.a < Sections.size() && "Should have detected this earlier"); 2068 return getStruct<MachO::section_64>(this, Sections[DRI.d.a]); 2069 } 2070 2071 MachO::section MachOObjectFile::getSection(const LoadCommandInfo &L, 2072 unsigned Index) const { 2073 const char *Sec = getSectionPtr(this, L, Index); 2074 return getStruct<MachO::section>(this, Sec); 2075 } 2076 2077 MachO::section_64 MachOObjectFile::getSection64(const LoadCommandInfo &L, 2078 unsigned Index) const { 2079 const char *Sec = getSectionPtr(this, L, Index); 2080 return getStruct<MachO::section_64>(this, Sec); 2081 } 2082 2083 MachO::nlist 2084 MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI) const { 2085 const char *P = reinterpret_cast<const char *>(DRI.p); 2086 return getStruct<MachO::nlist>(this, P); 2087 } 2088 2089 MachO::nlist_64 2090 MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI) const { 2091 const char *P = reinterpret_cast<const char *>(DRI.p); 2092 return getStruct<MachO::nlist_64>(this, P); 2093 } 2094 2095 MachO::linkedit_data_command 2096 MachOObjectFile::getLinkeditDataLoadCommand(const LoadCommandInfo &L) const { 2097 return getStruct<MachO::linkedit_data_command>(this, L.Ptr); 2098 } 2099 2100 MachO::segment_command 2101 MachOObjectFile::getSegmentLoadCommand(const LoadCommandInfo &L) const { 2102 return getStruct<MachO::segment_command>(this, L.Ptr); 2103 } 2104 2105 MachO::segment_command_64 2106 MachOObjectFile::getSegment64LoadCommand(const LoadCommandInfo &L) const { 2107 return getStruct<MachO::segment_command_64>(this, L.Ptr); 2108 } 2109 2110 MachO::linker_option_command 2111 MachOObjectFile::getLinkerOptionLoadCommand(const LoadCommandInfo &L) const { 2112 return getStruct<MachO::linker_option_command>(this, L.Ptr); 2113 } 2114 2115 MachO::version_min_command 2116 MachOObjectFile::getVersionMinLoadCommand(const LoadCommandInfo &L) const { 2117 return getStruct<MachO::version_min_command>(this, L.Ptr); 2118 } 2119 2120 MachO::dylib_command 2121 MachOObjectFile::getDylibIDLoadCommand(const LoadCommandInfo &L) const { 2122 return getStruct<MachO::dylib_command>(this, L.Ptr); 2123 } 2124 2125 MachO::dyld_info_command 2126 MachOObjectFile::getDyldInfoLoadCommand(const LoadCommandInfo &L) const { 2127 return getStruct<MachO::dyld_info_command>(this, L.Ptr); 2128 } 2129 2130 MachO::dylinker_command 2131 MachOObjectFile::getDylinkerCommand(const LoadCommandInfo &L) const { 2132 return getStruct<MachO::dylinker_command>(this, L.Ptr); 2133 } 2134 2135 MachO::uuid_command 2136 MachOObjectFile::getUuidCommand(const LoadCommandInfo &L) const { 2137 return getStruct<MachO::uuid_command>(this, L.Ptr); 2138 } 2139 2140 MachO::rpath_command 2141 MachOObjectFile::getRpathCommand(const LoadCommandInfo &L) const { 2142 return getStruct<MachO::rpath_command>(this, L.Ptr); 2143 } 2144 2145 MachO::source_version_command 2146 MachOObjectFile::getSourceVersionCommand(const LoadCommandInfo &L) const { 2147 return getStruct<MachO::source_version_command>(this, L.Ptr); 2148 } 2149 2150 MachO::entry_point_command 2151 MachOObjectFile::getEntryPointCommand(const LoadCommandInfo &L) const { 2152 return getStruct<MachO::entry_point_command>(this, L.Ptr); 2153 } 2154 2155 MachO::encryption_info_command 2156 MachOObjectFile::getEncryptionInfoCommand(const LoadCommandInfo &L) const { 2157 return getStruct<MachO::encryption_info_command>(this, L.Ptr); 2158 } 2159 2160 MachO::encryption_info_command_64 2161 MachOObjectFile::getEncryptionInfoCommand64(const LoadCommandInfo &L) const { 2162 return getStruct<MachO::encryption_info_command_64>(this, L.Ptr); 2163 } 2164 2165 MachO::sub_framework_command 2166 MachOObjectFile::getSubFrameworkCommand(const LoadCommandInfo &L) const { 2167 return getStruct<MachO::sub_framework_command>(this, L.Ptr); 2168 } 2169 2170 MachO::sub_umbrella_command 2171 MachOObjectFile::getSubUmbrellaCommand(const LoadCommandInfo &L) const { 2172 return getStruct<MachO::sub_umbrella_command>(this, L.Ptr); 2173 } 2174 2175 MachO::sub_library_command 2176 MachOObjectFile::getSubLibraryCommand(const LoadCommandInfo &L) const { 2177 return getStruct<MachO::sub_library_command>(this, L.Ptr); 2178 } 2179 2180 MachO::sub_client_command 2181 MachOObjectFile::getSubClientCommand(const LoadCommandInfo &L) const { 2182 return getStruct<MachO::sub_client_command>(this, L.Ptr); 2183 } 2184 2185 MachO::routines_command 2186 MachOObjectFile::getRoutinesCommand(const LoadCommandInfo &L) const { 2187 return getStruct<MachO::routines_command>(this, L.Ptr); 2188 } 2189 2190 MachO::routines_command_64 2191 MachOObjectFile::getRoutinesCommand64(const LoadCommandInfo &L) const { 2192 return getStruct<MachO::routines_command_64>(this, L.Ptr); 2193 } 2194 2195 MachO::thread_command 2196 MachOObjectFile::getThreadCommand(const LoadCommandInfo &L) const { 2197 return getStruct<MachO::thread_command>(this, L.Ptr); 2198 } 2199 2200 MachO::any_relocation_info 2201 MachOObjectFile::getRelocation(DataRefImpl Rel) const { 2202 DataRefImpl Sec; 2203 Sec.d.a = Rel.d.a; 2204 uint32_t Offset; 2205 if (is64Bit()) { 2206 MachO::section_64 Sect = getSection64(Sec); 2207 Offset = Sect.reloff; 2208 } else { 2209 MachO::section Sect = getSection(Sec); 2210 Offset = Sect.reloff; 2211 } 2212 2213 auto P = reinterpret_cast<const MachO::any_relocation_info *>( 2214 getPtr(this, Offset)) + Rel.d.b; 2215 return getStruct<MachO::any_relocation_info>( 2216 this, reinterpret_cast<const char *>(P)); 2217 } 2218 2219 MachO::data_in_code_entry 2220 MachOObjectFile::getDice(DataRefImpl Rel) const { 2221 const char *P = reinterpret_cast<const char *>(Rel.p); 2222 return getStruct<MachO::data_in_code_entry>(this, P); 2223 } 2224 2225 const MachO::mach_header &MachOObjectFile::getHeader() const { 2226 return Header; 2227 } 2228 2229 const MachO::mach_header_64 &MachOObjectFile::getHeader64() const { 2230 assert(is64Bit()); 2231 return Header64; 2232 } 2233 2234 uint32_t MachOObjectFile::getIndirectSymbolTableEntry( 2235 const MachO::dysymtab_command &DLC, 2236 unsigned Index) const { 2237 uint64_t Offset = DLC.indirectsymoff + Index * sizeof(uint32_t); 2238 return getStruct<uint32_t>(this, getPtr(this, Offset)); 2239 } 2240 2241 MachO::data_in_code_entry 2242 MachOObjectFile::getDataInCodeTableEntry(uint32_t DataOffset, 2243 unsigned Index) const { 2244 uint64_t Offset = DataOffset + Index * sizeof(MachO::data_in_code_entry); 2245 return getStruct<MachO::data_in_code_entry>(this, getPtr(this, Offset)); 2246 } 2247 2248 MachO::symtab_command MachOObjectFile::getSymtabLoadCommand() const { 2249 if (SymtabLoadCmd) 2250 return getStruct<MachO::symtab_command>(this, SymtabLoadCmd); 2251 2252 // If there is no SymtabLoadCmd return a load command with zero'ed fields. 2253 MachO::symtab_command Cmd; 2254 Cmd.cmd = MachO::LC_SYMTAB; 2255 Cmd.cmdsize = sizeof(MachO::symtab_command); 2256 Cmd.symoff = 0; 2257 Cmd.nsyms = 0; 2258 Cmd.stroff = 0; 2259 Cmd.strsize = 0; 2260 return Cmd; 2261 } 2262 2263 MachO::dysymtab_command MachOObjectFile::getDysymtabLoadCommand() const { 2264 if (DysymtabLoadCmd) 2265 return getStruct<MachO::dysymtab_command>(this, DysymtabLoadCmd); 2266 2267 // If there is no DysymtabLoadCmd return a load command with zero'ed fields. 2268 MachO::dysymtab_command Cmd; 2269 Cmd.cmd = MachO::LC_DYSYMTAB; 2270 Cmd.cmdsize = sizeof(MachO::dysymtab_command); 2271 Cmd.ilocalsym = 0; 2272 Cmd.nlocalsym = 0; 2273 Cmd.iextdefsym = 0; 2274 Cmd.nextdefsym = 0; 2275 Cmd.iundefsym = 0; 2276 Cmd.nundefsym = 0; 2277 Cmd.tocoff = 0; 2278 Cmd.ntoc = 0; 2279 Cmd.modtaboff = 0; 2280 Cmd.nmodtab = 0; 2281 Cmd.extrefsymoff = 0; 2282 Cmd.nextrefsyms = 0; 2283 Cmd.indirectsymoff = 0; 2284 Cmd.nindirectsyms = 0; 2285 Cmd.extreloff = 0; 2286 Cmd.nextrel = 0; 2287 Cmd.locreloff = 0; 2288 Cmd.nlocrel = 0; 2289 return Cmd; 2290 } 2291 2292 MachO::linkedit_data_command 2293 MachOObjectFile::getDataInCodeLoadCommand() const { 2294 if (DataInCodeLoadCmd) 2295 return getStruct<MachO::linkedit_data_command>(this, DataInCodeLoadCmd); 2296 2297 // If there is no DataInCodeLoadCmd return a load command with zero'ed fields. 2298 MachO::linkedit_data_command Cmd; 2299 Cmd.cmd = MachO::LC_DATA_IN_CODE; 2300 Cmd.cmdsize = sizeof(MachO::linkedit_data_command); 2301 Cmd.dataoff = 0; 2302 Cmd.datasize = 0; 2303 return Cmd; 2304 } 2305 2306 MachO::linkedit_data_command 2307 MachOObjectFile::getLinkOptHintsLoadCommand() const { 2308 if (LinkOptHintsLoadCmd) 2309 return getStruct<MachO::linkedit_data_command>(this, LinkOptHintsLoadCmd); 2310 2311 // If there is no LinkOptHintsLoadCmd return a load command with zero'ed 2312 // fields. 2313 MachO::linkedit_data_command Cmd; 2314 Cmd.cmd = MachO::LC_LINKER_OPTIMIZATION_HINT; 2315 Cmd.cmdsize = sizeof(MachO::linkedit_data_command); 2316 Cmd.dataoff = 0; 2317 Cmd.datasize = 0; 2318 return Cmd; 2319 } 2320 2321 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoRebaseOpcodes() const { 2322 if (!DyldInfoLoadCmd) 2323 return None; 2324 2325 MachO::dyld_info_command DyldInfo = 2326 getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd); 2327 const uint8_t *Ptr = 2328 reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.rebase_off)); 2329 return makeArrayRef(Ptr, DyldInfo.rebase_size); 2330 } 2331 2332 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoBindOpcodes() const { 2333 if (!DyldInfoLoadCmd) 2334 return None; 2335 2336 MachO::dyld_info_command DyldInfo = 2337 getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd); 2338 const uint8_t *Ptr = 2339 reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.bind_off)); 2340 return makeArrayRef(Ptr, DyldInfo.bind_size); 2341 } 2342 2343 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoWeakBindOpcodes() const { 2344 if (!DyldInfoLoadCmd) 2345 return None; 2346 2347 MachO::dyld_info_command DyldInfo = 2348 getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd); 2349 const uint8_t *Ptr = 2350 reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.weak_bind_off)); 2351 return makeArrayRef(Ptr, DyldInfo.weak_bind_size); 2352 } 2353 2354 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoLazyBindOpcodes() const { 2355 if (!DyldInfoLoadCmd) 2356 return None; 2357 2358 MachO::dyld_info_command DyldInfo = 2359 getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd); 2360 const uint8_t *Ptr = 2361 reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.lazy_bind_off)); 2362 return makeArrayRef(Ptr, DyldInfo.lazy_bind_size); 2363 } 2364 2365 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoExportsTrie() const { 2366 if (!DyldInfoLoadCmd) 2367 return None; 2368 2369 MachO::dyld_info_command DyldInfo = 2370 getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd); 2371 const uint8_t *Ptr = 2372 reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.export_off)); 2373 return makeArrayRef(Ptr, DyldInfo.export_size); 2374 } 2375 2376 ArrayRef<uint8_t> MachOObjectFile::getUuid() const { 2377 if (!UuidLoadCmd) 2378 return None; 2379 // Returning a pointer is fine as uuid doesn't need endian swapping. 2380 const char *Ptr = UuidLoadCmd + offsetof(MachO::uuid_command, uuid); 2381 return makeArrayRef(reinterpret_cast<const uint8_t *>(Ptr), 16); 2382 } 2383 2384 StringRef MachOObjectFile::getStringTableData() const { 2385 MachO::symtab_command S = getSymtabLoadCommand(); 2386 return getData().substr(S.stroff, S.strsize); 2387 } 2388 2389 bool MachOObjectFile::is64Bit() const { 2390 return getType() == getMachOType(false, true) || 2391 getType() == getMachOType(true, true); 2392 } 2393 2394 void MachOObjectFile::ReadULEB128s(uint64_t Index, 2395 SmallVectorImpl<uint64_t> &Out) const { 2396 DataExtractor extractor(ObjectFile::getData(), true, 0); 2397 2398 uint32_t offset = Index; 2399 uint64_t data = 0; 2400 while (uint64_t delta = extractor.getULEB128(&offset)) { 2401 data += delta; 2402 Out.push_back(data); 2403 } 2404 } 2405 2406 bool MachOObjectFile::isRelocatableObject() const { 2407 return getHeader().filetype == MachO::MH_OBJECT; 2408 } 2409 2410 Expected<std::unique_ptr<MachOObjectFile>> 2411 ObjectFile::createMachOObjectFile(MemoryBufferRef Buffer) { 2412 StringRef Magic = Buffer.getBuffer().slice(0, 4); 2413 if (Magic == "\xFE\xED\xFA\xCE") 2414 return MachOObjectFile::create(Buffer, false, false); 2415 if (Magic == "\xCE\xFA\xED\xFE") 2416 return MachOObjectFile::create(Buffer, true, false); 2417 if (Magic == "\xFE\xED\xFA\xCF") 2418 return MachOObjectFile::create(Buffer, false, true); 2419 if (Magic == "\xCF\xFA\xED\xFE") 2420 return MachOObjectFile::create(Buffer, true, true); 2421 return make_error<GenericBinaryError>("Unrecognized MachO magic number", 2422 object_error::invalid_file_type); 2423 } 2424
