--- a/lld/MachO/Target.h	Mon May 25 11:55:54 2020 +0900
+++ b/lld/MachO/Target.h	Tue Jun 08 06:07:14 2021 +0900
@@ -9,55 +9,130 @@
 #ifndef LLD_MACHO_TARGET_H
 #define LLD_MACHO_TARGET_H
 
+#include "MachOStructs.h"
+#include "Relocations.h"
+
+#include "llvm/ADT/BitmaskEnum.h"
+#include "llvm/BinaryFormat/MachO.h"
+#include "llvm/Support/MemoryBuffer.h"
+
 #include <cstddef>
 #include <cstdint>
 
 namespace lld {
 namespace macho {
-
-class DylibSymbol;
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
-enum {
-  // We are currently only supporting 64-bit targets since macOS and iOS are
-  // deprecating 32-bit apps.
-  WordSize = 8,
-  PageSize = 4096,
-  ImageBase = 4096,
-  MaxAlignmentPowerOf2 = 32,
-};
+class Symbol;
+class Defined;
+class DylibSymbol;
+class InputSection;
 
 class TargetInfo {
 public:
+  template <class LP> TargetInfo(LP) {
+    // Having these values available in TargetInfo allows us to access them
+    // without having to resort to templates.
+    magic = LP::magic;
+    pageZeroSize = LP::pageZeroSize;
+    headerSize = sizeof(typename LP::mach_header);
+    wordSize = LP::wordSize;
+  }
+
   virtual ~TargetInfo() = default;
 
-  virtual uint64_t getImplicitAddend(const uint8_t *loc,
-                                     uint8_t type) const = 0;
-  virtual void relocateOne(uint8_t *loc, uint8_t type, uint64_t val) const = 0;
+  // Validate the relocation structure and get its addend.
+  virtual int64_t
+  getEmbeddedAddend(llvm::MemoryBufferRef, uint64_t offset,
+                    const llvm::MachO::relocation_info) const = 0;
+  virtual void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
+                           uint64_t relocVA) const = 0;
 
   // Write code for lazy binding. See the comments on StubsSection for more
   // details.
-  virtual void writeStub(uint8_t *buf, const DylibSymbol &) const = 0;
+  virtual void writeStub(uint8_t *buf, const Symbol &) const = 0;
   virtual void writeStubHelperHeader(uint8_t *buf) const = 0;
   virtual void writeStubHelperEntry(uint8_t *buf, const DylibSymbol &,
                                     uint64_t entryAddr) const = 0;
 
-  // Dylib symbols are referenced via either the GOT or the stubs section,
-  // depending on the relocation type. prepareDylibSymbolRelocation() will set
-  // up the GOT/stubs entries, and getDylibSymbolVA() will return the addresses
-  // of those entries.
-  virtual void prepareDylibSymbolRelocation(DylibSymbol &, uint8_t type) = 0;
-  virtual uint64_t getDylibSymbolVA(const DylibSymbol &,
-                                    uint8_t type) const = 0;
+  // Symbols may be referenced via either the GOT or the stubs section,
+  // depending on the relocation type. prepareSymbolRelocation() will set up the
+  // GOT/stubs entries, and resolveSymbolVA() will return the addresses of those
+  // entries. resolveSymbolVA() may also relax the target instructions to save
+  // on a level of address indirection.
+  virtual void relaxGotLoad(uint8_t *loc, uint8_t type) const = 0;
+
+  virtual const RelocAttrs &getRelocAttrs(uint8_t type) const = 0;
+
+  virtual uint64_t getPageSize() const = 0;
 
-  uint32_t cpuType;
+  virtual void populateThunk(InputSection *thunk, Symbol *funcSym) {
+    llvm_unreachable("target does not use thunks");
+  }
+
+  bool hasAttr(uint8_t type, RelocAttrBits bit) const {
+    return getRelocAttrs(type).hasAttr(bit);
+  }
+
+  bool usesThunks() const { return thunkSize > 0; }
+
+  uint32_t magic;
+  llvm::MachO::CPUType cpuType;
   uint32_t cpuSubtype;
 
+  uint64_t pageZeroSize;
+  size_t headerSize;
   size_t stubSize;
   size_t stubHelperHeaderSize;
   size_t stubHelperEntrySize;
+  size_t wordSize;
+
+  size_t thunkSize = 0;
+  uint64_t branchRange = 0;
+
+  // We contrive this value as sufficiently far from any valid address that it
+  // will always be out-of-range for any architecture. UINT64_MAX is not a
+  // good choice because it is (a) only 1 away from wrapping to 0, and (b) the
+  // tombstone value for DenseMap<> and caused weird assertions for me.
+  static constexpr uint64_t outOfRangeVA = 0xfull << 60;
 };
 
 TargetInfo *createX86_64TargetInfo();
+TargetInfo *createARM64TargetInfo();
+TargetInfo *createARM64_32TargetInfo();
+TargetInfo *createARMTargetInfo(uint32_t cpuSubtype);
+
+struct LP64 {
+  using mach_header = llvm::MachO::mach_header_64;
+  using nlist = structs::nlist_64;
+  using segment_command = llvm::MachO::segment_command_64;
+  using section = llvm::MachO::section_64;
+  using encryption_info_command = llvm::MachO::encryption_info_command_64;
+
+  static constexpr uint32_t magic = llvm::MachO::MH_MAGIC_64;
+  static constexpr uint32_t segmentLCType = llvm::MachO::LC_SEGMENT_64;
+  static constexpr uint32_t encryptionInfoLCType =
+      llvm::MachO::LC_ENCRYPTION_INFO_64;
+
+  static constexpr uint64_t pageZeroSize = 1ull << 32;
+  static constexpr size_t wordSize = 8;
+};
+
+struct ILP32 {
+  using mach_header = llvm::MachO::mach_header;
+  using nlist = structs::nlist;
+  using segment_command = llvm::MachO::segment_command;
+  using section = llvm::MachO::section;
+  using encryption_info_command = llvm::MachO::encryption_info_command;
+
+  static constexpr uint32_t magic = llvm::MachO::MH_MAGIC;
+  static constexpr uint32_t segmentLCType = llvm::MachO::LC_SEGMENT;
+  static constexpr uint32_t encryptionInfoLCType =
+      llvm::MachO::LC_ENCRYPTION_INFO;
+
+  static constexpr uint64_t pageZeroSize = 1ull << 12;
+  static constexpr size_t wordSize = 4;
+};
 
 extern TargetInfo *target;