contrib/llvm/include/llvm/Object/MachO.h

   1 //===- MachO.h - MachO object file implementation ---------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file declares the MachOObjectFile class, which implement the ObjectFile
  11 // interface for MachO files.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_OBJECT_MACHO_H
  16 #define LLVM_OBJECT_MACHO_H
  17
  18 #include "llvm/ADT/ArrayRef.h"
  19 #include "llvm/ADT/SmallString.h"
  20 #include "llvm/ADT/SmallVector.h"
  21 #include "llvm/ADT/StringExtras.h"
  22 #include "llvm/ADT/StringRef.h"
  23 #include "llvm/ADT/Triple.h"
  24 #include "llvm/ADT/iterator_range.h"
  25 #include "llvm/BinaryFormat/MachO.h"
  26 #include "llvm/MC/SubtargetFeature.h"
  27 #include "llvm/Object/Binary.h"
  28 #include "llvm/Object/ObjectFile.h"
  29 #include "llvm/Object/SymbolicFile.h"
  30 #include "llvm/Support/Error.h"
  31 #include "llvm/Support/Format.h"
  32 #include "llvm/Support/MemoryBuffer.h"
  33 #include "llvm/Support/raw_ostream.h"
  34 #include <cstdint>
  35 #include <memory>
  36 #include <string>
  37 #include <system_error>
  38
  39 namespace llvm {
  40 namespace object {
  41
  42 /// DiceRef - This is a value type class that represents a single
  43 /// data in code entry in the table in a Mach-O object file.
  44 class DiceRef {
  45   DataRefImpl DicePimpl;
  46   const ObjectFile *OwningObject = nullptr;
  47
  48 public:
  49   DiceRef() = default;
  50   DiceRef(DataRefImpl DiceP, const ObjectFile *Owner);
  51
  52   bool operator==(const DiceRef &Other) const;
  53   bool operator<(const DiceRef &Other) const;
  54
  55   void moveNext();
  56
  57   std::error_code getOffset(uint32_t &Result) const;
  58   std::error_code getLength(uint16_t &Result) const;
  59   std::error_code getKind(uint16_t &Result) const;
  60
  61   DataRefImpl getRawDataRefImpl() const;
  62   const ObjectFile *getObjectFile() const;
  63 };
  64 using dice_iterator = content_iterator<DiceRef>;
  65
  66 /// ExportEntry encapsulates the current-state-of-the-walk used when doing a
  67 /// non-recursive walk of the trie data structure.  This allows you to iterate
  68 /// across all exported symbols using:
  69 ///      Error Err;
  70 ///      for (const llvm::object::ExportEntry &AnExport : Obj->exports(&Err)) {
  71 ///      }
  72 ///      if (Err) { report error ...
  73 class ExportEntry {
  74 public:
  75   ExportEntry(Error *Err, const MachOObjectFile *O, ArrayRef<uint8_t> Trie);
  76
  77   StringRef name() const;
  78   uint64_t flags() const;
  79   uint64_t address() const;
  80   uint64_t other() const;
  81   StringRef otherName() const;
  82   uint32_t nodeOffset() const;
  83
  84   bool operator==(const ExportEntry &) const;
  85
  86   void moveNext();
  87
  88 private:
  89   friend class MachOObjectFile;
  90
  91   void moveToFirst();
  92   void moveToEnd();
  93   uint64_t readULEB128(const uint8_t *&p, const char **error);
  94   void pushDownUntilBottom();
  95   void pushNode(uint64_t Offset);
  96
  97   // Represents a node in the mach-o exports trie.
  98   struct NodeState {
  99     NodeState(const uint8_t *Ptr);
 100
 101     const uint8_t *Start;
 102     const uint8_t *Current;
 103     uint64_t Flags = 0;
 104     uint64_t Address = 0;
 105     uint64_t Other = 0;
 106     const char *ImportName = nullptr;
 107     unsigned ChildCount = 0;
 108     unsigned NextChildIndex = 0;
 109     unsigned ParentStringLength = 0;
 110     bool IsExportNode = false;
 111   };
 112   using NodeList = SmallVector<NodeState, 16>;
 113   using node_iterator = NodeList::const_iterator;
 114
 115   Error *E;
 116   const MachOObjectFile *O;
 117   ArrayRef<uint8_t> Trie;
 118   SmallString<256> CumulativeString;
 119   NodeList Stack;
 120   bool Done = false;
 121
 122   iterator_range<node_iterator> nodes() const {
 123     return make_range(Stack.begin(), Stack.end());
 124   }
 125 };
 126 using export_iterator = content_iterator<ExportEntry>;
 127
 128 // Segment info so SegIndex/SegOffset pairs in a Mach-O Bind or Rebase entry
 129 // can be checked and translated.  Only the SegIndex/SegOffset pairs from
 130 // checked entries are to be used with the segmentName(), sectionName() and
 131 // address() methods below.
 132 class BindRebaseSegInfo {
 133 public:
 134   BindRebaseSegInfo(const MachOObjectFile *Obj);
 135
 136   // Used to check a Mach-O Bind or Rebase entry for errors when iterating.
 137   const char *checkSegAndOffset(int32_t SegIndex, uint64_t SegOffset,
 138                                 bool endInvalid);
 139   const char *checkCountAndSkip(uint32_t Count, uint32_t Skip,
 140                                 uint8_t PointerSize, int32_t SegIndex,
 141                                 uint64_t SegOffset);
 142   // Used with valid SegIndex/SegOffset values from checked entries.
 143   StringRef segmentName(int32_t SegIndex);
 144   StringRef sectionName(int32_t SegIndex, uint64_t SegOffset);
 145   uint64_t address(uint32_t SegIndex, uint64_t SegOffset);
 146
 147 private:
 148   struct SectionInfo {
 149     uint64_t Address;
 150     uint64_t Size;
 151     StringRef SectionName;
 152     StringRef SegmentName;
 153     uint64_t OffsetInSegment;
 154     uint64_t SegmentStartAddress;
 155     int32_t SegmentIndex;
 156   };
 157   const SectionInfo &findSection(int32_t SegIndex, uint64_t SegOffset);
 158
 159   SmallVector<SectionInfo, 32> Sections;
 160   int32_t MaxSegIndex;
 161 };
 162
 163 /// MachORebaseEntry encapsulates the current state in the decompression of
 164 /// rebasing opcodes. This allows you to iterate through the compressed table of
 165 /// rebasing using:
 166 ///    Error Err;
 167 ///    for (const llvm::object::MachORebaseEntry &Entry : Obj->rebaseTable(&Err)) {
 168 ///    }
 169 ///    if (Err) { report error ...
 170 class MachORebaseEntry {
 171 public:
 172   MachORebaseEntry(Error *Err, const MachOObjectFile *O,
 173                    ArrayRef<uint8_t> opcodes, bool is64Bit);
 174
 175   int32_t segmentIndex() const;
 176   uint64_t segmentOffset() const;
 177   StringRef typeName() const;
 178   StringRef segmentName() const;
 179   StringRef sectionName() const;
 180   uint64_t address() const;
 181
 182   bool operator==(const MachORebaseEntry &) const;
 183
 184   void moveNext();
 185
 186 private:
 187   friend class MachOObjectFile;
 188
 189   void moveToFirst();
 190   void moveToEnd();
 191   uint64_t readULEB128(const char **error);
 192
 193   Error *E;
 194   const MachOObjectFile *O;
 195   ArrayRef<uint8_t> Opcodes;
 196   const uint8_t *Ptr;
 197   uint64_t SegmentOffset = 0;
 198   int32_t SegmentIndex = -1;
 199   uint64_t RemainingLoopCount = 0;
 200   uint64_t AdvanceAmount = 0;
 201   uint8_t  RebaseType = 0;
 202   uint8_t  PointerSize;
 203   bool     Done = false;
 204 };
 205 using rebase_iterator = content_iterator<MachORebaseEntry>;
 206
 207 /// MachOBindEntry encapsulates the current state in the decompression of
 208 /// binding opcodes. This allows you to iterate through the compressed table of
 209 /// bindings using:
 210 ///    Error Err;
 211 ///    for (const llvm::object::MachOBindEntry &Entry : Obj->bindTable(&Err)) {
 212 ///    }
 213 ///    if (Err) { report error ...
 214 class MachOBindEntry {
 215 public:
 216   enum class Kind { Regular, Lazy, Weak };
 217
 218   MachOBindEntry(Error *Err, const MachOObjectFile *O,
 219                  ArrayRef<uint8_t> Opcodes, bool is64Bit, MachOBindEntry::Kind);
 220
 221   int32_t segmentIndex() const;
 222   uint64_t segmentOffset() const;
 223   StringRef typeName() const;
 224   StringRef symbolName() const;
 225   uint32_t flags() const;
 226   int64_t addend() const;
 227   int ordinal() const;
 228
 229   StringRef segmentName() const;
 230   StringRef sectionName() const;
 231   uint64_t address() const;
 232
 233   bool operator==(const MachOBindEntry &) const;
 234
 235   void moveNext();
 236
 237 private:
 238   friend class MachOObjectFile;
 239
 240   void moveToFirst();
 241   void moveToEnd();
 242   uint64_t readULEB128(const char **error);
 243   int64_t readSLEB128(const char **error);
 244
 245   Error *E;
 246   const MachOObjectFile *O;
 247   ArrayRef<uint8_t> Opcodes;
 248   const uint8_t *Ptr;
 249   uint64_t SegmentOffset = 0;
 250   int32_t  SegmentIndex = -1;
 251   StringRef SymbolName;
 252   bool     LibraryOrdinalSet = false;
 253   int      Ordinal = 0;
 254   uint32_t Flags = 0;
 255   int64_t  Addend = 0;
 256   uint64_t RemainingLoopCount = 0;
 257   uint64_t AdvanceAmount = 0;
 258   uint8_t  BindType = 0;
 259   uint8_t  PointerSize;
 260   Kind     TableKind;
 261   bool     Done = false;
 262 };
 263 using bind_iterator = content_iterator<MachOBindEntry>;
 264
 265 class MachOObjectFile : public ObjectFile {
 266 public:
 267   struct LoadCommandInfo {
 268     const char *Ptr;      // Where in memory the load command is.
 269     MachO::load_command C; // The command itself.
 270   };
 271   using LoadCommandList = SmallVector<LoadCommandInfo, 4>;
 272   using load_command_iterator = LoadCommandList::const_iterator;
 273
 274   static Expected<std::unique_ptr<MachOObjectFile>>
 275   create(MemoryBufferRef Object, bool IsLittleEndian, bool Is64Bits,
 276          uint32_t UniversalCputype = 0, uint32_t UniversalIndex = 0);
 277
 278   void moveSymbolNext(DataRefImpl &Symb) const override;
 279
 280   uint64_t getNValue(DataRefImpl Sym) const;
 281   Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
 282
 283   // MachO specific.
 284   Error checkSymbolTable() const;
 285
 286   std::error_code getIndirectName(DataRefImpl Symb, StringRef &Res) const;
 287   unsigned getSectionType(SectionRef Sec) const;
 288
 289   Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
 290   uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
 291   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
 292   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
 293   uint32_t getSymbolFlags(DataRefImpl Symb) const override;
 294   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
 295   unsigned getSymbolSectionID(SymbolRef Symb) const;
 296   unsigned getSectionID(SectionRef Sec) const;
 297
 298   void moveSectionNext(DataRefImpl &Sec) const override;
 299   std::error_code getSectionName(DataRefImpl Sec,
 300                                  StringRef &Res) const override;
 301   uint64_t getSectionAddress(DataRefImpl Sec) const override;
 302   uint64_t getSectionIndex(DataRefImpl Sec) const override;
 303   uint64_t getSectionSize(DataRefImpl Sec) const override;
 304   std::error_code getSectionContents(DataRefImpl Sec,
 305                                      StringRef &Res) const override;
 306   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
 307   Expected<SectionRef> getSection(unsigned SectionIndex) const;
 308   Expected<SectionRef> getSection(StringRef SectionName) const;
 309   bool isSectionCompressed(DataRefImpl Sec) const override;
 310   bool isSectionText(DataRefImpl Sec) const override;
 311   bool isSectionData(DataRefImpl Sec) const override;
 312   bool isSectionBSS(DataRefImpl Sec) const override;
 313   bool isSectionVirtual(DataRefImpl Sec) const override;
 314   bool isSectionBitcode(DataRefImpl Sec) const override;
 315
 316   /// When dsymutil generates the companion file, it strips all unnecessary
 317   /// sections (e.g. everything in the _TEXT segment) by omitting their body
 318   /// and setting the offset in their corresponding load command to zero.
 319   ///
 320   /// While the load command itself is valid, reading the section corresponds
 321   /// to reading the number of bytes specified in the load command, starting
 322   /// from offset 0 (i.e. the Mach-O header at the beginning of the file).
 323   bool isSectionStripped(DataRefImpl Sec) const override;
 324
 325   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
 326   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
 327
 328   relocation_iterator extrel_begin() const;
 329   relocation_iterator extrel_end() const;
 330   iterator_range<relocation_iterator> external_relocations() const {
 331     return make_range(extrel_begin(), extrel_end());
 332   }
 333
 334   relocation_iterator locrel_begin() const;
 335   relocation_iterator locrel_end() const;
 336
 337   void moveRelocationNext(DataRefImpl &Rel) const override;
 338   uint64_t getRelocationOffset(DataRefImpl Rel) const override;
 339   symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
 340   section_iterator getRelocationSection(DataRefImpl Rel) const;
 341   uint64_t getRelocationType(DataRefImpl Rel) const override;
 342   void getRelocationTypeName(DataRefImpl Rel,
 343                              SmallVectorImpl<char> &Result) const override;
 344   uint8_t getRelocationLength(DataRefImpl Rel) const;
 345
 346   // MachO specific.
 347   std::error_code getLibraryShortNameByIndex(unsigned Index, StringRef &) const;
 348   uint32_t getLibraryCount() const;
 349
 350   section_iterator getRelocationRelocatedSection(relocation_iterator Rel) const;
 351
 352   // TODO: Would be useful to have an iterator based version
 353   // of the load command interface too.
 354
 355   basic_symbol_iterator symbol_begin() const override;
 356   basic_symbol_iterator symbol_end() const override;
 357
 358   // MachO specific.
 359   basic_symbol_iterator getSymbolByIndex(unsigned Index) const;
 360   uint64_t getSymbolIndex(DataRefImpl Symb) const;
 361
 362   section_iterator section_begin() const override;
 363   section_iterator section_end() const override;
 364
 365   uint8_t getBytesInAddress() const override;
 366
 367   StringRef getFileFormatName() const override;
 368   Triple::ArchType getArch() const override;
 369   SubtargetFeatures getFeatures() const override { return SubtargetFeatures(); }
 370   Triple getArchTriple(const char **McpuDefault = nullptr) const;
 371
 372   relocation_iterator section_rel_begin(unsigned Index) const;
 373   relocation_iterator section_rel_end(unsigned Index) const;
 374
 375   dice_iterator begin_dices() const;
 376   dice_iterator end_dices() const;
 377
 378   load_command_iterator begin_load_commands() const;
 379   load_command_iterator end_load_commands() const;
 380   iterator_range<load_command_iterator> load_commands() const;
 381
 382   /// For use iterating over all exported symbols.
 383   iterator_range<export_iterator> exports(Error &Err) const;
 384
 385   /// For use examining a trie not in a MachOObjectFile.
 386   static iterator_range<export_iterator> exports(Error &Err,
 387                                                  ArrayRef<uint8_t> Trie,
 388                                                  const MachOObjectFile *O =
 389                                                                       nullptr);
 390
 391   /// For use iterating over all rebase table entries.
 392   iterator_range<rebase_iterator> rebaseTable(Error &Err);
 393
 394   /// For use examining rebase opcodes in a MachOObjectFile.
 395   static iterator_range<rebase_iterator> rebaseTable(Error &Err,
 396                                                      MachOObjectFile *O,
 397                                                      ArrayRef<uint8_t> Opcodes,
 398                                                      bool is64);
 399
 400   /// For use iterating over all bind table entries.
 401   iterator_range<bind_iterator> bindTable(Error &Err);
 402
 403   /// For use iterating over all lazy bind table entries.
 404   iterator_range<bind_iterator> lazyBindTable(Error &Err);
 405
 406   /// For use iterating over all weak bind table entries.
 407   iterator_range<bind_iterator> weakBindTable(Error &Err);
 408
 409   /// For use examining bind opcodes in a MachOObjectFile.
 410   static iterator_range<bind_iterator> bindTable(Error &Err,
 411                                                  MachOObjectFile *O,
 412                                                  ArrayRef<uint8_t> Opcodes,
 413                                                  bool is64,
 414                                                  MachOBindEntry::Kind);
 415
 416   /// For use with a SegIndex,SegOffset pair in MachOBindEntry::moveNext() to
 417   /// validate a MachOBindEntry.
 418   const char *BindEntryCheckSegAndOffset(int32_t SegIndex, uint64_t SegOffset,
 419                                          bool endInvalid) const {
 420     return BindRebaseSectionTable->checkSegAndOffset(SegIndex, SegOffset,
 421                                                      endInvalid);
 422   }
 423   /// For use in MachOBindEntry::moveNext() to validate a MachOBindEntry for
 424   /// the BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB opcode.
 425   const char *BindEntryCheckCountAndSkip(uint32_t Count, uint32_t Skip,
 426                                          uint8_t PointerSize, int32_t SegIndex,
 427                                          uint64_t SegOffset) const {
 428     return BindRebaseSectionTable->checkCountAndSkip(Count, Skip, PointerSize,
 429                                                      SegIndex, SegOffset);
 430   }
 431
 432   /// For use with a SegIndex,SegOffset pair in MachORebaseEntry::moveNext() to
 433   /// validate a MachORebaseEntry.
 434   const char *RebaseEntryCheckSegAndOffset(int32_t SegIndex, uint64_t SegOffset,
 435                                            bool endInvalid) const {
 436     return BindRebaseSectionTable->checkSegAndOffset(SegIndex, SegOffset,
 437                                                      endInvalid);
 438   }
 439   /// For use in MachORebaseEntry::moveNext() to validate a MachORebaseEntry for
 440   /// the REBASE_OPCODE_DO_*_TIMES* opcodes.
 441   const char *RebaseEntryCheckCountAndSkip(uint32_t Count, uint32_t Skip,
 442                                          uint8_t PointerSize, int32_t SegIndex,
 443                                          uint64_t SegOffset) const {
 444     return BindRebaseSectionTable->checkCountAndSkip(Count, Skip, PointerSize,
 445                                                      SegIndex, SegOffset);
 446   }
 447
 448   /// For use with the SegIndex of a checked Mach-O Bind or Rebase entry to
 449   /// get the segment name.
 450   StringRef BindRebaseSegmentName(int32_t SegIndex) const {
 451     return BindRebaseSectionTable->segmentName(SegIndex);
 452   }
 453
 454   /// For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or
 455   /// Rebase entry to get the section name.
 456   StringRef BindRebaseSectionName(uint32_t SegIndex, uint64_t SegOffset) const {
 457     return BindRebaseSectionTable->sectionName(SegIndex, SegOffset);
 458   }
 459
 460   /// For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or
 461   /// Rebase entry to get the address.
 462   uint64_t BindRebaseAddress(uint32_t SegIndex, uint64_t SegOffset) const {
 463     return BindRebaseSectionTable->address(SegIndex, SegOffset);
 464   }
 465
 466   // In a MachO file, sections have a segment name. This is used in the .o
 467   // files. They have a single segment, but this field specifies which segment
 468   // a section should be put in the final object.
 469   StringRef getSectionFinalSegmentName(DataRefImpl Sec) const;
 470
 471   // Names are stored as 16 bytes. These returns the raw 16 bytes without
 472   // interpreting them as a C string.
 473   ArrayRef<char> getSectionRawName(DataRefImpl Sec) const;
 474   ArrayRef<char> getSectionRawFinalSegmentName(DataRefImpl Sec) const;
 475
 476   // MachO specific Info about relocations.
 477   bool isRelocationScattered(const MachO::any_relocation_info &RE) const;
 478   unsigned getPlainRelocationSymbolNum(
 479                                     const MachO::any_relocation_info &RE) const;
 480   bool getPlainRelocationExternal(const MachO::any_relocation_info &RE) const;
 481   bool getScatteredRelocationScattered(
 482                                     const MachO::any_relocation_info &RE) const;
 483   uint32_t getScatteredRelocationValue(
 484                                     const MachO::any_relocation_info &RE) const;
 485   uint32_t getScatteredRelocationType(
 486                                     const MachO::any_relocation_info &RE) const;
 487   unsigned getAnyRelocationAddress(const MachO::any_relocation_info &RE) const;
 488   unsigned getAnyRelocationPCRel(const MachO::any_relocation_info &RE) const;
 489   unsigned getAnyRelocationLength(const MachO::any_relocation_info &RE) const;
 490   unsigned getAnyRelocationType(const MachO::any_relocation_info &RE) const;
 491   SectionRef getAnyRelocationSection(const MachO::any_relocation_info &RE) const;
 492
 493   // MachO specific structures.
 494   MachO::section getSection(DataRefImpl DRI) const;
 495   MachO::section_64 getSection64(DataRefImpl DRI) const;
 496   MachO::section getSection(const LoadCommandInfo &L, unsigned Index) const;
 497   MachO::section_64 getSection64(const LoadCommandInfo &L,unsigned Index) const;
 498   MachO::nlist getSymbolTableEntry(DataRefImpl DRI) const;
 499   MachO::nlist_64 getSymbol64TableEntry(DataRefImpl DRI) const;
 500
 501   MachO::linkedit_data_command
 502   getLinkeditDataLoadCommand(const LoadCommandInfo &L) const;
 503   MachO::segment_command
 504   getSegmentLoadCommand(const LoadCommandInfo &L) const;
 505   MachO::segment_command_64
 506   getSegment64LoadCommand(const LoadCommandInfo &L) const;
 507   MachO::linker_option_command
 508   getLinkerOptionLoadCommand(const LoadCommandInfo &L) const;
 509   MachO::version_min_command
 510   getVersionMinLoadCommand(const LoadCommandInfo &L) const;
 511   MachO::note_command
 512   getNoteLoadCommand(const LoadCommandInfo &L) const;
 513   MachO::build_version_command
 514   getBuildVersionLoadCommand(const LoadCommandInfo &L) const;
 515   MachO::build_tool_version
 516   getBuildToolVersion(unsigned index) const;
 517   MachO::dylib_command
 518   getDylibIDLoadCommand(const LoadCommandInfo &L) const;
 519   MachO::dyld_info_command
 520   getDyldInfoLoadCommand(const LoadCommandInfo &L) const;
 521   MachO::dylinker_command
 522   getDylinkerCommand(const LoadCommandInfo &L) const;
 523   MachO::uuid_command
 524   getUuidCommand(const LoadCommandInfo &L) const;
 525   MachO::rpath_command
 526   getRpathCommand(const LoadCommandInfo &L) const;
 527   MachO::source_version_command
 528   getSourceVersionCommand(const LoadCommandInfo &L) const;
 529   MachO::entry_point_command
 530   getEntryPointCommand(const LoadCommandInfo &L) const;
 531   MachO::encryption_info_command
 532   getEncryptionInfoCommand(const LoadCommandInfo &L) const;
 533   MachO::encryption_info_command_64
 534   getEncryptionInfoCommand64(const LoadCommandInfo &L) const;
 535   MachO::sub_framework_command
 536   getSubFrameworkCommand(const LoadCommandInfo &L) const;
 537   MachO::sub_umbrella_command
 538   getSubUmbrellaCommand(const LoadCommandInfo &L) const;
 539   MachO::sub_library_command
 540   getSubLibraryCommand(const LoadCommandInfo &L) const;
 541   MachO::sub_client_command
 542   getSubClientCommand(const LoadCommandInfo &L) const;
 543   MachO::routines_command
 544   getRoutinesCommand(const LoadCommandInfo &L) const;
 545   MachO::routines_command_64
 546   getRoutinesCommand64(const LoadCommandInfo &L) const;
 547   MachO::thread_command
 548   getThreadCommand(const LoadCommandInfo &L) const;
 549
 550   MachO::any_relocation_info getRelocation(DataRefImpl Rel) const;
 551   MachO::data_in_code_entry getDice(DataRefImpl Rel) const;
 552   const MachO::mach_header &getHeader() const;
 553   const MachO::mach_header_64 &getHeader64() const;
 554   uint32_t
 555   getIndirectSymbolTableEntry(const MachO::dysymtab_command &DLC,
 556                               unsigned Index) const;
 557   MachO::data_in_code_entry getDataInCodeTableEntry(uint32_t DataOffset,
 558                                                     unsigned Index) const;
 559   MachO::symtab_command getSymtabLoadCommand() const;
 560   MachO::dysymtab_command getDysymtabLoadCommand() const;
 561   MachO::linkedit_data_command getDataInCodeLoadCommand() const;
 562   MachO::linkedit_data_command getLinkOptHintsLoadCommand() const;
 563   ArrayRef<uint8_t> getDyldInfoRebaseOpcodes() const;
 564   ArrayRef<uint8_t> getDyldInfoBindOpcodes() const;
 565   ArrayRef<uint8_t> getDyldInfoWeakBindOpcodes() const;
 566   ArrayRef<uint8_t> getDyldInfoLazyBindOpcodes() const;
 567   ArrayRef<uint8_t> getDyldInfoExportsTrie() const;
 568   ArrayRef<uint8_t> getUuid() const;
 569
 570   StringRef getStringTableData() const;
 571   bool is64Bit() const;
 572   void ReadULEB128s(uint64_t Index, SmallVectorImpl<uint64_t> &Out) const;
 573
 574   static StringRef guessLibraryShortName(StringRef Name, bool &isFramework,
 575                                          StringRef &Suffix);
 576
 577   static Triple::ArchType getArch(uint32_t CPUType);
 578   static Triple getArchTriple(uint32_t CPUType, uint32_t CPUSubType,
 579                               const char **McpuDefault = nullptr,
 580                               const char **ArchFlag = nullptr);
 581   static bool isValidArch(StringRef ArchFlag);
 582   static Triple getHostArch();
 583
 584   bool isRelocatableObject() const override;
 585
 586   StringRef mapDebugSectionName(StringRef Name) const override;
 587
 588   bool hasPageZeroSegment() const { return HasPageZeroSegment; }
 589
 590   static bool classof(const Binary *v) {
 591     return v->isMachO();
 592   }
 593
 594   static uint32_t
 595   getVersionMinMajor(MachO::version_min_command &C, bool SDK) {
 596     uint32_t VersionOrSDK = (SDK) ? C.sdk : C.version;
 597     return (VersionOrSDK >> 16) & 0xffff;
 598   }
 599
 600   static uint32_t
 601   getVersionMinMinor(MachO::version_min_command &C, bool SDK) {
 602     uint32_t VersionOrSDK = (SDK) ? C.sdk : C.version;
 603     return (VersionOrSDK >> 8) & 0xff;
 604   }
 605
 606   static uint32_t
 607   getVersionMinUpdate(MachO::version_min_command &C, bool SDK) {
 608     uint32_t VersionOrSDK = (SDK) ? C.sdk : C.version;
 609     return VersionOrSDK & 0xff;
 610   }
 611
 612   static std::string getBuildPlatform(uint32_t platform) {
 613     switch (platform) {
 614     case MachO::PLATFORM_MACOS: return "macos";
 615     case MachO::PLATFORM_IOS: return "ios";
 616     case MachO::PLATFORM_TVOS: return "tvos";
 617     case MachO::PLATFORM_WATCHOS: return "watchos";
 618     case MachO::PLATFORM_BRIDGEOS: return "bridgeos";
 619     default:
 620       std::string ret;
 621       raw_string_ostream ss(ret);
 622       ss << format_hex(platform, 8, true);
 623       return ss.str();
 624     }
 625   }
 626
 627   static std::string getBuildTool(uint32_t tools) {
 628     switch (tools) {
 629     case MachO::TOOL_CLANG: return "clang";
 630     case MachO::TOOL_SWIFT: return "swift";
 631     case MachO::TOOL_LD: return "ld";
 632     default:
 633       std::string ret;
 634       raw_string_ostream ss(ret);
 635       ss << format_hex(tools, 8, true);
 636       return ss.str();
 637     }
 638   }
 639
 640   static std::string getVersionString(uint32_t version) {
 641     uint32_t major = (version >> 16) & 0xffff;
 642     uint32_t minor = (version >> 8) & 0xff;
 643     uint32_t update = version & 0xff;
 644
 645     SmallString<32> Version;
 646     Version = utostr(major) + "." + utostr(minor);
 647     if (update != 0)
 648       Version += "." + utostr(update);
 649     return Version.str();
 650   }
 651
 652 private:
 653   MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian, bool Is64Bits,
 654                   Error &Err, uint32_t UniversalCputype = 0,
 655                   uint32_t UniversalIndex = 0);
 656
 657   uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
 658
 659   union {
 660     MachO::mach_header_64 Header64;
 661     MachO::mach_header Header;
 662   };
 663   using SectionList = SmallVector<const char*, 1>;
 664   SectionList Sections;
 665   using LibraryList = SmallVector<const char*, 1>;
 666   LibraryList Libraries;
 667   LoadCommandList LoadCommands;
 668   using LibraryShortName = SmallVector<StringRef, 1>;
 669   using BuildToolList = SmallVector<const char*, 1>;
 670   BuildToolList BuildTools;
 671   mutable LibraryShortName LibrariesShortNames;
 672   std::unique_ptr<BindRebaseSegInfo> BindRebaseSectionTable;
 673   const char *SymtabLoadCmd = nullptr;
 674   const char *DysymtabLoadCmd = nullptr;
 675   const char *DataInCodeLoadCmd = nullptr;
 676   const char *LinkOptHintsLoadCmd = nullptr;
 677   const char *DyldInfoLoadCmd = nullptr;
 678   const char *UuidLoadCmd = nullptr;
 679   bool HasPageZeroSegment = false;
 680 };
 681
 682 /// DiceRef
 683 inline DiceRef::DiceRef(DataRefImpl DiceP, const ObjectFile *Owner)
 684   : DicePimpl(DiceP) , OwningObject(Owner) {}
 685
 686 inline bool DiceRef::operator==(const DiceRef &Other) const {
 687   return DicePimpl == Other.DicePimpl;
 688 }
 689
 690 inline bool DiceRef::operator<(const DiceRef &Other) const {
 691   return DicePimpl < Other.DicePimpl;
 692 }
 693
 694 inline void DiceRef::moveNext() {
 695   const MachO::data_in_code_entry *P =
 696     reinterpret_cast<const MachO::data_in_code_entry *>(DicePimpl.p);
 697   DicePimpl.p = reinterpret_cast<uintptr_t>(P + 1);
 698 }
 699
 700 // Since a Mach-O data in code reference, a DiceRef, can only be created when
 701 // the OwningObject ObjectFile is a MachOObjectFile a static_cast<> is used for
 702 // the methods that get the values of the fields of the reference.
 703
 704 inline std::error_code DiceRef::getOffset(uint32_t &Result) const {
 705   const MachOObjectFile *MachOOF =
 706     static_cast<const MachOObjectFile *>(OwningObject);
 707   MachO::data_in_code_entry Dice = MachOOF->getDice(DicePimpl);
 708   Result = Dice.offset;
 709   return std::error_code();
 710 }
 711
 712 inline std::error_code DiceRef::getLength(uint16_t &Result) const {
 713   const MachOObjectFile *MachOOF =
 714     static_cast<const MachOObjectFile *>(OwningObject);
 715   MachO::data_in_code_entry Dice = MachOOF->getDice(DicePimpl);
 716   Result = Dice.length;
 717   return std::error_code();
 718 }
 719
 720 inline std::error_code DiceRef::getKind(uint16_t &Result) const {
 721   const MachOObjectFile *MachOOF =
 722     static_cast<const MachOObjectFile *>(OwningObject);
 723   MachO::data_in_code_entry Dice = MachOOF->getDice(DicePimpl);
 724   Result = Dice.kind;
 725   return std::error_code();
 726 }
 727
 728 inline DataRefImpl DiceRef::getRawDataRefImpl() const {
 729   return DicePimpl;
 730 }
 731
 732 inline const ObjectFile *DiceRef::getObjectFile() const {
 733   return OwningObject;
 734 }
 735
 736 } // end namespace object
 737 } // end namespace llvm
 738
 739 #endif // LLVM_OBJECT_MACHO_H