lib/Object/MachOObjectFile.cpp

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