contrib/llvm-project/llvm/lib/Object/MachOObjectFile.cpp

   1 //===- MachOObjectFile.cpp - Mach-O object file binding -------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file defines the MachOObjectFile class, which binds the MachOObject
  10 // class to the generic ObjectFile wrapper.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/ADT/ArrayRef.h"
  15 #include "llvm/ADT/None.h"
  16 #include "llvm/ADT/STLExtras.h"
  17 #include "llvm/ADT/SmallVector.h"
  18 #include "llvm/ADT/StringRef.h"
  19 #include "llvm/ADT/StringSwitch.h"
  20 #include "llvm/ADT/Triple.h"
  21 #include "llvm/ADT/Twine.h"
  22 #include "llvm/BinaryFormat/MachO.h"
  23 #include "llvm/Object/Error.h"
  24 #include "llvm/Object/MachO.h"
  25 #include "llvm/Object/ObjectFile.h"
  26 #include "llvm/Object/SymbolicFile.h"
  27 #include "llvm/Support/DataExtractor.h"
  28 #include "llvm/Support/Debug.h"
  29 #include "llvm/Support/Error.h"
  30 #include "llvm/Support/ErrorHandling.h"
  31 #include "llvm/Support/Format.h"
  32 #include "llvm/Support/Host.h"
  33 #include "llvm/Support/LEB128.h"
  34 #include "llvm/Support/MemoryBuffer.h"
  35 #include "llvm/Support/SwapByteOrder.h"
  36 #include "llvm/Support/raw_ostream.h"
  37 #include <algorithm>
  38 #include <cassert>
  39 #include <cstddef>
  40 #include <cstdint>
  41 #include <cstring>
  42 #include <limits>
  43 #include <list>
  44 #include <memory>
  45 #include <string>
  46 #include <system_error>
  47
  48 using namespace llvm;
  49 using namespace object;
  50
  51 namespace {
  52
  53   struct section_base {
  54     char sectname[16];
  55     char segname[16];
  56   };
  57
  58 } // end anonymous namespace
  59
  60 static const std::array<StringRef, 17> validArchs = {
  61     "i386",   "x86_64", "x86_64h",  "armv4t",  "arm",    "armv5e",
  62     "armv6",  "armv6m", "armv7",    "armv7em", "armv7k", "armv7m",
  63     "armv7s", "arm64",  "arm64_32", "ppc",     "ppc64",
  64 };
  65
  66 static Error malformedError(const Twine &Msg) {
  67   return make_error<GenericBinaryError>("truncated or malformed object (" +
  68                                             Msg + ")",
  69                                         object_error::parse_failed);
  70 }
  71
  72 // FIXME: Replace all uses of this function with getStructOrErr.
  73 template <typename T>
  74 static T getStruct(const MachOObjectFile &O, const char *P) {
  75   // Don't read before the beginning or past the end of the file
  76   if (P < O.getData().begin() || P + sizeof(T) > O.getData().end())
  77     report_fatal_error("Malformed MachO file.");
  78
  79   T Cmd;
  80   memcpy(&Cmd, P, sizeof(T));
  81   if (O.isLittleEndian() != sys::IsLittleEndianHost)
  82     MachO::swapStruct(Cmd);
  83   return Cmd;
  84 }
  85
  86 template <typename T>
  87 static Expected<T> getStructOrErr(const MachOObjectFile &O, const char *P) {
  88   // Don't read before the beginning or past the end of the file
  89   if (P < O.getData().begin() || P + sizeof(T) > O.getData().end())
  90     return malformedError("Structure read out-of-range");
  91
  92   T Cmd;
  93   memcpy(&Cmd, P, sizeof(T));
  94   if (O.isLittleEndian() != sys::IsLittleEndianHost)
  95     MachO::swapStruct(Cmd);
  96   return Cmd;
  97 }
  98
  99 static const char *
 100 getSectionPtr(const MachOObjectFile &O, MachOObjectFile::LoadCommandInfo L,
 101               unsigned Sec) {
 102   uintptr_t CommandAddr = reinterpret_cast<uintptr_t>(L.Ptr);
 103
 104   bool Is64 = O.is64Bit();
 105   unsigned SegmentLoadSize = Is64 ? sizeof(MachO::segment_command_64) :
 106                                     sizeof(MachO::segment_command);
 107   unsigned SectionSize = Is64 ? sizeof(MachO::section_64) :
 108                                 sizeof(MachO::section);
 109
 110   uintptr_t SectionAddr = CommandAddr + SegmentLoadSize + Sec * SectionSize;
 111   return reinterpret_cast<const char*>(SectionAddr);
 112 }
 113
 114 static const char *getPtr(const MachOObjectFile &O, size_t Offset) {
 115   assert(Offset <= O.getData().size());
 116   return O.getData().data() + Offset;
 117 }
 118
 119 static MachO::nlist_base
 120 getSymbolTableEntryBase(const MachOObjectFile &O, DataRefImpl DRI) {
 121   const char *P = reinterpret_cast<const char *>(DRI.p);
 122   return getStruct<MachO::nlist_base>(O, P);
 123 }
 124
 125 static StringRef parseSegmentOrSectionName(const char *P) {
 126   if (P[15] == 0)
 127     // Null terminated.
 128     return P;
 129   // Not null terminated, so this is a 16 char string.
 130   return StringRef(P, 16);
 131 }
 132
 133 static unsigned getCPUType(const MachOObjectFile &O) {
 134   return O.getHeader().cputype;
 135 }
 136
 137 static uint32_t
 138 getPlainRelocationAddress(const MachO::any_relocation_info &RE) {
 139   return RE.r_word0;
 140 }
 141
 142 static unsigned
 143 getScatteredRelocationAddress(const MachO::any_relocation_info &RE) {
 144   return RE.r_word0 & 0xffffff;
 145 }
 146
 147 static bool getPlainRelocationPCRel(const MachOObjectFile &O,
 148                                     const MachO::any_relocation_info &RE) {
 149   if (O.isLittleEndian())
 150     return (RE.r_word1 >> 24) & 1;
 151   return (RE.r_word1 >> 7) & 1;
 152 }
 153
 154 static bool
 155 getScatteredRelocationPCRel(const MachO::any_relocation_info &RE) {
 156   return (RE.r_word0 >> 30) & 1;
 157 }
 158
 159 static unsigned getPlainRelocationLength(const MachOObjectFile &O,
 160                                          const MachO::any_relocation_info &RE) {
 161   if (O.isLittleEndian())
 162     return (RE.r_word1 >> 25) & 3;
 163   return (RE.r_word1 >> 5) & 3;
 164 }
 165
 166 static unsigned
 167 getScatteredRelocationLength(const MachO::any_relocation_info &RE) {
 168   return (RE.r_word0 >> 28) & 3;
 169 }
 170
 171 static unsigned getPlainRelocationType(const MachOObjectFile &O,
 172                                        const MachO::any_relocation_info &RE) {
 173   if (O.isLittleEndian())
 174     return RE.r_word1 >> 28;
 175   return RE.r_word1 & 0xf;
 176 }
 177
 178 static uint32_t getSectionFlags(const MachOObjectFile &O,
 179                                 DataRefImpl Sec) {
 180   if (O.is64Bit()) {
 181     MachO::section_64 Sect = O.getSection64(Sec);
 182     return Sect.flags;
 183   }
 184   MachO::section Sect = O.getSection(Sec);
 185   return Sect.flags;
 186 }
 187
 188 static Expected<MachOObjectFile::LoadCommandInfo>
 189 getLoadCommandInfo(const MachOObjectFile &Obj, const char *Ptr,
 190                    uint32_t LoadCommandIndex) {
 191   if (auto CmdOrErr = getStructOrErr<MachO::load_command>(Obj, Ptr)) {
 192     if (CmdOrErr->cmdsize + Ptr > Obj.getData().end())
 193       return malformedError("load command " + Twine(LoadCommandIndex) +
 194                             " extends past end of file");
 195     if (CmdOrErr->cmdsize < 8)
 196       return malformedError("load command " + Twine(LoadCommandIndex) +
 197                             " with size less than 8 bytes");
 198     return MachOObjectFile::LoadCommandInfo({Ptr, *CmdOrErr});
 199   } else
 200     return CmdOrErr.takeError();
 201 }
 202
 203 static Expected<MachOObjectFile::LoadCommandInfo>
 204 getFirstLoadCommandInfo(const MachOObjectFile &Obj) {
 205   unsigned HeaderSize = Obj.is64Bit() ? sizeof(MachO::mach_header_64)
 206                                       : sizeof(MachO::mach_header);
 207   if (sizeof(MachO::load_command) > Obj.getHeader().sizeofcmds)
 208     return malformedError("load command 0 extends past the end all load "
 209                           "commands in the file");
 210   return getLoadCommandInfo(Obj, getPtr(Obj, HeaderSize), 0);
 211 }
 212
 213 static Expected<MachOObjectFile::LoadCommandInfo>
 214 getNextLoadCommandInfo(const MachOObjectFile &Obj, uint32_t LoadCommandIndex,
 215                        const MachOObjectFile::LoadCommandInfo &L) {
 216   unsigned HeaderSize = Obj.is64Bit() ? sizeof(MachO::mach_header_64)
 217                                       : sizeof(MachO::mach_header);
 218   if (L.Ptr + L.C.cmdsize + sizeof(MachO::load_command) >
 219       Obj.getData().data() + HeaderSize + Obj.getHeader().sizeofcmds)
 220     return malformedError("load command " + Twine(LoadCommandIndex + 1) +
 221                           " extends past the end all load commands in the file");
 222   return getLoadCommandInfo(Obj, L.Ptr + L.C.cmdsize, LoadCommandIndex + 1);
 223 }
 224
 225 template <typename T>
 226 static void parseHeader(const MachOObjectFile &Obj, T &Header,
 227                         Error &Err) {
 228   if (sizeof(T) > Obj.getData().size()) {
 229     Err = malformedError("the mach header extends past the end of the "
 230                          "file");
 231     return;
 232   }
 233   if (auto HeaderOrErr = getStructOrErr<T>(Obj, getPtr(Obj, 0)))
 234     Header = *HeaderOrErr;
 235   else
 236     Err = HeaderOrErr.takeError();
 237 }
 238
 239 // This is used to check for overlapping of Mach-O elements.
 240 struct MachOElement {
 241   uint64_t Offset;
 242   uint64_t Size;
 243   const char *Name;
 244 };
 245
 246 static Error checkOverlappingElement(std::list<MachOElement> &Elements,
 247                                      uint64_t Offset, uint64_t Size,
 248                                      const char *Name) {
 249   if (Size == 0)
 250     return Error::success();
 251
 252   for (auto it=Elements.begin() ; it != Elements.end(); ++it) {
 253     auto E = *it;
 254     if ((Offset >= E.Offset && Offset < E.Offset + E.Size) ||
 255         (Offset + Size > E.Offset && Offset + Size < E.Offset + E.Size) ||
 256         (Offset <= E.Offset && Offset + Size >= E.Offset + E.Size))
 257       return malformedError(Twine(Name) + " at offset " + Twine(Offset) +
 258                             " with a size of " + Twine(Size) + ", overlaps " +
 259                             E.Name + " at offset " + Twine(E.Offset) + " with "
 260                             "a size of " + Twine(E.Size));
 261     auto nt = it;
 262     nt++;
 263     if (nt != Elements.end()) {
 264       auto N = *nt;
 265       if (Offset + Size <= N.Offset) {
 266         Elements.insert(nt, {Offset, Size, Name});
 267         return Error::success();
 268       }
 269     }
 270   }
 271   Elements.push_back({Offset, Size, Name});
 272   return Error::success();
 273 }
 274
 275 // Parses LC_SEGMENT or LC_SEGMENT_64 load command, adds addresses of all
 276 // sections to \param Sections, and optionally sets
 277 // \param IsPageZeroSegment to true.
 278 template <typename Segment, typename Section>
 279 static Error parseSegmentLoadCommand(
 280     const MachOObjectFile &Obj, const MachOObjectFile::LoadCommandInfo &Load,
 281     SmallVectorImpl<const char *> &Sections, bool &IsPageZeroSegment,
 282     uint32_t LoadCommandIndex, const char *CmdName, uint64_t SizeOfHeaders,
 283     std::list<MachOElement> &Elements) {
 284   const unsigned SegmentLoadSize = sizeof(Segment);
 285   if (Load.C.cmdsize < SegmentLoadSize)
 286     return malformedError("load command " + Twine(LoadCommandIndex) +
 287                           " " + CmdName + " cmdsize too small");
 288   if (auto SegOrErr = getStructOrErr<Segment>(Obj, Load.Ptr)) {
 289     Segment S = SegOrErr.get();
 290     const unsigned SectionSize = sizeof(Section);
 291     uint64_t FileSize = Obj.getData().size();
 292     if (S.nsects > std::numeric_limits<uint32_t>::max() / SectionSize ||
 293         S.nsects * SectionSize > Load.C.cmdsize - SegmentLoadSize)
 294       return malformedError("load command " + Twine(LoadCommandIndex) +
 295                             " inconsistent cmdsize in " + CmdName +
 296                             " for the number of sections");
 297     for (unsigned J = 0; J < S.nsects; ++J) {
 298       const char *Sec = getSectionPtr(Obj, Load, J);
 299       Sections.push_back(Sec);
 300       auto SectionOrErr = getStructOrErr<Section>(Obj, Sec);
 301       if (!SectionOrErr)
 302         return SectionOrErr.takeError();
 303       Section s = SectionOrErr.get();
 304       if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
 305           Obj.getHeader().filetype != MachO::MH_DSYM &&
 306           s.flags != MachO::S_ZEROFILL &&
 307           s.flags != MachO::S_THREAD_LOCAL_ZEROFILL &&
 308           s.offset > FileSize)
 309         return malformedError("offset field of section " + Twine(J) + " in " +
 310                               CmdName + " command " + Twine(LoadCommandIndex) +
 311                               " extends past the end of the file");
 312       if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
 313           Obj.getHeader().filetype != MachO::MH_DSYM &&
 314           s.flags != MachO::S_ZEROFILL &&
 315           s.flags != MachO::S_THREAD_LOCAL_ZEROFILL && S.fileoff == 0 &&
 316           s.offset < SizeOfHeaders && s.size != 0)
 317         return malformedError("offset field of section " + Twine(J) + " in " +
 318                               CmdName + " command " + Twine(LoadCommandIndex) +
 319                               " not past the headers of the file");
 320       uint64_t BigSize = s.offset;
 321       BigSize += s.size;
 322       if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
 323           Obj.getHeader().filetype != MachO::MH_DSYM &&
 324           s.flags != MachO::S_ZEROFILL &&
 325           s.flags != MachO::S_THREAD_LOCAL_ZEROFILL &&
 326           BigSize > FileSize)
 327         return malformedError("offset field plus size field of section " +
 328                               Twine(J) + " in " + CmdName + " command " +
 329                               Twine(LoadCommandIndex) +
 330                               " extends past the end of the file");
 331       if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
 332           Obj.getHeader().filetype != MachO::MH_DSYM &&
 333           s.flags != MachO::S_ZEROFILL &&
 334           s.flags != MachO::S_THREAD_LOCAL_ZEROFILL &&
 335           s.size > S.filesize)
 336         return malformedError("size field of section " +
 337                               Twine(J) + " in " + CmdName + " command " +
 338                               Twine(LoadCommandIndex) +
 339                               " greater than the segment");
 340       if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
 341           Obj.getHeader().filetype != MachO::MH_DSYM && s.size != 0 &&
 342           s.addr < S.vmaddr)
 343         return malformedError("addr field of section " + Twine(J) + " in " +
 344                               CmdName + " command " + Twine(LoadCommandIndex) +
 345                               " less than the segment's vmaddr");
 346       BigSize = s.addr;
 347       BigSize += s.size;
 348       uint64_t BigEnd = S.vmaddr;
 349       BigEnd += S.vmsize;
 350       if (S.vmsize != 0 && s.size != 0 && BigSize > BigEnd)
 351         return malformedError("addr field plus size of section " + Twine(J) +
 352                               " in " + CmdName + " command " +
 353                               Twine(LoadCommandIndex) +
 354                               " greater than than "
 355                               "the segment's vmaddr plus vmsize");
 356       if (Obj.getHeader().filetype != MachO::MH_DYLIB_STUB &&
 357           Obj.getHeader().filetype != MachO::MH_DSYM &&
 358           s.flags != MachO::S_ZEROFILL &&
 359           s.flags != MachO::S_THREAD_LOCAL_ZEROFILL)
 360         if (Error Err = checkOverlappingElement(Elements, s.offset, s.size,
 361                                                 "section contents"))
 362           return Err;
 363       if (s.reloff > FileSize)
 364         return malformedError("reloff field of section " + Twine(J) + " in " +
 365                               CmdName + " command " + Twine(LoadCommandIndex) +
 366                               " extends past the end of the file");
 367       BigSize = s.nreloc;
 368       BigSize *= sizeof(struct MachO::relocation_info);
 369       BigSize += s.reloff;
 370       if (BigSize > FileSize)
 371         return malformedError("reloff field plus nreloc field times sizeof("
 372                               "struct relocation_info) of section " +
 373                               Twine(J) + " in " + CmdName + " command " +
 374                               Twine(LoadCommandIndex) +
 375                               " extends past the end of the file");
 376       if (Error Err = checkOverlappingElement(Elements, s.reloff, s.nreloc *
 377                                               sizeof(struct
 378                                               MachO::relocation_info),
 379                                               "section relocation entries"))
 380         return Err;
 381     }
 382     if (S.fileoff > FileSize)
 383       return malformedError("load command " + Twine(LoadCommandIndex) +
 384                             " fileoff field in " + CmdName +
 385                             " extends past the end of the file");
 386     uint64_t BigSize = S.fileoff;
 387     BigSize += S.filesize;
 388     if (BigSize > FileSize)
 389       return malformedError("load command " + Twine(LoadCommandIndex) +
 390                             " fileoff field plus filesize field in " +
 391                             CmdName + " extends past the end of the file");
 392     if (S.vmsize != 0 && S.filesize > S.vmsize)
 393       return malformedError("load command " + Twine(LoadCommandIndex) +
 394                             " filesize field in " + CmdName +
 395                             " greater than vmsize field");
 396     IsPageZeroSegment |= StringRef("__PAGEZERO").equals(S.segname);
 397   } else
 398     return SegOrErr.takeError();
 399
 400   return Error::success();
 401 }
 402
 403 static Error checkSymtabCommand(const MachOObjectFile &Obj,
 404                                 const MachOObjectFile::LoadCommandInfo &Load,
 405                                 uint32_t LoadCommandIndex,
 406                                 const char **SymtabLoadCmd,
 407                                 std::list<MachOElement> &Elements) {
 408   if (Load.C.cmdsize < sizeof(MachO::symtab_command))
 409     return malformedError("load command " + Twine(LoadCommandIndex) +
 410                           " LC_SYMTAB cmdsize too small");
 411   if (*SymtabLoadCmd != nullptr)
 412     return malformedError("more than one LC_SYMTAB command");
 413   auto SymtabOrErr = getStructOrErr<MachO::symtab_command>(Obj, Load.Ptr);
 414   if (!SymtabOrErr)
 415     return SymtabOrErr.takeError();
 416   MachO::symtab_command Symtab = SymtabOrErr.get();
 417   if (Symtab.cmdsize != sizeof(MachO::symtab_command))
 418     return malformedError("LC_SYMTAB command " + Twine(LoadCommandIndex) +
 419                           " has incorrect cmdsize");
 420   uint64_t FileSize = Obj.getData().size();
 421   if (Symtab.symoff > FileSize)
 422     return malformedError("symoff field of LC_SYMTAB command " +
 423                           Twine(LoadCommandIndex) + " extends past the end "
 424                           "of the file");
 425   uint64_t SymtabSize = Symtab.nsyms;
 426   const char *struct_nlist_name;
 427   if (Obj.is64Bit()) {
 428     SymtabSize *= sizeof(MachO::nlist_64);
 429     struct_nlist_name = "struct nlist_64";
 430   } else {
 431     SymtabSize *= sizeof(MachO::nlist);
 432     struct_nlist_name = "struct nlist";
 433   }
 434   uint64_t BigSize = SymtabSize;
 435   BigSize += Symtab.symoff;
 436   if (BigSize > FileSize)
 437     return malformedError("symoff field plus nsyms field times sizeof(" +
 438                           Twine(struct_nlist_name) + ") of LC_SYMTAB command " +
 439                           Twine(LoadCommandIndex) + " extends past the end "
 440                           "of the file");
 441   if (Error Err = checkOverlappingElement(Elements, Symtab.symoff, SymtabSize,
 442                                           "symbol table"))
 443     return Err;
 444   if (Symtab.stroff > FileSize)
 445     return malformedError("stroff field of LC_SYMTAB command " +
 446                           Twine(LoadCommandIndex) + " extends past the end "
 447                           "of the file");
 448   BigSize = Symtab.stroff;
 449   BigSize += Symtab.strsize;
 450   if (BigSize > FileSize)
 451     return malformedError("stroff field plus strsize field of LC_SYMTAB "
 452                           "command " + Twine(LoadCommandIndex) + " extends "
 453                           "past the end of the file");
 454   if (Error Err = checkOverlappingElement(Elements, Symtab.stroff,
 455                                           Symtab.strsize, "string table"))
 456     return Err;
 457   *SymtabLoadCmd = Load.Ptr;
 458   return Error::success();
 459 }
 460
 461 static Error checkDysymtabCommand(const MachOObjectFile &Obj,
 462                                   const MachOObjectFile::LoadCommandInfo &Load,
 463                                   uint32_t LoadCommandIndex,
 464                                   const char **DysymtabLoadCmd,
 465                                   std::list<MachOElement> &Elements) {
 466   if (Load.C.cmdsize < sizeof(MachO::dysymtab_command))
 467     return malformedError("load command " + Twine(LoadCommandIndex) +
 468                           " LC_DYSYMTAB cmdsize too small");
 469   if (*DysymtabLoadCmd != nullptr)
 470     return malformedError("more than one LC_DYSYMTAB command");
 471   auto DysymtabOrErr =
 472     getStructOrErr<MachO::dysymtab_command>(Obj, Load.Ptr);
 473   if (!DysymtabOrErr)
 474     return DysymtabOrErr.takeError();
 475   MachO::dysymtab_command Dysymtab = DysymtabOrErr.get();
 476   if (Dysymtab.cmdsize != sizeof(MachO::dysymtab_command))
 477     return malformedError("LC_DYSYMTAB command " + Twine(LoadCommandIndex) +
 478                           " has incorrect cmdsize");
 479   uint64_t FileSize = Obj.getData().size();
 480   if (Dysymtab.tocoff > FileSize)
 481     return malformedError("tocoff field of LC_DYSYMTAB command " +
 482                           Twine(LoadCommandIndex) + " extends past the end of "
 483                           "the file");
 484   uint64_t BigSize = Dysymtab.ntoc;
 485   BigSize *= sizeof(MachO::dylib_table_of_contents);
 486   BigSize += Dysymtab.tocoff;
 487   if (BigSize > FileSize)
 488     return malformedError("tocoff field plus ntoc field times sizeof(struct "
 489                           "dylib_table_of_contents) of LC_DYSYMTAB command " +
 490                           Twine(LoadCommandIndex) + " extends past the end of "
 491                           "the file");
 492   if (Error Err = checkOverlappingElement(Elements, Dysymtab.tocoff,
 493                                           Dysymtab.ntoc * sizeof(struct
 494                                           MachO::dylib_table_of_contents),
 495                                           "table of contents"))
 496     return Err;
 497   if (Dysymtab.modtaboff > FileSize)
 498     return malformedError("modtaboff field of LC_DYSYMTAB command " +
 499                           Twine(LoadCommandIndex) + " extends past the end of "
 500                           "the file");
 501   BigSize = Dysymtab.nmodtab;
 502   const char *struct_dylib_module_name;
 503   uint64_t sizeof_modtab;
 504   if (Obj.is64Bit()) {
 505     sizeof_modtab = sizeof(MachO::dylib_module_64);
 506     struct_dylib_module_name = "struct dylib_module_64";
 507   } else {
 508     sizeof_modtab = sizeof(MachO::dylib_module);
 509     struct_dylib_module_name = "struct dylib_module";
 510   }
 511   BigSize *= sizeof_modtab;
 512   BigSize += Dysymtab.modtaboff;
 513   if (BigSize > FileSize)
 514     return malformedError("modtaboff field plus nmodtab field times sizeof(" +
 515                           Twine(struct_dylib_module_name) + ") of LC_DYSYMTAB "
 516                           "command " + Twine(LoadCommandIndex) + " extends "
 517                           "past the end of the file");
 518   if (Error Err = checkOverlappingElement(Elements, Dysymtab.modtaboff,
 519                                           Dysymtab.nmodtab * sizeof_modtab,
 520                                           "module table"))
 521     return Err;
 522   if (Dysymtab.extrefsymoff > FileSize)
 523     return malformedError("extrefsymoff field of LC_DYSYMTAB command " +
 524                           Twine(LoadCommandIndex) + " extends past the end of "
 525                           "the file");
 526   BigSize = Dysymtab.nextrefsyms;
 527   BigSize *= sizeof(MachO::dylib_reference);
 528   BigSize += Dysymtab.extrefsymoff;
 529   if (BigSize > FileSize)
 530     return malformedError("extrefsymoff field plus nextrefsyms field times "
 531                           "sizeof(struct dylib_reference) of LC_DYSYMTAB "
 532                           "command " + Twine(LoadCommandIndex) + " extends "
 533                           "past the end of the file");
 534   if (Error Err = checkOverlappingElement(Elements, Dysymtab.extrefsymoff,
 535                                           Dysymtab.nextrefsyms *
 536                                               sizeof(MachO::dylib_reference),
 537                                           "reference table"))
 538     return Err;
 539   if (Dysymtab.indirectsymoff > FileSize)
 540     return malformedError("indirectsymoff field of LC_DYSYMTAB command " +
 541                           Twine(LoadCommandIndex) + " extends past the end of "
 542                           "the file");
 543   BigSize = Dysymtab.nindirectsyms;
 544   BigSize *= sizeof(uint32_t);
 545   BigSize += Dysymtab.indirectsymoff;
 546   if (BigSize > FileSize)
 547     return malformedError("indirectsymoff field plus nindirectsyms field times "
 548                           "sizeof(uint32_t) of LC_DYSYMTAB command " +
 549                           Twine(LoadCommandIndex) + " extends past the end of "
 550                           "the file");
 551   if (Error Err = checkOverlappingElement(Elements, Dysymtab.indirectsymoff,
 552                                           Dysymtab.nindirectsyms *
 553                                           sizeof(uint32_t),
 554                                           "indirect table"))
 555     return Err;
 556   if (Dysymtab.extreloff > FileSize)
 557     return malformedError("extreloff field of LC_DYSYMTAB command " +
 558                           Twine(LoadCommandIndex) + " extends past the end of "
 559                           "the file");
 560   BigSize = Dysymtab.nextrel;
 561   BigSize *= sizeof(MachO::relocation_info);
 562   BigSize += Dysymtab.extreloff;
 563   if (BigSize > FileSize)
 564     return malformedError("extreloff field plus nextrel field times sizeof"
 565                           "(struct relocation_info) of LC_DYSYMTAB command " +
 566                           Twine(LoadCommandIndex) + " extends past the end of "
 567                           "the file");
 568   if (Error Err = checkOverlappingElement(Elements, Dysymtab.extreloff,
 569                                           Dysymtab.nextrel *
 570                                               sizeof(MachO::relocation_info),
 571                                           "external relocation table"))
 572     return Err;
 573   if (Dysymtab.locreloff > FileSize)
 574     return malformedError("locreloff field of LC_DYSYMTAB command " +
 575                           Twine(LoadCommandIndex) + " extends past the end of "
 576                           "the file");
 577   BigSize = Dysymtab.nlocrel;
 578   BigSize *= sizeof(MachO::relocation_info);
 579   BigSize += Dysymtab.locreloff;
 580   if (BigSize > FileSize)
 581     return malformedError("locreloff field plus nlocrel field times sizeof"
 582                           "(struct relocation_info) of LC_DYSYMTAB command " +
 583                           Twine(LoadCommandIndex) + " extends past the end of "
 584                           "the file");
 585   if (Error Err = checkOverlappingElement(Elements, Dysymtab.locreloff,
 586                                           Dysymtab.nlocrel *
 587                                               sizeof(MachO::relocation_info),
 588                                           "local relocation table"))
 589     return Err;
 590   *DysymtabLoadCmd = Load.Ptr;
 591   return Error::success();
 592 }
 593
 594 static Error checkLinkeditDataCommand(const MachOObjectFile &Obj,
 595                                  const MachOObjectFile::LoadCommandInfo &Load,
 596                                  uint32_t LoadCommandIndex,
 597                                  const char **LoadCmd, const char *CmdName,
 598                                  std::list<MachOElement> &Elements,
 599                                  const char *ElementName) {
 600   if (Load.C.cmdsize < sizeof(MachO::linkedit_data_command))
 601     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
 602                           CmdName + " cmdsize too small");
 603   if (*LoadCmd != nullptr)
 604     return malformedError("more than one " + Twine(CmdName) + " command");
 605   auto LinkDataOrError =
 606     getStructOrErr<MachO::linkedit_data_command>(Obj, Load.Ptr);
 607   if (!LinkDataOrError)
 608     return LinkDataOrError.takeError();
 609   MachO::linkedit_data_command LinkData = LinkDataOrError.get();
 610   if (LinkData.cmdsize != sizeof(MachO::linkedit_data_command))
 611     return malformedError(Twine(CmdName) + " command " +
 612                           Twine(LoadCommandIndex) + " has incorrect cmdsize");
 613   uint64_t FileSize = Obj.getData().size();
 614   if (LinkData.dataoff > FileSize)
 615     return malformedError("dataoff field of " + Twine(CmdName) + " command " +
 616                           Twine(LoadCommandIndex) + " extends past the end of "
 617                           "the file");
 618   uint64_t BigSize = LinkData.dataoff;
 619   BigSize += LinkData.datasize;
 620   if (BigSize > FileSize)
 621     return malformedError("dataoff field plus datasize field of " +
 622                           Twine(CmdName) + " command " +
 623                           Twine(LoadCommandIndex) + " extends past the end of "
 624                           "the file");
 625   if (Error Err = checkOverlappingElement(Elements, LinkData.dataoff,
 626                                           LinkData.datasize, ElementName))
 627     return Err;
 628   *LoadCmd = Load.Ptr;
 629   return Error::success();
 630 }
 631
 632 static Error checkDyldInfoCommand(const MachOObjectFile &Obj,
 633                                   const MachOObjectFile::LoadCommandInfo &Load,
 634                                   uint32_t LoadCommandIndex,
 635                                   const char **LoadCmd, const char *CmdName,
 636                                   std::list<MachOElement> &Elements) {
 637   if (Load.C.cmdsize < sizeof(MachO::dyld_info_command))
 638     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
 639                           CmdName + " cmdsize too small");
 640   if (*LoadCmd != nullptr)
 641     return malformedError("more than one LC_DYLD_INFO and or LC_DYLD_INFO_ONLY "
 642                           "command");
 643   auto DyldInfoOrErr =
 644     getStructOrErr<MachO::dyld_info_command>(Obj, Load.Ptr);
 645   if (!DyldInfoOrErr)
 646     return DyldInfoOrErr.takeError();
 647   MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
 648   if (DyldInfo.cmdsize != sizeof(MachO::dyld_info_command))
 649     return malformedError(Twine(CmdName) + " command " +
 650                           Twine(LoadCommandIndex) + " has incorrect cmdsize");
 651   uint64_t FileSize = Obj.getData().size();
 652   if (DyldInfo.rebase_off > FileSize)
 653     return malformedError("rebase_off field of " + Twine(CmdName) +
 654                           " command " + Twine(LoadCommandIndex) + " extends "
 655                           "past the end of the file");
 656   uint64_t BigSize = DyldInfo.rebase_off;
 657   BigSize += DyldInfo.rebase_size;
 658   if (BigSize > FileSize)
 659     return malformedError("rebase_off field plus rebase_size field of " +
 660                           Twine(CmdName) + " command " +
 661                           Twine(LoadCommandIndex) + " extends past the end of "
 662                           "the file");
 663   if (Error Err = checkOverlappingElement(Elements, DyldInfo.rebase_off,
 664                                           DyldInfo.rebase_size,
 665                                           "dyld rebase info"))
 666     return Err;
 667   if (DyldInfo.bind_off > FileSize)
 668     return malformedError("bind_off field of " + Twine(CmdName) +
 669                           " command " + Twine(LoadCommandIndex) + " extends "
 670                           "past the end of the file");
 671   BigSize = DyldInfo.bind_off;
 672   BigSize += DyldInfo.bind_size;
 673   if (BigSize > FileSize)
 674     return malformedError("bind_off field plus bind_size field of " +
 675                           Twine(CmdName) + " command " +
 676                           Twine(LoadCommandIndex) + " extends past the end of "
 677                           "the file");
 678   if (Error Err = checkOverlappingElement(Elements, DyldInfo.bind_off,
 679                                           DyldInfo.bind_size,
 680                                           "dyld bind info"))
 681     return Err;
 682   if (DyldInfo.weak_bind_off > FileSize)
 683     return malformedError("weak_bind_off field of " + Twine(CmdName) +
 684                           " command " + Twine(LoadCommandIndex) + " extends "
 685                           "past the end of the file");
 686   BigSize = DyldInfo.weak_bind_off;
 687   BigSize += DyldInfo.weak_bind_size;
 688   if (BigSize > FileSize)
 689     return malformedError("weak_bind_off field plus weak_bind_size field of " +
 690                           Twine(CmdName) + " command " +
 691                           Twine(LoadCommandIndex) + " extends past the end of "
 692                           "the file");
 693   if (Error Err = checkOverlappingElement(Elements, DyldInfo.weak_bind_off,
 694                                           DyldInfo.weak_bind_size,
 695                                           "dyld weak bind info"))
 696     return Err;
 697   if (DyldInfo.lazy_bind_off > FileSize)
 698     return malformedError("lazy_bind_off field of " + Twine(CmdName) +
 699                           " command " + Twine(LoadCommandIndex) + " extends "
 700                           "past the end of the file");
 701   BigSize = DyldInfo.lazy_bind_off;
 702   BigSize += DyldInfo.lazy_bind_size;
 703   if (BigSize > FileSize)
 704     return malformedError("lazy_bind_off field plus lazy_bind_size field of " +
 705                           Twine(CmdName) + " command " +
 706                           Twine(LoadCommandIndex) + " extends past the end of "
 707                           "the file");
 708   if (Error Err = checkOverlappingElement(Elements, DyldInfo.lazy_bind_off,
 709                                           DyldInfo.lazy_bind_size,
 710                                           "dyld lazy bind info"))
 711     return Err;
 712   if (DyldInfo.export_off > FileSize)
 713     return malformedError("export_off field of " + Twine(CmdName) +
 714                           " command " + Twine(LoadCommandIndex) + " extends "
 715                           "past the end of the file");
 716   BigSize = DyldInfo.export_off;
 717   BigSize += DyldInfo.export_size;
 718   if (BigSize > FileSize)
 719     return malformedError("export_off field plus export_size field of " +
 720                           Twine(CmdName) + " command " +
 721                           Twine(LoadCommandIndex) + " extends past the end of "
 722                           "the file");
 723   if (Error Err = checkOverlappingElement(Elements, DyldInfo.export_off,
 724                                           DyldInfo.export_size,
 725                                           "dyld export info"))
 726     return Err;
 727   *LoadCmd = Load.Ptr;
 728   return Error::success();
 729 }
 730
 731 static Error checkDylibCommand(const MachOObjectFile &Obj,
 732                                const MachOObjectFile::LoadCommandInfo &Load,
 733                                uint32_t LoadCommandIndex, const char *CmdName) {
 734   if (Load.C.cmdsize < sizeof(MachO::dylib_command))
 735     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
 736                           CmdName + " cmdsize too small");
 737   auto CommandOrErr = getStructOrErr<MachO::dylib_command>(Obj, Load.Ptr);
 738   if (!CommandOrErr)
 739     return CommandOrErr.takeError();
 740   MachO::dylib_command D = CommandOrErr.get();
 741   if (D.dylib.name < sizeof(MachO::dylib_command))
 742     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
 743                           CmdName + " name.offset field too small, not past "
 744                           "the end of the dylib_command struct");
 745   if (D.dylib.name >= D.cmdsize)
 746     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
 747                           CmdName + " name.offset field extends past the end "
 748                           "of the load command");
 749   // Make sure there is a null between the starting offset of the name and
 750   // the end of the load command.
 751   uint32_t i;
 752   const char *P = (const char *)Load.Ptr;
 753   for (i = D.dylib.name; i < D.cmdsize; i++)
 754     if (P[i] == '\0')
 755       break;
 756   if (i >= D.cmdsize)
 757     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
 758                           CmdName + " library name extends past the end of the "
 759                           "load command");
 760   return Error::success();
 761 }
 762
 763 static Error checkDylibIdCommand(const MachOObjectFile &Obj,
 764                                  const MachOObjectFile::LoadCommandInfo &Load,
 765                                  uint32_t LoadCommandIndex,
 766                                  const char **LoadCmd) {
 767   if (Error Err = checkDylibCommand(Obj, Load, LoadCommandIndex,
 768                                      "LC_ID_DYLIB"))
 769     return Err;
 770   if (*LoadCmd != nullptr)
 771     return malformedError("more than one LC_ID_DYLIB command");
 772   if (Obj.getHeader().filetype != MachO::MH_DYLIB &&
 773       Obj.getHeader().filetype != MachO::MH_DYLIB_STUB)
 774     return malformedError("LC_ID_DYLIB load command in non-dynamic library "
 775                           "file type");
 776   *LoadCmd = Load.Ptr;
 777   return Error::success();
 778 }
 779
 780 static Error checkDyldCommand(const MachOObjectFile &Obj,
 781                               const MachOObjectFile::LoadCommandInfo &Load,
 782                               uint32_t LoadCommandIndex, const char *CmdName) {
 783   if (Load.C.cmdsize < sizeof(MachO::dylinker_command))
 784     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
 785                           CmdName + " cmdsize too small");
 786   auto CommandOrErr = getStructOrErr<MachO::dylinker_command>(Obj, Load.Ptr);
 787   if (!CommandOrErr)
 788     return CommandOrErr.takeError();
 789   MachO::dylinker_command D = CommandOrErr.get();
 790   if (D.name < sizeof(MachO::dylinker_command))
 791     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
 792                           CmdName + " name.offset field too small, not past "
 793                           "the end of the dylinker_command struct");
 794   if (D.name >= D.cmdsize)
 795     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
 796                           CmdName + " name.offset field extends past the end "
 797                           "of the load command");
 798   // Make sure there is a null between the starting offset of the name and
 799   // the end of the load command.
 800   uint32_t i;
 801   const char *P = (const char *)Load.Ptr;
 802   for (i = D.name; i < D.cmdsize; i++)
 803     if (P[i] == '\0')
 804       break;
 805   if (i >= D.cmdsize)
 806     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
 807                           CmdName + " dyld name extends past the end of the "
 808                           "load command");
 809   return Error::success();
 810 }
 811
 812 static Error checkVersCommand(const MachOObjectFile &Obj,
 813                               const MachOObjectFile::LoadCommandInfo &Load,
 814                               uint32_t LoadCommandIndex,
 815                               const char **LoadCmd, const char *CmdName) {
 816   if (Load.C.cmdsize != sizeof(MachO::version_min_command))
 817     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
 818                           CmdName + " has incorrect cmdsize");
 819   if (*LoadCmd != nullptr)
 820     return malformedError("more than one LC_VERSION_MIN_MACOSX, "
 821                           "LC_VERSION_MIN_IPHONEOS, LC_VERSION_MIN_TVOS or "
 822                           "LC_VERSION_MIN_WATCHOS command");
 823   *LoadCmd = Load.Ptr;
 824   return Error::success();
 825 }
 826
 827 static Error checkNoteCommand(const MachOObjectFile &Obj,
 828                               const MachOObjectFile::LoadCommandInfo &Load,
 829                               uint32_t LoadCommandIndex,
 830                               std::list<MachOElement> &Elements) {
 831   if (Load.C.cmdsize != sizeof(MachO::note_command))
 832     return malformedError("load command " + Twine(LoadCommandIndex) +
 833                           " LC_NOTE has incorrect cmdsize");
 834   auto NoteCmdOrErr = getStructOrErr<MachO::note_command>(Obj, Load.Ptr);
 835   if (!NoteCmdOrErr)
 836     return NoteCmdOrErr.takeError();
 837   MachO::note_command Nt = NoteCmdOrErr.get();
 838   uint64_t FileSize = Obj.getData().size();
 839   if (Nt.offset > FileSize)
 840     return malformedError("offset field of LC_NOTE command " +
 841                           Twine(LoadCommandIndex) + " extends "
 842                           "past the end of the file");
 843   uint64_t BigSize = Nt.offset;
 844   BigSize += Nt.size;
 845   if (BigSize > FileSize)
 846     return malformedError("size field plus offset field of LC_NOTE command " +
 847                           Twine(LoadCommandIndex) + " extends past the end of "
 848                           "the file");
 849   if (Error Err = checkOverlappingElement(Elements, Nt.offset, Nt.size,
 850                                           "LC_NOTE data"))
 851     return Err;
 852   return Error::success();
 853 }
 854
 855 static Error
 856 parseBuildVersionCommand(const MachOObjectFile &Obj,
 857                          const MachOObjectFile::LoadCommandInfo &Load,
 858                          SmallVectorImpl<const char*> &BuildTools,
 859                          uint32_t LoadCommandIndex) {
 860   auto BVCOrErr =
 861     getStructOrErr<MachO::build_version_command>(Obj, Load.Ptr);
 862   if (!BVCOrErr)
 863     return BVCOrErr.takeError();
 864   MachO::build_version_command BVC = BVCOrErr.get();
 865   if (Load.C.cmdsize !=
 866       sizeof(MachO::build_version_command) +
 867           BVC.ntools * sizeof(MachO::build_tool_version))
 868     return malformedError("load command " + Twine(LoadCommandIndex) +
 869                           " LC_BUILD_VERSION_COMMAND has incorrect cmdsize");
 870
 871   auto Start = Load.Ptr + sizeof(MachO::build_version_command);
 872   BuildTools.resize(BVC.ntools);
 873   for (unsigned i = 0; i < BVC.ntools; ++i)
 874     BuildTools[i] = Start + i * sizeof(MachO::build_tool_version);
 875
 876   return Error::success();
 877 }
 878
 879 static Error checkRpathCommand(const MachOObjectFile &Obj,
 880                                const MachOObjectFile::LoadCommandInfo &Load,
 881                                uint32_t LoadCommandIndex) {
 882   if (Load.C.cmdsize < sizeof(MachO::rpath_command))
 883     return malformedError("load command " + Twine(LoadCommandIndex) +
 884                           " LC_RPATH cmdsize too small");
 885   auto ROrErr = getStructOrErr<MachO::rpath_command>(Obj, Load.Ptr);
 886   if (!ROrErr)
 887     return ROrErr.takeError();
 888   MachO::rpath_command R = ROrErr.get();
 889   if (R.path < sizeof(MachO::rpath_command))
 890     return malformedError("load command " + Twine(LoadCommandIndex) +
 891                           " LC_RPATH path.offset field too small, not past "
 892                           "the end of the rpath_command struct");
 893   if (R.path >= R.cmdsize)
 894     return malformedError("load command " + Twine(LoadCommandIndex) +
 895                           " LC_RPATH path.offset field extends past the end "
 896                           "of the load command");
 897   // Make sure there is a null between the starting offset of the path and
 898   // the end of the load command.
 899   uint32_t i;
 900   const char *P = (const char *)Load.Ptr;
 901   for (i = R.path; i < R.cmdsize; i++)
 902     if (P[i] == '\0')
 903       break;
 904   if (i >= R.cmdsize)
 905     return malformedError("load command " + Twine(LoadCommandIndex) +
 906                           " LC_RPATH library name extends past the end of the "
 907                           "load command");
 908   return Error::success();
 909 }
 910
 911 static Error checkEncryptCommand(const MachOObjectFile &Obj,
 912                                  const MachOObjectFile::LoadCommandInfo &Load,
 913                                  uint32_t LoadCommandIndex,
 914                                  uint64_t cryptoff, uint64_t cryptsize,
 915                                  const char **LoadCmd, const char *CmdName) {
 916   if (*LoadCmd != nullptr)
 917     return malformedError("more than one LC_ENCRYPTION_INFO and or "
 918                           "LC_ENCRYPTION_INFO_64 command");
 919   uint64_t FileSize = Obj.getData().size();
 920   if (cryptoff > FileSize)
 921     return malformedError("cryptoff field of " + Twine(CmdName) +
 922                           " command " + Twine(LoadCommandIndex) + " extends "
 923                           "past the end of the file");
 924   uint64_t BigSize = cryptoff;
 925   BigSize += cryptsize;
 926   if (BigSize > FileSize)
 927     return malformedError("cryptoff field plus cryptsize field of " +
 928                           Twine(CmdName) + " command " +
 929                           Twine(LoadCommandIndex) + " extends past the end of "
 930                           "the file");
 931   *LoadCmd = Load.Ptr;
 932   return Error::success();
 933 }
 934
 935 static Error checkLinkerOptCommand(const MachOObjectFile &Obj,
 936                                    const MachOObjectFile::LoadCommandInfo &Load,
 937                                    uint32_t LoadCommandIndex) {
 938   if (Load.C.cmdsize < sizeof(MachO::linker_option_command))
 939     return malformedError("load command " + Twine(LoadCommandIndex) +
 940                           " LC_LINKER_OPTION cmdsize too small");
 941   auto LinkOptionOrErr =
 942     getStructOrErr<MachO::linker_option_command>(Obj, Load.Ptr);
 943   if (!LinkOptionOrErr)
 944     return LinkOptionOrErr.takeError();
 945   MachO::linker_option_command L = LinkOptionOrErr.get();
 946   // Make sure the count of strings is correct.
 947   const char *string = (const char *)Load.Ptr +
 948                        sizeof(struct MachO::linker_option_command);
 949   uint32_t left = L.cmdsize - sizeof(struct MachO::linker_option_command);
 950   uint32_t i = 0;
 951   while (left > 0) {
 952     while (*string == '\0' && left > 0) {
 953       string++;
 954       left--;
 955     }
 956     if (left > 0) {
 957       i++;
 958       uint32_t NullPos = StringRef(string, left).find('\0');
 959       if (0xffffffff == NullPos)
 960         return malformedError("load command " + Twine(LoadCommandIndex) +
 961                               " LC_LINKER_OPTION string #" + Twine(i) +
 962                               " is not NULL terminated");
 963       uint32_t len = std::min(NullPos, left) + 1;
 964       string += len;
 965       left -= len;
 966     }
 967   }
 968   if (L.count != i)
 969     return malformedError("load command " + Twine(LoadCommandIndex) +
 970                           " LC_LINKER_OPTION string count " + Twine(L.count) +
 971                           " does not match number of strings");
 972   return Error::success();
 973 }
 974
 975 static Error checkSubCommand(const MachOObjectFile &Obj,
 976                              const MachOObjectFile::LoadCommandInfo &Load,
 977                              uint32_t LoadCommandIndex, const char *CmdName,
 978                              size_t SizeOfCmd, const char *CmdStructName,
 979                              uint32_t PathOffset, const char *PathFieldName) {
 980   if (PathOffset < SizeOfCmd)
 981     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
 982                           CmdName + " " + PathFieldName + ".offset field too "
 983                           "small, not past the end of the " + CmdStructName);
 984   if (PathOffset >= Load.C.cmdsize)
 985     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
 986                           CmdName + " " + PathFieldName + ".offset field "
 987                           "extends past the end of the load command");
 988   // Make sure there is a null between the starting offset of the path and
 989   // the end of the load command.
 990   uint32_t i;
 991   const char *P = (const char *)Load.Ptr;
 992   for (i = PathOffset; i < Load.C.cmdsize; i++)
 993     if (P[i] == '\0')
 994       break;
 995   if (i >= Load.C.cmdsize)
 996     return malformedError("load command " + Twine(LoadCommandIndex) + " " +
 997                           CmdName + " " + PathFieldName + " name extends past "
 998                           "the end of the load command");
 999   return Error::success();
1000 }
1001
1002 static Error checkThreadCommand(const MachOObjectFile &Obj,
1003                                 const MachOObjectFile::LoadCommandInfo &Load,
1004                                 uint32_t LoadCommandIndex,
1005                                 const char *CmdName) {
1006   if (Load.C.cmdsize < sizeof(MachO::thread_command))
1007     return malformedError("load command " + Twine(LoadCommandIndex) +
1008                           CmdName + " cmdsize too small");
1009   auto ThreadCommandOrErr =
1010     getStructOrErr<MachO::thread_command>(Obj, Load.Ptr);
1011   if (!ThreadCommandOrErr)
1012     return ThreadCommandOrErr.takeError();
1013   MachO::thread_command T = ThreadCommandOrErr.get();
1014   const char *state = Load.Ptr + sizeof(MachO::thread_command);
1015   const char *end = Load.Ptr + T.cmdsize;
1016   uint32_t nflavor = 0;
1017   uint32_t cputype = getCPUType(Obj);
1018   while (state < end) {
1019     if(state + sizeof(uint32_t) > end)
1020       return malformedError("load command " + Twine(LoadCommandIndex) +
1021                             "flavor in " + CmdName + " extends past end of "
1022                             "command");
1023     uint32_t flavor;
1024     memcpy(&flavor, state, sizeof(uint32_t));
1025     if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
1026       sys::swapByteOrder(flavor);
1027     state += sizeof(uint32_t);
1028
1029     if(state + sizeof(uint32_t) > end)
1030       return malformedError("load command " + Twine(LoadCommandIndex) +
1031                             " count in " + CmdName + " extends past end of "
1032                             "command");
1033     uint32_t count;
1034     memcpy(&count, state, sizeof(uint32_t));
1035     if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
1036       sys::swapByteOrder(count);
1037     state += sizeof(uint32_t);
1038
1039     if (cputype == MachO::CPU_TYPE_I386) {
1040       if (flavor == MachO::x86_THREAD_STATE32) {
1041         if (count != MachO::x86_THREAD_STATE32_COUNT)
1042           return malformedError("load command " + Twine(LoadCommandIndex) +
1043                                 " count not x86_THREAD_STATE32_COUNT for "
1044                                 "flavor number " + Twine(nflavor) + " which is "
1045                                 "a x86_THREAD_STATE32 flavor in " + CmdName +
1046                                 " command");
1047         if (state + sizeof(MachO::x86_thread_state32_t) > end)
1048           return malformedError("load command " + Twine(LoadCommandIndex) +
1049                                 " x86_THREAD_STATE32 extends past end of "
1050                                 "command in " + CmdName + " command");
1051         state += sizeof(MachO::x86_thread_state32_t);
1052       } else {
1053         return malformedError("load command " + Twine(LoadCommandIndex) +
1054                               " unknown flavor (" + Twine(flavor) + ") for "
1055                               "flavor number " + Twine(nflavor) + " in " +
1056                               CmdName + " command");
1057       }
1058     } else if (cputype == MachO::CPU_TYPE_X86_64) {
1059       if (flavor == MachO::x86_THREAD_STATE) {
1060         if (count != MachO::x86_THREAD_STATE_COUNT)
1061           return malformedError("load command " + Twine(LoadCommandIndex) +
1062                                 " count not x86_THREAD_STATE_COUNT for "
1063                                 "flavor number " + Twine(nflavor) + " which is "
1064                                 "a x86_THREAD_STATE flavor in " + CmdName +
1065                                 " command");
1066         if (state + sizeof(MachO::x86_thread_state_t) > end)
1067           return malformedError("load command " + Twine(LoadCommandIndex) +
1068                                 " x86_THREAD_STATE extends past end of "
1069                                 "command in " + CmdName + " command");
1070         state += sizeof(MachO::x86_thread_state_t);
1071       } else if (flavor == MachO::x86_FLOAT_STATE) {
1072         if (count != MachO::x86_FLOAT_STATE_COUNT)
1073           return malformedError("load command " + Twine(LoadCommandIndex) +
1074                                 " count not x86_FLOAT_STATE_COUNT for "
1075                                 "flavor number " + Twine(nflavor) + " which is "
1076                                 "a x86_FLOAT_STATE flavor in " + CmdName +
1077                                 " command");
1078         if (state + sizeof(MachO::x86_float_state_t) > end)
1079           return malformedError("load command " + Twine(LoadCommandIndex) +
1080                                 " x86_FLOAT_STATE extends past end of "
1081                                 "command in " + CmdName + " command");
1082         state += sizeof(MachO::x86_float_state_t);
1083       } else if (flavor == MachO::x86_EXCEPTION_STATE) {
1084         if (count != MachO::x86_EXCEPTION_STATE_COUNT)
1085           return malformedError("load command " + Twine(LoadCommandIndex) +
1086                                 " count not x86_EXCEPTION_STATE_COUNT for "
1087                                 "flavor number " + Twine(nflavor) + " which is "
1088                                 "a x86_EXCEPTION_STATE flavor in " + CmdName +
1089                                 " command");
1090         if (state + sizeof(MachO::x86_exception_state_t) > end)
1091           return malformedError("load command " + Twine(LoadCommandIndex) +
1092                                 " x86_EXCEPTION_STATE extends past end of "
1093                                 "command in " + CmdName + " command");
1094         state += sizeof(MachO::x86_exception_state_t);
1095       } else if (flavor == MachO::x86_THREAD_STATE64) {
1096         if (count != MachO::x86_THREAD_STATE64_COUNT)
1097           return malformedError("load command " + Twine(LoadCommandIndex) +
1098                                 " count not x86_THREAD_STATE64_COUNT for "
1099                                 "flavor number " + Twine(nflavor) + " which is "
1100                                 "a x86_THREAD_STATE64 flavor in " + CmdName +
1101                                 " command");
1102         if (state + sizeof(MachO::x86_thread_state64_t) > end)
1103           return malformedError("load command " + Twine(LoadCommandIndex) +
1104                                 " x86_THREAD_STATE64 extends past end of "
1105                                 "command in " + CmdName + " command");
1106         state += sizeof(MachO::x86_thread_state64_t);
1107       } else if (flavor == MachO::x86_EXCEPTION_STATE64) {
1108         if (count != MachO::x86_EXCEPTION_STATE64_COUNT)
1109           return malformedError("load command " + Twine(LoadCommandIndex) +
1110                                 " count not x86_EXCEPTION_STATE64_COUNT for "
1111                                 "flavor number " + Twine(nflavor) + " which is "
1112                                 "a x86_EXCEPTION_STATE64 flavor in " + CmdName +
1113                                 " command");
1114         if (state + sizeof(MachO::x86_exception_state64_t) > end)
1115           return malformedError("load command " + Twine(LoadCommandIndex) +
1116                                 " x86_EXCEPTION_STATE64 extends past end of "
1117                                 "command in " + CmdName + " command");
1118         state += sizeof(MachO::x86_exception_state64_t);
1119       } else {
1120         return malformedError("load command " + Twine(LoadCommandIndex) +
1121                               " unknown flavor (" + Twine(flavor) + ") for "
1122                               "flavor number " + Twine(nflavor) + " in " +
1123                               CmdName + " command");
1124       }
1125     } else if (cputype == MachO::CPU_TYPE_ARM) {
1126       if (flavor == MachO::ARM_THREAD_STATE) {
1127         if (count != MachO::ARM_THREAD_STATE_COUNT)
1128           return malformedError("load command " + Twine(LoadCommandIndex) +
1129                                 " count not ARM_THREAD_STATE_COUNT for "
1130                                 "flavor number " + Twine(nflavor) + " which is "
1131                                 "a ARM_THREAD_STATE flavor in " + CmdName +
1132                                 " command");
1133         if (state + sizeof(MachO::arm_thread_state32_t) > end)
1134           return malformedError("load command " + Twine(LoadCommandIndex) +
1135                                 " ARM_THREAD_STATE extends past end of "
1136                                 "command in " + CmdName + " command");
1137         state += sizeof(MachO::arm_thread_state32_t);
1138       } else {
1139         return malformedError("load command " + Twine(LoadCommandIndex) +
1140                               " unknown flavor (" + Twine(flavor) + ") for "
1141                               "flavor number " + Twine(nflavor) + " in " +
1142                               CmdName + " command");
1143       }
1144     } else if (cputype == MachO::CPU_TYPE_ARM64 ||
1145                cputype == MachO::CPU_TYPE_ARM64_32) {
1146       if (flavor == MachO::ARM_THREAD_STATE64) {
1147         if (count != MachO::ARM_THREAD_STATE64_COUNT)
1148           return malformedError("load command " + Twine(LoadCommandIndex) +
1149                                 " count not ARM_THREAD_STATE64_COUNT for "
1150                                 "flavor number " + Twine(nflavor) + " which is "
1151                                 "a ARM_THREAD_STATE64 flavor in " + CmdName +
1152                                 " command");
1153         if (state + sizeof(MachO::arm_thread_state64_t) > end)
1154           return malformedError("load command " + Twine(LoadCommandIndex) +
1155                                 " ARM_THREAD_STATE64 extends past end of "
1156                                 "command in " + CmdName + " command");
1157         state += sizeof(MachO::arm_thread_state64_t);
1158       } else {
1159         return malformedError("load command " + Twine(LoadCommandIndex) +
1160                               " unknown flavor (" + Twine(flavor) + ") for "
1161                               "flavor number " + Twine(nflavor) + " in " +
1162                               CmdName + " command");
1163       }
1164     } else if (cputype == MachO::CPU_TYPE_POWERPC) {
1165       if (flavor == MachO::PPC_THREAD_STATE) {
1166         if (count != MachO::PPC_THREAD_STATE_COUNT)
1167           return malformedError("load command " + Twine(LoadCommandIndex) +
1168                                 " count not PPC_THREAD_STATE_COUNT for "
1169                                 "flavor number " + Twine(nflavor) + " which is "
1170                                 "a PPC_THREAD_STATE flavor in " + CmdName +
1171                                 " command");
1172         if (state + sizeof(MachO::ppc_thread_state32_t) > end)
1173           return malformedError("load command " + Twine(LoadCommandIndex) +
1174                                 " PPC_THREAD_STATE extends past end of "
1175                                 "command in " + CmdName + " command");
1176         state += sizeof(MachO::ppc_thread_state32_t);
1177       } else {
1178         return malformedError("load command " + Twine(LoadCommandIndex) +
1179                               " unknown flavor (" + Twine(flavor) + ") for "
1180                               "flavor number " + Twine(nflavor) + " in " +
1181                               CmdName + " command");
1182       }
1183     } else {
1184       return malformedError("unknown cputype (" + Twine(cputype) + ") load "
1185                             "command " + Twine(LoadCommandIndex) + " for " +
1186                             CmdName + " command can't be checked");
1187     }
1188     nflavor++;
1189   }
1190   return Error::success();
1191 }
1192
1193 static Error checkTwoLevelHintsCommand(const MachOObjectFile &Obj,
1194                                        const MachOObjectFile::LoadCommandInfo
1195                                          &Load,
1196                                        uint32_t LoadCommandIndex,
1197                                        const char **LoadCmd,
1198                                        std::list<MachOElement> &Elements) {
1199   if (Load.C.cmdsize != sizeof(MachO::twolevel_hints_command))
1200     return malformedError("load command " + Twine(LoadCommandIndex) +
1201                           " LC_TWOLEVEL_HINTS has incorrect cmdsize");
1202   if (*LoadCmd != nullptr)
1203     return malformedError("more than one LC_TWOLEVEL_HINTS command");
1204   auto HintsOrErr = getStructOrErr<MachO::twolevel_hints_command>(Obj, Load.Ptr);
1205   if(!HintsOrErr)
1206     return HintsOrErr.takeError();
1207   MachO::twolevel_hints_command Hints = HintsOrErr.get();
1208   uint64_t FileSize = Obj.getData().size();
1209   if (Hints.offset > FileSize)
1210     return malformedError("offset field of LC_TWOLEVEL_HINTS command " +
1211                           Twine(LoadCommandIndex) + " extends past the end of "
1212                           "the file");
1213   uint64_t BigSize = Hints.nhints;
1214   BigSize *= sizeof(MachO::twolevel_hint);
1215   BigSize += Hints.offset;
1216   if (BigSize > FileSize)
1217     return malformedError("offset field plus nhints times sizeof(struct "
1218                           "twolevel_hint) field of LC_TWOLEVEL_HINTS command " +
1219                           Twine(LoadCommandIndex) + " extends past the end of "
1220                           "the file");
1221   if (Error Err = checkOverlappingElement(Elements, Hints.offset, Hints.nhints *
1222                                           sizeof(MachO::twolevel_hint),
1223                                           "two level hints"))
1224     return Err;
1225   *LoadCmd = Load.Ptr;
1226   return Error::success();
1227 }
1228
1229 // Returns true if the libObject code does not support the load command and its
1230 // contents.  The cmd value it is treated as an unknown load command but with
1231 // an error message that says the cmd value is obsolete.
1232 static bool isLoadCommandObsolete(uint32_t cmd) {
1233   if (cmd == MachO::LC_SYMSEG ||
1234       cmd == MachO::LC_LOADFVMLIB ||
1235       cmd == MachO::LC_IDFVMLIB ||
1236       cmd == MachO::LC_IDENT ||
1237       cmd == MachO::LC_FVMFILE ||
1238       cmd == MachO::LC_PREPAGE ||
1239       cmd == MachO::LC_PREBOUND_DYLIB ||
1240       cmd == MachO::LC_TWOLEVEL_HINTS ||
1241       cmd == MachO::LC_PREBIND_CKSUM)
1242     return true;
1243   return false;
1244 }
1245
1246 Expected<std::unique_ptr<MachOObjectFile>>
1247 MachOObjectFile::create(MemoryBufferRef Object, bool IsLittleEndian,
1248                         bool Is64Bits, uint32_t UniversalCputype,
1249                         uint32_t UniversalIndex) {
1250   Error Err = Error::success();
1251   std::unique_ptr<MachOObjectFile> Obj(
1252       new MachOObjectFile(std::move(Object), IsLittleEndian,
1253                           Is64Bits, Err, UniversalCputype,
1254                           UniversalIndex));
1255   if (Err)
1256     return std::move(Err);
1257   return std::move(Obj);
1258 }
1259
1260 MachOObjectFile::MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian,
1261                                  bool Is64bits, Error &Err,
1262                                  uint32_t UniversalCputype,
1263                                  uint32_t UniversalIndex)
1264     : ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object) {
1265   ErrorAsOutParameter ErrAsOutParam(&Err);
1266   uint64_t SizeOfHeaders;
1267   uint32_t cputype;
1268   if (is64Bit()) {
1269     parseHeader(*this, Header64, Err);
1270     SizeOfHeaders = sizeof(MachO::mach_header_64);
1271     cputype = Header64.cputype;
1272   } else {
1273     parseHeader(*this, Header, Err);
1274     SizeOfHeaders = sizeof(MachO::mach_header);
1275     cputype = Header.cputype;
1276   }
1277   if (Err)
1278     return;
1279   SizeOfHeaders += getHeader().sizeofcmds;
1280   if (getData().data() + SizeOfHeaders > getData().end()) {
1281     Err = malformedError("load commands extend past the end of the file");
1282     return;
1283   }
1284   if (UniversalCputype != 0 && cputype != UniversalCputype) {
1285     Err = malformedError("universal header architecture: " +
1286                          Twine(UniversalIndex) + "'s cputype does not match "
1287                          "object file's mach header");
1288     return;
1289   }
1290   std::list<MachOElement> Elements;
1291   Elements.push_back({0, SizeOfHeaders, "Mach-O headers"});
1292
1293   uint32_t LoadCommandCount = getHeader().ncmds;
1294   LoadCommandInfo Load;
1295   if (LoadCommandCount != 0) {
1296     if (auto LoadOrErr = getFirstLoadCommandInfo(*this))
1297       Load = *LoadOrErr;
1298     else {
1299       Err = LoadOrErr.takeError();
1300       return;
1301     }
1302   }
1303
1304   const char *DyldIdLoadCmd = nullptr;
1305   const char *FuncStartsLoadCmd = nullptr;
1306   const char *SplitInfoLoadCmd = nullptr;
1307   const char *CodeSignDrsLoadCmd = nullptr;
1308   const char *CodeSignLoadCmd = nullptr;
1309   const char *VersLoadCmd = nullptr;
1310   const char *SourceLoadCmd = nullptr;
1311   const char *EntryPointLoadCmd = nullptr;
1312   const char *EncryptLoadCmd = nullptr;
1313   const char *RoutinesLoadCmd = nullptr;
1314   const char *UnixThreadLoadCmd = nullptr;
1315   const char *TwoLevelHintsLoadCmd = nullptr;
1316   for (unsigned I = 0; I < LoadCommandCount; ++I) {
1317     if (is64Bit()) {
1318       if (Load.C.cmdsize % 8 != 0) {
1319         // We have a hack here to allow 64-bit Mach-O core files to have
1320         // LC_THREAD commands that are only a multiple of 4 and not 8 to be
1321         // allowed since the macOS kernel produces them.
1322         if (getHeader().filetype != MachO::MH_CORE ||
1323             Load.C.cmd != MachO::LC_THREAD || Load.C.cmdsize % 4) {
1324           Err = malformedError("load command " + Twine(I) + " cmdsize not a "
1325                                "multiple of 8");
1326           return;
1327         }
1328       }
1329     } else {
1330       if (Load.C.cmdsize % 4 != 0) {
1331         Err = malformedError("load command " + Twine(I) + " cmdsize not a "
1332                              "multiple of 4");
1333         return;
1334       }
1335     }
1336     LoadCommands.push_back(Load);
1337     if (Load.C.cmd == MachO::LC_SYMTAB) {
1338       if ((Err = checkSymtabCommand(*this, Load, I, &SymtabLoadCmd, Elements)))
1339         return;
1340     } else if (Load.C.cmd == MachO::LC_DYSYMTAB) {
1341       if ((Err = checkDysymtabCommand(*this, Load, I, &DysymtabLoadCmd,
1342                                       Elements)))
1343         return;
1344     } else if (Load.C.cmd == MachO::LC_DATA_IN_CODE) {
1345       if ((Err = checkLinkeditDataCommand(*this, Load, I, &DataInCodeLoadCmd,
1346                                           "LC_DATA_IN_CODE", Elements,
1347                                           "data in code info")))
1348         return;
1349     } else if (Load.C.cmd == MachO::LC_LINKER_OPTIMIZATION_HINT) {
1350       if ((Err = checkLinkeditDataCommand(*this, Load, I, &LinkOptHintsLoadCmd,
1351                                           "LC_LINKER_OPTIMIZATION_HINT",
1352                                           Elements, "linker optimization "
1353                                           "hints")))
1354         return;
1355     } else if (Load.C.cmd == MachO::LC_FUNCTION_STARTS) {
1356       if ((Err = checkLinkeditDataCommand(*this, Load, I, &FuncStartsLoadCmd,
1357                                           "LC_FUNCTION_STARTS", Elements,
1358                                           "function starts data")))
1359         return;
1360     } else if (Load.C.cmd == MachO::LC_SEGMENT_SPLIT_INFO) {
1361       if ((Err = checkLinkeditDataCommand(*this, Load, I, &SplitInfoLoadCmd,
1362                                           "LC_SEGMENT_SPLIT_INFO", Elements,
1363                                           "split info data")))
1364         return;
1365     } else if (Load.C.cmd == MachO::LC_DYLIB_CODE_SIGN_DRS) {
1366       if ((Err = checkLinkeditDataCommand(*this, Load, I, &CodeSignDrsLoadCmd,
1367                                           "LC_DYLIB_CODE_SIGN_DRS", Elements,
1368                                           "code signing RDs data")))
1369         return;
1370     } else if (Load.C.cmd == MachO::LC_CODE_SIGNATURE) {
1371       if ((Err = checkLinkeditDataCommand(*this, Load, I, &CodeSignLoadCmd,
1372                                           "LC_CODE_SIGNATURE", Elements,
1373                                           "code signature data")))
1374         return;
1375     } else if (Load.C.cmd == MachO::LC_DYLD_INFO) {
1376       if ((Err = checkDyldInfoCommand(*this, Load, I, &DyldInfoLoadCmd,
1377                                       "LC_DYLD_INFO", Elements)))
1378         return;
1379     } else if (Load.C.cmd == MachO::LC_DYLD_INFO_ONLY) {
1380       if ((Err = checkDyldInfoCommand(*this, Load, I, &DyldInfoLoadCmd,
1381                                       "LC_DYLD_INFO_ONLY", Elements)))
1382         return;
1383     } else if (Load.C.cmd == MachO::LC_UUID) {
1384       if (Load.C.cmdsize != sizeof(MachO::uuid_command)) {
1385         Err = malformedError("LC_UUID command " + Twine(I) + " has incorrect "
1386                              "cmdsize");
1387         return;
1388       }
1389       if (UuidLoadCmd) {
1390         Err = malformedError("more than one LC_UUID command");
1391         return;
1392       }
1393       UuidLoadCmd = Load.Ptr;
1394     } else if (Load.C.cmd == MachO::LC_SEGMENT_64) {
1395       if ((Err = parseSegmentLoadCommand<MachO::segment_command_64,
1396                                          MachO::section_64>(
1397                    *this, Load, Sections, HasPageZeroSegment, I,
1398                    "LC_SEGMENT_64", SizeOfHeaders, Elements)))
1399         return;
1400     } else if (Load.C.cmd == MachO::LC_SEGMENT) {
1401       if ((Err = parseSegmentLoadCommand<MachO::segment_command,
1402                                          MachO::section>(
1403                    *this, Load, Sections, HasPageZeroSegment, I,
1404                    "LC_SEGMENT", SizeOfHeaders, Elements)))
1405         return;
1406     } else if (Load.C.cmd == MachO::LC_ID_DYLIB) {
1407       if ((Err = checkDylibIdCommand(*this, Load, I, &DyldIdLoadCmd)))
1408         return;
1409     } else if (Load.C.cmd == MachO::LC_LOAD_DYLIB) {
1410       if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_DYLIB")))
1411         return;
1412       Libraries.push_back(Load.Ptr);
1413     } else if (Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB) {
1414       if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_WEAK_DYLIB")))
1415         return;
1416       Libraries.push_back(Load.Ptr);
1417     } else if (Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB) {
1418       if ((Err = checkDylibCommand(*this, Load, I, "LC_LAZY_LOAD_DYLIB")))
1419         return;
1420       Libraries.push_back(Load.Ptr);
1421     } else if (Load.C.cmd == MachO::LC_REEXPORT_DYLIB) {
1422       if ((Err = checkDylibCommand(*this, Load, I, "LC_REEXPORT_DYLIB")))
1423         return;
1424       Libraries.push_back(Load.Ptr);
1425     } else if (Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) {
1426       if ((Err = checkDylibCommand(*this, Load, I, "LC_LOAD_UPWARD_DYLIB")))
1427         return;
1428       Libraries.push_back(Load.Ptr);
1429     } else if (Load.C.cmd == MachO::LC_ID_DYLINKER) {
1430       if ((Err = checkDyldCommand(*this, Load, I, "LC_ID_DYLINKER")))
1431         return;
1432     } else if (Load.C.cmd == MachO::LC_LOAD_DYLINKER) {
1433       if ((Err = checkDyldCommand(*this, Load, I, "LC_LOAD_DYLINKER")))
1434         return;
1435     } else if (Load.C.cmd == MachO::LC_DYLD_ENVIRONMENT) {
1436       if ((Err = checkDyldCommand(*this, Load, I, "LC_DYLD_ENVIRONMENT")))
1437         return;
1438     } else if (Load.C.cmd == MachO::LC_VERSION_MIN_MACOSX) {
1439       if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1440                                   "LC_VERSION_MIN_MACOSX")))
1441         return;
1442     } else if (Load.C.cmd == MachO::LC_VERSION_MIN_IPHONEOS) {
1443       if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1444                                   "LC_VERSION_MIN_IPHONEOS")))
1445         return;
1446     } else if (Load.C.cmd == MachO::LC_VERSION_MIN_TVOS) {
1447       if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1448                                   "LC_VERSION_MIN_TVOS")))
1449         return;
1450     } else if (Load.C.cmd == MachO::LC_VERSION_MIN_WATCHOS) {
1451       if ((Err = checkVersCommand(*this, Load, I, &VersLoadCmd,
1452                                   "LC_VERSION_MIN_WATCHOS")))
1453         return;
1454     } else if (Load.C.cmd == MachO::LC_NOTE) {
1455       if ((Err = checkNoteCommand(*this, Load, I, Elements)))
1456         return;
1457     } else if (Load.C.cmd == MachO::LC_BUILD_VERSION) {
1458       if ((Err = parseBuildVersionCommand(*this, Load, BuildTools, I)))
1459         return;
1460     } else if (Load.C.cmd == MachO::LC_RPATH) {
1461       if ((Err = checkRpathCommand(*this, Load, I)))
1462         return;
1463     } else if (Load.C.cmd == MachO::LC_SOURCE_VERSION) {
1464       if (Load.C.cmdsize != sizeof(MachO::source_version_command)) {
1465         Err = malformedError("LC_SOURCE_VERSION command " + Twine(I) +
1466                              " has incorrect cmdsize");
1467         return;
1468       }
1469       if (SourceLoadCmd) {
1470         Err = malformedError("more than one LC_SOURCE_VERSION command");
1471         return;
1472       }
1473       SourceLoadCmd = Load.Ptr;
1474     } else if (Load.C.cmd == MachO::LC_MAIN) {
1475       if (Load.C.cmdsize != sizeof(MachO::entry_point_command)) {
1476         Err = malformedError("LC_MAIN command " + Twine(I) +
1477                              " has incorrect cmdsize");
1478         return;
1479       }
1480       if (EntryPointLoadCmd) {
1481         Err = malformedError("more than one LC_MAIN command");
1482         return;
1483       }
1484       EntryPointLoadCmd = Load.Ptr;
1485     } else if (Load.C.cmd == MachO::LC_ENCRYPTION_INFO) {
1486       if (Load.C.cmdsize != sizeof(MachO::encryption_info_command)) {
1487         Err = malformedError("LC_ENCRYPTION_INFO command " + Twine(I) +
1488                              " has incorrect cmdsize");
1489         return;
1490       }
1491       MachO::encryption_info_command E =
1492         getStruct<MachO::encryption_info_command>(*this, Load.Ptr);
1493       if ((Err = checkEncryptCommand(*this, Load, I, E.cryptoff, E.cryptsize,
1494                                      &EncryptLoadCmd, "LC_ENCRYPTION_INFO")))
1495         return;
1496     } else if (Load.C.cmd == MachO::LC_ENCRYPTION_INFO_64) {
1497       if (Load.C.cmdsize != sizeof(MachO::encryption_info_command_64)) {
1498         Err = malformedError("LC_ENCRYPTION_INFO_64 command " + Twine(I) +
1499                              " has incorrect cmdsize");
1500         return;
1501       }
1502       MachO::encryption_info_command_64 E =
1503         getStruct<MachO::encryption_info_command_64>(*this, Load.Ptr);
1504       if ((Err = checkEncryptCommand(*this, Load, I, E.cryptoff, E.cryptsize,
1505                                      &EncryptLoadCmd, "LC_ENCRYPTION_INFO_64")))
1506         return;
1507     } else if (Load.C.cmd == MachO::LC_LINKER_OPTION) {
1508       if ((Err = checkLinkerOptCommand(*this, Load, I)))
1509         return;
1510     } else if (Load.C.cmd == MachO::LC_SUB_FRAMEWORK) {
1511       if (Load.C.cmdsize < sizeof(MachO::sub_framework_command)) {
1512         Err =  malformedError("load command " + Twine(I) +
1513                               " LC_SUB_FRAMEWORK cmdsize too small");
1514         return;
1515       }
1516       MachO::sub_framework_command S =
1517         getStruct<MachO::sub_framework_command>(*this, Load.Ptr);
1518       if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_FRAMEWORK",
1519                                  sizeof(MachO::sub_framework_command),
1520                                  "sub_framework_command", S.umbrella,
1521                                  "umbrella")))
1522         return;
1523     } else if (Load.C.cmd == MachO::LC_SUB_UMBRELLA) {
1524       if (Load.C.cmdsize < sizeof(MachO::sub_umbrella_command)) {
1525         Err =  malformedError("load command " + Twine(I) +
1526                               " LC_SUB_UMBRELLA cmdsize too small");
1527         return;
1528       }
1529       MachO::sub_umbrella_command S =
1530         getStruct<MachO::sub_umbrella_command>(*this, Load.Ptr);
1531       if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_UMBRELLA",
1532                                  sizeof(MachO::sub_umbrella_command),
1533                                  "sub_umbrella_command", S.sub_umbrella,
1534                                  "sub_umbrella")))
1535         return;
1536     } else if (Load.C.cmd == MachO::LC_SUB_LIBRARY) {
1537       if (Load.C.cmdsize < sizeof(MachO::sub_library_command)) {
1538         Err =  malformedError("load command " + Twine(I) +
1539                               " LC_SUB_LIBRARY cmdsize too small");
1540         return;
1541       }
1542       MachO::sub_library_command S =
1543         getStruct<MachO::sub_library_command>(*this, Load.Ptr);
1544       if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_LIBRARY",
1545                                  sizeof(MachO::sub_library_command),
1546                                  "sub_library_command", S.sub_library,
1547                                  "sub_library")))
1548         return;
1549     } else if (Load.C.cmd == MachO::LC_SUB_CLIENT) {
1550       if (Load.C.cmdsize < sizeof(MachO::sub_client_command)) {
1551         Err =  malformedError("load command " + Twine(I) +
1552                               " LC_SUB_CLIENT cmdsize too small");
1553         return;
1554       }
1555       MachO::sub_client_command S =
1556         getStruct<MachO::sub_client_command>(*this, Load.Ptr);
1557       if ((Err = checkSubCommand(*this, Load, I, "LC_SUB_CLIENT",
1558                                  sizeof(MachO::sub_client_command),
1559                                  "sub_client_command", S.client, "client")))
1560         return;
1561     } else if (Load.C.cmd == MachO::LC_ROUTINES) {
1562       if (Load.C.cmdsize != sizeof(MachO::routines_command)) {
1563         Err = malformedError("LC_ROUTINES command " + Twine(I) +
1564                              " has incorrect cmdsize");
1565         return;
1566       }
1567       if (RoutinesLoadCmd) {
1568         Err = malformedError("more than one LC_ROUTINES and or LC_ROUTINES_64 "
1569                              "command");
1570         return;
1571       }
1572       RoutinesLoadCmd = Load.Ptr;
1573     } else if (Load.C.cmd == MachO::LC_ROUTINES_64) {
1574       if (Load.C.cmdsize != sizeof(MachO::routines_command_64)) {
1575         Err = malformedError("LC_ROUTINES_64 command " + Twine(I) +
1576                              " has incorrect cmdsize");
1577         return;
1578       }
1579       if (RoutinesLoadCmd) {
1580         Err = malformedError("more than one LC_ROUTINES_64 and or LC_ROUTINES "
1581                              "command");
1582         return;
1583       }
1584       RoutinesLoadCmd = Load.Ptr;
1585     } else if (Load.C.cmd == MachO::LC_UNIXTHREAD) {
1586       if ((Err = checkThreadCommand(*this, Load, I, "LC_UNIXTHREAD")))
1587         return;
1588       if (UnixThreadLoadCmd) {
1589         Err = malformedError("more than one LC_UNIXTHREAD command");
1590         return;
1591       }
1592       UnixThreadLoadCmd = Load.Ptr;
1593     } else if (Load.C.cmd == MachO::LC_THREAD) {
1594       if ((Err = checkThreadCommand(*this, Load, I, "LC_THREAD")))
1595         return;
1596     // Note: LC_TWOLEVEL_HINTS is really obsolete and is not supported.
1597     } else if (Load.C.cmd == MachO::LC_TWOLEVEL_HINTS) {
1598        if ((Err = checkTwoLevelHintsCommand(*this, Load, I,
1599                                             &TwoLevelHintsLoadCmd, Elements)))
1600          return;
1601     } else if (isLoadCommandObsolete(Load.C.cmd)) {
1602       Err = malformedError("load command " + Twine(I) + " for cmd value of: " +
1603                            Twine(Load.C.cmd) + " is obsolete and not "
1604                            "supported");
1605       return;
1606     }
1607     // TODO: generate a error for unknown load commands by default.  But still
1608     // need work out an approach to allow or not allow unknown values like this
1609     // as an option for some uses like lldb.
1610     if (I < LoadCommandCount - 1) {
1611       if (auto LoadOrErr = getNextLoadCommandInfo(*this, I, Load))
1612         Load = *LoadOrErr;
1613       else {
1614         Err = LoadOrErr.takeError();
1615         return;
1616       }
1617     }
1618   }
1619   if (!SymtabLoadCmd) {
1620     if (DysymtabLoadCmd) {
1621       Err = malformedError("contains LC_DYSYMTAB load command without a "
1622                            "LC_SYMTAB load command");
1623       return;
1624     }
1625   } else if (DysymtabLoadCmd) {
1626     MachO::symtab_command Symtab =
1627       getStruct<MachO::symtab_command>(*this, SymtabLoadCmd);
1628     MachO::dysymtab_command Dysymtab =
1629       getStruct<MachO::dysymtab_command>(*this, DysymtabLoadCmd);
1630     if (Dysymtab.nlocalsym != 0 && Dysymtab.ilocalsym > Symtab.nsyms) {
1631       Err = malformedError("ilocalsym in LC_DYSYMTAB load command "
1632                            "extends past the end of the symbol table");
1633       return;
1634     }
1635     uint64_t BigSize = Dysymtab.ilocalsym;
1636     BigSize += Dysymtab.nlocalsym;
1637     if (Dysymtab.nlocalsym != 0 && BigSize > Symtab.nsyms) {
1638       Err = malformedError("ilocalsym plus nlocalsym in LC_DYSYMTAB load "
1639                            "command extends past the end of the symbol table");
1640       return;
1641     }
1642     if (Dysymtab.nextdefsym != 0 && Dysymtab.iextdefsym > Symtab.nsyms) {
1643       Err = malformedError("iextdefsym in LC_DYSYMTAB load command "
1644                            "extends past the end of the symbol table");
1645       return;
1646     }
1647     BigSize = Dysymtab.iextdefsym;
1648     BigSize += Dysymtab.nextdefsym;
1649     if (Dysymtab.nextdefsym != 0 && BigSize > Symtab.nsyms) {
1650       Err = malformedError("iextdefsym plus nextdefsym in LC_DYSYMTAB "
1651                            "load command extends past the end of the symbol "
1652                            "table");
1653       return;
1654     }
1655     if (Dysymtab.nundefsym != 0 && Dysymtab.iundefsym > Symtab.nsyms) {
1656       Err = malformedError("iundefsym in LC_DYSYMTAB load command "
1657                            "extends past the end of the symbol table");
1658       return;
1659     }
1660     BigSize = Dysymtab.iundefsym;
1661     BigSize += Dysymtab.nundefsym;
1662     if (Dysymtab.nundefsym != 0 && BigSize > Symtab.nsyms) {
1663       Err = malformedError("iundefsym plus nundefsym in LC_DYSYMTAB load "
1664                            " command extends past the end of the symbol table");
1665       return;
1666     }
1667   }
1668   if ((getHeader().filetype == MachO::MH_DYLIB ||
1669        getHeader().filetype == MachO::MH_DYLIB_STUB) &&
1670        DyldIdLoadCmd == nullptr) {
1671     Err = malformedError("no LC_ID_DYLIB load command in dynamic library "
1672                          "filetype");
1673     return;
1674   }
1675   assert(LoadCommands.size() == LoadCommandCount);
1676
1677   Err = Error::success();
1678 }
1679
1680 Error MachOObjectFile::checkSymbolTable() const {
1681   uint32_t Flags = 0;
1682   if (is64Bit()) {
1683     MachO::mach_header_64 H_64 = MachOObjectFile::getHeader64();
1684     Flags = H_64.flags;
1685   } else {
1686     MachO::mach_header H = MachOObjectFile::getHeader();
1687     Flags = H.flags;
1688   }
1689   uint8_t NType = 0;
1690   uint8_t NSect = 0;
1691   uint16_t NDesc = 0;
1692   uint32_t NStrx = 0;
1693   uint64_t NValue = 0;
1694   uint32_t SymbolIndex = 0;
1695   MachO::symtab_command S = getSymtabLoadCommand();
1696   for (const SymbolRef &Symbol : symbols()) {
1697     DataRefImpl SymDRI = Symbol.getRawDataRefImpl();
1698     if (is64Bit()) {
1699       MachO::nlist_64 STE_64 = getSymbol64TableEntry(SymDRI);
1700       NType = STE_64.n_type;
1701       NSect = STE_64.n_sect;
1702       NDesc = STE_64.n_desc;
1703       NStrx = STE_64.n_strx;
1704       NValue = STE_64.n_value;
1705     } else {
1706       MachO::nlist STE = getSymbolTableEntry(SymDRI);
1707       NType = STE.n_type;
1708       NSect = STE.n_sect;
1709       NDesc = STE.n_desc;
1710       NStrx = STE.n_strx;
1711       NValue = STE.n_value;
1712     }
1713     if ((NType & MachO::N_STAB) == 0) {
1714       if ((NType & MachO::N_TYPE) == MachO::N_SECT) {
1715         if (NSect == 0 || NSect > Sections.size())
1716           return malformedError("bad section index: " + Twine((int)NSect) +
1717                                 " for symbol at index " + Twine(SymbolIndex));
1718       }
1719       if ((NType & MachO::N_TYPE) == MachO::N_INDR) {
1720         if (NValue >= S.strsize)
1721           return malformedError("bad n_value: " + Twine((int)NValue) + " past "
1722                                 "the end of string table, for N_INDR symbol at "
1723                                 "index " + Twine(SymbolIndex));
1724       }
1725       if ((Flags & MachO::MH_TWOLEVEL) == MachO::MH_TWOLEVEL &&
1726           (((NType & MachO::N_TYPE) == MachO::N_UNDF && NValue == 0) ||
1727            (NType & MachO::N_TYPE) == MachO::N_PBUD)) {
1728             uint32_t LibraryOrdinal = MachO::GET_LIBRARY_ORDINAL(NDesc);
1729             if (LibraryOrdinal != 0 &&
1730                 LibraryOrdinal != MachO::EXECUTABLE_ORDINAL &&
1731                 LibraryOrdinal != MachO::DYNAMIC_LOOKUP_ORDINAL &&
1732                 LibraryOrdinal - 1 >= Libraries.size() ) {
1733               return malformedError("bad library ordinal: " + Twine(LibraryOrdinal) +
1734                                     " for symbol at index " + Twine(SymbolIndex));
1735             }
1736           }
1737     }
1738     if (NStrx >= S.strsize)
1739       return malformedError("bad string table index: " + Twine((int)NStrx) +
1740                             " past the end of string table, for symbol at "
1741                             "index " + Twine(SymbolIndex));
1742     SymbolIndex++;
1743   }
1744   return Error::success();
1745 }
1746
1747 void MachOObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
1748   unsigned SymbolTableEntrySize = is64Bit() ?
1749     sizeof(MachO::nlist_64) :
1750     sizeof(MachO::nlist);
1751   Symb.p += SymbolTableEntrySize;
1752 }
1753
1754 Expected<StringRef> MachOObjectFile::getSymbolName(DataRefImpl Symb) const {
1755   StringRef StringTable = getStringTableData();
1756   MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1757   if (Entry.n_strx == 0)
1758     // A n_strx value of 0 indicates that no name is associated with a
1759     // particular symbol table entry.
1760     return StringRef();
1761   const char *Start = &StringTable.data()[Entry.n_strx];
1762   if (Start < getData().begin() || Start >= getData().end()) {
1763     return malformedError("bad string index: " + Twine(Entry.n_strx) +
1764                           " for symbol at index " + Twine(getSymbolIndex(Symb)));
1765   }
1766   return StringRef(Start);
1767 }
1768
1769 unsigned MachOObjectFile::getSectionType(SectionRef Sec) const {
1770   DataRefImpl DRI = Sec.getRawDataRefImpl();
1771   uint32_t Flags = getSectionFlags(*this, DRI);
1772   return Flags & MachO::SECTION_TYPE;
1773 }
1774
1775 uint64_t MachOObjectFile::getNValue(DataRefImpl Sym) const {
1776   if (is64Bit()) {
1777     MachO::nlist_64 Entry = getSymbol64TableEntry(Sym);
1778     return Entry.n_value;
1779   }
1780   MachO::nlist Entry = getSymbolTableEntry(Sym);
1781   return Entry.n_value;
1782 }
1783
1784 // getIndirectName() returns the name of the alias'ed symbol who's string table
1785 // index is in the n_value field.
1786 std::error_code MachOObjectFile::getIndirectName(DataRefImpl Symb,
1787                                                  StringRef &Res) const {
1788   StringRef StringTable = getStringTableData();
1789   MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1790   if ((Entry.n_type & MachO::N_TYPE) != MachO::N_INDR)
1791     return object_error::parse_failed;
1792   uint64_t NValue = getNValue(Symb);
1793   if (NValue >= StringTable.size())
1794     return object_error::parse_failed;
1795   const char *Start = &StringTable.data()[NValue];
1796   Res = StringRef(Start);
1797   return std::error_code();
1798 }
1799
1800 uint64_t MachOObjectFile::getSymbolValueImpl(DataRefImpl Sym) const {
1801   return getNValue(Sym);
1802 }
1803
1804 Expected<uint64_t> MachOObjectFile::getSymbolAddress(DataRefImpl Sym) const {
1805   return getSymbolValue(Sym);
1806 }
1807
1808 uint32_t MachOObjectFile::getSymbolAlignment(DataRefImpl DRI) const {
1809   uint32_t flags = getSymbolFlags(DRI);
1810   if (flags & SymbolRef::SF_Common) {
1811     MachO::nlist_base Entry = getSymbolTableEntryBase(*this, DRI);
1812     return 1 << MachO::GET_COMM_ALIGN(Entry.n_desc);
1813   }
1814   return 0;
1815 }
1816
1817 uint64_t MachOObjectFile::getCommonSymbolSizeImpl(DataRefImpl DRI) const {
1818   return getNValue(DRI);
1819 }
1820
1821 Expected<SymbolRef::Type>
1822 MachOObjectFile::getSymbolType(DataRefImpl Symb) const {
1823   MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1824   uint8_t n_type = Entry.n_type;
1825
1826   // If this is a STAB debugging symbol, we can do nothing more.
1827   if (n_type & MachO::N_STAB)
1828     return SymbolRef::ST_Debug;
1829
1830   switch (n_type & MachO::N_TYPE) {
1831     case MachO::N_UNDF :
1832       return SymbolRef::ST_Unknown;
1833     case MachO::N_SECT :
1834       Expected<section_iterator> SecOrError = getSymbolSection(Symb);
1835       if (!SecOrError)
1836         return SecOrError.takeError();
1837       section_iterator Sec = *SecOrError;
1838       if (Sec->isData() || Sec->isBSS())
1839         return SymbolRef::ST_Data;
1840       return SymbolRef::ST_Function;
1841   }
1842   return SymbolRef::ST_Other;
1843 }
1844
1845 uint32_t MachOObjectFile::getSymbolFlags(DataRefImpl DRI) const {
1846   MachO::nlist_base Entry = getSymbolTableEntryBase(*this, DRI);
1847
1848   uint8_t MachOType = Entry.n_type;
1849   uint16_t MachOFlags = Entry.n_desc;
1850
1851   uint32_t Result = SymbolRef::SF_None;
1852
1853   if ((MachOType & MachO::N_TYPE) == MachO::N_INDR)
1854     Result |= SymbolRef::SF_Indirect;
1855
1856   if (MachOType & MachO::N_STAB)
1857     Result |= SymbolRef::SF_FormatSpecific;
1858
1859   if (MachOType & MachO::N_EXT) {
1860     Result |= SymbolRef::SF_Global;
1861     if ((MachOType & MachO::N_TYPE) == MachO::N_UNDF) {
1862       if (getNValue(DRI))
1863         Result |= SymbolRef::SF_Common;
1864       else
1865         Result |= SymbolRef::SF_Undefined;
1866     }
1867
1868     if (!(MachOType & MachO::N_PEXT))
1869       Result |= SymbolRef::SF_Exported;
1870   }
1871
1872   if (MachOFlags & (MachO::N_WEAK_REF | MachO::N_WEAK_DEF))
1873     Result |= SymbolRef::SF_Weak;
1874
1875   if (MachOFlags & (MachO::N_ARM_THUMB_DEF))
1876     Result |= SymbolRef::SF_Thumb;
1877
1878   if ((MachOType & MachO::N_TYPE) == MachO::N_ABS)
1879     Result |= SymbolRef::SF_Absolute;
1880
1881   return Result;
1882 }
1883
1884 Expected<section_iterator>
1885 MachOObjectFile::getSymbolSection(DataRefImpl Symb) const {
1886   MachO::nlist_base Entry = getSymbolTableEntryBase(*this, Symb);
1887   uint8_t index = Entry.n_sect;
1888
1889   if (index == 0)
1890     return section_end();
1891   DataRefImpl DRI;
1892   DRI.d.a = index - 1;
1893   if (DRI.d.a >= Sections.size()){
1894     return malformedError("bad section index: " + Twine((int)index) +
1895                           " for symbol at index " + Twine(getSymbolIndex(Symb)));
1896   }
1897   return section_iterator(SectionRef(DRI, this));
1898 }
1899
1900 unsigned MachOObjectFile::getSymbolSectionID(SymbolRef Sym) const {
1901   MachO::nlist_base Entry =
1902       getSymbolTableEntryBase(*this, Sym.getRawDataRefImpl());
1903   return Entry.n_sect - 1;
1904 }
1905
1906 void MachOObjectFile::moveSectionNext(DataRefImpl &Sec) const {
1907   Sec.d.a++;
1908 }
1909
1910 Expected<StringRef> MachOObjectFile::getSectionName(DataRefImpl Sec) const {
1911   ArrayRef<char> Raw = getSectionRawName(Sec);
1912   return parseSegmentOrSectionName(Raw.data());
1913 }
1914
1915 uint64_t MachOObjectFile::getSectionAddress(DataRefImpl Sec) const {
1916   if (is64Bit())
1917     return getSection64(Sec).addr;
1918   return getSection(Sec).addr;
1919 }
1920
1921 uint64_t MachOObjectFile::getSectionIndex(DataRefImpl Sec) const {
1922   return Sec.d.a;
1923 }
1924
1925 uint64_t MachOObjectFile::getSectionSize(DataRefImpl Sec) const {
1926   // In the case if a malformed Mach-O file where the section offset is past
1927   // the end of the file or some part of the section size is past the end of
1928   // the file return a size of zero or a size that covers the rest of the file
1929   // but does not extend past the end of the file.
1930   uint32_t SectOffset, SectType;
1931   uint64_t SectSize;
1932
1933   if (is64Bit()) {
1934     MachO::section_64 Sect = getSection64(Sec);
1935     SectOffset = Sect.offset;
1936     SectSize = Sect.size;
1937     SectType = Sect.flags & MachO::SECTION_TYPE;
1938   } else {
1939     MachO::section Sect = getSection(Sec);
1940     SectOffset = Sect.offset;
1941     SectSize = Sect.size;
1942     SectType = Sect.flags & MachO::SECTION_TYPE;
1943   }
1944   if (SectType == MachO::S_ZEROFILL || SectType == MachO::S_GB_ZEROFILL)
1945     return SectSize;
1946   uint64_t FileSize = getData().size();
1947   if (SectOffset > FileSize)
1948     return 0;
1949   if (FileSize - SectOffset < SectSize)
1950     return FileSize - SectOffset;
1951   return SectSize;
1952 }
1953
1954 Expected<ArrayRef<uint8_t>>
1955 MachOObjectFile::getSectionContents(DataRefImpl Sec) const {
1956   uint32_t Offset;
1957   uint64_t Size;
1958
1959   if (is64Bit()) {
1960     MachO::section_64 Sect = getSection64(Sec);
1961     Offset = Sect.offset;
1962     Size = Sect.size;
1963   } else {
1964     MachO::section Sect = getSection(Sec);
1965     Offset = Sect.offset;
1966     Size = Sect.size;
1967   }
1968
1969   return arrayRefFromStringRef(getData().substr(Offset, Size));
1970 }
1971
1972 uint64_t MachOObjectFile::getSectionAlignment(DataRefImpl Sec) const {
1973   uint32_t Align;
1974   if (is64Bit()) {
1975     MachO::section_64 Sect = getSection64(Sec);
1976     Align = Sect.align;
1977   } else {
1978     MachO::section Sect = getSection(Sec);
1979     Align = Sect.align;
1980   }
1981
1982   return uint64_t(1) << Align;
1983 }
1984
1985 Expected<SectionRef> MachOObjectFile::getSection(unsigned SectionIndex) const {
1986   if (SectionIndex < 1 || SectionIndex > Sections.size())
1987     return malformedError("bad section index: " + Twine((int)SectionIndex));
1988
1989   DataRefImpl DRI;
1990   DRI.d.a = SectionIndex - 1;
1991   return SectionRef(DRI, this);
1992 }
1993
1994 Expected<SectionRef> MachOObjectFile::getSection(StringRef SectionName) const {
1995   StringRef SecName;
1996   for (const SectionRef &Section : sections()) {
1997     if (std::error_code E = Section.getName(SecName))
1998       return errorCodeToError(E);
1999     if (SecName == SectionName) {
2000       return Section;
2001     }
2002   }
2003   return errorCodeToError(object_error::parse_failed);
2004 }
2005
2006 bool MachOObjectFile::isSectionCompressed(DataRefImpl Sec) const {
2007   return false;
2008 }
2009
2010 bool MachOObjectFile::isSectionText(DataRefImpl Sec) const {
2011   uint32_t Flags = getSectionFlags(*this, Sec);
2012   return Flags & MachO::S_ATTR_PURE_INSTRUCTIONS;
2013 }
2014
2015 bool MachOObjectFile::isSectionData(DataRefImpl Sec) const {
2016   uint32_t Flags = getSectionFlags(*this, Sec);
2017   unsigned SectionType = Flags & MachO::SECTION_TYPE;
2018   return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
2019          !(SectionType == MachO::S_ZEROFILL ||
2020            SectionType == MachO::S_GB_ZEROFILL);
2021 }
2022
2023 bool MachOObjectFile::isSectionBSS(DataRefImpl Sec) const {
2024   uint32_t Flags = getSectionFlags(*this, Sec);
2025   unsigned SectionType = Flags & MachO::SECTION_TYPE;
2026   return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
2027          (SectionType == MachO::S_ZEROFILL ||
2028           SectionType == MachO::S_GB_ZEROFILL);
2029 }
2030
2031 unsigned MachOObjectFile::getSectionID(SectionRef Sec) const {
2032   return Sec.getRawDataRefImpl().d.a;
2033 }
2034
2035 bool MachOObjectFile::isSectionVirtual(DataRefImpl Sec) const {
2036   uint32_t Flags = getSectionFlags(*this, Sec);
2037   unsigned SectionType = Flags & MachO::SECTION_TYPE;
2038   return SectionType == MachO::S_ZEROFILL ||
2039          SectionType == MachO::S_GB_ZEROFILL;
2040 }
2041
2042 bool MachOObjectFile::isSectionBitcode(DataRefImpl Sec) const {
2043   StringRef SegmentName = getSectionFinalSegmentName(Sec);
2044   if (Expected<StringRef> NameOrErr = getSectionName(Sec))
2045     return (SegmentName == "__LLVM" && *NameOrErr == "__bitcode");
2046   return false;
2047 }
2048
2049 bool MachOObjectFile::isSectionStripped(DataRefImpl Sec) const {
2050   if (is64Bit())
2051     return getSection64(Sec).offset == 0;
2052   return getSection(Sec).offset == 0;
2053 }
2054
2055 relocation_iterator MachOObjectFile::section_rel_begin(DataRefImpl Sec) const {
2056   DataRefImpl Ret;
2057   Ret.d.a = Sec.d.a;
2058   Ret.d.b = 0;
2059   return relocation_iterator(RelocationRef(Ret, this));
2060 }
2061
2062 relocation_iterator
2063 MachOObjectFile::section_rel_end(DataRefImpl Sec) const {
2064   uint32_t Num;
2065   if (is64Bit()) {
2066     MachO::section_64 Sect = getSection64(Sec);
2067     Num = Sect.nreloc;
2068   } else {
2069     MachO::section Sect = getSection(Sec);
2070     Num = Sect.nreloc;
2071   }
2072
2073   DataRefImpl Ret;
2074   Ret.d.a = Sec.d.a;
2075   Ret.d.b = Num;
2076   return relocation_iterator(RelocationRef(Ret, this));
2077 }
2078
2079 relocation_iterator MachOObjectFile::extrel_begin() const {
2080   DataRefImpl Ret;
2081   // for DYSYMTAB symbols, Ret.d.a == 0 for external relocations
2082   Ret.d.a = 0; // Would normally be a section index.
2083   Ret.d.b = 0; // Index into the external relocations
2084   return relocation_iterator(RelocationRef(Ret, this));
2085 }
2086
2087 relocation_iterator MachOObjectFile::extrel_end() const {
2088   MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
2089   DataRefImpl Ret;
2090   // for DYSYMTAB symbols, Ret.d.a == 0 for external relocations
2091   Ret.d.a = 0; // Would normally be a section index.
2092   Ret.d.b = DysymtabLoadCmd.nextrel; // Index into the external relocations
2093   return relocation_iterator(RelocationRef(Ret, this));
2094 }
2095
2096 relocation_iterator MachOObjectFile::locrel_begin() const {
2097   DataRefImpl Ret;
2098   // for DYSYMTAB symbols, Ret.d.a == 1 for local relocations
2099   Ret.d.a = 1; // Would normally be a section index.
2100   Ret.d.b = 0; // Index into the local relocations
2101   return relocation_iterator(RelocationRef(Ret, this));
2102 }
2103
2104 relocation_iterator MachOObjectFile::locrel_end() const {
2105   MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
2106   DataRefImpl Ret;
2107   // for DYSYMTAB symbols, Ret.d.a == 1 for local relocations
2108   Ret.d.a = 1; // Would normally be a section index.
2109   Ret.d.b = DysymtabLoadCmd.nlocrel; // Index into the local relocations
2110   return relocation_iterator(RelocationRef(Ret, this));
2111 }
2112
2113 void MachOObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
2114   ++Rel.d.b;
2115 }
2116
2117 uint64_t MachOObjectFile::getRelocationOffset(DataRefImpl Rel) const {
2118   assert((getHeader().filetype == MachO::MH_OBJECT ||
2119           getHeader().filetype == MachO::MH_KEXT_BUNDLE) &&
2120          "Only implemented for MH_OBJECT && MH_KEXT_BUNDLE");
2121   MachO::any_relocation_info RE = getRelocation(Rel);
2122   return getAnyRelocationAddress(RE);
2123 }
2124
2125 symbol_iterator
2126 MachOObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
2127   MachO::any_relocation_info RE = getRelocation(Rel);
2128   if (isRelocationScattered(RE))
2129     return symbol_end();
2130
2131   uint32_t SymbolIdx = getPlainRelocationSymbolNum(RE);
2132   bool isExtern = getPlainRelocationExternal(RE);
2133   if (!isExtern)
2134     return symbol_end();
2135
2136   MachO::symtab_command S = getSymtabLoadCommand();
2137   unsigned SymbolTableEntrySize = is64Bit() ?
2138     sizeof(MachO::nlist_64) :
2139     sizeof(MachO::nlist);
2140   uint64_t Offset = S.symoff + SymbolIdx * SymbolTableEntrySize;
2141   DataRefImpl Sym;
2142   Sym.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2143   return symbol_iterator(SymbolRef(Sym, this));
2144 }
2145
2146 section_iterator
2147 MachOObjectFile::getRelocationSection(DataRefImpl Rel) const {
2148   return section_iterator(getAnyRelocationSection(getRelocation(Rel)));
2149 }
2150
2151 uint64_t MachOObjectFile::getRelocationType(DataRefImpl Rel) const {
2152   MachO::any_relocation_info RE = getRelocation(Rel);
2153   return getAnyRelocationType(RE);
2154 }
2155
2156 void MachOObjectFile::getRelocationTypeName(
2157     DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
2158   StringRef res;
2159   uint64_t RType = getRelocationType(Rel);
2160
2161   unsigned Arch = this->getArch();
2162
2163   switch (Arch) {
2164     case Triple::x86: {
2165       static const char *const Table[] =  {
2166         "GENERIC_RELOC_VANILLA",
2167         "GENERIC_RELOC_PAIR",
2168         "GENERIC_RELOC_SECTDIFF",
2169         "GENERIC_RELOC_PB_LA_PTR",
2170         "GENERIC_RELOC_LOCAL_SECTDIFF",
2171         "GENERIC_RELOC_TLV" };
2172
2173       if (RType > 5)
2174         res = "Unknown";
2175       else
2176         res = Table[RType];
2177       break;
2178     }
2179     case Triple::x86_64: {
2180       static const char *const Table[] =  {
2181         "X86_64_RELOC_UNSIGNED",
2182         "X86_64_RELOC_SIGNED",
2183         "X86_64_RELOC_BRANCH",
2184         "X86_64_RELOC_GOT_LOAD",
2185         "X86_64_RELOC_GOT",
2186         "X86_64_RELOC_SUBTRACTOR",
2187         "X86_64_RELOC_SIGNED_1",
2188         "X86_64_RELOC_SIGNED_2",
2189         "X86_64_RELOC_SIGNED_4",
2190         "X86_64_RELOC_TLV" };
2191
2192       if (RType > 9)
2193         res = "Unknown";
2194       else
2195         res = Table[RType];
2196       break;
2197     }
2198     case Triple::arm: {
2199       static const char *const Table[] =  {
2200         "ARM_RELOC_VANILLA",
2201         "ARM_RELOC_PAIR",
2202         "ARM_RELOC_SECTDIFF",
2203         "ARM_RELOC_LOCAL_SECTDIFF",
2204         "ARM_RELOC_PB_LA_PTR",
2205         "ARM_RELOC_BR24",
2206         "ARM_THUMB_RELOC_BR22",
2207         "ARM_THUMB_32BIT_BRANCH",
2208         "ARM_RELOC_HALF",
2209         "ARM_RELOC_HALF_SECTDIFF" };
2210
2211       if (RType > 9)
2212         res = "Unknown";
2213       else
2214         res = Table[RType];
2215       break;
2216     }
2217     case Triple::aarch64:
2218     case Triple::aarch64_32: {
2219       static const char *const Table[] = {
2220         "ARM64_RELOC_UNSIGNED",           "ARM64_RELOC_SUBTRACTOR",
2221         "ARM64_RELOC_BRANCH26",           "ARM64_RELOC_PAGE21",
2222         "ARM64_RELOC_PAGEOFF12",          "ARM64_RELOC_GOT_LOAD_PAGE21",
2223         "ARM64_RELOC_GOT_LOAD_PAGEOFF12", "ARM64_RELOC_POINTER_TO_GOT",
2224         "ARM64_RELOC_TLVP_LOAD_PAGE21",   "ARM64_RELOC_TLVP_LOAD_PAGEOFF12",
2225         "ARM64_RELOC_ADDEND"
2226       };
2227
2228       if (RType >= array_lengthof(Table))
2229         res = "Unknown";
2230       else
2231         res = Table[RType];
2232       break;
2233     }
2234     case Triple::ppc: {
2235       static const char *const Table[] =  {
2236         "PPC_RELOC_VANILLA",
2237         "PPC_RELOC_PAIR",
2238         "PPC_RELOC_BR14",
2239         "PPC_RELOC_BR24",
2240         "PPC_RELOC_HI16",
2241         "PPC_RELOC_LO16",
2242         "PPC_RELOC_HA16",
2243         "PPC_RELOC_LO14",
2244         "PPC_RELOC_SECTDIFF",
2245         "PPC_RELOC_PB_LA_PTR",
2246         "PPC_RELOC_HI16_SECTDIFF",
2247         "PPC_RELOC_LO16_SECTDIFF",
2248         "PPC_RELOC_HA16_SECTDIFF",
2249         "PPC_RELOC_JBSR",
2250         "PPC_RELOC_LO14_SECTDIFF",
2251         "PPC_RELOC_LOCAL_SECTDIFF" };
2252
2253       if (RType > 15)
2254         res = "Unknown";
2255       else
2256         res = Table[RType];
2257       break;
2258     }
2259     case Triple::UnknownArch:
2260       res = "Unknown";
2261       break;
2262   }
2263   Result.append(res.begin(), res.end());
2264 }
2265
2266 uint8_t MachOObjectFile::getRelocationLength(DataRefImpl Rel) const {
2267   MachO::any_relocation_info RE = getRelocation(Rel);
2268   return getAnyRelocationLength(RE);
2269 }
2270
2271 //
2272 // guessLibraryShortName() is passed a name of a dynamic library and returns a
2273 // guess on what the short name is.  Then name is returned as a substring of the
2274 // StringRef Name passed in.  The name of the dynamic library is recognized as
2275 // a framework if it has one of the two following forms:
2276 //      Foo.framework/Versions/A/Foo
2277 //      Foo.framework/Foo
2278 // Where A and Foo can be any string.  And may contain a trailing suffix
2279 // starting with an underbar.  If the Name is recognized as a framework then
2280 // isFramework is set to true else it is set to false.  If the Name has a
2281 // suffix then Suffix is set to the substring in Name that contains the suffix
2282 // else it is set to a NULL StringRef.
2283 //
2284 // The Name of the dynamic library is recognized as a library name if it has
2285 // one of the two following forms:
2286 //      libFoo.A.dylib
2287 //      libFoo.dylib
2288 //
2289 // The library may have a suffix trailing the name Foo of the form:
2290 //      libFoo_profile.A.dylib
2291 //      libFoo_profile.dylib
2292 // These dyld image suffixes are separated from the short name by a '_'
2293 // character. Because the '_' character is commonly used to separate words in
2294 // filenames guessLibraryShortName() cannot reliably separate a dylib's short
2295 // name from an arbitrary image suffix; imagine if both the short name and the
2296 // suffix contains an '_' character! To better deal with this ambiguity,
2297 // guessLibraryShortName() will recognize only "_debug" and "_profile" as valid
2298 // Suffix values. Calling code needs to be tolerant of guessLibraryShortName()
2299 // guessing incorrectly.
2300 //
2301 // The Name of the dynamic library is also recognized as a library name if it
2302 // has the following form:
2303 //      Foo.qtx
2304 //
2305 // If the Name of the dynamic library is none of the forms above then a NULL
2306 // StringRef is returned.
2307 StringRef MachOObjectFile::guessLibraryShortName(StringRef Name,
2308                                                  bool &isFramework,
2309                                                  StringRef &Suffix) {
2310   StringRef Foo, F, DotFramework, V, Dylib, Lib, Dot, Qtx;
2311   size_t a, b, c, d, Idx;
2312
2313   isFramework = false;
2314   Suffix = StringRef();
2315
2316   // Pull off the last component and make Foo point to it
2317   a = Name.rfind('/');
2318   if (a == Name.npos || a == 0)
2319     goto guess_library;
2320   Foo = Name.slice(a+1, Name.npos);
2321
2322   // Look for a suffix starting with a '_'
2323   Idx = Foo.rfind('_');
2324   if (Idx != Foo.npos && Foo.size() >= 2) {
2325     Suffix = Foo.slice(Idx, Foo.npos);
2326     if (Suffix != "_debug" && Suffix != "_profile")
2327       Suffix = StringRef();
2328     else
2329       Foo = Foo.slice(0, Idx);
2330   }
2331
2332   // First look for the form Foo.framework/Foo
2333   b = Name.rfind('/', a);
2334   if (b == Name.npos)
2335     Idx = 0;
2336   else
2337     Idx = b+1;
2338   F = Name.slice(Idx, Idx + Foo.size());
2339   DotFramework = Name.slice(Idx + Foo.size(),
2340                             Idx + Foo.size() + sizeof(".framework/")-1);
2341   if (F == Foo && DotFramework == ".framework/") {
2342     isFramework = true;
2343     return Foo;
2344   }
2345
2346   // Next look for the form Foo.framework/Versions/A/Foo
2347   if (b == Name.npos)
2348     goto guess_library;
2349   c =  Name.rfind('/', b);
2350   if (c == Name.npos || c == 0)
2351     goto guess_library;
2352   V = Name.slice(c+1, Name.npos);
2353   if (!V.startswith("Versions/"))
2354     goto guess_library;
2355   d =  Name.rfind('/', c);
2356   if (d == Name.npos)
2357     Idx = 0;
2358   else
2359     Idx = d+1;
2360   F = Name.slice(Idx, Idx + Foo.size());
2361   DotFramework = Name.slice(Idx + Foo.size(),
2362                             Idx + Foo.size() + sizeof(".framework/")-1);
2363   if (F == Foo && DotFramework == ".framework/") {
2364     isFramework = true;
2365     return Foo;
2366   }
2367
2368 guess_library:
2369   // pull off the suffix after the "." and make a point to it
2370   a = Name.rfind('.');
2371   if (a == Name.npos || a == 0)
2372     return StringRef();
2373   Dylib = Name.slice(a, Name.npos);
2374   if (Dylib != ".dylib")
2375     goto guess_qtx;
2376
2377   // First pull off the version letter for the form Foo.A.dylib if any.
2378   if (a >= 3) {
2379     Dot = Name.slice(a-2, a-1);
2380     if (Dot == ".")
2381       a = a - 2;
2382   }
2383
2384   b = Name.rfind('/', a);
2385   if (b == Name.npos)
2386     b = 0;
2387   else
2388     b = b+1;
2389   // ignore any suffix after an underbar like Foo_profile.A.dylib
2390   Idx = Name.rfind('_');
2391   if (Idx != Name.npos && Idx != b) {
2392     Lib = Name.slice(b, Idx);
2393     Suffix = Name.slice(Idx, a);
2394     if (Suffix != "_debug" && Suffix != "_profile") {
2395       Suffix = StringRef();
2396       Lib = Name.slice(b, a);
2397     }
2398   }
2399   else
2400     Lib = Name.slice(b, a);
2401   // There are incorrect library names of the form:
2402   // libATS.A_profile.dylib so check for these.
2403   if (Lib.size() >= 3) {
2404     Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
2405     if (Dot == ".")
2406       Lib = Lib.slice(0, Lib.size()-2);
2407   }
2408   return Lib;
2409
2410 guess_qtx:
2411   Qtx = Name.slice(a, Name.npos);
2412   if (Qtx != ".qtx")
2413     return StringRef();
2414   b = Name.rfind('/', a);
2415   if (b == Name.npos)
2416     Lib = Name.slice(0, a);
2417   else
2418     Lib = Name.slice(b+1, a);
2419   // There are library names of the form: QT.A.qtx so check for these.
2420   if (Lib.size() >= 3) {
2421     Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
2422     if (Dot == ".")
2423       Lib = Lib.slice(0, Lib.size()-2);
2424   }
2425   return Lib;
2426 }
2427
2428 // getLibraryShortNameByIndex() is used to get the short name of the library
2429 // for an undefined symbol in a linked Mach-O binary that was linked with the
2430 // normal two-level namespace default (that is MH_TWOLEVEL in the header).
2431 // It is passed the index (0 - based) of the library as translated from
2432 // GET_LIBRARY_ORDINAL (1 - based).
2433 std::error_code MachOObjectFile::getLibraryShortNameByIndex(unsigned Index,
2434                                                          StringRef &Res) const {
2435   if (Index >= Libraries.size())
2436     return object_error::parse_failed;
2437
2438   // If the cache of LibrariesShortNames is not built up do that first for
2439   // all the Libraries.
2440   if (LibrariesShortNames.size() == 0) {
2441     for (unsigned i = 0; i < Libraries.size(); i++) {
2442       auto CommandOrErr =
2443         getStructOrErr<MachO::dylib_command>(*this, Libraries[i]);
2444       if (!CommandOrErr)
2445         return object_error::parse_failed;
2446       MachO::dylib_command D = CommandOrErr.get();
2447       if (D.dylib.name >= D.cmdsize)
2448         return object_error::parse_failed;
2449       const char *P = (const char *)(Libraries[i]) + D.dylib.name;
2450       StringRef Name = StringRef(P);
2451       if (D.dylib.name+Name.size() >= D.cmdsize)
2452         return object_error::parse_failed;
2453       StringRef Suffix;
2454       bool isFramework;
2455       StringRef shortName = guessLibraryShortName(Name, isFramework, Suffix);
2456       if (shortName.empty())
2457         LibrariesShortNames.push_back(Name);
2458       else
2459         LibrariesShortNames.push_back(shortName);
2460     }
2461   }
2462
2463   Res = LibrariesShortNames[Index];
2464   return std::error_code();
2465 }
2466
2467 uint32_t MachOObjectFile::getLibraryCount() const {
2468   return Libraries.size();
2469 }
2470
2471 section_iterator
2472 MachOObjectFile::getRelocationRelocatedSection(relocation_iterator Rel) const {
2473   DataRefImpl Sec;
2474   Sec.d.a = Rel->getRawDataRefImpl().d.a;
2475   return section_iterator(SectionRef(Sec, this));
2476 }
2477
2478 basic_symbol_iterator MachOObjectFile::symbol_begin() const {
2479   DataRefImpl DRI;
2480   MachO::symtab_command Symtab = getSymtabLoadCommand();
2481   if (!SymtabLoadCmd || Symtab.nsyms == 0)
2482     return basic_symbol_iterator(SymbolRef(DRI, this));
2483
2484   return getSymbolByIndex(0);
2485 }
2486
2487 basic_symbol_iterator MachOObjectFile::symbol_end() const {
2488   DataRefImpl DRI;
2489   MachO::symtab_command Symtab = getSymtabLoadCommand();
2490   if (!SymtabLoadCmd || Symtab.nsyms == 0)
2491     return basic_symbol_iterator(SymbolRef(DRI, this));
2492
2493   unsigned SymbolTableEntrySize = is64Bit() ?
2494     sizeof(MachO::nlist_64) :
2495     sizeof(MachO::nlist);
2496   unsigned Offset = Symtab.symoff +
2497     Symtab.nsyms * SymbolTableEntrySize;
2498   DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2499   return basic_symbol_iterator(SymbolRef(DRI, this));
2500 }
2501
2502 symbol_iterator MachOObjectFile::getSymbolByIndex(unsigned Index) const {
2503   MachO::symtab_command Symtab = getSymtabLoadCommand();
2504   if (!SymtabLoadCmd || Index >= Symtab.nsyms)
2505     report_fatal_error("Requested symbol index is out of range.");
2506   unsigned SymbolTableEntrySize =
2507     is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
2508   DataRefImpl DRI;
2509   DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Symtab.symoff));
2510   DRI.p += Index * SymbolTableEntrySize;
2511   return basic_symbol_iterator(SymbolRef(DRI, this));
2512 }
2513
2514 uint64_t MachOObjectFile::getSymbolIndex(DataRefImpl Symb) const {
2515   MachO::symtab_command Symtab = getSymtabLoadCommand();
2516   if (!SymtabLoadCmd)
2517     report_fatal_error("getSymbolIndex() called with no symbol table symbol");
2518   unsigned SymbolTableEntrySize =
2519     is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
2520   DataRefImpl DRIstart;
2521   DRIstart.p = reinterpret_cast<uintptr_t>(getPtr(*this, Symtab.symoff));
2522   uint64_t Index = (Symb.p - DRIstart.p) / SymbolTableEntrySize;
2523   return Index;
2524 }
2525
2526 section_iterator MachOObjectFile::section_begin() const {
2527   DataRefImpl DRI;
2528   return section_iterator(SectionRef(DRI, this));
2529 }
2530
2531 section_iterator MachOObjectFile::section_end() const {
2532   DataRefImpl DRI;
2533   DRI.d.a = Sections.size();
2534   return section_iterator(SectionRef(DRI, this));
2535 }
2536
2537 uint8_t MachOObjectFile::getBytesInAddress() const {
2538   return is64Bit() ? 8 : 4;
2539 }
2540
2541 StringRef MachOObjectFile::getFileFormatName() const {
2542   unsigned CPUType = getCPUType(*this);
2543   if (!is64Bit()) {
2544     switch (CPUType) {
2545     case MachO::CPU_TYPE_I386:
2546       return "Mach-O 32-bit i386";
2547     case MachO::CPU_TYPE_ARM:
2548       return "Mach-O arm";
2549     case MachO::CPU_TYPE_ARM64_32:
2550       return "Mach-O arm64 (ILP32)";
2551     case MachO::CPU_TYPE_POWERPC:
2552       return "Mach-O 32-bit ppc";
2553     default:
2554       return "Mach-O 32-bit unknown";
2555     }
2556   }
2557
2558   switch (CPUType) {
2559   case MachO::CPU_TYPE_X86_64:
2560     return "Mach-O 64-bit x86-64";
2561   case MachO::CPU_TYPE_ARM64:
2562     return "Mach-O arm64";
2563   case MachO::CPU_TYPE_POWERPC64:
2564     return "Mach-O 64-bit ppc64";
2565   default:
2566     return "Mach-O 64-bit unknown";
2567   }
2568 }
2569
2570 Triple::ArchType MachOObjectFile::getArch(uint32_t CPUType) {
2571   switch (CPUType) {
2572   case MachO::CPU_TYPE_I386:
2573     return Triple::x86;
2574   case MachO::CPU_TYPE_X86_64:
2575     return Triple::x86_64;
2576   case MachO::CPU_TYPE_ARM:
2577     return Triple::arm;
2578   case MachO::CPU_TYPE_ARM64:
2579     return Triple::aarch64;
2580   case MachO::CPU_TYPE_ARM64_32:
2581     return Triple::aarch64_32;
2582   case MachO::CPU_TYPE_POWERPC:
2583     return Triple::ppc;
2584   case MachO::CPU_TYPE_POWERPC64:
2585     return Triple::ppc64;
2586   default:
2587     return Triple::UnknownArch;
2588   }
2589 }
2590
2591 Triple MachOObjectFile::getArchTriple(uint32_t CPUType, uint32_t CPUSubType,
2592                                       const char **McpuDefault,
2593                                       const char **ArchFlag) {
2594   if (McpuDefault)
2595     *McpuDefault = nullptr;
2596   if (ArchFlag)
2597     *ArchFlag = nullptr;
2598
2599   switch (CPUType) {
2600   case MachO::CPU_TYPE_I386:
2601     switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2602     case MachO::CPU_SUBTYPE_I386_ALL:
2603       if (ArchFlag)
2604         *ArchFlag = "i386";
2605       return Triple("i386-apple-darwin");
2606     default:
2607       return Triple();
2608     }
2609   case MachO::CPU_TYPE_X86_64:
2610     switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2611     case MachO::CPU_SUBTYPE_X86_64_ALL:
2612       if (ArchFlag)
2613         *ArchFlag = "x86_64";
2614       return Triple("x86_64-apple-darwin");
2615     case MachO::CPU_SUBTYPE_X86_64_H:
2616       if (ArchFlag)
2617         *ArchFlag = "x86_64h";
2618       return Triple("x86_64h-apple-darwin");
2619     default:
2620       return Triple();
2621     }
2622   case MachO::CPU_TYPE_ARM:
2623     switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2624     case MachO::CPU_SUBTYPE_ARM_V4T:
2625       if (ArchFlag)
2626         *ArchFlag = "armv4t";
2627       return Triple("armv4t-apple-darwin");
2628     case MachO::CPU_SUBTYPE_ARM_V5TEJ:
2629       if (ArchFlag)
2630         *ArchFlag = "armv5e";
2631       return Triple("armv5e-apple-darwin");
2632     case MachO::CPU_SUBTYPE_ARM_XSCALE:
2633       if (ArchFlag)
2634         *ArchFlag = "xscale";
2635       return Triple("xscale-apple-darwin");
2636     case MachO::CPU_SUBTYPE_ARM_V6:
2637       if (ArchFlag)
2638         *ArchFlag = "armv6";
2639       return Triple("armv6-apple-darwin");
2640     case MachO::CPU_SUBTYPE_ARM_V6M:
2641       if (McpuDefault)
2642         *McpuDefault = "cortex-m0";
2643       if (ArchFlag)
2644         *ArchFlag = "armv6m";
2645       return Triple("armv6m-apple-darwin");
2646     case MachO::CPU_SUBTYPE_ARM_V7:
2647       if (ArchFlag)
2648         *ArchFlag = "armv7";
2649       return Triple("armv7-apple-darwin");
2650     case MachO::CPU_SUBTYPE_ARM_V7EM:
2651       if (McpuDefault)
2652         *McpuDefault = "cortex-m4";
2653       if (ArchFlag)
2654         *ArchFlag = "armv7em";
2655       return Triple("thumbv7em-apple-darwin");
2656     case MachO::CPU_SUBTYPE_ARM_V7K:
2657       if (McpuDefault)
2658         *McpuDefault = "cortex-a7";
2659       if (ArchFlag)
2660         *ArchFlag = "armv7k";
2661       return Triple("armv7k-apple-darwin");
2662     case MachO::CPU_SUBTYPE_ARM_V7M:
2663       if (McpuDefault)
2664         *McpuDefault = "cortex-m3";
2665       if (ArchFlag)
2666         *ArchFlag = "armv7m";
2667       return Triple("thumbv7m-apple-darwin");
2668     case MachO::CPU_SUBTYPE_ARM_V7S:
2669       if (McpuDefault)
2670         *McpuDefault = "cortex-a7";
2671       if (ArchFlag)
2672         *ArchFlag = "armv7s";
2673       return Triple("armv7s-apple-darwin");
2674     default:
2675       return Triple();
2676     }
2677   case MachO::CPU_TYPE_ARM64:
2678     switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2679     case MachO::CPU_SUBTYPE_ARM64_ALL:
2680       if (McpuDefault)
2681         *McpuDefault = "cyclone";
2682       if (ArchFlag)
2683         *ArchFlag = "arm64";
2684       return Triple("arm64-apple-darwin");
2685     default:
2686       return Triple();
2687     }
2688   case MachO::CPU_TYPE_ARM64_32:
2689     switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2690     case MachO::CPU_SUBTYPE_ARM64_32_V8:
2691       if (McpuDefault)
2692         *McpuDefault = "cyclone";
2693       if (ArchFlag)
2694         *ArchFlag = "arm64_32";
2695       return Triple("arm64_32-apple-darwin");
2696     default:
2697       return Triple();
2698     }
2699   case MachO::CPU_TYPE_POWERPC:
2700     switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2701     case MachO::CPU_SUBTYPE_POWERPC_ALL:
2702       if (ArchFlag)
2703         *ArchFlag = "ppc";
2704       return Triple("ppc-apple-darwin");
2705     default:
2706       return Triple();
2707     }
2708   case MachO::CPU_TYPE_POWERPC64:
2709     switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
2710     case MachO::CPU_SUBTYPE_POWERPC_ALL:
2711       if (ArchFlag)
2712         *ArchFlag = "ppc64";
2713       return Triple("ppc64-apple-darwin");
2714     default:
2715       return Triple();
2716     }
2717   default:
2718     return Triple();
2719   }
2720 }
2721
2722 Triple MachOObjectFile::getHostArch() {
2723   return Triple(sys::getDefaultTargetTriple());
2724 }
2725
2726 bool MachOObjectFile::isValidArch(StringRef ArchFlag) {
2727   return std::find(validArchs.cbegin(), validArchs.cend(), ArchFlag) !=
2728          validArchs.cend();
2729 }
2730
2731 ArrayRef<StringRef> MachOObjectFile::getValidArchs() { return validArchs; }
2732
2733 Triple::ArchType MachOObjectFile::getArch() const {
2734   return getArch(getCPUType(*this));
2735 }
2736
2737 Triple MachOObjectFile::getArchTriple(const char **McpuDefault) const {
2738   return getArchTriple(Header.cputype, Header.cpusubtype, McpuDefault);
2739 }
2740
2741 relocation_iterator MachOObjectFile::section_rel_begin(unsigned Index) const {
2742   DataRefImpl DRI;
2743   DRI.d.a = Index;
2744   return section_rel_begin(DRI);
2745 }
2746
2747 relocation_iterator MachOObjectFile::section_rel_end(unsigned Index) const {
2748   DataRefImpl DRI;
2749   DRI.d.a = Index;
2750   return section_rel_end(DRI);
2751 }
2752
2753 dice_iterator MachOObjectFile::begin_dices() const {
2754   DataRefImpl DRI;
2755   if (!DataInCodeLoadCmd)
2756     return dice_iterator(DiceRef(DRI, this));
2757
2758   MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
2759   DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, DicLC.dataoff));
2760   return dice_iterator(DiceRef(DRI, this));
2761 }
2762
2763 dice_iterator MachOObjectFile::end_dices() const {
2764   DataRefImpl DRI;
2765   if (!DataInCodeLoadCmd)
2766     return dice_iterator(DiceRef(DRI, this));
2767
2768   MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
2769   unsigned Offset = DicLC.dataoff + DicLC.datasize;
2770   DRI.p = reinterpret_cast<uintptr_t>(getPtr(*this, Offset));
2771   return dice_iterator(DiceRef(DRI, this));
2772 }
2773
2774 ExportEntry::ExportEntry(Error *E, const MachOObjectFile *O,
2775                          ArrayRef<uint8_t> T) : E(E), O(O), Trie(T) {}
2776
2777 void ExportEntry::moveToFirst() {
2778   ErrorAsOutParameter ErrAsOutParam(E);
2779   pushNode(0);
2780   if (*E)
2781     return;
2782   pushDownUntilBottom();
2783 }
2784
2785 void ExportEntry::moveToEnd() {
2786   Stack.clear();
2787   Done = true;
2788 }
2789
2790 bool ExportEntry::operator==(const ExportEntry &Other) const {
2791   // Common case, one at end, other iterating from begin.
2792   if (Done || Other.Done)
2793     return (Done == Other.Done);
2794   // Not equal if different stack sizes.
2795   if (Stack.size() != Other.Stack.size())
2796     return false;
2797   // Not equal if different cumulative strings.
2798   if (!CumulativeString.equals(Other.CumulativeString))
2799     return false;
2800   // Equal if all nodes in both stacks match.
2801   for (unsigned i=0; i < Stack.size(); ++i) {
2802     if (Stack[i].Start != Other.Stack[i].Start)
2803       return false;
2804   }
2805   return true;
2806 }
2807
2808 uint64_t ExportEntry::readULEB128(const uint8_t *&Ptr, const char **error) {
2809   unsigned Count;
2810   uint64_t Result = decodeULEB128(Ptr, &Count, Trie.end(), error);
2811   Ptr += Count;
2812   if (Ptr > Trie.end())
2813     Ptr = Trie.end();
2814   return Result;
2815 }
2816
2817 StringRef ExportEntry::name() const {
2818   return CumulativeString;
2819 }
2820
2821 uint64_t ExportEntry::flags() const {
2822   return Stack.back().Flags;
2823 }
2824
2825 uint64_t ExportEntry::address() const {
2826   return Stack.back().Address;
2827 }
2828
2829 uint64_t ExportEntry::other() const {
2830   return Stack.back().Other;
2831 }
2832
2833 StringRef ExportEntry::otherName() const {
2834   const char* ImportName = Stack.back().ImportName;
2835   if (ImportName)
2836     return StringRef(ImportName);
2837   return StringRef();
2838 }
2839
2840 uint32_t ExportEntry::nodeOffset() const {
2841   return Stack.back().Start - Trie.begin();
2842 }
2843
2844 ExportEntry::NodeState::NodeState(const uint8_t *Ptr)
2845     : Start(Ptr), Current(Ptr) {}
2846
2847 void ExportEntry::pushNode(uint64_t offset) {
2848   ErrorAsOutParameter ErrAsOutParam(E);
2849   const uint8_t *Ptr = Trie.begin() + offset;
2850   NodeState State(Ptr);
2851   const char *error;
2852   uint64_t ExportInfoSize = readULEB128(State.Current, &error);
2853   if (error) {
2854     *E = malformedError("export info size " + Twine(error) +
2855                         " in export trie data at node: 0x" +
2856                         Twine::utohexstr(offset));
2857     moveToEnd();
2858     return;
2859   }
2860   State.IsExportNode = (ExportInfoSize != 0);
2861   const uint8_t* Children = State.Current + ExportInfoSize;
2862   if (Children > Trie.end()) {
2863     *E = malformedError(
2864         "export info size: 0x" + Twine::utohexstr(ExportInfoSize) +
2865         " in export trie data at node: 0x" + Twine::utohexstr(offset) +
2866         " too big and extends past end of trie data");
2867     moveToEnd();
2868     return;
2869   }
2870   if (State.IsExportNode) {
2871     const uint8_t *ExportStart = State.Current;
2872     State.Flags = readULEB128(State.Current, &error);
2873     if (error) {
2874       *E = malformedError("flags " + Twine(error) +
2875                           " in export trie data at node: 0x" +
2876                           Twine::utohexstr(offset));
2877       moveToEnd();
2878       return;
2879     }
2880     uint64_t Kind = State.Flags & MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK;
2881     if (State.Flags != 0 &&
2882         (Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_REGULAR &&
2883          Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE &&
2884          Kind != MachO::EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL)) {
2885       *E = malformedError(
2886           "unsupported exported symbol kind: " + Twine((int)Kind) +
2887           " in flags: 0x" + Twine::utohexstr(State.Flags) +
2888           " in export trie data at node: 0x" + Twine::utohexstr(offset));
2889       moveToEnd();
2890       return;
2891     }
2892     if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT) {
2893       State.Address = 0;
2894       State.Other = readULEB128(State.Current, &error); // dylib ordinal
2895       if (error) {
2896         *E = malformedError("dylib ordinal of re-export " + Twine(error) +
2897                             " in export trie data at node: 0x" +
2898                             Twine::utohexstr(offset));
2899         moveToEnd();
2900         return;
2901       }
2902       if (O != nullptr) {
2903         if (State.Other > O->getLibraryCount()) {
2904           *E = malformedError(
2905               "bad library ordinal: " + Twine((int)State.Other) + " (max " +
2906               Twine((int)O->getLibraryCount()) +
2907               ") in export trie data at node: 0x" + Twine::utohexstr(offset));
2908           moveToEnd();
2909           return;
2910         }
2911       }
2912       State.ImportName = reinterpret_cast<const char*>(State.Current);
2913       if (*State.ImportName == '\0') {
2914         State.Current++;
2915       } else {
2916         const uint8_t *End = State.Current + 1;
2917         if (End >= Trie.end()) {
2918           *E = malformedError("import name of re-export in export trie data at "
2919                               "node: 0x" +
2920                               Twine::utohexstr(offset) +
2921                               " starts past end of trie data");
2922           moveToEnd();
2923           return;
2924         }
2925         while(*End != '\0' && End < Trie.end())
2926           End++;
2927         if (*End != '\0') {
2928           *E = malformedError("import name of re-export in export trie data at "
2929                               "node: 0x" +
2930                               Twine::utohexstr(offset) +
2931                               " extends past end of trie data");
2932           moveToEnd();
2933           return;
2934         }
2935         State.Current = End + 1;
2936       }
2937     } else {
2938       State.Address = readULEB128(State.Current, &error);
2939       if (error) {
2940         *E = malformedError("address " + Twine(error) +
2941                             " in export trie data at node: 0x" +
2942                             Twine::utohexstr(offset));
2943         moveToEnd();
2944         return;
2945       }
2946       if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER) {
2947         State.Other = readULEB128(State.Current, &error);
2948         if (error) {
2949           *E = malformedError("resolver of stub and resolver " + Twine(error) +
2950                               " in export trie data at node: 0x" +
2951                               Twine::utohexstr(offset));
2952           moveToEnd();
2953           return;
2954         }
2955       }
2956     }
2957     if(ExportStart + ExportInfoSize != State.Current) {
2958       *E = malformedError(
2959           "inconsistant export info size: 0x" +
2960           Twine::utohexstr(ExportInfoSize) + " where actual size was: 0x" +
2961           Twine::utohexstr(State.Current - ExportStart) +
2962           " in export trie data at node: 0x" + Twine::utohexstr(offset));
2963       moveToEnd();
2964       return;
2965     }
2966   }
2967   State.ChildCount = *Children;
2968   if (State.ChildCount != 0 && Children + 1 >= Trie.end()) {
2969     *E = malformedError("byte for count of childern in export trie data at "
2970                         "node: 0x" +
2971                         Twine::utohexstr(offset) +
2972                         " extends past end of trie data");
2973     moveToEnd();
2974     return;
2975   }
2976   State.Current = Children + 1;
2977   State.NextChildIndex = 0;
2978   State.ParentStringLength = CumulativeString.size();
2979   Stack.push_back(State);
2980 }
2981
2982 void ExportEntry::pushDownUntilBottom() {
2983   ErrorAsOutParameter ErrAsOutParam(E);
2984   const char *error;
2985   while (Stack.back().NextChildIndex < Stack.back().ChildCount) {
2986     NodeState &Top = Stack.back();
2987     CumulativeString.resize(Top.ParentStringLength);
2988     for (;*Top.Current != 0 && Top.Current < Trie.end(); Top.Current++) {
2989       char C = *Top.Current;
2990       CumulativeString.push_back(C);
2991     }
2992     if (Top.Current >= Trie.end()) {
2993       *E = malformedError("edge sub-string in export trie data at node: 0x" +
2994                           Twine::utohexstr(Top.Start - Trie.begin()) +
2995                           " for child #" + Twine((int)Top.NextChildIndex) +
2996                           " extends past end of trie data");
2997       moveToEnd();
2998       return;
2999     }
3000     Top.Current += 1;
3001     uint64_t childNodeIndex = readULEB128(Top.Current, &error);
3002     if (error) {
3003       *E = malformedError("child node offset " + Twine(error) +
3004                           " in export trie data at node: 0x" +
3005                           Twine::utohexstr(Top.Start - Trie.begin()));
3006       moveToEnd();
3007       return;
3008     }
3009     for (const NodeState &node : nodes()) {
3010       if (node.Start == Trie.begin() + childNodeIndex){
3011         *E = malformedError("loop in childern in export trie data at node: 0x" +
3012                             Twine::utohexstr(Top.Start - Trie.begin()) +
3013                             " back to node: 0x" +
3014                             Twine::utohexstr(childNodeIndex));
3015         moveToEnd();
3016         return;
3017       }
3018     }
3019     Top.NextChildIndex += 1;
3020     pushNode(childNodeIndex);
3021     if (*E)
3022       return;
3023   }
3024   if (!Stack.back().IsExportNode) {
3025     *E = malformedError("node is not an export node in export trie data at "
3026                         "node: 0x" +
3027                         Twine::utohexstr(Stack.back().Start - Trie.begin()));
3028     moveToEnd();
3029     return;
3030   }
3031 }
3032
3033 // We have a trie data structure and need a way to walk it that is compatible
3034 // with the C++ iterator model. The solution is a non-recursive depth first
3035 // traversal where the iterator contains a stack of parent nodes along with a
3036 // string that is the accumulation of all edge strings along the parent chain
3037 // to this point.
3038 //
3039 // There is one "export" node for each exported symbol.  But because some
3040 // symbols may be a prefix of another symbol (e.g. _dup and _dup2), an export
3041 // node may have child nodes too.
3042 //
3043 // The algorithm for moveNext() is to keep moving down the leftmost unvisited
3044 // child until hitting a node with no children (which is an export node or
3045 // else the trie is malformed). On the way down, each node is pushed on the
3046 // stack ivar.  If there is no more ways down, it pops up one and tries to go
3047 // down a sibling path until a childless node is reached.
3048 void ExportEntry::moveNext() {
3049   assert(!Stack.empty() && "ExportEntry::moveNext() with empty node stack");
3050   if (!Stack.back().IsExportNode) {
3051     *E = malformedError("node is not an export node in export trie data at "
3052                         "node: 0x" +
3053                         Twine::utohexstr(Stack.back().Start - Trie.begin()));
3054     moveToEnd();
3055     return;
3056   }
3057
3058   Stack.pop_back();
3059   while (!Stack.empty()) {
3060     NodeState &Top = Stack.back();
3061     if (Top.NextChildIndex < Top.ChildCount) {
3062       pushDownUntilBottom();
3063       // Now at the next export node.
3064       return;
3065     } else {
3066       if (Top.IsExportNode) {
3067         // This node has no children but is itself an export node.
3068         CumulativeString.resize(Top.ParentStringLength);
3069         return;
3070       }
3071       Stack.pop_back();
3072     }
3073   }
3074   Done = true;
3075 }
3076
3077 iterator_range<export_iterator>
3078 MachOObjectFile::exports(Error &E, ArrayRef<uint8_t> Trie,
3079                          const MachOObjectFile *O) {
3080   ExportEntry Start(&E, O, Trie);
3081   if (Trie.empty())
3082     Start.moveToEnd();
3083   else
3084     Start.moveToFirst();
3085
3086   ExportEntry Finish(&E, O, Trie);
3087   Finish.moveToEnd();
3088
3089   return make_range(export_iterator(Start), export_iterator(Finish));
3090 }
3091
3092 iterator_range<export_iterator> MachOObjectFile::exports(Error &Err) const {
3093   return exports(Err, getDyldInfoExportsTrie(), this);
3094 }
3095
3096 MachORebaseEntry::MachORebaseEntry(Error *E, const MachOObjectFile *O,
3097                                    ArrayRef<uint8_t> Bytes, bool is64Bit)
3098     : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()),
3099       PointerSize(is64Bit ? 8 : 4) {}
3100
3101 void MachORebaseEntry::moveToFirst() {
3102   Ptr = Opcodes.begin();
3103   moveNext();
3104 }
3105
3106 void MachORebaseEntry::moveToEnd() {
3107   Ptr = Opcodes.end();
3108   RemainingLoopCount = 0;
3109   Done = true;
3110 }
3111
3112 void MachORebaseEntry::moveNext() {
3113   ErrorAsOutParameter ErrAsOutParam(E);
3114   // If in the middle of some loop, move to next rebasing in loop.
3115   SegmentOffset += AdvanceAmount;
3116   if (RemainingLoopCount) {
3117     --RemainingLoopCount;
3118     return;
3119   }
3120   // REBASE_OPCODE_DONE is only used for padding if we are not aligned to
3121   // pointer size. Therefore it is possible to reach the end without ever having
3122   // seen REBASE_OPCODE_DONE.
3123   if (Ptr == Opcodes.end()) {
3124     Done = true;
3125     return;
3126   }
3127   bool More = true;
3128   while (More) {
3129     // Parse next opcode and set up next loop.
3130     const uint8_t *OpcodeStart = Ptr;
3131     uint8_t Byte = *Ptr++;
3132     uint8_t ImmValue = Byte & MachO::REBASE_IMMEDIATE_MASK;
3133     uint8_t Opcode = Byte & MachO::REBASE_OPCODE_MASK;
3134     uint32_t Count, Skip;
3135     const char *error = nullptr;
3136     switch (Opcode) {
3137     case MachO::REBASE_OPCODE_DONE:
3138       More = false;
3139       Done = true;
3140       moveToEnd();
3141       DEBUG_WITH_TYPE("mach-o-rebase", dbgs() << "REBASE_OPCODE_DONE\n");
3142       break;
3143     case MachO::REBASE_OPCODE_SET_TYPE_IMM:
3144       RebaseType = ImmValue;
3145       if (RebaseType > MachO::REBASE_TYPE_TEXT_PCREL32) {
3146         *E = malformedError("for REBASE_OPCODE_SET_TYPE_IMM bad bind type: " +
3147                             Twine((int)RebaseType) + " for opcode at: 0x" +
3148                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3149         moveToEnd();
3150         return;
3151       }
3152       DEBUG_WITH_TYPE(
3153           "mach-o-rebase",
3154           dbgs() << "REBASE_OPCODE_SET_TYPE_IMM: "
3155                  << "RebaseType=" << (int) RebaseType << "\n");
3156       break;
3157     case MachO::REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
3158       SegmentIndex = ImmValue;
3159       SegmentOffset = readULEB128(&error);
3160       if (error) {
3161         *E = malformedError("for REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3162                             Twine(error) + " for opcode at: 0x" +
3163                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3164         moveToEnd();
3165         return;
3166       }
3167       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3168                                                PointerSize);
3169       if (error) {
3170         *E = malformedError("for REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3171                             Twine(error) + " for opcode at: 0x" +
3172                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3173         moveToEnd();
3174         return;
3175       }
3176       DEBUG_WITH_TYPE(
3177           "mach-o-rebase",
3178           dbgs() << "REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
3179                  << "SegmentIndex=" << SegmentIndex << ", "
3180                  << format("SegmentOffset=0x%06X", SegmentOffset)
3181                  << "\n");
3182       break;
3183     case MachO::REBASE_OPCODE_ADD_ADDR_ULEB:
3184       SegmentOffset += readULEB128(&error);
3185       if (error) {
3186         *E = malformedError("for REBASE_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3187                             " for opcode at: 0x" +
3188                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3189         moveToEnd();
3190         return;
3191       }
3192       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3193                                                PointerSize);
3194       if (error) {
3195         *E = malformedError("for REBASE_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3196                             " for opcode at: 0x" +
3197                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3198         moveToEnd();
3199         return;
3200       }
3201       DEBUG_WITH_TYPE("mach-o-rebase",
3202                       dbgs() << "REBASE_OPCODE_ADD_ADDR_ULEB: "
3203                              << format("SegmentOffset=0x%06X",
3204                                        SegmentOffset) << "\n");
3205       break;
3206     case MachO::REBASE_OPCODE_ADD_ADDR_IMM_SCALED:
3207       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3208                                                PointerSize);
3209       if (error) {
3210         *E = malformedError("for REBASE_OPCODE_ADD_ADDR_IMM_SCALED " +
3211                             Twine(error) + " for opcode at: 0x" +
3212                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3213         moveToEnd();
3214         return;
3215       }
3216       SegmentOffset += ImmValue * PointerSize;
3217       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3218                                                PointerSize);
3219       if (error) {
3220         *E =
3221             malformedError("for REBASE_OPCODE_ADD_ADDR_IMM_SCALED "
3222                            " (after adding immediate times the pointer size) " +
3223                            Twine(error) + " for opcode at: 0x" +
3224                            Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3225         moveToEnd();
3226         return;
3227       }
3228       DEBUG_WITH_TYPE("mach-o-rebase",
3229                       dbgs() << "REBASE_OPCODE_ADD_ADDR_IMM_SCALED: "
3230                              << format("SegmentOffset=0x%06X",
3231                                        SegmentOffset) << "\n");
3232       break;
3233     case MachO::REBASE_OPCODE_DO_REBASE_IMM_TIMES:
3234       AdvanceAmount = PointerSize;
3235       Skip = 0;
3236       Count = ImmValue;
3237       if (ImmValue != 0)
3238         RemainingLoopCount = ImmValue - 1;
3239       else
3240         RemainingLoopCount = 0;
3241       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3242                                                PointerSize, Count, Skip);
3243       if (error) {
3244         *E = malformedError("for REBASE_OPCODE_DO_REBASE_IMM_TIMES " +
3245                             Twine(error) + " for opcode at: 0x" +
3246                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3247         moveToEnd();
3248         return;
3249       }
3250       DEBUG_WITH_TYPE(
3251           "mach-o-rebase",
3252           dbgs() << "REBASE_OPCODE_DO_REBASE_IMM_TIMES: "
3253                  << format("SegmentOffset=0x%06X", SegmentOffset)
3254                  << ", AdvanceAmount=" << AdvanceAmount
3255                  << ", RemainingLoopCount=" << RemainingLoopCount
3256                  << "\n");
3257       return;
3258     case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES:
3259       AdvanceAmount = PointerSize;
3260       Skip = 0;
3261       Count = readULEB128(&error);
3262       if (error) {
3263         *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES " +
3264                             Twine(error) + " for opcode at: 0x" +
3265                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3266         moveToEnd();
3267         return;
3268       }
3269       if (Count != 0)
3270         RemainingLoopCount = Count - 1;
3271       else
3272         RemainingLoopCount = 0;
3273       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3274                                                PointerSize, Count, Skip);
3275       if (error) {
3276         *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES " +
3277                             Twine(error) + " for opcode at: 0x" +
3278                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3279         moveToEnd();
3280         return;
3281       }
3282       DEBUG_WITH_TYPE(
3283           "mach-o-rebase",
3284           dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES: "
3285                  << format("SegmentOffset=0x%06X", SegmentOffset)
3286                  << ", AdvanceAmount=" << AdvanceAmount
3287                  << ", RemainingLoopCount=" << RemainingLoopCount
3288                  << "\n");
3289       return;
3290     case MachO::REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB:
3291       Skip = readULEB128(&error);
3292       if (error) {
3293         *E = malformedError("for REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB " +
3294                             Twine(error) + " for opcode at: 0x" +
3295                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3296         moveToEnd();
3297         return;
3298       }
3299       AdvanceAmount = Skip + PointerSize;
3300       Count = 1;
3301       RemainingLoopCount = 0;
3302       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3303                                                PointerSize, Count, Skip);
3304       if (error) {
3305         *E = malformedError("for REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB " +
3306                             Twine(error) + " for opcode at: 0x" +
3307                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3308         moveToEnd();
3309         return;
3310       }
3311       DEBUG_WITH_TYPE(
3312           "mach-o-rebase",
3313           dbgs() << "REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: "
3314                  << format("SegmentOffset=0x%06X", SegmentOffset)
3315                  << ", AdvanceAmount=" << AdvanceAmount
3316                  << ", RemainingLoopCount=" << RemainingLoopCount
3317                  << "\n");
3318       return;
3319     case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB:
3320       Count = readULEB128(&error);
3321       if (error) {
3322         *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3323                             "ULEB " +
3324                             Twine(error) + " for opcode at: 0x" +
3325                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3326         moveToEnd();
3327         return;
3328       }
3329       if (Count != 0)
3330         RemainingLoopCount = Count - 1;
3331       else
3332         RemainingLoopCount = 0;
3333       Skip = readULEB128(&error);
3334       if (error) {
3335         *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3336                             "ULEB " +
3337                             Twine(error) + " for opcode at: 0x" +
3338                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3339         moveToEnd();
3340         return;
3341       }
3342       AdvanceAmount = Skip + PointerSize;
3343
3344       error = O->RebaseEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3345                                                PointerSize, Count, Skip);
3346       if (error) {
3347         *E = malformedError("for REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_"
3348                             "ULEB " +
3349                             Twine(error) + " for opcode at: 0x" +
3350                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3351         moveToEnd();
3352         return;
3353       }
3354       DEBUG_WITH_TYPE(
3355           "mach-o-rebase",
3356           dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: "
3357                  << format("SegmentOffset=0x%06X", SegmentOffset)
3358                  << ", AdvanceAmount=" << AdvanceAmount
3359                  << ", RemainingLoopCount=" << RemainingLoopCount
3360                  << "\n");
3361       return;
3362     default:
3363       *E = malformedError("bad rebase info (bad opcode value 0x" +
3364                           Twine::utohexstr(Opcode) + " for opcode at: 0x" +
3365                           Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3366       moveToEnd();
3367       return;
3368     }
3369   }
3370 }
3371
3372 uint64_t MachORebaseEntry::readULEB128(const char **error) {
3373   unsigned Count;
3374   uint64_t Result = decodeULEB128(Ptr, &Count, Opcodes.end(), error);
3375   Ptr += Count;
3376   if (Ptr > Opcodes.end())
3377     Ptr = Opcodes.end();
3378   return Result;
3379 }
3380
3381 int32_t MachORebaseEntry::segmentIndex() const { return SegmentIndex; }
3382
3383 uint64_t MachORebaseEntry::segmentOffset() const { return SegmentOffset; }
3384
3385 StringRef MachORebaseEntry::typeName() const {
3386   switch (RebaseType) {
3387   case MachO::REBASE_TYPE_POINTER:
3388     return "pointer";
3389   case MachO::REBASE_TYPE_TEXT_ABSOLUTE32:
3390     return "text abs32";
3391   case MachO::REBASE_TYPE_TEXT_PCREL32:
3392     return "text rel32";
3393   }
3394   return "unknown";
3395 }
3396
3397 // For use with the SegIndex of a checked Mach-O Rebase entry
3398 // to get the segment name.
3399 StringRef MachORebaseEntry::segmentName() const {
3400   return O->BindRebaseSegmentName(SegmentIndex);
3401 }
3402
3403 // For use with a SegIndex,SegOffset pair from a checked Mach-O Rebase entry
3404 // to get the section name.
3405 StringRef MachORebaseEntry::sectionName() const {
3406   return O->BindRebaseSectionName(SegmentIndex, SegmentOffset);
3407 }
3408
3409 // For use with a SegIndex,SegOffset pair from a checked Mach-O Rebase entry
3410 // to get the address.
3411 uint64_t MachORebaseEntry::address() const {
3412   return O->BindRebaseAddress(SegmentIndex, SegmentOffset);
3413 }
3414
3415 bool MachORebaseEntry::operator==(const MachORebaseEntry &Other) const {
3416 #ifdef EXPENSIVE_CHECKS
3417   assert(Opcodes == Other.Opcodes && "compare iterators of different files");
3418 #else
3419   assert(Opcodes.data() == Other.Opcodes.data() && "compare iterators of different files");
3420 #endif
3421   return (Ptr == Other.Ptr) &&
3422          (RemainingLoopCount == Other.RemainingLoopCount) &&
3423          (Done == Other.Done);
3424 }
3425
3426 iterator_range<rebase_iterator>
3427 MachOObjectFile::rebaseTable(Error &Err, MachOObjectFile *O,
3428                              ArrayRef<uint8_t> Opcodes, bool is64) {
3429   if (O->BindRebaseSectionTable == nullptr)
3430     O->BindRebaseSectionTable = llvm::make_unique<BindRebaseSegInfo>(O);
3431   MachORebaseEntry Start(&Err, O, Opcodes, is64);
3432   Start.moveToFirst();
3433
3434   MachORebaseEntry Finish(&Err, O, Opcodes, is64);
3435   Finish.moveToEnd();
3436
3437   return make_range(rebase_iterator(Start), rebase_iterator(Finish));
3438 }
3439
3440 iterator_range<rebase_iterator> MachOObjectFile::rebaseTable(Error &Err) {
3441   return rebaseTable(Err, this, getDyldInfoRebaseOpcodes(), is64Bit());
3442 }
3443
3444 MachOBindEntry::MachOBindEntry(Error *E, const MachOObjectFile *O,
3445                                ArrayRef<uint8_t> Bytes, bool is64Bit, Kind BK)
3446     : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()),
3447       PointerSize(is64Bit ? 8 : 4), TableKind(BK) {}
3448
3449 void MachOBindEntry::moveToFirst() {
3450   Ptr = Opcodes.begin();
3451   moveNext();
3452 }
3453
3454 void MachOBindEntry::moveToEnd() {
3455   Ptr = Opcodes.end();
3456   RemainingLoopCount = 0;
3457   Done = true;
3458 }
3459
3460 void MachOBindEntry::moveNext() {
3461   ErrorAsOutParameter ErrAsOutParam(E);
3462   // If in the middle of some loop, move to next binding in loop.
3463   SegmentOffset += AdvanceAmount;
3464   if (RemainingLoopCount) {
3465     --RemainingLoopCount;
3466     return;
3467   }
3468   // BIND_OPCODE_DONE is only used for padding if we are not aligned to
3469   // pointer size. Therefore it is possible to reach the end without ever having
3470   // seen BIND_OPCODE_DONE.
3471   if (Ptr == Opcodes.end()) {
3472     Done = true;
3473     return;
3474   }
3475   bool More = true;
3476   while (More) {
3477     // Parse next opcode and set up next loop.
3478     const uint8_t *OpcodeStart = Ptr;
3479     uint8_t Byte = *Ptr++;
3480     uint8_t ImmValue = Byte & MachO::BIND_IMMEDIATE_MASK;
3481     uint8_t Opcode = Byte & MachO::BIND_OPCODE_MASK;
3482     int8_t SignExtended;
3483     const uint8_t *SymStart;
3484     uint32_t Count, Skip;
3485     const char *error = nullptr;
3486     switch (Opcode) {
3487     case MachO::BIND_OPCODE_DONE:
3488       if (TableKind == Kind::Lazy) {
3489         // Lazying bindings have a DONE opcode between entries.  Need to ignore
3490         // it to advance to next entry.  But need not if this is last entry.
3491         bool NotLastEntry = false;
3492         for (const uint8_t *P = Ptr; P < Opcodes.end(); ++P) {
3493           if (*P) {
3494             NotLastEntry = true;
3495           }
3496         }
3497         if (NotLastEntry)
3498           break;
3499       }
3500       More = false;
3501       moveToEnd();
3502       DEBUG_WITH_TYPE("mach-o-bind", dbgs() << "BIND_OPCODE_DONE\n");
3503       break;
3504     case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
3505       if (TableKind == Kind::Weak) {
3506         *E = malformedError("BIND_OPCODE_SET_DYLIB_ORDINAL_IMM not allowed in "
3507                             "weak bind table for opcode at: 0x" +
3508                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3509         moveToEnd();
3510         return;
3511       }
3512       Ordinal = ImmValue;
3513       LibraryOrdinalSet = true;
3514       if (ImmValue > O->getLibraryCount()) {
3515         *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB bad "
3516                             "library ordinal: " +
3517                             Twine((int)ImmValue) + " (max " +
3518                             Twine((int)O->getLibraryCount()) +
3519                             ") for opcode at: 0x" +
3520                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3521         moveToEnd();
3522         return;
3523       }
3524       DEBUG_WITH_TYPE(
3525           "mach-o-bind",
3526           dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: "
3527                  << "Ordinal=" << Ordinal << "\n");
3528       break;
3529     case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
3530       if (TableKind == Kind::Weak) {
3531         *E = malformedError("BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB not allowed in "
3532                             "weak bind table for opcode at: 0x" +
3533                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3534         moveToEnd();
3535         return;
3536       }
3537       Ordinal = readULEB128(&error);
3538       LibraryOrdinalSet = true;
3539       if (error) {
3540         *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB " +
3541                             Twine(error) + " for opcode at: 0x" +
3542                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3543         moveToEnd();
3544         return;
3545       }
3546       if (Ordinal > (int)O->getLibraryCount()) {
3547         *E = malformedError("for BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB bad "
3548                             "library ordinal: " +
3549                             Twine((int)Ordinal) + " (max " +
3550                             Twine((int)O->getLibraryCount()) +
3551                             ") for opcode at: 0x" +
3552                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3553         moveToEnd();
3554         return;
3555       }
3556       DEBUG_WITH_TYPE(
3557           "mach-o-bind",
3558           dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: "
3559                  << "Ordinal=" << Ordinal << "\n");
3560       break;
3561     case MachO::BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:
3562       if (TableKind == Kind::Weak) {
3563         *E = malformedError("BIND_OPCODE_SET_DYLIB_SPECIAL_IMM not allowed in "
3564                             "weak bind table for opcode at: 0x" +
3565                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3566         moveToEnd();
3567         return;
3568       }
3569       if (ImmValue) {
3570         SignExtended = MachO::BIND_OPCODE_MASK | ImmValue;
3571         Ordinal = SignExtended;
3572         if (Ordinal < MachO::BIND_SPECIAL_DYLIB_FLAT_LOOKUP) {
3573           *E = malformedError("for BIND_OPCODE_SET_DYLIB_SPECIAL_IMM unknown "
3574                               "special ordinal: " +
3575                               Twine((int)Ordinal) + " for opcode at: 0x" +
3576                               Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3577           moveToEnd();
3578           return;
3579         }
3580       } else
3581         Ordinal = 0;
3582       LibraryOrdinalSet = true;
3583       DEBUG_WITH_TYPE(
3584           "mach-o-bind",
3585           dbgs() << "BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: "
3586                  << "Ordinal=" << Ordinal << "\n");
3587       break;
3588     case MachO::BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
3589       Flags = ImmValue;
3590       SymStart = Ptr;
3591       while (*Ptr && (Ptr < Opcodes.end())) {
3592         ++Ptr;
3593       }
3594       if (Ptr == Opcodes.end()) {
3595         *E = malformedError(
3596             "for BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM "
3597             "symbol name extends past opcodes for opcode at: 0x" +
3598             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3599         moveToEnd();
3600         return;
3601       }
3602       SymbolName = StringRef(reinterpret_cast<const char*>(SymStart),
3603                              Ptr-SymStart);
3604       ++Ptr;
3605       DEBUG_WITH_TYPE(
3606           "mach-o-bind",
3607           dbgs() << "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: "
3608                  << "SymbolName=" << SymbolName << "\n");
3609       if (TableKind == Kind::Weak) {
3610         if (ImmValue & MachO::BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION)
3611           return;
3612       }
3613       break;
3614     case MachO::BIND_OPCODE_SET_TYPE_IMM:
3615       BindType = ImmValue;
3616       if (ImmValue > MachO::BIND_TYPE_TEXT_PCREL32) {
3617         *E = malformedError("for BIND_OPCODE_SET_TYPE_IMM bad bind type: " +
3618                             Twine((int)ImmValue) + " for opcode at: 0x" +
3619                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3620         moveToEnd();
3621         return;
3622       }
3623       DEBUG_WITH_TYPE(
3624           "mach-o-bind",
3625           dbgs() << "BIND_OPCODE_SET_TYPE_IMM: "
3626                  << "BindType=" << (int)BindType << "\n");
3627       break;
3628     case MachO::BIND_OPCODE_SET_ADDEND_SLEB:
3629       Addend = readSLEB128(&error);
3630       if (error) {
3631         *E = malformedError("for BIND_OPCODE_SET_ADDEND_SLEB " + Twine(error) +
3632                             " for opcode at: 0x" +
3633                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3634         moveToEnd();
3635         return;
3636       }
3637       DEBUG_WITH_TYPE(
3638           "mach-o-bind",
3639           dbgs() << "BIND_OPCODE_SET_ADDEND_SLEB: "
3640                  << "Addend=" << Addend << "\n");
3641       break;
3642     case MachO::BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
3643       SegmentIndex = ImmValue;
3644       SegmentOffset = readULEB128(&error);
3645       if (error) {
3646         *E = malformedError("for BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3647                             Twine(error) + " for opcode at: 0x" +
3648                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3649         moveToEnd();
3650         return;
3651       }
3652       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3653                                              PointerSize);
3654       if (error) {
3655         *E = malformedError("for BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB " +
3656                             Twine(error) + " for opcode at: 0x" +
3657                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3658         moveToEnd();
3659         return;
3660       }
3661       DEBUG_WITH_TYPE(
3662           "mach-o-bind",
3663           dbgs() << "BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
3664                  << "SegmentIndex=" << SegmentIndex << ", "
3665                  << format("SegmentOffset=0x%06X", SegmentOffset)
3666                  << "\n");
3667       break;
3668     case MachO::BIND_OPCODE_ADD_ADDR_ULEB:
3669       SegmentOffset += readULEB128(&error);
3670       if (error) {
3671         *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3672                             " for opcode at: 0x" +
3673                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3674         moveToEnd();
3675         return;
3676       }
3677       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3678                                              PointerSize);
3679       if (error) {
3680         *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB " + Twine(error) +
3681                             " for opcode at: 0x" +
3682                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3683         moveToEnd();
3684         return;
3685       }
3686       DEBUG_WITH_TYPE("mach-o-bind",
3687                       dbgs() << "BIND_OPCODE_ADD_ADDR_ULEB: "
3688                              << format("SegmentOffset=0x%06X",
3689                                        SegmentOffset) << "\n");
3690       break;
3691     case MachO::BIND_OPCODE_DO_BIND:
3692       AdvanceAmount = PointerSize;
3693       RemainingLoopCount = 0;
3694       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3695                                              PointerSize);
3696       if (error) {
3697         *E = malformedError("for BIND_OPCODE_DO_BIND " + Twine(error) +
3698                             " for opcode at: 0x" +
3699                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3700         moveToEnd();
3701         return;
3702       }
3703       if (SymbolName == StringRef()) {
3704         *E = malformedError(
3705             "for BIND_OPCODE_DO_BIND missing preceding "
3706             "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for opcode at: 0x" +
3707             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3708         moveToEnd();
3709         return;
3710       }
3711       if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3712         *E =
3713             malformedError("for BIND_OPCODE_DO_BIND missing preceding "
3714                            "BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode at: 0x" +
3715                            Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3716         moveToEnd();
3717         return;
3718       }
3719       DEBUG_WITH_TYPE("mach-o-bind",
3720                       dbgs() << "BIND_OPCODE_DO_BIND: "
3721                              << format("SegmentOffset=0x%06X",
3722                                        SegmentOffset) << "\n");
3723       return;
3724      case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
3725       if (TableKind == Kind::Lazy) {
3726         *E = malformedError("BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB not allowed in "
3727                             "lazy bind table for opcode at: 0x" +
3728                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3729         moveToEnd();
3730         return;
3731       }
3732       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3733                                              PointerSize);
3734       if (error) {
3735         *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB " +
3736                             Twine(error) + " for opcode at: 0x" +
3737                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3738         moveToEnd();
3739         return;
3740       }
3741       if (SymbolName == StringRef()) {
3742         *E = malformedError(
3743             "for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB missing "
3744             "preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for opcode "
3745             "at: 0x" +
3746             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3747         moveToEnd();
3748         return;
3749       }
3750       if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3751         *E = malformedError(
3752             "for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB missing "
3753             "preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode at: 0x" +
3754             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3755         moveToEnd();
3756         return;
3757       }
3758       AdvanceAmount = readULEB128(&error) + PointerSize;
3759       if (error) {
3760         *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB " +
3761                             Twine(error) + " for opcode at: 0x" +
3762                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3763         moveToEnd();
3764         return;
3765       }
3766       // Note, this is not really an error until the next bind but make no sense
3767       // for a BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB to not be followed by another
3768       // bind operation.
3769       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset +
3770                                             AdvanceAmount, PointerSize);
3771       if (error) {
3772         *E = malformedError("for BIND_OPCODE_ADD_ADDR_ULEB (after adding "
3773                             "ULEB) " +
3774                             Twine(error) + " for opcode at: 0x" +
3775                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3776         moveToEnd();
3777         return;
3778       }
3779       RemainingLoopCount = 0;
3780       DEBUG_WITH_TYPE(
3781           "mach-o-bind",
3782           dbgs() << "BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: "
3783                  << format("SegmentOffset=0x%06X", SegmentOffset)
3784                  << ", AdvanceAmount=" << AdvanceAmount
3785                  << ", RemainingLoopCount=" << RemainingLoopCount
3786                  << "\n");
3787       return;
3788     case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
3789       if (TableKind == Kind::Lazy) {
3790         *E = malformedError("BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED not "
3791                             "allowed in lazy bind table for opcode at: 0x" +
3792                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3793         moveToEnd();
3794         return;
3795       }
3796       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3797                                              PointerSize);
3798       if (error) {
3799         *E = malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED " +
3800                             Twine(error) + " for opcode at: 0x" +
3801                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3802         moveToEnd();
3803         return;
3804       }
3805       if (SymbolName == StringRef()) {
3806         *E = malformedError(
3807             "for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED "
3808             "missing preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for "
3809             "opcode at: 0x" +
3810             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3811         moveToEnd();
3812         return;
3813       }
3814       if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3815         *E = malformedError(
3816             "for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED "
3817             "missing preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode "
3818             "at: 0x" +
3819             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3820         moveToEnd();
3821         return;
3822       }
3823       AdvanceAmount = ImmValue * PointerSize + PointerSize;
3824       RemainingLoopCount = 0;
3825       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset +
3826                                              AdvanceAmount, PointerSize);
3827       if (error) {
3828         *E =
3829             malformedError("for BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED "
3830                            " (after adding immediate times the pointer size) " +
3831                            Twine(error) + " for opcode at: 0x" +
3832                            Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3833         moveToEnd();
3834         return;
3835       }
3836       DEBUG_WITH_TYPE("mach-o-bind",
3837                       dbgs()
3838                       << "BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: "
3839                       << format("SegmentOffset=0x%06X", SegmentOffset) << "\n");
3840       return;
3841     case MachO::BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
3842       if (TableKind == Kind::Lazy) {
3843         *E = malformedError("BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB not "
3844                             "allowed in lazy bind table for opcode at: 0x" +
3845                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3846         moveToEnd();
3847         return;
3848       }
3849       Count = readULEB128(&error);
3850       if (Count != 0)
3851         RemainingLoopCount = Count - 1;
3852       else
3853         RemainingLoopCount = 0;
3854       if (error) {
3855         *E = malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3856                             " (count value) " +
3857                             Twine(error) + " for opcode at: 0x" +
3858                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3859         moveToEnd();
3860         return;
3861       }
3862       Skip = readULEB128(&error);
3863       AdvanceAmount = Skip + PointerSize;
3864       if (error) {
3865         *E = malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3866                             " (skip value) " +
3867                             Twine(error) + " for opcode at: 0x" +
3868                             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3869         moveToEnd();
3870         return;
3871       }
3872       if (SymbolName == StringRef()) {
3873         *E = malformedError(
3874             "for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3875             "missing preceding BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM for "
3876             "opcode at: 0x" +
3877             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3878         moveToEnd();
3879         return;
3880       }
3881       if (!LibraryOrdinalSet && TableKind != Kind::Weak) {
3882         *E = malformedError(
3883             "for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB "
3884             "missing preceding BIND_OPCODE_SET_DYLIB_ORDINAL_* for opcode "
3885             "at: 0x" +
3886             Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3887         moveToEnd();
3888         return;
3889       }
3890       error = O->BindEntryCheckSegAndOffsets(SegmentIndex, SegmentOffset,
3891                                              PointerSize, Count, Skip);
3892       if (error) {
3893         *E =
3894             malformedError("for BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB " +
3895                            Twine(error) + " for opcode at: 0x" +
3896                            Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3897         moveToEnd();
3898         return;
3899       }
3900       DEBUG_WITH_TYPE(
3901           "mach-o-bind",
3902           dbgs() << "BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: "
3903                  << format("SegmentOffset=0x%06X", SegmentOffset)
3904                  << ", AdvanceAmount=" << AdvanceAmount
3905                  << ", RemainingLoopCount=" << RemainingLoopCount
3906                  << "\n");
3907       return;
3908     default:
3909       *E = malformedError("bad bind info (bad opcode value 0x" +
3910                           Twine::utohexstr(Opcode) + " for opcode at: 0x" +
3911                           Twine::utohexstr(OpcodeStart - Opcodes.begin()));
3912       moveToEnd();
3913       return;
3914     }
3915   }
3916 }
3917
3918 uint64_t MachOBindEntry::readULEB128(const char **error) {
3919   unsigned Count;
3920   uint64_t Result = decodeULEB128(Ptr, &Count, Opcodes.end(), error);
3921   Ptr += Count;
3922   if (Ptr > Opcodes.end())
3923     Ptr = Opcodes.end();
3924   return Result;
3925 }
3926
3927 int64_t MachOBindEntry::readSLEB128(const char **error) {
3928   unsigned Count;
3929   int64_t Result = decodeSLEB128(Ptr, &Count, Opcodes.end(), error);
3930   Ptr += Count;
3931   if (Ptr > Opcodes.end())
3932     Ptr = Opcodes.end();
3933   return Result;
3934 }
3935
3936 int32_t MachOBindEntry::segmentIndex() const { return SegmentIndex; }
3937
3938 uint64_t MachOBindEntry::segmentOffset() const { return SegmentOffset; }
3939
3940 StringRef MachOBindEntry::typeName() const {
3941   switch (BindType) {
3942   case MachO::BIND_TYPE_POINTER:
3943     return "pointer";
3944   case MachO::BIND_TYPE_TEXT_ABSOLUTE32:
3945     return "text abs32";
3946   case MachO::BIND_TYPE_TEXT_PCREL32:
3947     return "text rel32";
3948   }
3949   return "unknown";
3950 }
3951
3952 StringRef MachOBindEntry::symbolName() const { return SymbolName; }
3953
3954 int64_t MachOBindEntry::addend() const { return Addend; }
3955
3956 uint32_t MachOBindEntry::flags() const { return Flags; }
3957
3958 int MachOBindEntry::ordinal() const { return Ordinal; }
3959
3960 // For use with the SegIndex of a checked Mach-O Bind entry
3961 // to get the segment name.
3962 StringRef MachOBindEntry::segmentName() const {
3963   return O->BindRebaseSegmentName(SegmentIndex);
3964 }
3965
3966 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind entry
3967 // to get the section name.
3968 StringRef MachOBindEntry::sectionName() const {
3969   return O->BindRebaseSectionName(SegmentIndex, SegmentOffset);
3970 }
3971
3972 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind entry
3973 // to get the address.
3974 uint64_t MachOBindEntry::address() const {
3975   return O->BindRebaseAddress(SegmentIndex, SegmentOffset);
3976 }
3977
3978 bool MachOBindEntry::operator==(const MachOBindEntry &Other) const {
3979 #ifdef EXPENSIVE_CHECKS
3980   assert(Opcodes == Other.Opcodes && "compare iterators of different files");
3981 #else
3982   assert(Opcodes.data() == Other.Opcodes.data() && "compare iterators of different files");
3983 #endif
3984   return (Ptr == Other.Ptr) &&
3985          (RemainingLoopCount == Other.RemainingLoopCount) &&
3986          (Done == Other.Done);
3987 }
3988
3989 // Build table of sections so SegIndex/SegOffset pairs can be translated.
3990 BindRebaseSegInfo::BindRebaseSegInfo(const object::MachOObjectFile *Obj) {
3991   uint32_t CurSegIndex = Obj->hasPageZeroSegment() ? 1 : 0;
3992   StringRef CurSegName;
3993   uint64_t CurSegAddress;
3994   for (const SectionRef &Section : Obj->sections()) {
3995     SectionInfo Info;
3996     Section.getName(Info.SectionName);
3997     Info.Address = Section.getAddress();
3998     Info.Size = Section.getSize();
3999     Info.SegmentName =
4000         Obj->getSectionFinalSegmentName(Section.getRawDataRefImpl());
4001     if (!Info.SegmentName.equals(CurSegName)) {
4002       ++CurSegIndex;
4003       CurSegName = Info.SegmentName;
4004       CurSegAddress = Info.Address;
4005     }
4006     Info.SegmentIndex = CurSegIndex - 1;
4007     Info.OffsetInSegment = Info.Address - CurSegAddress;
4008     Info.SegmentStartAddress = CurSegAddress;
4009     Sections.push_back(Info);
4010   }
4011   MaxSegIndex = CurSegIndex;
4012 }
4013
4014 // For use with a SegIndex, SegOffset, and PointerSize triple in
4015 // MachOBindEntry::moveNext() to validate a MachOBindEntry or MachORebaseEntry.
4016 //
4017 // Given a SegIndex, SegOffset, and PointerSize, verify a valid section exists
4018 // that fully contains a pointer at that location. Multiple fixups in a bind
4019 // (such as with the BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB opcode) can
4020 // be tested via the Count and Skip parameters.
4021 const char * BindRebaseSegInfo::checkSegAndOffsets(int32_t SegIndex,
4022                                                    uint64_t SegOffset,
4023                                                    uint8_t PointerSize,
4024                                                    uint32_t Count,
4025                                                    uint32_t Skip) {
4026   if (SegIndex == -1)
4027     return "missing preceding *_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB";
4028   if (SegIndex >= MaxSegIndex)
4029     return "bad segIndex (too large)";
4030   for (uint32_t i = 0; i < Count; ++i) {
4031     uint32_t Start = SegOffset + i * (PointerSize + Skip);
4032     uint32_t End = Start + PointerSize;
4033     bool Found = false;
4034     for (const SectionInfo &SI : Sections) {
4035       if (SI.SegmentIndex != SegIndex)
4036         continue;
4037       if ((SI.OffsetInSegment<=Start) && (Start<(SI.OffsetInSegment+SI.Size))) {
4038         if (End <= SI.OffsetInSegment + SI.Size) {
4039           Found = true;
4040           break;
4041         }
4042         else
4043           return "bad offset, extends beyond section boundary";
4044       }
4045     }
4046     if (!Found)
4047       return "bad offset, not in section";
4048   }
4049   return nullptr;
4050 }
4051
4052 // For use with the SegIndex of a checked Mach-O Bind or Rebase entry
4053 // to get the segment name.
4054 StringRef BindRebaseSegInfo::segmentName(int32_t SegIndex) {
4055   for (const SectionInfo &SI : Sections) {
4056     if (SI.SegmentIndex == SegIndex)
4057       return SI.SegmentName;
4058   }
4059   llvm_unreachable("invalid SegIndex");
4060 }
4061
4062 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
4063 // to get the SectionInfo.
4064 const BindRebaseSegInfo::SectionInfo &BindRebaseSegInfo::findSection(
4065                                      int32_t SegIndex, uint64_t SegOffset) {
4066   for (const SectionInfo &SI : Sections) {
4067     if (SI.SegmentIndex != SegIndex)
4068       continue;
4069     if (SI.OffsetInSegment > SegOffset)
4070       continue;
4071     if (SegOffset >= (SI.OffsetInSegment + SI.Size))
4072       continue;
4073     return SI;
4074   }
4075   llvm_unreachable("SegIndex and SegOffset not in any section");
4076 }
4077
4078 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
4079 // entry to get the section name.
4080 StringRef BindRebaseSegInfo::sectionName(int32_t SegIndex,
4081                                          uint64_t SegOffset) {
4082   return findSection(SegIndex, SegOffset).SectionName;
4083 }
4084
4085 // For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or Rebase
4086 // entry to get the address.
4087 uint64_t BindRebaseSegInfo::address(uint32_t SegIndex, uint64_t OffsetInSeg) {
4088   const SectionInfo &SI = findSection(SegIndex, OffsetInSeg);
4089   return SI.SegmentStartAddress + OffsetInSeg;
4090 }
4091
4092 iterator_range<bind_iterator>
4093 MachOObjectFile::bindTable(Error &Err, MachOObjectFile *O,
4094                            ArrayRef<uint8_t> Opcodes, bool is64,
4095                            MachOBindEntry::Kind BKind) {
4096   if (O->BindRebaseSectionTable == nullptr)
4097     O->BindRebaseSectionTable = llvm::make_unique<BindRebaseSegInfo>(O);
4098   MachOBindEntry Start(&Err, O, Opcodes, is64, BKind);
4099   Start.moveToFirst();
4100
4101   MachOBindEntry Finish(&Err, O, Opcodes, is64, BKind);
4102   Finish.moveToEnd();
4103
4104   return make_range(bind_iterator(Start), bind_iterator(Finish));
4105 }
4106
4107 iterator_range<bind_iterator> MachOObjectFile::bindTable(Error &Err) {
4108   return bindTable(Err, this, getDyldInfoBindOpcodes(), is64Bit(),
4109                    MachOBindEntry::Kind::Regular);
4110 }
4111
4112 iterator_range<bind_iterator> MachOObjectFile::lazyBindTable(Error &Err) {
4113   return bindTable(Err, this, getDyldInfoLazyBindOpcodes(), is64Bit(),
4114                    MachOBindEntry::Kind::Lazy);
4115 }
4116
4117 iterator_range<bind_iterator> MachOObjectFile::weakBindTable(Error &Err) {
4118   return bindTable(Err, this, getDyldInfoWeakBindOpcodes(), is64Bit(),
4119                    MachOBindEntry::Kind::Weak);
4120 }
4121
4122 MachOObjectFile::load_command_iterator
4123 MachOObjectFile::begin_load_commands() const {
4124   return LoadCommands.begin();
4125 }
4126
4127 MachOObjectFile::load_command_iterator
4128 MachOObjectFile::end_load_commands() const {
4129   return LoadCommands.end();
4130 }
4131
4132 iterator_range<MachOObjectFile::load_command_iterator>
4133 MachOObjectFile::load_commands() const {
4134   return make_range(begin_load_commands(), end_load_commands());
4135 }
4136
4137 StringRef
4138 MachOObjectFile::getSectionFinalSegmentName(DataRefImpl Sec) const {
4139   ArrayRef<char> Raw = getSectionRawFinalSegmentName(Sec);
4140   return parseSegmentOrSectionName(Raw.data());
4141 }
4142
4143 ArrayRef<char>
4144 MachOObjectFile::getSectionRawName(DataRefImpl Sec) const {
4145   assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
4146   const section_base *Base =
4147     reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
4148   return makeArrayRef(Base->sectname);
4149 }
4150
4151 ArrayRef<char>
4152 MachOObjectFile::getSectionRawFinalSegmentName(DataRefImpl Sec) const {
4153   assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
4154   const section_base *Base =
4155     reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
4156   return makeArrayRef(Base->segname);
4157 }
4158
4159 bool
4160 MachOObjectFile::isRelocationScattered(const MachO::any_relocation_info &RE)
4161   const {
4162   if (getCPUType(*this) == MachO::CPU_TYPE_X86_64)
4163     return false;
4164   return getPlainRelocationAddress(RE) & MachO::R_SCATTERED;
4165 }
4166
4167 unsigned MachOObjectFile::getPlainRelocationSymbolNum(
4168     const MachO::any_relocation_info &RE) const {
4169   if (isLittleEndian())
4170     return RE.r_word1 & 0xffffff;
4171   return RE.r_word1 >> 8;
4172 }
4173
4174 bool MachOObjectFile::getPlainRelocationExternal(
4175     const MachO::any_relocation_info &RE) const {
4176   if (isLittleEndian())
4177     return (RE.r_word1 >> 27) & 1;
4178   return (RE.r_word1 >> 4) & 1;
4179 }
4180
4181 bool MachOObjectFile::getScatteredRelocationScattered(
4182     const MachO::any_relocation_info &RE) const {
4183   return RE.r_word0 >> 31;
4184 }
4185
4186 uint32_t MachOObjectFile::getScatteredRelocationValue(
4187     const MachO::any_relocation_info &RE) const {
4188   return RE.r_word1;
4189 }
4190
4191 uint32_t MachOObjectFile::getScatteredRelocationType(
4192     const MachO::any_relocation_info &RE) const {
4193   return (RE.r_word0 >> 24) & 0xf;
4194 }
4195
4196 unsigned MachOObjectFile::getAnyRelocationAddress(
4197     const MachO::any_relocation_info &RE) const {
4198   if (isRelocationScattered(RE))
4199     return getScatteredRelocationAddress(RE);
4200   return getPlainRelocationAddress(RE);
4201 }
4202
4203 unsigned MachOObjectFile::getAnyRelocationPCRel(
4204     const MachO::any_relocation_info &RE) const {
4205   if (isRelocationScattered(RE))
4206     return getScatteredRelocationPCRel(RE);
4207   return getPlainRelocationPCRel(*this, RE);
4208 }
4209
4210 unsigned MachOObjectFile::getAnyRelocationLength(
4211     const MachO::any_relocation_info &RE) const {
4212   if (isRelocationScattered(RE))
4213     return getScatteredRelocationLength(RE);
4214   return getPlainRelocationLength(*this, RE);
4215 }
4216
4217 unsigned
4218 MachOObjectFile::getAnyRelocationType(
4219                                    const MachO::any_relocation_info &RE) const {
4220   if (isRelocationScattered(RE))
4221     return getScatteredRelocationType(RE);
4222   return getPlainRelocationType(*this, RE);
4223 }
4224
4225 SectionRef
4226 MachOObjectFile::getAnyRelocationSection(
4227                                    const MachO::any_relocation_info &RE) const {
4228   if (isRelocationScattered(RE) || getPlainRelocationExternal(RE))
4229     return *section_end();
4230   unsigned SecNum = getPlainRelocationSymbolNum(RE);
4231   if (SecNum == MachO::R_ABS || SecNum > Sections.size())
4232     return *section_end();
4233   DataRefImpl DRI;
4234   DRI.d.a = SecNum - 1;
4235   return SectionRef(DRI, this);
4236 }
4237
4238 MachO::section MachOObjectFile::getSection(DataRefImpl DRI) const {
4239   assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
4240   return getStruct<MachO::section>(*this, Sections[DRI.d.a]);
4241 }
4242
4243 MachO::section_64 MachOObjectFile::getSection64(DataRefImpl DRI) const {
4244   assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
4245   return getStruct<MachO::section_64>(*this, Sections[DRI.d.a]);
4246 }
4247
4248 MachO::section MachOObjectFile::getSection(const LoadCommandInfo &L,
4249                                            unsigned Index) const {
4250   const char *Sec = getSectionPtr(*this, L, Index);
4251   return getStruct<MachO::section>(*this, Sec);
4252 }
4253
4254 MachO::section_64 MachOObjectFile::getSection64(const LoadCommandInfo &L,
4255                                                 unsigned Index) const {
4256   const char *Sec = getSectionPtr(*this, L, Index);
4257   return getStruct<MachO::section_64>(*this, Sec);
4258 }
4259
4260 MachO::nlist
4261 MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI) const {
4262   const char *P = reinterpret_cast<const char *>(DRI.p);
4263   return getStruct<MachO::nlist>(*this, P);
4264 }
4265
4266 MachO::nlist_64
4267 MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI) const {
4268   const char *P = reinterpret_cast<const char *>(DRI.p);
4269   return getStruct<MachO::nlist_64>(*this, P);
4270 }
4271
4272 MachO::linkedit_data_command
4273 MachOObjectFile::getLinkeditDataLoadCommand(const LoadCommandInfo &L) const {
4274   return getStruct<MachO::linkedit_data_command>(*this, L.Ptr);
4275 }
4276
4277 MachO::segment_command
4278 MachOObjectFile::getSegmentLoadCommand(const LoadCommandInfo &L) const {
4279   return getStruct<MachO::segment_command>(*this, L.Ptr);
4280 }
4281
4282 MachO::segment_command_64
4283 MachOObjectFile::getSegment64LoadCommand(const LoadCommandInfo &L) const {
4284   return getStruct<MachO::segment_command_64>(*this, L.Ptr);
4285 }
4286
4287 MachO::linker_option_command
4288 MachOObjectFile::getLinkerOptionLoadCommand(const LoadCommandInfo &L) const {
4289   return getStruct<MachO::linker_option_command>(*this, L.Ptr);
4290 }
4291
4292 MachO::version_min_command
4293 MachOObjectFile::getVersionMinLoadCommand(const LoadCommandInfo &L) const {
4294   return getStruct<MachO::version_min_command>(*this, L.Ptr);
4295 }
4296
4297 MachO::note_command
4298 MachOObjectFile::getNoteLoadCommand(const LoadCommandInfo &L) const {
4299   return getStruct<MachO::note_command>(*this, L.Ptr);
4300 }
4301
4302 MachO::build_version_command
4303 MachOObjectFile::getBuildVersionLoadCommand(const LoadCommandInfo &L) const {
4304   return getStruct<MachO::build_version_command>(*this, L.Ptr);
4305 }
4306
4307 MachO::build_tool_version
4308 MachOObjectFile::getBuildToolVersion(unsigned index) const {
4309   return getStruct<MachO::build_tool_version>(*this, BuildTools[index]);
4310 }
4311
4312 MachO::dylib_command
4313 MachOObjectFile::getDylibIDLoadCommand(const LoadCommandInfo &L) const {
4314   return getStruct<MachO::dylib_command>(*this, L.Ptr);
4315 }
4316
4317 MachO::dyld_info_command
4318 MachOObjectFile::getDyldInfoLoadCommand(const LoadCommandInfo &L) const {
4319   return getStruct<MachO::dyld_info_command>(*this, L.Ptr);
4320 }
4321
4322 MachO::dylinker_command
4323 MachOObjectFile::getDylinkerCommand(const LoadCommandInfo &L) const {
4324   return getStruct<MachO::dylinker_command>(*this, L.Ptr);
4325 }
4326
4327 MachO::uuid_command
4328 MachOObjectFile::getUuidCommand(const LoadCommandInfo &L) const {
4329   return getStruct<MachO::uuid_command>(*this, L.Ptr);
4330 }
4331
4332 MachO::rpath_command
4333 MachOObjectFile::getRpathCommand(const LoadCommandInfo &L) const {
4334   return getStruct<MachO::rpath_command>(*this, L.Ptr);
4335 }
4336
4337 MachO::source_version_command
4338 MachOObjectFile::getSourceVersionCommand(const LoadCommandInfo &L) const {
4339   return getStruct<MachO::source_version_command>(*this, L.Ptr);
4340 }
4341
4342 MachO::entry_point_command
4343 MachOObjectFile::getEntryPointCommand(const LoadCommandInfo &L) const {
4344   return getStruct<MachO::entry_point_command>(*this, L.Ptr);
4345 }
4346
4347 MachO::encryption_info_command
4348 MachOObjectFile::getEncryptionInfoCommand(const LoadCommandInfo &L) const {
4349   return getStruct<MachO::encryption_info_command>(*this, L.Ptr);
4350 }
4351
4352 MachO::encryption_info_command_64
4353 MachOObjectFile::getEncryptionInfoCommand64(const LoadCommandInfo &L) const {
4354   return getStruct<MachO::encryption_info_command_64>(*this, L.Ptr);
4355 }
4356
4357 MachO::sub_framework_command
4358 MachOObjectFile::getSubFrameworkCommand(const LoadCommandInfo &L) const {
4359   return getStruct<MachO::sub_framework_command>(*this, L.Ptr);
4360 }
4361
4362 MachO::sub_umbrella_command
4363 MachOObjectFile::getSubUmbrellaCommand(const LoadCommandInfo &L) const {
4364   return getStruct<MachO::sub_umbrella_command>(*this, L.Ptr);
4365 }
4366
4367 MachO::sub_library_command
4368 MachOObjectFile::getSubLibraryCommand(const LoadCommandInfo &L) const {
4369   return getStruct<MachO::sub_library_command>(*this, L.Ptr);
4370 }
4371
4372 MachO::sub_client_command
4373 MachOObjectFile::getSubClientCommand(const LoadCommandInfo &L) const {
4374   return getStruct<MachO::sub_client_command>(*this, L.Ptr);
4375 }
4376
4377 MachO::routines_command
4378 MachOObjectFile::getRoutinesCommand(const LoadCommandInfo &L) const {
4379   return getStruct<MachO::routines_command>(*this, L.Ptr);
4380 }
4381
4382 MachO::routines_command_64
4383 MachOObjectFile::getRoutinesCommand64(const LoadCommandInfo &L) const {
4384   return getStruct<MachO::routines_command_64>(*this, L.Ptr);
4385 }
4386
4387 MachO::thread_command
4388 MachOObjectFile::getThreadCommand(const LoadCommandInfo &L) const {
4389   return getStruct<MachO::thread_command>(*this, L.Ptr);
4390 }
4391
4392 MachO::any_relocation_info
4393 MachOObjectFile::getRelocation(DataRefImpl Rel) const {
4394   uint32_t Offset;
4395   if (getHeader().filetype == MachO::MH_OBJECT) {
4396     DataRefImpl Sec;
4397     Sec.d.a = Rel.d.a;
4398     if (is64Bit()) {
4399       MachO::section_64 Sect = getSection64(Sec);
4400       Offset = Sect.reloff;
4401     } else {
4402       MachO::section Sect = getSection(Sec);
4403       Offset = Sect.reloff;
4404     }
4405   } else {
4406     MachO::dysymtab_command DysymtabLoadCmd = getDysymtabLoadCommand();
4407     if (Rel.d.a == 0)
4408       Offset = DysymtabLoadCmd.extreloff; // Offset to the external relocations
4409     else
4410       Offset = DysymtabLoadCmd.locreloff; // Offset to the local relocations
4411   }
4412
4413   auto P = reinterpret_cast<const MachO::any_relocation_info *>(
4414       getPtr(*this, Offset)) + Rel.d.b;
4415   return getStruct<MachO::any_relocation_info>(
4416       *this, reinterpret_cast<const char *>(P));
4417 }
4418
4419 MachO::data_in_code_entry
4420 MachOObjectFile::getDice(DataRefImpl Rel) const {
4421   const char *P = reinterpret_cast<const char *>(Rel.p);
4422   return getStruct<MachO::data_in_code_entry>(*this, P);
4423 }
4424
4425 const MachO::mach_header &MachOObjectFile::getHeader() const {
4426   return Header;
4427 }
4428
4429 const MachO::mach_header_64 &MachOObjectFile::getHeader64() const {
4430   assert(is64Bit());
4431   return Header64;
4432 }
4433
4434 uint32_t MachOObjectFile::getIndirectSymbolTableEntry(
4435                                              const MachO::dysymtab_command &DLC,
4436                                              unsigned Index) const {
4437   uint64_t Offset = DLC.indirectsymoff + Index * sizeof(uint32_t);
4438   return getStruct<uint32_t>(*this, getPtr(*this, Offset));
4439 }
4440
4441 MachO::data_in_code_entry
4442 MachOObjectFile::getDataInCodeTableEntry(uint32_t DataOffset,
4443                                          unsigned Index) const {
4444   uint64_t Offset = DataOffset + Index * sizeof(MachO::data_in_code_entry);
4445   return getStruct<MachO::data_in_code_entry>(*this, getPtr(*this, Offset));
4446 }
4447
4448 MachO::symtab_command MachOObjectFile::getSymtabLoadCommand() const {
4449   if (SymtabLoadCmd)
4450     return getStruct<MachO::symtab_command>(*this, SymtabLoadCmd);
4451
4452   // If there is no SymtabLoadCmd return a load command with zero'ed fields.
4453   MachO::symtab_command Cmd;
4454   Cmd.cmd = MachO::LC_SYMTAB;
4455   Cmd.cmdsize = sizeof(MachO::symtab_command);
4456   Cmd.symoff = 0;
4457   Cmd.nsyms = 0;
4458   Cmd.stroff = 0;
4459   Cmd.strsize = 0;
4460   return Cmd;
4461 }
4462
4463 MachO::dysymtab_command MachOObjectFile::getDysymtabLoadCommand() const {
4464   if (DysymtabLoadCmd)
4465     return getStruct<MachO::dysymtab_command>(*this, DysymtabLoadCmd);
4466
4467   // If there is no DysymtabLoadCmd return a load command with zero'ed fields.
4468   MachO::dysymtab_command Cmd;
4469   Cmd.cmd = MachO::LC_DYSYMTAB;
4470   Cmd.cmdsize = sizeof(MachO::dysymtab_command);
4471   Cmd.ilocalsym = 0;
4472   Cmd.nlocalsym = 0;
4473   Cmd.iextdefsym = 0;
4474   Cmd.nextdefsym = 0;
4475   Cmd.iundefsym = 0;
4476   Cmd.nundefsym = 0;
4477   Cmd.tocoff = 0;
4478   Cmd.ntoc = 0;
4479   Cmd.modtaboff = 0;
4480   Cmd.nmodtab = 0;
4481   Cmd.extrefsymoff = 0;
4482   Cmd.nextrefsyms = 0;
4483   Cmd.indirectsymoff = 0;
4484   Cmd.nindirectsyms = 0;
4485   Cmd.extreloff = 0;
4486   Cmd.nextrel = 0;
4487   Cmd.locreloff = 0;
4488   Cmd.nlocrel = 0;
4489   return Cmd;
4490 }
4491
4492 MachO::linkedit_data_command
4493 MachOObjectFile::getDataInCodeLoadCommand() const {
4494   if (DataInCodeLoadCmd)
4495     return getStruct<MachO::linkedit_data_command>(*this, DataInCodeLoadCmd);
4496
4497   // If there is no DataInCodeLoadCmd return a load command with zero'ed fields.
4498   MachO::linkedit_data_command Cmd;
4499   Cmd.cmd = MachO::LC_DATA_IN_CODE;
4500   Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
4501   Cmd.dataoff = 0;
4502   Cmd.datasize = 0;
4503   return Cmd;
4504 }
4505
4506 MachO::linkedit_data_command
4507 MachOObjectFile::getLinkOptHintsLoadCommand() const {
4508   if (LinkOptHintsLoadCmd)
4509     return getStruct<MachO::linkedit_data_command>(*this, LinkOptHintsLoadCmd);
4510
4511   // If there is no LinkOptHintsLoadCmd return a load command with zero'ed
4512   // fields.
4513   MachO::linkedit_data_command Cmd;
4514   Cmd.cmd = MachO::LC_LINKER_OPTIMIZATION_HINT;
4515   Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
4516   Cmd.dataoff = 0;
4517   Cmd.datasize = 0;
4518   return Cmd;
4519 }
4520
4521 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoRebaseOpcodes() const {
4522   if (!DyldInfoLoadCmd)
4523     return None;
4524
4525   auto DyldInfoOrErr =
4526     getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4527   if (!DyldInfoOrErr)
4528     return None;
4529   MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4530   const uint8_t *Ptr =
4531       reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.rebase_off));
4532   return makeArrayRef(Ptr, DyldInfo.rebase_size);
4533 }
4534
4535 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoBindOpcodes() const {
4536   if (!DyldInfoLoadCmd)
4537     return None;
4538
4539   auto DyldInfoOrErr =
4540     getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4541   if (!DyldInfoOrErr)
4542     return None;
4543   MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4544   const uint8_t *Ptr =
4545       reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.bind_off));
4546   return makeArrayRef(Ptr, DyldInfo.bind_size);
4547 }
4548
4549 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoWeakBindOpcodes() const {
4550   if (!DyldInfoLoadCmd)
4551     return None;
4552
4553   auto DyldInfoOrErr =
4554     getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4555   if (!DyldInfoOrErr)
4556     return None;
4557   MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4558   const uint8_t *Ptr =
4559       reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.weak_bind_off));
4560   return makeArrayRef(Ptr, DyldInfo.weak_bind_size);
4561 }
4562
4563 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoLazyBindOpcodes() const {
4564   if (!DyldInfoLoadCmd)
4565     return None;
4566
4567   auto DyldInfoOrErr =
4568     getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4569   if (!DyldInfoOrErr)
4570     return None;
4571   MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4572   const uint8_t *Ptr =
4573       reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.lazy_bind_off));
4574   return makeArrayRef(Ptr, DyldInfo.lazy_bind_size);
4575 }
4576
4577 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoExportsTrie() const {
4578   if (!DyldInfoLoadCmd)
4579     return None;
4580
4581   auto DyldInfoOrErr =
4582     getStructOrErr<MachO::dyld_info_command>(*this, DyldInfoLoadCmd);
4583   if (!DyldInfoOrErr)
4584     return None;
4585   MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
4586   const uint8_t *Ptr =
4587       reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.export_off));
4588   return makeArrayRef(Ptr, DyldInfo.export_size);
4589 }
4590
4591 ArrayRef<uint8_t> MachOObjectFile::getUuid() const {
4592   if (!UuidLoadCmd)
4593     return None;
4594   // Returning a pointer is fine as uuid doesn't need endian swapping.
4595   const char *Ptr = UuidLoadCmd + offsetof(MachO::uuid_command, uuid);
4596   return makeArrayRef(reinterpret_cast<const uint8_t *>(Ptr), 16);
4597 }
4598
4599 StringRef MachOObjectFile::getStringTableData() const {
4600   MachO::symtab_command S = getSymtabLoadCommand();
4601   return getData().substr(S.stroff, S.strsize);
4602 }
4603
4604 bool MachOObjectFile::is64Bit() const {
4605   return getType() == getMachOType(false, true) ||
4606     getType() == getMachOType(true, true);
4607 }
4608
4609 void MachOObjectFile::ReadULEB128s(uint64_t Index,
4610                                    SmallVectorImpl<uint64_t> &Out) const {
4611   DataExtractor extractor(ObjectFile::getData(), true, 0);
4612
4613   uint32_t offset = Index;
4614   uint64_t data = 0;
4615   while (uint64_t delta = extractor.getULEB128(&offset)) {
4616     data += delta;
4617     Out.push_back(data);
4618   }
4619 }
4620
4621 bool MachOObjectFile::isRelocatableObject() const {
4622   return getHeader().filetype == MachO::MH_OBJECT;
4623 }
4624
4625 Expected<std::unique_ptr<MachOObjectFile>>
4626 ObjectFile::createMachOObjectFile(MemoryBufferRef Buffer,
4627                                   uint32_t UniversalCputype,
4628                                   uint32_t UniversalIndex) {
4629   StringRef Magic = Buffer.getBuffer().slice(0, 4);
4630   if (Magic == "\xFE\xED\xFA\xCE")
4631     return MachOObjectFile::create(Buffer, false, false,
4632                                    UniversalCputype, UniversalIndex);
4633   if (Magic == "\xCE\xFA\xED\xFE")
4634     return MachOObjectFile::create(Buffer, true, false,
4635                                    UniversalCputype, UniversalIndex);
4636   if (Magic == "\xFE\xED\xFA\xCF")
4637     return MachOObjectFile::create(Buffer, false, true,
4638                                    UniversalCputype, UniversalIndex);
4639   if (Magic == "\xCF\xFA\xED\xFE")
4640     return MachOObjectFile::create(Buffer, true, true,
4641                                    UniversalCputype, UniversalIndex);
4642   return make_error<GenericBinaryError>("Unrecognized MachO magic number",
4643                                         object_error::invalid_file_type);
4644 }
4645
4646 StringRef MachOObjectFile::mapDebugSectionName(StringRef Name) const {
4647   return StringSwitch<StringRef>(Name)
4648       .Case("debug_str_offs", "debug_str_offsets")
4649       .Default(Name);
4650 }