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