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