xref: /openbsd/gnu/llvm/llvm/include/llvm/Object/MachO.h (revision d415bd75)
1 //===- MachO.h - MachO object file implementation ---------------*- C++ -*-===//
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 declares the MachOObjectFile class, which implement the ObjectFile
10 // interface for MachO files.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_OBJECT_MACHO_H
15 #define LLVM_OBJECT_MACHO_H
16 
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/ADT/SmallString.h"
19 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/ADT/StringExtras.h"
21 #include "llvm/ADT/StringRef.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/ADT/iterator_range.h"
24 #include "llvm/BinaryFormat/MachO.h"
25 #include "llvm/BinaryFormat/Swift.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 = Error::success();
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 
nodes()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* checkSegAndOffsets(int32_t SegIndex, uint64_t SegOffset,
138                                  uint8_t PointerSize, uint32_t Count=1,
139                                  uint32_t Skip=0);
140   // Used with valid SegIndex/SegOffset values from checked entries.
141   StringRef segmentName(int32_t SegIndex);
142   StringRef sectionName(int32_t SegIndex, uint64_t SegOffset);
143   uint64_t address(uint32_t SegIndex, uint64_t SegOffset);
144 
145 private:
146   struct SectionInfo {
147     uint64_t Address;
148     uint64_t Size;
149     StringRef SectionName;
150     StringRef SegmentName;
151     uint64_t OffsetInSegment;
152     uint64_t SegmentStartAddress;
153     int32_t SegmentIndex;
154   };
155   const SectionInfo &findSection(int32_t SegIndex, uint64_t SegOffset);
156 
157   SmallVector<SectionInfo, 32> Sections;
158   int32_t MaxSegIndex;
159 };
160 
161 /// MachORebaseEntry encapsulates the current state in the decompression of
162 /// rebasing opcodes. This allows you to iterate through the compressed table of
163 /// rebasing using:
164 ///    Error Err = Error::success();
165 ///    for (const llvm::object::MachORebaseEntry &Entry : Obj->rebaseTable(&Err)) {
166 ///    }
167 ///    if (Err) { report error ...
168 class MachORebaseEntry {
169 public:
170   MachORebaseEntry(Error *Err, const MachOObjectFile *O,
171                    ArrayRef<uint8_t> opcodes, bool is64Bit);
172 
173   int32_t segmentIndex() const;
174   uint64_t segmentOffset() const;
175   StringRef typeName() const;
176   StringRef segmentName() const;
177   StringRef sectionName() const;
178   uint64_t address() const;
179 
180   bool operator==(const MachORebaseEntry &) const;
181 
182   void moveNext();
183 
184 private:
185   friend class MachOObjectFile;
186 
187   void moveToFirst();
188   void moveToEnd();
189   uint64_t readULEB128(const char **error);
190 
191   Error *E;
192   const MachOObjectFile *O;
193   ArrayRef<uint8_t> Opcodes;
194   const uint8_t *Ptr;
195   uint64_t SegmentOffset = 0;
196   int32_t SegmentIndex = -1;
197   uint64_t RemainingLoopCount = 0;
198   uint64_t AdvanceAmount = 0;
199   uint8_t  RebaseType = 0;
200   uint8_t  PointerSize;
201   bool     Done = false;
202 };
203 using rebase_iterator = content_iterator<MachORebaseEntry>;
204 
205 /// MachOBindEntry encapsulates the current state in the decompression of
206 /// binding opcodes. This allows you to iterate through the compressed table of
207 /// bindings using:
208 ///    Error Err = Error::success();
209 ///    for (const llvm::object::MachOBindEntry &Entry : Obj->bindTable(&Err)) {
210 ///    }
211 ///    if (Err) { report error ...
212 class MachOBindEntry {
213 public:
214   enum class Kind { Regular, Lazy, Weak };
215 
216   MachOBindEntry(Error *Err, const MachOObjectFile *O,
217                  ArrayRef<uint8_t> Opcodes, bool is64Bit, MachOBindEntry::Kind);
218 
219   int32_t segmentIndex() const;
220   uint64_t segmentOffset() const;
221   StringRef typeName() const;
222   StringRef symbolName() const;
223   uint32_t flags() const;
224   int64_t addend() const;
225   int ordinal() const;
226 
227   StringRef segmentName() const;
228   StringRef sectionName() const;
229   uint64_t address() const;
230 
231   bool operator==(const MachOBindEntry &) const;
232 
233   void moveNext();
234 
235 private:
236   friend class MachOObjectFile;
237 
238   void moveToFirst();
239   void moveToEnd();
240   uint64_t readULEB128(const char **error);
241   int64_t readSLEB128(const char **error);
242 
243   Error *E;
244   const MachOObjectFile *O;
245   ArrayRef<uint8_t> Opcodes;
246   const uint8_t *Ptr;
247   uint64_t SegmentOffset = 0;
248   int32_t  SegmentIndex = -1;
249   StringRef SymbolName;
250   bool     LibraryOrdinalSet = false;
251   int      Ordinal = 0;
252   uint32_t Flags = 0;
253   int64_t  Addend = 0;
254   uint64_t RemainingLoopCount = 0;
255   uint64_t AdvanceAmount = 0;
256   uint8_t  BindType = 0;
257   uint8_t  PointerSize;
258   Kind     TableKind;
259   bool     Done = false;
260 };
261 using bind_iterator = content_iterator<MachOBindEntry>;
262 
263 /// ChainedFixupTarget holds all the information about an external symbol
264 /// necessary to bind this binary to that symbol. These values are referenced
265 /// indirectly by chained fixup binds. This structure captures values from all
266 /// import and symbol formats.
267 ///
268 /// Be aware there are two notions of weak here:
269 ///   WeakImport == true
270 ///     The associated bind may be set to 0 if this symbol is missing from its
271 ///     parent library. This is called a "weak import."
272 ///   LibOrdinal == BIND_SPECIAL_DYLIB_WEAK_LOOKUP
273 ///     This symbol may be coalesced with other libraries vending the same
274 ///     symbol. E.g., C++'s "operator new". This is called a "weak bind."
275 struct ChainedFixupTarget {
276 public:
ChainedFixupTargetChainedFixupTarget277   ChainedFixupTarget(int LibOrdinal, uint32_t NameOffset, StringRef Symbol,
278                      uint64_t Addend, bool WeakImport)
279       : LibOrdinal(LibOrdinal), NameOffset(NameOffset), SymbolName(Symbol),
280         Addend(Addend), WeakImport(WeakImport) {}
281 
libOrdinalChainedFixupTarget282   int libOrdinal() { return LibOrdinal; }
nameOffsetChainedFixupTarget283   uint32_t nameOffset() { return NameOffset; }
symbolNameChainedFixupTarget284   StringRef symbolName() { return SymbolName; }
addendChainedFixupTarget285   uint64_t addend() { return Addend; }
weakImportChainedFixupTarget286   bool weakImport() { return WeakImport; }
weakBindChainedFixupTarget287   bool weakBind() {
288     return LibOrdinal == MachO::BIND_SPECIAL_DYLIB_WEAK_LOOKUP;
289   }
290 
291 private:
292   int LibOrdinal;
293   uint32_t NameOffset;
294   StringRef SymbolName;
295   uint64_t Addend;
296   bool WeakImport;
297 };
298 
299 struct ChainedFixupsSegment {
ChainedFixupsSegmentChainedFixupsSegment300   ChainedFixupsSegment(uint8_t SegIdx, uint32_t Offset,
301                        const MachO::dyld_chained_starts_in_segment &Header,
302                        std::vector<uint16_t> &&PageStarts)
303       : SegIdx(SegIdx), Offset(Offset), Header(Header),
304         PageStarts(PageStarts){};
305 
306   uint32_t SegIdx;
307   uint32_t Offset; // dyld_chained_starts_in_image::seg_info_offset[SegIdx]
308   MachO::dyld_chained_starts_in_segment Header;
309   std::vector<uint16_t> PageStarts; // page_start[] entries, host endianness
310 };
311 
312 /// MachOAbstractFixupEntry is an abstract class representing a fixup in a
313 /// MH_DYLDLINK file. Fixups generally represent rebases and binds. Binds also
314 /// subdivide into additional subtypes (weak, lazy, reexport).
315 ///
316 /// The two concrete subclasses of MachOAbstractFixupEntry are:
317 ///
318 ///   MachORebaseBindEntry   - for dyld opcode-based tables, including threaded-
319 ///                            rebase, where rebases are mixed in with other
320 ///                            bind opcodes.
321 ///   MachOChainedFixupEntry - for pointer chains embedded in data pages.
322 class MachOAbstractFixupEntry {
323 public:
324   MachOAbstractFixupEntry(Error *Err, const MachOObjectFile *O);
325 
326   int32_t segmentIndex() const;
327   uint64_t segmentOffset() const;
328   uint64_t segmentAddress() const;
329   StringRef segmentName() const;
330   StringRef sectionName() const;
331   StringRef typeName() const;
332   StringRef symbolName() const;
333   uint32_t flags() const;
334   int64_t addend() const;
335   int ordinal() const;
336 
337   /// \return the location of this fixup as a VM Address. For the VM
338   /// Address this fixup is pointing to, use pointerValue().
339   uint64_t address() const;
340 
341   /// \return the VM Address pointed to by this fixup. Use
342   /// pointerValue() to compare against other VM Addresses, such as
343   /// section addresses or segment vmaddrs.
pointerValue()344   uint64_t pointerValue() const { return PointerValue; }
345 
346   /// \return the raw "on-disk" representation of the fixup. For
347   /// Threaded rebases and Chained pointers these values are generally
348   /// encoded into various different pointer formats. This value is
349   /// exposed in API for tools that want to display and annotate the
350   /// raw bits.
rawValue()351   uint64_t rawValue() const { return RawValue; }
352 
353   void moveNext();
354 
355 protected:
356   Error *E;
357   const MachOObjectFile *O;
358   uint64_t SegmentOffset = 0;
359   int32_t SegmentIndex = -1;
360   StringRef SymbolName;
361   int32_t Ordinal = 0;
362   uint32_t Flags = 0;
363   int64_t Addend = 0;
364   uint64_t PointerValue = 0;
365   uint64_t RawValue = 0;
366   bool Done = false;
367 
368   void moveToFirst();
369   void moveToEnd();
370 
371   /// \return the vm address of the start of __TEXT segment.
textAddress()372   uint64_t textAddress() const { return TextAddress; }
373 
374 private:
375   uint64_t TextAddress;
376 };
377 
378 class MachOChainedFixupEntry : public MachOAbstractFixupEntry {
379 public:
380   enum class FixupKind { Bind, Rebase };
381 
382   MachOChainedFixupEntry(Error *Err, const MachOObjectFile *O, bool Parse);
383 
384   bool operator==(const MachOChainedFixupEntry &) const;
385 
isBind()386   bool isBind() const { return Kind == FixupKind::Bind; }
isRebase()387   bool isRebase() const { return Kind == FixupKind::Rebase; }
388 
389   void moveNext();
390   void moveToFirst();
391   void moveToEnd();
392 
393 private:
394   void findNextPageWithFixups();
395 
396   std::vector<ChainedFixupTarget> FixupTargets;
397   std::vector<ChainedFixupsSegment> Segments;
398   ArrayRef<uint8_t> SegmentData;
399   FixupKind Kind;
400   uint32_t InfoSegIndex = 0; // Index into Segments
401   uint32_t PageIndex = 0;    // Index into Segments[InfoSegIdx].PageStarts
402   uint32_t PageOffset = 0;   // Page offset of the current fixup
403 };
404 using fixup_iterator = content_iterator<MachOChainedFixupEntry>;
405 
406 class MachOObjectFile : public ObjectFile {
407 public:
408   struct LoadCommandInfo {
409     const char *Ptr;      // Where in memory the load command is.
410     MachO::load_command C; // The command itself.
411   };
412   using LoadCommandList = SmallVector<LoadCommandInfo, 4>;
413   using load_command_iterator = LoadCommandList::const_iterator;
414 
415   static Expected<std::unique_ptr<MachOObjectFile>>
416   create(MemoryBufferRef Object, bool IsLittleEndian, bool Is64Bits,
417          uint32_t UniversalCputype = 0, uint32_t UniversalIndex = 0);
418 
419   static bool isMachOPairedReloc(uint64_t RelocType, uint64_t Arch);
420 
421   void moveSymbolNext(DataRefImpl &Symb) const override;
422 
423   uint64_t getNValue(DataRefImpl Sym) const;
424   Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
425 
426   // MachO specific.
427   Error checkSymbolTable() const;
428 
429   std::error_code getIndirectName(DataRefImpl Symb, StringRef &Res) const;
430   unsigned getSectionType(SectionRef Sec) const;
431 
432   Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
433   uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
434   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
435   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
436   Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override;
437   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
438   unsigned getSymbolSectionID(SymbolRef Symb) const;
439   unsigned getSectionID(SectionRef Sec) const;
440 
441   void moveSectionNext(DataRefImpl &Sec) const override;
442   Expected<StringRef> getSectionName(DataRefImpl Sec) const override;
443   uint64_t getSectionAddress(DataRefImpl Sec) const override;
444   uint64_t getSectionIndex(DataRefImpl Sec) const override;
445   uint64_t getSectionSize(DataRefImpl Sec) const override;
446   ArrayRef<uint8_t> getSectionContents(uint32_t Offset, uint64_t Size) const;
447   Expected<ArrayRef<uint8_t>>
448   getSectionContents(DataRefImpl Sec) const override;
449   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
450   Expected<SectionRef> getSection(unsigned SectionIndex) const;
451   Expected<SectionRef> getSection(StringRef SectionName) const;
452   bool isSectionCompressed(DataRefImpl Sec) const override;
453   bool isSectionText(DataRefImpl Sec) const override;
454   bool isSectionData(DataRefImpl Sec) const override;
455   bool isSectionBSS(DataRefImpl Sec) const override;
456   bool isSectionVirtual(DataRefImpl Sec) const override;
457   bool isSectionBitcode(DataRefImpl Sec) const override;
458   bool isDebugSection(DataRefImpl Sec) const override;
459 
460   /// Return the raw contents of an entire segment.
461   ArrayRef<uint8_t> getSegmentContents(StringRef SegmentName) const;
462   ArrayRef<uint8_t> getSegmentContents(size_t SegmentIndex) const;
463 
464   /// When dsymutil generates the companion file, it strips all unnecessary
465   /// sections (e.g. everything in the _TEXT segment) by omitting their body
466   /// and setting the offset in their corresponding load command to zero.
467   ///
468   /// While the load command itself is valid, reading the section corresponds
469   /// to reading the number of bytes specified in the load command, starting
470   /// from offset 0 (i.e. the Mach-O header at the beginning of the file).
471   bool isSectionStripped(DataRefImpl Sec) const override;
472 
473   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
474   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
475 
476   relocation_iterator extrel_begin() const;
477   relocation_iterator extrel_end() const;
external_relocations()478   iterator_range<relocation_iterator> external_relocations() const {
479     return make_range(extrel_begin(), extrel_end());
480   }
481 
482   relocation_iterator locrel_begin() const;
483   relocation_iterator locrel_end() const;
484 
485   void moveRelocationNext(DataRefImpl &Rel) const override;
486   uint64_t getRelocationOffset(DataRefImpl Rel) const override;
487   symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
488   section_iterator getRelocationSection(DataRefImpl Rel) const;
489   uint64_t getRelocationType(DataRefImpl Rel) const override;
490   void getRelocationTypeName(DataRefImpl Rel,
491                              SmallVectorImpl<char> &Result) const override;
492   uint8_t getRelocationLength(DataRefImpl Rel) const;
493 
494   // MachO specific.
495   std::error_code getLibraryShortNameByIndex(unsigned Index, StringRef &) const;
496   uint32_t getLibraryCount() const;
497 
498   section_iterator getRelocationRelocatedSection(relocation_iterator Rel) const;
499 
500   // TODO: Would be useful to have an iterator based version
501   // of the load command interface too.
502 
503   basic_symbol_iterator symbol_begin() const override;
504   basic_symbol_iterator symbol_end() const override;
505 
506   // MachO specific.
507   symbol_iterator getSymbolByIndex(unsigned Index) const;
508   uint64_t getSymbolIndex(DataRefImpl Symb) const;
509 
510   section_iterator section_begin() const override;
511   section_iterator section_end() const override;
512 
513   uint8_t getBytesInAddress() const override;
514 
515   StringRef getFileFormatName() const override;
516   Triple::ArchType getArch() const override;
getFeatures()517   Expected<SubtargetFeatures> getFeatures() const override {
518     return SubtargetFeatures();
519   }
520   Triple getArchTriple(const char **McpuDefault = nullptr) const;
521 
522   relocation_iterator section_rel_begin(unsigned Index) const;
523   relocation_iterator section_rel_end(unsigned Index) const;
524 
525   dice_iterator begin_dices() const;
526   dice_iterator end_dices() const;
527 
528   load_command_iterator begin_load_commands() const;
529   load_command_iterator end_load_commands() const;
530   iterator_range<load_command_iterator> load_commands() const;
531 
532   /// For use iterating over all exported symbols.
533   iterator_range<export_iterator> exports(Error &Err) const;
534 
535   /// For use examining a trie not in a MachOObjectFile.
536   static iterator_range<export_iterator> exports(Error &Err,
537                                                  ArrayRef<uint8_t> Trie,
538                                                  const MachOObjectFile *O =
539                                                                       nullptr);
540 
541   /// For use iterating over all rebase table entries.
542   iterator_range<rebase_iterator> rebaseTable(Error &Err);
543 
544   /// For use examining rebase opcodes in a MachOObjectFile.
545   static iterator_range<rebase_iterator> rebaseTable(Error &Err,
546                                                      MachOObjectFile *O,
547                                                      ArrayRef<uint8_t> Opcodes,
548                                                      bool is64);
549 
550   /// For use iterating over all bind table entries.
551   iterator_range<bind_iterator> bindTable(Error &Err);
552 
553   /// For iterating over all chained fixups.
554   iterator_range<fixup_iterator> fixupTable(Error &Err);
555 
556   /// For use iterating over all lazy bind table entries.
557   iterator_range<bind_iterator> lazyBindTable(Error &Err);
558 
559   /// For use iterating over all weak bind table entries.
560   iterator_range<bind_iterator> weakBindTable(Error &Err);
561 
562   /// For use examining bind opcodes in a MachOObjectFile.
563   static iterator_range<bind_iterator> bindTable(Error &Err,
564                                                  MachOObjectFile *O,
565                                                  ArrayRef<uint8_t> Opcodes,
566                                                  bool is64,
567                                                  MachOBindEntry::Kind);
568 
569   // Given a SegIndex, SegOffset, and PointerSize, verify a valid section exists
570   // that fully contains a pointer at that location. Multiple fixups in a bind
571   // (such as with the BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB opcode) can
572   // be tested via the Count and Skip parameters.
573   //
574   // This is used by MachOBindEntry::moveNext() to validate a MachOBindEntry.
575   const char *BindEntryCheckSegAndOffsets(int32_t SegIndex, uint64_t SegOffset,
576                                          uint8_t PointerSize, uint32_t Count=1,
577                                           uint32_t Skip=0) const {
578     return BindRebaseSectionTable->checkSegAndOffsets(SegIndex, SegOffset,
579                                                      PointerSize, Count, Skip);
580   }
581 
582   // Given a SegIndex, SegOffset, and PointerSize, verify a valid section exists
583   // that fully contains a pointer at that location. Multiple fixups in a rebase
584   // (such as with the REBASE_OPCODE_DO_*_TIMES* opcodes) can be tested via the
585   // Count and Skip parameters.
586   //
587   // This is used by MachORebaseEntry::moveNext() to validate a MachORebaseEntry
588   const char *RebaseEntryCheckSegAndOffsets(int32_t SegIndex,
589                                             uint64_t SegOffset,
590                                             uint8_t PointerSize,
591                                             uint32_t Count=1,
592                                             uint32_t Skip=0) const {
593     return BindRebaseSectionTable->checkSegAndOffsets(SegIndex, SegOffset,
594                                                       PointerSize, Count, Skip);
595   }
596 
597   /// For use with the SegIndex of a checked Mach-O Bind or Rebase entry to
598   /// get the segment name.
BindRebaseSegmentName(int32_t SegIndex)599   StringRef BindRebaseSegmentName(int32_t SegIndex) const {
600     return BindRebaseSectionTable->segmentName(SegIndex);
601   }
602 
603   /// For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or
604   /// Rebase entry to get the section name.
BindRebaseSectionName(uint32_t SegIndex,uint64_t SegOffset)605   StringRef BindRebaseSectionName(uint32_t SegIndex, uint64_t SegOffset) const {
606     return BindRebaseSectionTable->sectionName(SegIndex, SegOffset);
607   }
608 
609   /// For use with a SegIndex,SegOffset pair from a checked Mach-O Bind or
610   /// Rebase entry to get the address.
BindRebaseAddress(uint32_t SegIndex,uint64_t SegOffset)611   uint64_t BindRebaseAddress(uint32_t SegIndex, uint64_t SegOffset) const {
612     return BindRebaseSectionTable->address(SegIndex, SegOffset);
613   }
614 
615   // In a MachO file, sections have a segment name. This is used in the .o
616   // files. They have a single segment, but this field specifies which segment
617   // a section should be put in the final object.
618   StringRef getSectionFinalSegmentName(DataRefImpl Sec) const;
619 
620   // Names are stored as 16 bytes. These returns the raw 16 bytes without
621   // interpreting them as a C string.
622   ArrayRef<char> getSectionRawName(DataRefImpl Sec) const;
623   ArrayRef<char> getSectionRawFinalSegmentName(DataRefImpl Sec) const;
624 
625   // MachO specific Info about relocations.
626   bool isRelocationScattered(const MachO::any_relocation_info &RE) const;
627   unsigned getPlainRelocationSymbolNum(
628                                     const MachO::any_relocation_info &RE) const;
629   bool getPlainRelocationExternal(const MachO::any_relocation_info &RE) const;
630   bool getScatteredRelocationScattered(
631                                     const MachO::any_relocation_info &RE) const;
632   uint32_t getScatteredRelocationValue(
633                                     const MachO::any_relocation_info &RE) const;
634   uint32_t getScatteredRelocationType(
635                                     const MachO::any_relocation_info &RE) const;
636   unsigned getAnyRelocationAddress(const MachO::any_relocation_info &RE) const;
637   unsigned getAnyRelocationPCRel(const MachO::any_relocation_info &RE) const;
638   unsigned getAnyRelocationLength(const MachO::any_relocation_info &RE) const;
639   unsigned getAnyRelocationType(const MachO::any_relocation_info &RE) const;
640   SectionRef getAnyRelocationSection(const MachO::any_relocation_info &RE) const;
641 
642   // MachO specific structures.
643   MachO::section getSection(DataRefImpl DRI) const;
644   MachO::section_64 getSection64(DataRefImpl DRI) const;
645   MachO::section getSection(const LoadCommandInfo &L, unsigned Index) const;
646   MachO::section_64 getSection64(const LoadCommandInfo &L,unsigned Index) const;
647   MachO::nlist getSymbolTableEntry(DataRefImpl DRI) const;
648   MachO::nlist_64 getSymbol64TableEntry(DataRefImpl DRI) const;
649 
650   MachO::linkedit_data_command
651   getLinkeditDataLoadCommand(const LoadCommandInfo &L) const;
652   MachO::segment_command
653   getSegmentLoadCommand(const LoadCommandInfo &L) const;
654   MachO::segment_command_64
655   getSegment64LoadCommand(const LoadCommandInfo &L) const;
656   MachO::linker_option_command
657   getLinkerOptionLoadCommand(const LoadCommandInfo &L) const;
658   MachO::version_min_command
659   getVersionMinLoadCommand(const LoadCommandInfo &L) const;
660   MachO::note_command
661   getNoteLoadCommand(const LoadCommandInfo &L) const;
662   MachO::build_version_command
663   getBuildVersionLoadCommand(const LoadCommandInfo &L) const;
664   MachO::build_tool_version
665   getBuildToolVersion(unsigned index) const;
666   MachO::dylib_command
667   getDylibIDLoadCommand(const LoadCommandInfo &L) const;
668   MachO::dyld_info_command
669   getDyldInfoLoadCommand(const LoadCommandInfo &L) const;
670   MachO::dylinker_command
671   getDylinkerCommand(const LoadCommandInfo &L) const;
672   MachO::uuid_command
673   getUuidCommand(const LoadCommandInfo &L) const;
674   MachO::rpath_command
675   getRpathCommand(const LoadCommandInfo &L) const;
676   MachO::source_version_command
677   getSourceVersionCommand(const LoadCommandInfo &L) const;
678   MachO::entry_point_command
679   getEntryPointCommand(const LoadCommandInfo &L) const;
680   MachO::encryption_info_command
681   getEncryptionInfoCommand(const LoadCommandInfo &L) const;
682   MachO::encryption_info_command_64
683   getEncryptionInfoCommand64(const LoadCommandInfo &L) const;
684   MachO::sub_framework_command
685   getSubFrameworkCommand(const LoadCommandInfo &L) const;
686   MachO::sub_umbrella_command
687   getSubUmbrellaCommand(const LoadCommandInfo &L) const;
688   MachO::sub_library_command
689   getSubLibraryCommand(const LoadCommandInfo &L) const;
690   MachO::sub_client_command
691   getSubClientCommand(const LoadCommandInfo &L) const;
692   MachO::routines_command
693   getRoutinesCommand(const LoadCommandInfo &L) const;
694   MachO::routines_command_64
695   getRoutinesCommand64(const LoadCommandInfo &L) const;
696   MachO::thread_command
697   getThreadCommand(const LoadCommandInfo &L) const;
698 
699   MachO::any_relocation_info getRelocation(DataRefImpl Rel) const;
700   MachO::data_in_code_entry getDice(DataRefImpl Rel) const;
701   const MachO::mach_header &getHeader() const;
702   const MachO::mach_header_64 &getHeader64() const;
703   uint32_t
704   getIndirectSymbolTableEntry(const MachO::dysymtab_command &DLC,
705                               unsigned Index) const;
706   MachO::data_in_code_entry getDataInCodeTableEntry(uint32_t DataOffset,
707                                                     unsigned Index) const;
708   MachO::symtab_command getSymtabLoadCommand() const;
709   MachO::dysymtab_command getDysymtabLoadCommand() const;
710   MachO::linkedit_data_command getDataInCodeLoadCommand() const;
711   MachO::linkedit_data_command getLinkOptHintsLoadCommand() const;
712   ArrayRef<uint8_t> getDyldInfoRebaseOpcodes() const;
713   ArrayRef<uint8_t> getDyldInfoBindOpcodes() const;
714   ArrayRef<uint8_t> getDyldInfoWeakBindOpcodes() const;
715   ArrayRef<uint8_t> getDyldInfoLazyBindOpcodes() const;
716   ArrayRef<uint8_t> getDyldInfoExportsTrie() const;
717 
718   /// If the optional is None, no header was found, but the object was
719   /// well-formed.
720   Expected<std::optional<MachO::dyld_chained_fixups_header>>
721   getChainedFixupsHeader() const;
722   Expected<std::vector<ChainedFixupTarget>> getDyldChainedFixupTargets() const;
723 
724   // Note: This is a limited, temporary API, which will be removed when Apple
725   // upstreams their implementation. Please do not rely on this.
726   Expected<std::optional<MachO::linkedit_data_command>>
727   getChainedFixupsLoadCommand() const;
728   // Returns the number of sections listed in dyld_chained_starts_in_image, and
729   // a ChainedFixupsSegment for each segment that has fixups.
730   Expected<std::pair<size_t, std::vector<ChainedFixupsSegment>>>
731   getChainedFixupsSegments() const;
732   ArrayRef<uint8_t> getDyldExportsTrie() const;
733 
734   SmallVector<uint64_t> getFunctionStarts() const;
735   ArrayRef<uint8_t> getUuid() const;
736 
737   StringRef getStringTableData() const;
738   bool is64Bit() const;
739   void ReadULEB128s(uint64_t Index, SmallVectorImpl<uint64_t> &Out) const;
740 
741   static StringRef guessLibraryShortName(StringRef Name, bool &isFramework,
742                                          StringRef &Suffix);
743 
744   static Triple::ArchType getArch(uint32_t CPUType, uint32_t CPUSubType);
745   static Triple getArchTriple(uint32_t CPUType, uint32_t CPUSubType,
746                               const char **McpuDefault = nullptr,
747                               const char **ArchFlag = nullptr);
748   static bool isValidArch(StringRef ArchFlag);
749   static ArrayRef<StringRef> getValidArchs();
750   static Triple getHostArch();
751 
752   bool isRelocatableObject() const override;
753 
754   StringRef mapDebugSectionName(StringRef Name) const override;
755 
756   llvm::binaryformat::Swift5ReflectionSectionKind
757   mapReflectionSectionNameToEnumValue(StringRef SectionName) const override;
758 
hasPageZeroSegment()759   bool hasPageZeroSegment() const { return HasPageZeroSegment; }
760 
classof(const Binary * v)761   static bool classof(const Binary *v) {
762     return v->isMachO();
763   }
764 
765   static uint32_t
getVersionMinMajor(MachO::version_min_command & C,bool SDK)766   getVersionMinMajor(MachO::version_min_command &C, bool SDK) {
767     uint32_t VersionOrSDK = (SDK) ? C.sdk : C.version;
768     return (VersionOrSDK >> 16) & 0xffff;
769   }
770 
771   static uint32_t
getVersionMinMinor(MachO::version_min_command & C,bool SDK)772   getVersionMinMinor(MachO::version_min_command &C, bool SDK) {
773     uint32_t VersionOrSDK = (SDK) ? C.sdk : C.version;
774     return (VersionOrSDK >> 8) & 0xff;
775   }
776 
777   static uint32_t
getVersionMinUpdate(MachO::version_min_command & C,bool SDK)778   getVersionMinUpdate(MachO::version_min_command &C, bool SDK) {
779     uint32_t VersionOrSDK = (SDK) ? C.sdk : C.version;
780     return VersionOrSDK & 0xff;
781   }
782 
getBuildPlatform(uint32_t platform)783   static std::string getBuildPlatform(uint32_t platform) {
784     switch (platform) {
785     case MachO::PLATFORM_MACOS: return "macos";
786     case MachO::PLATFORM_IOS: return "ios";
787     case MachO::PLATFORM_TVOS: return "tvos";
788     case MachO::PLATFORM_WATCHOS: return "watchos";
789     case MachO::PLATFORM_BRIDGEOS: return "bridgeos";
790     case MachO::PLATFORM_MACCATALYST: return "macCatalyst";
791     case MachO::PLATFORM_IOSSIMULATOR: return "iossimulator";
792     case MachO::PLATFORM_TVOSSIMULATOR: return "tvossimulator";
793     case MachO::PLATFORM_WATCHOSSIMULATOR: return "watchossimulator";
794     case MachO::PLATFORM_DRIVERKIT: return "driverkit";
795     default:
796       std::string ret;
797       raw_string_ostream ss(ret);
798       ss << format_hex(platform, 8, true);
799       return ss.str();
800     }
801   }
802 
getBuildTool(uint32_t tools)803   static std::string getBuildTool(uint32_t tools) {
804     switch (tools) {
805     case MachO::TOOL_CLANG: return "clang";
806     case MachO::TOOL_SWIFT: return "swift";
807     case MachO::TOOL_LD: return "ld";
808     default:
809       std::string ret;
810       raw_string_ostream ss(ret);
811       ss << format_hex(tools, 8, true);
812       return ss.str();
813     }
814   }
815 
getVersionString(uint32_t version)816   static std::string getVersionString(uint32_t version) {
817     uint32_t major = (version >> 16) & 0xffff;
818     uint32_t minor = (version >> 8) & 0xff;
819     uint32_t update = version & 0xff;
820 
821     SmallString<32> Version;
822     Version = utostr(major) + "." + utostr(minor);
823     if (update != 0)
824       Version += "." + utostr(update);
825     return std::string(std::string(Version.str()));
826   }
827 
828   /// If the input path is a .dSYM bundle (as created by the dsymutil tool),
829   /// return the paths to the object files found in the bundle, otherwise return
830   /// an empty vector. If the path appears to be a .dSYM bundle but no objects
831   /// were found or there was a filesystem error, then return an error.
832   static Expected<std::vector<std::string>>
833   findDsymObjectMembers(StringRef Path);
834 
835 private:
836   MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian, bool Is64Bits,
837                   Error &Err, uint32_t UniversalCputype = 0,
838                   uint32_t UniversalIndex = 0);
839 
840   uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
841 
842   union {
843     MachO::mach_header_64 Header64;
844     MachO::mach_header Header;
845   };
846   using SectionList = SmallVector<const char*, 1>;
847   SectionList Sections;
848   using LibraryList = SmallVector<const char*, 1>;
849   LibraryList Libraries;
850   LoadCommandList LoadCommands;
851   using LibraryShortName = SmallVector<StringRef, 1>;
852   using BuildToolList = SmallVector<const char*, 1>;
853   BuildToolList BuildTools;
854   mutable LibraryShortName LibrariesShortNames;
855   std::unique_ptr<BindRebaseSegInfo> BindRebaseSectionTable;
856   const char *SymtabLoadCmd = nullptr;
857   const char *DysymtabLoadCmd = nullptr;
858   const char *DataInCodeLoadCmd = nullptr;
859   const char *LinkOptHintsLoadCmd = nullptr;
860   const char *DyldInfoLoadCmd = nullptr;
861   const char *FuncStartsLoadCmd = nullptr;
862   const char *DyldChainedFixupsLoadCmd = nullptr;
863   const char *DyldExportsTrieLoadCmd = nullptr;
864   const char *UuidLoadCmd = nullptr;
865   bool HasPageZeroSegment = false;
866 };
867 
868 /// DiceRef
DiceRef(DataRefImpl DiceP,const ObjectFile * Owner)869 inline DiceRef::DiceRef(DataRefImpl DiceP, const ObjectFile *Owner)
870   : DicePimpl(DiceP) , OwningObject(Owner) {}
871 
872 inline bool DiceRef::operator==(const DiceRef &Other) const {
873   return DicePimpl == Other.DicePimpl;
874 }
875 
876 inline bool DiceRef::operator<(const DiceRef &Other) const {
877   return DicePimpl < Other.DicePimpl;
878 }
879 
moveNext()880 inline void DiceRef::moveNext() {
881   const MachO::data_in_code_entry *P =
882     reinterpret_cast<const MachO::data_in_code_entry *>(DicePimpl.p);
883   DicePimpl.p = reinterpret_cast<uintptr_t>(P + 1);
884 }
885 
886 // Since a Mach-O data in code reference, a DiceRef, can only be created when
887 // the OwningObject ObjectFile is a MachOObjectFile a static_cast<> is used for
888 // the methods that get the values of the fields of the reference.
889 
getOffset(uint32_t & Result)890 inline std::error_code DiceRef::getOffset(uint32_t &Result) const {
891   const MachOObjectFile *MachOOF =
892     static_cast<const MachOObjectFile *>(OwningObject);
893   MachO::data_in_code_entry Dice = MachOOF->getDice(DicePimpl);
894   Result = Dice.offset;
895   return std::error_code();
896 }
897 
getLength(uint16_t & Result)898 inline std::error_code DiceRef::getLength(uint16_t &Result) const {
899   const MachOObjectFile *MachOOF =
900     static_cast<const MachOObjectFile *>(OwningObject);
901   MachO::data_in_code_entry Dice = MachOOF->getDice(DicePimpl);
902   Result = Dice.length;
903   return std::error_code();
904 }
905 
getKind(uint16_t & Result)906 inline std::error_code DiceRef::getKind(uint16_t &Result) const {
907   const MachOObjectFile *MachOOF =
908     static_cast<const MachOObjectFile *>(OwningObject);
909   MachO::data_in_code_entry Dice = MachOOF->getDice(DicePimpl);
910   Result = Dice.kind;
911   return std::error_code();
912 }
913 
getRawDataRefImpl()914 inline DataRefImpl DiceRef::getRawDataRefImpl() const {
915   return DicePimpl;
916 }
917 
getObjectFile()918 inline const ObjectFile *DiceRef::getObjectFile() const {
919   return OwningObject;
920 }
921 
922 } // end namespace object
923 } // end namespace llvm
924 
925 #endif // LLVM_OBJECT_MACHO_H
926