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