[lld-macho][nfc] Refactor in preparation for 32-bit support

[int3]

Summary

The main challenge was handling the different on-disk structures (e.g.
mach_header vs mach_header_64). I tried to strike a balance between
sprinkling target->wordSize == 8 checks everywhere (branchy = slow, and ugly)
and templatizing everything (causes code bloat, also ugly). I think I struck a
decent balance by judicious use of type erasure.

Note that LLD-ELF has a similar architecture, though it seems to use more templating.

Linking chromium_framework takes about the same time before and after this
change:

    N           Min           Max        Median           Avg        Stddev
x  20          4.52          4.67         4.595        4.5945   0.044423204
+  20           4.5          4.71         4.575         4.582   0.056344803
No difference proven at 95.0% confidence

[int3]

lld/MachO/Target.h

43

changed this parameter so we wouldn't have to templatize TargetInfo

[int3]

lint

[int3]

tweak

[int3]

tweak

[int3]

tweak

[int3]

rebase

[tschuett]

Please feel free to ignore me, but it looks odd to needle 32bit support through the ARM64 and X86_64 structs. Inheritance? Common base class?

[tschuett]

Is sprinkling templates all over ObjFile better than ObjFile32 and ObjFile64?

[int3]

Please feel free to ignore me, but it looks odd to needle 32bit support through the ARM64 and X86_64 structs. Inheritance? Common base class?

I guess you're referring to the set32BitProperties thing? I was hoping to keep things like target->wordSize a direct field access instead of a virtual method, and I couldn't find a way to do it with inheritance... but maybe virtual methods are the way to go after all.

Is sprinkling templates all over ObjFile better than ObjFile32 and ObjFile64?

Pretty sure yes, otherwise every reference to ObjFile will either need to dispatch between the two, or have templates sprinkled on themselves

[oontvoo]

lld/MachO/Arch/ARM64.cpp

31

seems inconsistent that this parameter has name and the other two don't

49–50

Interesting. How so? (In the previous version I saw you were using uint64_t WordSize = ..., which makes more sense)
Can you explain why using an anonymous enum here is better than that?

lld/MachO/Arch/X86_64.cpp

28

maybe just uint64_t ?

[tschuett]

In D99633#2664082, @int3 wrote:

Please feel free to ignore me, but it looks odd to needle 32bit support through the ARM64 and X86_64 structs. Inheritance? Common base class?

I guess you're referring to the set32BitProperties thing? I was hoping to keep things like target->wordSize a direct field access instead of a virtual method, and I couldn't find a way to do it with inheritance... but maybe virtual methods are the way to go after all.

But target->wordSize also goes through the vtable?
And you are loosing section_64 and have to use the less type-safe offset.

[oontvoo]

lld/MachO/Target.h

90

not to be pedantic, but maybe ILP32 ?

[int3]

But target->wordSize also goes through the vtable?

I don't think that's true...? Why would it?

And you are loosing section_64 and have to use the less type-safe offset.

I don't see how we can avoid this without templatizing TargetInfo.... inheritance / virtual dispatch doesn't get around the problem of having to handle both section and section_64. (And FWIW, LLD-ELF passes offsets to TargetInfo too, presumably for the same reason)

lld/MachO/Arch/ARM64.cpp

31

My philosophy is to avoid redundancy :) MemoryBufferRef mbref is saying the same thing twice, whereas offset actually provides information that uint64_t doesn't

49–50

lint doesn't approve of uint64_t WordSize (it wants wordSize). That would result in it being shadowed by TargetInfo::wordSize. I think this is less ugly than having to use ::wordSize...

Optimization-wise, I think this is the same as using constexpr -- at least, the compiler is able to use the constant value as an immediate in both cases

lld/MachO/Target.h

90

for sure

[int3]

LP32 -> ILP32 + move set32BitProperties to ILP32

[int3]

I do agree that having 32-bit specific code in TargetInfo itself (and its 64-bit child classes) is a bit weird though. So I moved the 32-bit/64-bit property setting code into ILP32 and LP64 respectively, plus made the sole TargetInfo constructor require that one of the two be passed. It's not quite inheritance, and it does require constructing a zero-size struct just for template type inference purposes, but it does the job :)

[int3]

update

[int3]

lld/MachO/Arch/ARM64.cpp

49–50

I moved wordSize into the LP* classes, so we don't have to do this anymore :)

[oontvoo]

LGTM!

lld/MachO/Target.h

32

I wonder if it's possible to have TargetInfo contains all the stuff the LP* structs below have. That way, we don't have to branch on target->wordSize everytime to decide which struct to use .

(doesn't have to be done in this patch)

[int3]

lld/MachO/Target.h

32

We never branch on target->wordSize *just* to access different values though -- we are also doing it for the types. For instance, in the case of segmentLCType, we would have to branch anyway to choose between segment_command and segment_command_64. So I don't think there's any branching we could remove by moving more values from the LP* structs here.

[int3]

LGTM = stamp? :)

[oontvoo]

In D99633#2666577, @int3 wrote:

LGTM = stamp? :)

Yes - I thought maybe @tschuett wanted to stamp ...
But here you go!

lld/MachO/Arch/ARM64.cpp

 using namespace lld;
 using namespace lld::macho;
 
 namespace {
 
 struct ARM64 : TargetInfo {
   ARM64();
 
-  int64_t getEmbeddedAddend(MemoryBufferRef, const section_64 &,
+  int64_t getEmbeddedAddend(MemoryBufferRef, uint64_t offset,
                             const relocation_info) const override;
   void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
                    uint64_t pc) const override;
 
   void writeStub(uint8_t *buf, const Symbol &) const override;
   void writeStubHelperHeader(uint8_t *buf) const override;
   void writeStubHelperEntry(uint8_t *buf, const DylibSymbol &,
                             uint64_t entryAddr) const override;
 
   void relaxGotLoad(uint8_t *loc, uint8_t type) const override;
   const RelocAttrs &getRelocAttrs(uint8_t type) const override;
   uint64_t getPageSize() const override { return 16 * 1024; }
 };
 
 } // namespace
 
 // Random notes on reloc types:
 // ADDEND always pairs with BRANCH26, PAGE21, or PAGEOFF12
 // POINTER_TO_GOT: ld64 supports a 4-byte pc-relative form as well as an 8-byte
 // absolute version of this relocation. The semantics of the absolute relocation
 // are weird -- it results in the value of the GOT slot being written, instead
 // of the address. Let's not support it unless we find a real-world use case.
 
 const RelocAttrs &ARM64::getRelocAttrs(uint8_t type) const {
   static const std::array<RelocAttrs, 11> relocAttrsArray{{
 #define B(x) RelocAttrBits::x
       {"UNSIGNED", B(UNSIGNED) | B(ABSOLUTE) | B(EXTERN) | B(LOCAL) |

 #undef B
   }};
   assert(type < relocAttrsArray.size() && "invalid relocation type");
   if (type >= relocAttrsArray.size())
     return invalidRelocAttrs;
   return relocAttrsArray[type];
 }
 
-int64_t ARM64::getEmbeddedAddend(MemoryBufferRef mb, const section_64 &sec,
+int64_t ARM64::getEmbeddedAddend(MemoryBufferRef mb, uint64_t offset,
                                  const relocation_info rel) const {
   if (rel.r_type != ARM64_RELOC_UNSIGNED &&
       rel.r_type != ARM64_RELOC_SUBTRACTOR) {
     // All other reloc types should use the ADDEND relocation to store their
     // addends.
     // TODO(gkm): extract embedded addend just so we can assert that it is 0
     return 0;
   }
 
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
-  const uint8_t *loc = buf + sec.offset + rel.r_address;
+  const uint8_t *loc = buf + offset + rel.r_address;
   switch (rel.r_length) {
   case 2:
     return static_cast<int32_t>(read32le(loc));
   case 3:
     return read64le(loc);
   default:
     llvm_unreachable("invalid r_length");
   }
static constexpr uint32_t stubCode[] = {
     0xf9400210, // 04: ldr   x16, [x16, __la_symbol_ptr@pageoff]
     0xd61f0200, // 08: br    x16
 };
 
 void ARM64::writeStub(uint8_t *buf8, const Symbol &sym) const {
   auto *buf32 = reinterpret_cast<uint32_t *>(buf8);
   uint64_t pcPageBits =
       pageBits(in.stubs->addr + sym.stubsIndex * sizeof(stubCode));
-  uint64_t lazyPointerVA = in.lazyPointers->addr + sym.stubsIndex * WordSize;
+  uint64_t lazyPointerVA =
+      in.lazyPointers->addr + sym.stubsIndex * LP64::wordSize;
   buf32[0] = encodePage21({&sym, "stub"}, stubCode[0],
                           pageBits(lazyPointerVA) - pcPageBits);
   buf32[1] = encodePageOff12(stubCode[1], lazyPointerVA);
   buf32[2] = stubCode[2];
 }
 
 static constexpr uint32_t stubHelperHeaderCode[] = {
     0x90000011, // 00: adrp  x17, _dyld_private@page
void ARM64::writeStubHelperHeader(uint8_t *buf8) const {
   };
   uint64_t loaderVA = in.imageLoaderCache->getVA();
   SymbolDiagnostic d = {nullptr, "stub header helper"};
   buf32[0] = encodePage21(d, stubHelperHeaderCode[0],
                           pageBits(loaderVA) - pcPageBits(0));
   buf32[1] = encodePageOff12(stubHelperHeaderCode[1], loaderVA);
   buf32[2] = stubHelperHeaderCode[2];
   uint64_t binderVA =
-      in.got->addr + in.stubHelper->stubBinder->gotIndex * WordSize;
+      in.got->addr + in.stubHelper->stubBinder->gotIndex * LP64::wordSize;
   buf32[3] = encodePage21(d, stubHelperHeaderCode[3],
                           pageBits(binderVA) - pcPageBits(3));
   buf32[4] = encodePageOff12(stubHelperHeaderCode[4], binderVA);
   buf32[5] = stubHelperHeaderCode[5];
 }
 
 static constexpr uint32_t stubHelperEntryCode[] = {
     0x18000050, // 00: ldr  w16, l0
void ARM64::relaxGotLoad(uint8_t *loc, uint8_t type) const {
   assert(((instruction >> 10) & 0xfff) == 0 &&
          "non-zero embedded LDR immediate");
   // C6.2.4 ADD (immediate)
   // ADD <Xd|SP>, <Xn|SP>, #<imm>{, <shift>}
   instruction = ((instruction & 0x001fffff) | 0x91000000);
   write32le(loc, instruction);
 }
 
-ARM64::ARM64() {
+ARM64::ARM64() : TargetInfo(LP64()) {
   cpuType = CPU_TYPE_ARM64;
   cpuSubtype = CPU_SUBTYPE_ARM64_ALL;
 
   stubSize = sizeof(stubCode);
   stubHelperHeaderSize = sizeof(stubHelperHeaderCode);
   stubHelperEntrySize = sizeof(stubHelperEntryCode);
 }
 
 TargetInfo *macho::createARM64TargetInfo() {
   static ARM64 t;
   return &t;
 }

lld/MachO/Arch/X86_64.cpp

 using namespace lld;
 using namespace lld::macho;
 
 namespace {
 
 struct X86_64 : TargetInfo {
   X86_64();
 
-  int64_t getEmbeddedAddend(MemoryBufferRef, const section_64 &,
+  int64_t getEmbeddedAddend(MemoryBufferRef, uint64_t offset,
                             const relocation_info) const override;
   void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
                    uint64_t relocVA) const override;
 
   void writeStub(uint8_t *buf, const Symbol &) const override;
   void writeStubHelperHeader(uint8_t *buf) const override;
   void writeStubHelperEntry(uint8_t *buf, const DylibSymbol &,
                             uint64_t entryAddr) const override;
case X86_64_RELOC_SIGNED_2:
     return 2;
   case X86_64_RELOC_SIGNED_4:
     return 4;
   default:
     return 0;
   }
 }
 
-int64_t X86_64::getEmbeddedAddend(MemoryBufferRef mb, const section_64 &sec,
+int64_t X86_64::getEmbeddedAddend(MemoryBufferRef mb, uint64_t offset,
                                   relocation_info rel) const {
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
-  const uint8_t *loc = buf + sec.offset + rel.r_address;
+  const uint8_t *loc = buf + offset + rel.r_address;
 
   switch (rel.r_length) {
   case 2:
     return static_cast<int32_t>(read32le(loc)) + pcrelOffset(rel.r_type);
   case 3:
     return read64le(loc) + pcrelOffset(rel.r_type);
   default:
     llvm_unreachable("invalid r_length");

 static constexpr uint8_t stub[] = {
     0xff, 0x25, 0, 0, 0, 0, // jmpq *__la_symbol_ptr(%rip)
 };
 
 void X86_64::writeStub(uint8_t *buf, const Symbol &sym) const {
   memcpy(buf, stub, 2); // just copy the two nonzero bytes
   uint64_t stubAddr = in.stubs->addr + sym.stubsIndex * sizeof(stub);
   writeRipRelative({&sym, "stub"}, buf, stubAddr, sizeof(stub),
-                   in.lazyPointers->addr + sym.stubsIndex * WordSize);
+                   in.lazyPointers->addr + sym.stubsIndex * LP64::wordSize);
 }
 
 static constexpr uint8_t stubHelperHeader[] = {
     0x4c, 0x8d, 0x1d, 0, 0, 0, 0, // 0x0: leaq ImageLoaderCache(%rip), %r11
     0x41, 0x53,                   // 0x7: pushq %r11
     0xff, 0x25, 0,    0, 0, 0,    // 0x9: jmpq *dyld_stub_binder@GOT(%rip)
     0x90,                         // 0xf: nop
 };
 
 void X86_64::writeStubHelperHeader(uint8_t *buf) const {
   memcpy(buf, stubHelperHeader, sizeof(stubHelperHeader));
   SymbolDiagnostic d = {nullptr, "stub helper header"};
   writeRipRelative(d, buf, in.stubHelper->addr, 7,
                    in.imageLoaderCache->getVA());
   writeRipRelative(d, buf, in.stubHelper->addr, 0xf,
                    in.got->addr +
-                       in.stubHelper->stubBinder->gotIndex * WordSize);
+                       in.stubHelper->stubBinder->gotIndex * LP64::wordSize);
 }
 
 static constexpr uint8_t stubHelperEntry[] = {
     0x68, 0, 0, 0, 0, // 0x0: pushq <bind offset>
     0xe9, 0, 0, 0, 0, // 0x5: jmp <__stub_helper>
 };
 
 void X86_64::writeStubHelperEntry(uint8_t *buf, const DylibSymbol &sym,
                                   uint64_t entryAddr) const {
   memcpy(buf, stubHelperEntry, sizeof(stubHelperEntry));
   write32le(buf + 1, sym.lazyBindOffset);
   writeRipRelative({&sym, "stub helper"}, buf, entryAddr,
                    sizeof(stubHelperEntry), in.stubHelper->addr);
 }
 
 void X86_64::relaxGotLoad(uint8_t *loc, uint8_t type) const {
   // Convert MOVQ to LEAQ
   if (loc[-2] != 0x8b)
     error(getRelocAttrs(type).name + " reloc requires MOVQ instruction");
   loc[-2] = 0x8d;
 }
 
-X86_64::X86_64() {
+X86_64::X86_64() : TargetInfo(LP64()) {
   cpuType = CPU_TYPE_X86_64;
   cpuSubtype = CPU_SUBTYPE_X86_64_ALL;
 
   stubSize = sizeof(stub);
   stubHelperHeaderSize = sizeof(stubHelperHeader);
   stubHelperEntrySize = sizeof(stubHelperEntry);
 }
 
 TargetInfo *macho::createX86_64TargetInfo() {
   static X86_64 t;
   return &t;
 }

lld/MachO/Driver.cpp

for (const CachedHashStringRef &cachedName :
          config->exportedSymbols.literals) {
       if (const Symbol *sym = symtab->find(cachedName))
         if (isa<Defined>(sym))
           continue;
       error("undefined symbol " + cachedName.val() +
             "\n>>> referenced from option -exported_symbol(s_list)");
     }
 
-    createSyntheticSections();
+    if (target->wordSize == 8)
+      createSyntheticSections<LP64>();
+    else
+      createSyntheticSections<ILP32>();
+
     createSyntheticSymbols();
 
     for (const Arg *arg : args.filtered(OPT_sectcreate)) {
       StringRef segName = arg->getValue(0);
       StringRef sectName = arg->getValue(1);
       StringRef fileName = arg->getValue(2);
       Optional<MemoryBufferRef> buffer = readFile(fileName);
       if (buffer)
         inputFiles.insert(make<OpaqueFile>(*buffer, segName, sectName));
     }
 
     {
       TimeTraceScope timeScope("Gathering input sections");
       // Gather all InputSections into one vector.
       for (const InputFile *file : inputFiles) {
         for (const SubsectionMapping &map : file->subsections)
           for (const SubsectionEntry &subsectionEntry : map)
             inputSections.push_back(subsectionEntry.isec);
       }
     }
 
     // Write to an output file.
-    writeResult();
+    if (target->wordSize == 8)
+      writeResult<LP64>();
+    else
+      writeResult<ILP32>();
 
     depTracker->write(getLLDVersion(), inputFiles, config->outputFile);
   }
 
   if (config->timeTraceEnabled) {
     if (auto E = timeTraceProfilerWrite(
             args.getLastArgValue(OPT_time_trace_file_eq).str(),
             config->outputFile)) {

lld/MachO/DriverUtils.cpp

 //===- DriverUtils.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Config.h"
 #include "Driver.h"
 #include "InputFiles.h"
 #include "ObjC.h"
+#include "Target.h"
 
 #include "lld/Common/Args.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Reproduce.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Bitcode/BitcodeReader.h"

lld/MachO/InputFiles.h

 // .o file
 class ObjFile : public InputFile {
 public:
   ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName);
   static bool classof(const InputFile *f) { return f->kind() == ObjKind; }
 
   llvm::DWARFUnit *compileUnit = nullptr;
   const uint32_t modTime;
-  ArrayRef<llvm::MachO::section_64> sectionHeaders;
   std::vector<InputSection *> debugSections;
 
 private:
-  void parseSections(ArrayRef<llvm::MachO::section_64>);
-  void parseSymbols(ArrayRef<lld::structs::nlist_64> nList, const char *strtab,
+  template <class LP> void parse();
+  template <class Section> void parseSections(ArrayRef<Section>);
+  template <class LP>
+  void parseSymbols(ArrayRef<typename LP::section> sectionHeaders,
+                    ArrayRef<typename LP::nlist> nList, const char *strtab,
                     bool subsectionsViaSymbols);
-  Symbol *parseNonSectionSymbol(const structs::nlist_64 &sym, StringRef name);
-  void parseRelocations(const llvm::MachO::section_64 &, SubsectionMapping &);
+  template <class NList>
+  Symbol *parseNonSectionSymbol(const NList &sym, StringRef name);
+  template <class Section>
+  void parseRelocations(ArrayRef<Section> sectionHeaders, const Section &,
+                        SubsectionMapping &);
   void parseDebugInfo();
 };
 
 // command-line -sectcreate file
 class OpaqueFile : public InputFile {
 public:
   OpaqueFile(MemoryBufferRef mb, StringRef segName, StringRef sectName);
   static bool classof(const InputFile *f) { return f->kind() == OpaqueKind; }
 };
 
 // .dylib file
 class DylibFile : public InputFile {
 public:
   // Mach-O dylibs can re-export other dylibs as sub-libraries, meaning that the
   // symbols in those sub-libraries will be available under the umbrella
   // library's namespace. Those sub-libraries can also have their own
   // re-exports. When loading a re-exported dylib, `umbrella` should be set to
   // the root dylib to ensure symbols in the child library are correctly bound
   // to the root. On the other hand, if a dylib is being directly loaded
   // (through an -lfoo flag), then `umbrella` should be a nullptr.
-  explicit DylibFile(MemoryBufferRef mb, DylibFile *umbrella = nullptr,
+  explicit DylibFile(MemoryBufferRef mb, DylibFile *umbrella,
                      bool isBundleLoader = false);
 
   explicit DylibFile(const llvm::MachO::InterfaceFile &interface,
                      DylibFile *umbrella = nullptr,
                      bool isBundleLoader = false);
 
   static bool classof(const InputFile *f) { return f->kind() == DylibKind; }
 
   StringRef dylibName;
   uint32_t compatibilityVersion = 0;
   uint32_t currentVersion = 0;
   int64_t ordinal = 0; // Ordinal numbering starts from 1, so 0 is a sentinel
   RefState refState;
   bool reexport = false;
   bool forceWeakImport = false;
 
   // An executable can be used as a bundle loader that will load the output
   // file being linked, and that contains symbols referenced, but not
   // implemented in the bundle. When used like this, it is very similar
   // to a Dylib, so we re-used the same class to represent it.
   bool isBundleLoader;
+
+private:
+  template <class LP> void parse(DylibFile *umbrella = nullptr);
 };
 
 // .a file
 class ArchiveFile : public InputFile {
 public:
   explicit ArchiveFile(std::unique_ptr<llvm::object::Archive> &&file);
   static bool classof(const InputFile *f) { return f->kind() == ArchiveKind; }
   void fetch(const llvm::object::Archive::Symbol &sym);
public:
 
   std::unique_ptr<llvm::lto::InputFile> obj;
 };
 
 extern llvm::SetVector<InputFile *> inputFiles;
 
 llvm::Optional<MemoryBufferRef> readFile(StringRef path);
 
-template <class CommandType = llvm::MachO::load_command>
-const CommandType *findCommand(const llvm::MachO::mach_header_64 *hdr,
-                               uint32_t type) {
-  const uint8_t *p = reinterpret_cast<const uint8_t *>(hdr) +
-                     sizeof(llvm::MachO::mach_header_64);
+template <class CommandType = llvm::MachO::load_command, class Header>
+const CommandType *findCommand(const Header *hdr, uint32_t type) {
+  const uint8_t *p = reinterpret_cast<const uint8_t *>(hdr) + sizeof(Header);
 
   for (uint32_t i = 0, n = hdr->ncmds; i < n; ++i) {
     auto *cmd = reinterpret_cast<const CommandType *>(p);
     if (cmd->cmd == type)
       return cmd;
     p += cmd->cmdsize;
   }
   return nullptr;
 }
 
 } // namespace macho
 
 std::string toString(const macho::InputFile *file);
 } // namespace lld
 
 #endif

lld/MachO/InputFiles.cpp

Optional<MemoryBufferRef> macho::readFile(StringRef path) {
 
   error("unable to find matching architecture in " + path);
   return None;
 }
 
 InputFile::InputFile(Kind kind, const InterfaceFile &interface)
     : id(idCount++), fileKind(kind), name(saver.save(interface.getPath())) {}
 
-void ObjFile::parseSections(ArrayRef<section_64> sections) {
+template <class Section>
+void ObjFile::parseSections(ArrayRef<Section> sections) {
   subsections.reserve(sections.size());
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
 
-  for (const section_64 &sec : sections) {
+  for (const Section &sec : sections) {
     InputSection *isec = make<InputSection>();
     isec->file = this;
     isec->name =
         StringRef(sec.sectname, strnlen(sec.sectname, sizeof(sec.sectname)));
     isec->segname =
         StringRef(sec.segname, strnlen(sec.segname, sizeof(sec.segname)));
     isec->data = {isZeroFill(sec.flags) ? nullptr : buf + sec.offset,
                   static_cast<size_t>(sec.size)};
static InputSection *findContainingSubsection(SubsectionMapping &map,
   auto it = std::prev(llvm::upper_bound(
       map, *offset, [](uint64_t value, SubsectionEntry subsectionEntry) {
         return value < subsectionEntry.offset;
       }));
   *offset -= it->offset;
   return it->isec;
 }
 
-static bool validateRelocationInfo(InputFile *file, const section_64 &sec,
+template <class Section>
+static bool validateRelocationInfo(InputFile *file, const Section &sec,
                                    relocation_info rel) {
   const RelocAttrs &relocAttrs = target->getRelocAttrs(rel.r_type);
   bool valid = true;
   auto message = [relocAttrs, file, sec, rel, &valid](const Twine &diagnostic) {
     valid = false;
     return (relocAttrs.name + " relocation " + diagnostic + " at offset " +
             std::to_string(rel.r_address) + " of " + sec.segname + "," +
             sec.sectname + " in " + toString(file))
if (rel.r_length < 2 || rel.r_length > 3 ||
     error(message("has width " + std::to_string(1 << rel.r_length) +
                   " bytes, but must be " +
                   widths[(static_cast<int>(relocAttrs.bits) >> 2) & 3] +
                   " bytes"));
   }
   return valid;
 }
 
-void ObjFile::parseRelocations(const section_64 &sec,
+template <class Section>
+void ObjFile::parseRelocations(ArrayRef<Section> sectionHeaders,
+                               const Section &sec,
                                SubsectionMapping &subsecMap) {
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   ArrayRef<relocation_info> relInfos(
       reinterpret_cast<const relocation_info *>(buf + sec.reloff), sec.nreloc);
 
   for (size_t i = 0; i < relInfos.size(); i++) {
     // Paired relocations serve as Mach-O's method for attaching a
     // supplemental datum to a primary relocation record. ELF does not
if (target->hasAttr(relInfo.r_type, RelocAttrBits::ADDEND)) {
       relInfo = relInfos[++i];
     }
     assert(i < relInfos.size());
     if (!validateRelocationInfo(this, sec, relInfo))
       continue;
     if (relInfo.r_address & R_SCATTERED)
       fatal("TODO: Scattered relocations not supported");
 
-    int64_t embeddedAddend = target->getEmbeddedAddend(mb, sec, relInfo);
+    int64_t embeddedAddend = target->getEmbeddedAddend(mb, sec.offset, relInfo);
     assert(!(embeddedAddend && pairedAddend));
     int64_t totalAddend = pairedAddend + embeddedAddend;
     Reloc r;
     r.type = relInfo.r_type;
     r.pcrel = relInfo.r_pcrel;
     r.length = relInfo.r_length;
     r.offset = relInfo.r_address;
     if (relInfo.r_extern) {
       r.referent = symbols[relInfo.r_symbolnum];
       r.addend = totalAddend;
     } else {
       SubsectionMapping &referentSubsecMap =
           subsections[relInfo.r_symbolnum - 1];
-      const section_64 &referentSec = sectionHeaders[relInfo.r_symbolnum - 1];
+      const Section &referentSec = sectionHeaders[relInfo.r_symbolnum - 1];
       uint64_t referentOffset;
       if (relInfo.r_pcrel) {
         // The implicit addend for pcrel section relocations is the pcrel offset
         // in terms of the addresses in the input file. Here we adjust it so
         // that it describes the offset from the start of the referent section.
         // FIXME This logic was written around x86_64 behavior -- ARM64 doesn't
         // have pcrel section relocations. We may want to factor this out into
         // the arch-specific .cpp file.
if (target->hasAttr(r.type, RelocAttrBits::SUBTRAHEND)) {
       Reloc p;
       p.type = relInfo.r_type;
       p.referent = symbols[relInfo.r_symbolnum];
       subsec->relocs.push_back(p);
     }
   }
 }
 
-static macho::Symbol *createDefined(const structs::nlist_64 &sym,
-                                    StringRef name, InputSection *isec,
-                                    uint64_t value, uint64_t size) {
+template <class NList>
+static macho::Symbol *createDefined(const NList &sym, StringRef name,
+                                    InputSection *isec, uint64_t value,
+                                    uint64_t size) {
   // Symbol scope is determined by sym.n_type & (N_EXT | N_PEXT):
   // N_EXT: Global symbols
   // N_EXT | N_PEXT: Linkage unit (think: dylib) scoped
   // N_PEXT: Does not occur in input files in practice,
   //         a private extern must be external.
   // 0: Translation-unit scoped. These are not in the symbol table.
 
   if (sym.n_type & (N_EXT | N_PEXT)) {
static bool hasCompatVersion(const InputFile *input,
   error(toString(input) + " has version " + version.getAsString() +
         ", which is incompatible with target version of " +
         config->platformInfo.minimum.getAsString());
   return false;
 }
 
 // Absolute symbols are defined symbols that do not have an associated
 // InputSection. They cannot be weak.
-static macho::Symbol *createAbsolute(const structs::nlist_64 &sym,
-                                     InputFile *file, StringRef name) {
+template <class NList>
+static macho::Symbol *createAbsolute(const NList &sym, InputFile *file,
+                                     StringRef name) {
   if (sym.n_type & (N_EXT | N_PEXT)) {
     assert((sym.n_type & N_EXT) && "invalid input");
     return symtab->addDefined(name, file, nullptr, sym.n_value, /*size=*/0,
                               /*isWeakDef=*/false, sym.n_type & N_PEXT);
   }
   return make<Defined>(name, file, nullptr, sym.n_value, /*size=*/0,
                        /*isWeakDef=*/false,
                        /*isExternal=*/false, /*isPrivateExtern=*/false);
 }
 
-macho::Symbol *ObjFile::parseNonSectionSymbol(const structs::nlist_64 &sym,
+template <class NList>
+macho::Symbol *ObjFile::parseNonSectionSymbol(const NList &sym,
                                               StringRef name) {
   uint8_t type = sym.n_type & N_TYPE;
   switch (type) {
   case N_UNDF:
     return sym.n_value == 0
                ? symtab->addUndefined(name, this, sym.n_desc & N_WEAK_REF)
                : symtab->addCommon(name, this, sym.n_value,
                                    1 << GET_COMM_ALIGN(sym.n_desc),
                                    sym.n_type & N_PEXT);
   case N_ABS:
     return createAbsolute(sym, this, name);
   case N_PBUD:
   case N_INDR:
     error("TODO: support symbols of type " + std::to_string(type));
     return nullptr;
   case N_SECT:
     llvm_unreachable(
         "N_SECT symbols should not be passed to parseNonSectionSymbol");
   default:
     llvm_unreachable("invalid symbol type");
   }
 }
 
-void ObjFile::parseSymbols(ArrayRef<structs::nlist_64> nList,
+template <class LP>
+void ObjFile::parseSymbols(ArrayRef<typename LP::section> sectionHeaders,
+                           ArrayRef<typename LP::nlist> nList,
                            const char *strtab, bool subsectionsViaSymbols) {
+  using Section = typename LP::section;
+  using NList = typename LP::nlist;
+
   // Precompute the boundaries of symbols within a section.
   // If subsectionsViaSymbols is True then the corresponding subsections will be
   // created, otherwise these boundaries are used for the calculation of symbols
   // sizes only.
-
-  for (const structs::nlist_64 &sym : nList) {
+  for (const NList &sym : nList) {
     if ((sym.n_type & N_TYPE) == N_SECT && !(sym.n_desc & N_ALT_ENTRY) &&
         !subsections[sym.n_sect - 1].empty()) {
       SubsectionMapping &subsectionMapping = subsections[sym.n_sect - 1];
       subsectionMapping.push_back(
           {sym.n_value - sectionHeaders[sym.n_sect - 1].addr,
            subsectionMapping.front().isec});
     }
   }
for (size_t i = 0; i < subsectionMap.size(); ++i) {
       // subsection's offset from the last aligned address. We should consider
       // emulating that behavior.
       isec->align = MinAlign(isec->align, offset);
     }
   }
 
   symbols.resize(nList.size());
   for (size_t i = 0, n = nList.size(); i < n; ++i) {
-    const structs::nlist_64 &sym = nList[i];
+    const NList &sym = nList[i];
     StringRef name = strtab + sym.n_strx;
 
     if ((sym.n_type & N_TYPE) != N_SECT) {
       symbols[i] = parseNonSectionSymbol(sym, name);
       continue;
     }
 
-    const section_64 &sec = sectionHeaders[sym.n_sect - 1];
+    const Section &sec = sectionHeaders[sym.n_sect - 1];
     SubsectionMapping &subsecMap = subsections[sym.n_sect - 1];
 
     // parseSections() may have chosen not to parse this section.
     if (subsecMap.empty())
       continue;
 
     uint64_t offset = sym.n_value - sec.addr;
 
OpaqueFile::OpaqueFile(MemoryBufferRef mb, StringRef segName,
   const auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   isec->data = {buf, mb.getBufferSize()};
   subsections.push_back({{0, isec}});
 }
 
 ObjFile::ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName)
     : InputFile(ObjKind, mb), modTime(modTime) {
   this->archiveName = std::string(archiveName);
+  if (target->wordSize == 8)
+    parse<LP64>();
+  else
+    parse<ILP32>();
+}
+
+template <class LP> void ObjFile::parse() {
+  using Header = typename LP::mach_header;
+  using SegmentCommand = typename LP::segment_command;
+  using Section = typename LP::section;
+  using NList = typename LP::nlist;
 
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
-  auto *hdr = reinterpret_cast<const mach_header_64 *>(mb.getBufferStart());
+  auto *hdr = reinterpret_cast<const Header *>(mb.getBufferStart());
 
   Architecture arch = getArchitectureFromCpuType(hdr->cputype, hdr->cpusubtype);
   if (arch != config->target.Arch) {
     error(toString(this) + " has architecture " + getArchitectureName(arch) +
           " which is incompatible with target architecture " +
           getArchitectureName(config->target.Arch));
     return;
   }
 
   if (const auto *cmd =
           findCommand<build_version_command>(hdr, LC_BUILD_VERSION)) {
     if (!hasCompatVersion(this, cmd))
       return;
   }
 
   if (const load_command *cmd = findCommand(hdr, LC_LINKER_OPTION)) {
     auto *c = reinterpret_cast<const linker_option_command *>(cmd);
     StringRef data{reinterpret_cast<const char *>(c + 1),
                    c->cmdsize - sizeof(linker_option_command)};
     parseLCLinkerOption(this, c->count, data);
   }
 
-  if (const load_command *cmd = findCommand(hdr, LC_SEGMENT_64)) {
-    auto *c = reinterpret_cast<const segment_command_64 *>(cmd);
-    sectionHeaders = ArrayRef<section_64>{
-        reinterpret_cast<const section_64 *>(c + 1), c->nsects};
+  ArrayRef<Section> sectionHeaders;
+  if (const load_command *cmd = findCommand(hdr, LP::segmentLCType)) {
+    auto *c = reinterpret_cast<const SegmentCommand *>(cmd);
+    sectionHeaders =
+        ArrayRef<Section>{reinterpret_cast<const Section *>(c + 1), c->nsects};
     parseSections(sectionHeaders);
   }
 
   // TODO: Error on missing LC_SYMTAB?
   if (const load_command *cmd = findCommand(hdr, LC_SYMTAB)) {
     auto *c = reinterpret_cast<const symtab_command *>(cmd);
-    ArrayRef<structs::nlist_64> nList(
-        reinterpret_cast<const structs::nlist_64 *>(buf + c->symoff), c->nsyms);
+    ArrayRef<NList> nList(reinterpret_cast<const NList *>(buf + c->symoff),
+                          c->nsyms);
     const char *strtab = reinterpret_cast<const char *>(buf) + c->stroff;
     bool subsectionsViaSymbols = hdr->flags & MH_SUBSECTIONS_VIA_SYMBOLS;
-    parseSymbols(nList, strtab, subsectionsViaSymbols);
+    parseSymbols<LP>(sectionHeaders, nList, strtab, subsectionsViaSymbols);
   }
 
   // The relocations may refer to the symbols, so we parse them after we have
   // parsed all the symbols.
   for (size_t i = 0, n = subsections.size(); i < n; ++i)
     if (!subsections[i].empty())
-      parseRelocations(sectionHeaders[i], subsections[i]);
+      parseRelocations(sectionHeaders, sectionHeaders[i], subsections[i]);
 
   parseDebugInfo();
 }
 
 void ObjFile::parseDebugInfo() {
   std::unique_ptr<DwarfObject> dObj = DwarfObject::create(this);
   if (!dObj)
     return;

 DylibFile::DylibFile(MemoryBufferRef mb, DylibFile *umbrella,
                      bool isBundleLoader)
     : InputFile(DylibKind, mb), refState(RefState::Unreferenced),
       isBundleLoader(isBundleLoader) {
   assert(!isBundleLoader || !umbrella);
   if (umbrella == nullptr)
     umbrella = this;
 
+  if (target->wordSize == 8)
+    parse<LP64>(umbrella);
+  else
+    parse<ILP32>(umbrella);
+}
+
+template <class LP> void DylibFile::parse(DylibFile *umbrella) {
+  using Header = typename LP::mach_header;
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
-  auto *hdr = reinterpret_cast<const mach_header_64 *>(mb.getBufferStart());
+  auto *hdr = reinterpret_cast<const Header *>(mb.getBufferStart());
 
   // Initialize dylibName.
   if (const load_command *cmd = findCommand(hdr, LC_ID_DYLIB)) {
     auto *c = reinterpret_cast<const dylib_command *>(cmd);
     currentVersion = read32le(&c->dylib.current_version);
     compatibilityVersion = read32le(&c->dylib.compatibility_version);
     dylibName = reinterpret_cast<const char *>(cmd) + read32le(&c->dylib.name);
   } else if (!isBundleLoader) {
parseTrie(buf + c->export_off, c->export_size,
                 symbols.push_back(symtab->addDylib(
                     saver.save(name), exportingFile, isWeakDef, isTlv));
               });
   } else {
     error("LC_DYLD_INFO_ONLY not found in " + toString(this));
     return;
   }
 
-  const uint8_t *p =
-      reinterpret_cast<const uint8_t *>(hdr) + sizeof(mach_header_64);
+  const uint8_t *p = reinterpret_cast<const uint8_t *>(hdr) + sizeof(Header);
   for (uint32_t i = 0, n = hdr->ncmds; i < n; ++i) {
     auto *cmd = reinterpret_cast<const load_command *>(p);
     p += cmd->cmdsize;
 
     if (!(hdr->flags & MH_NO_REEXPORTED_DYLIBS) &&
         cmd->cmd == LC_REEXPORT_DYLIB) {
       const auto *c = reinterpret_cast<const dylib_command *>(cmd);
       StringRef reexportPath =
BitcodeFile::BitcodeFile(MemoryBufferRef mbref)
   obj = check(lto::InputFile::create(mbref));
 
   // Convert LTO Symbols to LLD Symbols in order to perform resolution. The
   // "winning" symbol will then be marked as Prevailing at LTO compilation
   // time.
   for (const lto::InputFile::Symbol &objSym : obj->symbols())
     symbols.push_back(createBitcodeSymbol(objSym, *this));
 }
+
+template void ObjFile::parse<LP64>();
+template void DylibFile::parse<LP64>(DylibFile *umbrella);

lld/MachO/InputSection.cpp

 
 static uint64_t resolveSymbolVA(uint8_t *loc, const Symbol &sym, uint8_t type) {
   const RelocAttrs &relocAttrs = target->getRelocAttrs(type);
   if (relocAttrs.hasAttr(RelocAttrBits::BRANCH)) {
     if (sym.isInStubs())
       return in.stubs->addr + sym.stubsIndex * target->stubSize;
   } else if (relocAttrs.hasAttr(RelocAttrBits::GOT)) {
     if (sym.isInGot())
-      return in.got->addr + sym.gotIndex * WordSize;
+      return in.got->addr + sym.gotIndex * target->wordSize;
   } else if (relocAttrs.hasAttr(RelocAttrBits::TLV)) {
     if (sym.isInGot())
-      return in.tlvPointers->addr + sym.gotIndex * WordSize;
+      return in.tlvPointers->addr + sym.gotIndex * target->wordSize;
     assert(isa<Defined>(&sym));
   }
   return sym.getVA();
 }
 
 void InputSection::writeTo(uint8_t *buf) {
   if (getFileSize() == 0)
     return;

lld/MachO/LTO.cpp

 //===- LTO.cpp ------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "LTO.h"
 #include "Config.h"
 #include "Driver.h"
 #include "InputFiles.h"
 #include "Symbols.h"
+#include "Target.h"
 
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/TargetOptionsCommandFlags.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"

lld/MachO/MachOStructs.h

 struct nlist_64 {
   llvm::support::ulittle32_t n_strx;
   uint8_t n_type;
   uint8_t n_sect;
   llvm::support::ulittle16_t n_desc;
   llvm::support::ulittle64_t n_value;
 };
 
+struct nlist {
+  llvm::support::ulittle32_t n_strx;
+  uint8_t n_type;
+  uint8_t n_sect;
+  llvm::support::ulittle16_t n_desc;
+  llvm::support::ulittle32_t n_value;
+};
+
 } // namespace structs
 
 } // namespace lld
 
 #endif

lld/MachO/ObjC.cpp

 //===- ObjC.cpp -----------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ObjC.h"
 #include "InputFiles.h"
 #include "OutputSegment.h"
+#include "Target.h"
 
 #include "llvm/BinaryFormat/MachO.h"
 
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace lld;
+using namespace lld::macho;
 
-bool macho::hasObjCSection(MemoryBufferRef mb) {
-  auto *hdr = reinterpret_cast<const mach_header_64 *>(mb.getBufferStart());
-  if (const load_command *cmd = findCommand(hdr, LC_SEGMENT_64)) {
-    auto *c = reinterpret_cast<const segment_command_64 *>(cmd);
-    auto sectionHeaders = ArrayRef<section_64>{
-        reinterpret_cast<const section_64 *>(c + 1), c->nsects};
-    for (const section_64 &sec : sectionHeaders) {
+template <class LP> static bool hasObjCSection(MemoryBufferRef mb) {
+  using Section = typename LP::section;
+
+  auto *hdr =
+      reinterpret_cast<const typename LP::mach_header *>(mb.getBufferStart());
+  if (const load_command *cmd = findCommand(hdr, LP::segmentLCType)) {
+    auto *c = reinterpret_cast<const typename LP::segment_command *>(cmd);
+    auto sectionHeaders =
+        ArrayRef<Section>{reinterpret_cast<const Section *>(c + 1), c->nsects};
+    for (const Section &sec : sectionHeaders) {
       StringRef sectname(sec.sectname,
                          strnlen(sec.sectname, sizeof(sec.sectname)));
       StringRef segname(sec.segname, strnlen(sec.segname, sizeof(sec.segname)));
       if ((segname == segment_names::data && sectname == "__objc_catlist") ||
           (segname == segment_names::text && sectname == "__swift")) {
         return true;
       }
     }
   }
   return false;
 }
+
+bool macho::hasObjCSection(MemoryBufferRef mb) {
+  if (target->wordSize == 8)
+    return ::hasObjCSection<LP64>(mb);
+  else
+    return ::hasObjCSection<ILP32>(mb);
+}

lld/MachO/SyntheticSections.h

public:
   InputSection *isec;
 };
 
 // All sections in __LINKEDIT should inherit from this.
 class LinkEditSection : public SyntheticSection {
 public:
   LinkEditSection(const char *segname, const char *name)
       : SyntheticSection(segname, name) {
-    align = WordSize; // mimic ld64
+    align = target->wordSize;
   }
 
   // Sections in __LINKEDIT are special: their offsets are recorded in the
   // load commands like LC_DYLD_INFO_ONLY and LC_SYMTAB, instead of in section
   // headers.
   bool isHidden() const override final { return true; }
 
   virtual uint64_t getRawSize() const = 0;
 
   // codesign (or more specifically libstuff) checks that each section in
   // __LINKEDIT ends where the next one starts -- no gaps are permitted. We
   // therefore align every section's start and end points to WordSize.
   //
   // NOTE: This assumes that the extra bytes required for alignment can be
   // zero-valued bytes.
   uint64_t getSize() const override final {
     return llvm::alignTo(getRawSize(), align);
   }
 };
 
 // The header of the Mach-O file, which must have a file offset of zero.
 class MachHeaderSection : public SyntheticSection {
 public:
-  MachHeaderSection();
   void addLoadCommand(LoadCommand *);
   bool isHidden() const override { return true; }
-  uint64_t getSize() const override;
-  void writeTo(uint8_t *buf) const override;
 
-private:
+protected:
+  MachHeaderSection();
   std::vector<LoadCommand *> loadCommands;
   uint32_t sizeOfCmds = 0;
 };
 
+template <class LP> MachHeaderSection *makeMachHeaderSection();
+
 // A hidden section that exists solely for the purpose of creating the
 // __PAGEZERO segment, which is used to catch null pointer dereferences.
 class PageZeroSection : public SyntheticSection {
 public:
   PageZeroSection();
   bool isHidden() const override { return true; }
-  uint64_t getSize() const override { return PageZeroSize; }
+  uint64_t getSize() const override { return target->pageZeroSize; }
   uint64_t getFileSize() const override { return 0; }
   void writeTo(uint8_t *buf) const override {}
 };
 
 // This is the base class for the GOT and TLVPointer sections, which are nearly
 // functionally identical -- they will both be populated by dyld with addresses
 // to non-lazily-loaded dylib symbols. The main difference is that the
 // TLVPointerSection stores references to thread-local variables.
 class NonLazyPointerSectionBase : public SyntheticSection {
 public:
   NonLazyPointerSectionBase(const char *segname, const char *name);
 
   const llvm::SetVector<const Symbol *> &getEntries() const { return entries; }
 
   bool isNeeded() const override { return !entries.empty(); }
 
-  uint64_t getSize() const override { return entries.size() * WordSize; }
+  uint64_t getSize() const override {
+    return entries.size() * target->wordSize;
+  }
 
   void writeTo(uint8_t *buf) const override;
 
   void addEntry(Symbol *sym);
 
 private:
   llvm::SetVector<const Symbol *> entries;
 };

 
 // This section contains space for just a single word, and will be used by dyld
 // to cache an address to the image loader it uses. Note that unlike the other
 // synthetic sections, which are OutputSections, the ImageLoaderCacheSection is
 // an InputSection that gets merged into the __data OutputSection.
 class ImageLoaderCacheSection : public InputSection {
 public:
   ImageLoaderCacheSection();
-  uint64_t getSize() const override { return WordSize; }
+  uint64_t getSize() const override { return target->wordSize; }
 };
 
 // Note that this section may also be targeted by non-lazy bindings. In
 // particular, this happens when branch relocations target weak symbols.
 class LazyPointerSection : public SyntheticSection {
 public:
   LazyPointerSection();
   uint64_t getSize() const override;

 };
 
 // Symbols of the same type must be laid out contiguously: we choose to emit
 // all local symbols first, then external symbols, and finally undefined
 // symbols. For each symbol type, the LC_DYSYMTAB load command will record the
 // range (start index and total number) of those symbols in the symbol table.
 class SymtabSection : public LinkEditSection {
 public:
-  SymtabSection(StringTableSection &);
   void finalizeContents();
   uint32_t getNumSymbols() const;
   uint32_t getNumLocalSymbols() const {
     return stabs.size() + localSymbols.size();
   }
   uint32_t getNumExternalSymbols() const { return externalSymbols.size(); }
   uint32_t getNumUndefinedSymbols() const { return undefinedSymbols.size(); }
-  uint64_t getRawSize() const override;
-  void writeTo(uint8_t *buf) const override;
 
 private:
   void emitBeginSourceStab(llvm::DWARFUnit *compileUnit);
   void emitEndSourceStab();
   void emitObjectFileStab(ObjFile *);
   void emitEndFunStab(Defined *);
   void emitStabs();
 
+protected:
+  SymtabSection(StringTableSection &);
+
   StringTableSection &stringTableSection;
   // STABS symbols are always local symbols, but we represent them with special
   // entries because they may use fields like n_sect and n_desc differently.
   std::vector<StabsEntry> stabs;
   std::vector<SymtabEntry> localSymbols;
   std::vector<SymtabEntry> externalSymbols;
   std::vector<SymtabEntry> undefinedSymbols;
 };
 
+template <class LP> SymtabSection *makeSymtabSection(StringTableSection &);
+
 // The indirect symbol table is a list of 32-bit integers that serve as indices
 // into the (actual) symbol table. The indirect symbol table is a
 // concatenation of several sub-arrays of indices, each sub-array belonging to
 // a separate section. The starting offset of each sub-array is stored in the
 // reserved1 header field of the respective section.
 //
 // These sub-arrays provide symbol information for sections that store
 // contiguous sequences of symbol references. These references can be pointers

lld/MachO/SyntheticSections.cpp

MachHeaderSection::MachHeaderSection()
   index = 1;
 }
 
 void MachHeaderSection::addLoadCommand(LoadCommand *lc) {
   loadCommands.push_back(lc);
   sizeOfCmds += lc->getSize();
 }
 
-uint64_t MachHeaderSection::getSize() const {
-  return sizeof(mach_header_64) + sizeOfCmds + config->headerPad;
+// This serves to hide (type-erase) the template parameter from
+// MachHeaderSection.
+template <class LP> class MachHeaderSectionImpl : public MachHeaderSection {
+public:
+  MachHeaderSectionImpl() = default;
+  uint64_t getSize() const override;
+  void writeTo(uint8_t *buf) const override;
+};
+
+template <class LP> MachHeaderSection *macho::makeMachHeaderSection() {
+  return make<MachHeaderSectionImpl<LP>>();
+}
+
+template <class LP> uint64_t MachHeaderSectionImpl<LP>::getSize() const {
+  return sizeof(typename LP::mach_header) + sizeOfCmds + config->headerPad;
 }
 
 static uint32_t cpuSubtype() {
   uint32_t subtype = target->cpuSubtype;
 
   if (config->outputType == MH_EXECUTE && !config->staticLink &&
       target->cpuSubtype == CPU_SUBTYPE_X86_64_ALL &&
       config->target.Platform == PlatformKind::macOS &&
       config->platformInfo.minimum >= VersionTuple(10, 5))
     subtype |= CPU_SUBTYPE_LIB64;
 
   return subtype;
 }
 
-void MachHeaderSection::writeTo(uint8_t *buf) const {
-  auto *hdr = reinterpret_cast<mach_header_64 *>(buf);
-  hdr->magic = MH_MAGIC_64;
+template <class LP>
+void MachHeaderSectionImpl<LP>::writeTo(uint8_t *buf) const {
+  auto *hdr = reinterpret_cast<typename LP::mach_header *>(buf);
+  hdr->magic = LP::magic;
   hdr->cputype = target->cpuType;
   hdr->cpusubtype = cpuSubtype();
   hdr->filetype = config->outputType;
   hdr->ncmds = loadCommands.size();
   hdr->sizeofcmds = sizeOfCmds;
   hdr->flags = MH_DYLDLINK;
 
   if (config->namespaceKind == NamespaceKind::twolevel)
if (lastRebase.segment != seg) {
       assert(lastRebase.offset != offset);
       os << static_cast<uint8_t>(REBASE_OPCODE_ADD_ADDR_ULEB);
       encodeULEB128(offset - lastRebase.offset, os);
       lastRebase.offset = offset;
     }
   }
   ++lastRebase.consecutiveCount;
   // DO_REBASE causes dyld to both perform the binding and increment the offset
-  lastRebase.offset += WordSize;
+  lastRebase.offset += target->wordSize;
 }
 
 void RebaseSection::finalizeContents() {
   if (locations.empty())
     return;
 
   raw_svector_ostream os{contents};
   Rebase lastRebase;

 
 void RebaseSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
 NonLazyPointerSectionBase::NonLazyPointerSectionBase(const char *segname,
                                                      const char *name)
     : SyntheticSection(segname, name) {
-  align = WordSize;
+  align = target->wordSize;
   flags = S_NON_LAZY_SYMBOL_POINTERS;
 }
 
 void macho::addNonLazyBindingEntries(const Symbol *sym,
                                      const InputSection *isec, uint64_t offset,
                                      int64_t addend) {
   if (const auto *dysym = dyn_cast<DylibSymbol>(sym)) {
     in.binding->addEntry(dysym, isec, offset, addend);
void macho::addNonLazyBindingEntries(const Symbol *sym,
   }
 }
 
 void NonLazyPointerSectionBase::addEntry(Symbol *sym) {
   if (entries.insert(sym)) {
     assert(!sym->isInGot());
     sym->gotIndex = entries.size() - 1;
 
-    addNonLazyBindingEntries(sym, isec, sym->gotIndex * WordSize);
+    addNonLazyBindingEntries(sym, isec, sym->gotIndex * target->wordSize);
   }
 }
 
 void NonLazyPointerSectionBase::writeTo(uint8_t *buf) const {
   for (size_t i = 0, n = entries.size(); i < n; ++i)
     if (auto *defined = dyn_cast<Defined>(entries[i]))
-      write64le(&buf[i * WordSize], defined->getVA());
+      write64le(&buf[i * target->wordSize], defined->getVA());
 }
 
 BindingSection::BindingSection()
     : LinkEditSection(segment_names::linkEdit, section_names::binding) {}
 
 namespace {
 struct Binding {
   OutputSegment *segment = nullptr;
static void encodeBinding(const Symbol *sym, const OutputSection *osec,
   uint8_t flags = BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM;
   if (!isWeakBinding && sym->isWeakRef())
     flags |= BIND_SYMBOL_FLAGS_WEAK_IMPORT;
 
   os << flags << sym->getName() << '\0'
      << static_cast<uint8_t>(BIND_OPCODE_SET_TYPE_IMM | BIND_TYPE_POINTER)
      << static_cast<uint8_t>(BIND_OPCODE_DO_BIND);
   // DO_BIND causes dyld to both perform the binding and increment the offset
-  lastBinding.offset += WordSize;
+  lastBinding.offset += target->wordSize;
 }
 
 // Non-weak bindings need to have their dylib ordinal encoded as well.
 static int16_t ordinalForDylibSymbol(const DylibSymbol &dysym) {
   return config->namespaceKind == NamespaceKind::flat || dysym.isDynamicLookup()
              ? static_cast<int16_t>(BIND_SPECIAL_DYLIB_FLAT_LOOKUP)
              : dysym.getFile()->ordinal;
 }
dyldPrivate =
       make<Defined>("__dyld_private", nullptr, in.imageLoaderCache, 0, 0,
                     /*isWeakDef=*/false,
                     /*isExternal=*/false, /*isPrivateExtern=*/false);
 }
 
 ImageLoaderCacheSection::ImageLoaderCacheSection() {
   segname = segment_names::data;
   name = "__data";
-  uint8_t *arr = bAlloc.Allocate<uint8_t>(WordSize);
-  memset(arr, 0, WordSize);
-  data = {arr, WordSize};
-  align = WordSize;
+  uint8_t *arr = bAlloc.Allocate<uint8_t>(target->wordSize);
+  memset(arr, 0, target->wordSize);
+  data = {arr, target->wordSize};
+  align = target->wordSize;
 }
 
 LazyPointerSection::LazyPointerSection()
     : SyntheticSection(segment_names::data, "__la_symbol_ptr") {
-  align = WordSize;
+  align = target->wordSize;
   flags = S_LAZY_SYMBOL_POINTERS;
 }
 
 uint64_t LazyPointerSection::getSize() const {
-  return in.stubs->getEntries().size() * WordSize;
+  return in.stubs->getEntries().size() * target->wordSize;
 }
 
 bool LazyPointerSection::isNeeded() const {
   return !in.stubs->getEntries().empty();
 }
 
 void LazyPointerSection::writeTo(uint8_t *buf) const {
   size_t off = 0;
   for (const Symbol *sym : in.stubs->getEntries()) {
     if (const auto *dysym = dyn_cast<DylibSymbol>(sym)) {
       if (dysym->hasStubsHelper()) {
         uint64_t stubHelperOffset =
             target->stubHelperHeaderSize +
             dysym->stubsHelperIndex * target->stubHelperEntrySize;
         write64le(buf + off, in.stubHelper->addr + stubHelperOffset);
       }
     } else {
       write64le(buf + off, sym->getVA());
     }
-    off += WordSize;
+    off += target->wordSize;
   }
 }
 
 LazyBindingSection::LazyBindingSection()
     : LinkEditSection(segment_names::linkEdit, section_names::lazyBinding) {}
 
 void LazyBindingSection::finalizeContents() {
   // TODO: Just precompute output size here instead of writing to a temporary
   // buffer
   for (DylibSymbol *sym : entries)
     sym->lazyBindOffset = encode(*sym);
 }
 
 void LazyBindingSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
 void LazyBindingSection::addEntry(DylibSymbol *dysym) {
   if (entries.insert(dysym)) {
     dysym->stubsHelperIndex = entries.size() - 1;
-    in.rebase->addEntry(in.lazyPointers->isec, dysym->stubsIndex * WordSize);
+    in.rebase->addEntry(in.lazyPointers->isec,
+                        dysym->stubsIndex * target->wordSize);
   }
 }
 
 // Unlike the non-lazy binding section, the bind opcodes in this section aren't
 // interpreted all at once. Rather, dyld will start interpreting opcodes at a
 // given offset, typically only binding a single symbol before it finds a
 // BIND_OPCODE_DONE terminator. As such, unlike in the non-lazy-binding case,
 // we cannot encode just the differences between symbols; we have to emit the
 // complete bind information for each symbol.
 uint32_t LazyBindingSection::encode(const DylibSymbol &sym) {
   uint32_t opstreamOffset = contents.size();
   OutputSegment *dataSeg = in.lazyPointers->parent;
   os << static_cast<uint8_t>(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
                              dataSeg->index);
   uint64_t offset = in.lazyPointers->addr - dataSeg->firstSection()->addr +
-                    sym.stubsIndex * WordSize;
+                    sym.stubsIndex * target->wordSize;
   encodeULEB128(offset, os);
   encodeDylibOrdinal(ordinalForDylibSymbol(sym), os);
 
   uint8_t flags = BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM;
   if (sym.isWeakRef())
     flags |= BIND_SYMBOL_FLAGS_WEAK_IMPORT;
 
   os << flags << sym.getName() << '\0'

 void FunctionStartsSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
 SymtabSection::SymtabSection(StringTableSection &stringTableSection)
     : LinkEditSection(segment_names::linkEdit, section_names::symbolTable),
       stringTableSection(stringTableSection) {}
 
-uint64_t SymtabSection::getRawSize() const {
-  return getNumSymbols() * sizeof(structs::nlist_64);
-}
-
 void SymtabSection::emitBeginSourceStab(DWARFUnit *compileUnit) {
   StabsEntry stab(N_SO);
   SmallString<261> dir(compileUnit->getCompilationDir());
   StringRef sep = sys::path::get_separator();
   // We don't use `path::append` here because we want an empty `dir` to result
   // in an absolute path. `append` would give us a relative path for that case.
   if (!dir.endswith(sep))
     dir += sep;
void SymtabSection::finalizeContents() {
   }
 }
 
 uint32_t SymtabSection::getNumSymbols() const {
   return stabs.size() + localSymbols.size() + externalSymbols.size() +
          undefinedSymbols.size();
 }
 
-void SymtabSection::writeTo(uint8_t *buf) const {
-  auto *nList = reinterpret_cast<structs::nlist_64 *>(buf);
+// This serves to hide (type-erase) the template parameter from SymtabSection.
+template <class LP> class SymtabSectionImpl : public SymtabSection {
+public:
+  SymtabSectionImpl(StringTableSection &stringTableSection)
+      : SymtabSection(stringTableSection) {}
+  uint64_t getRawSize() const override;
+  void writeTo(uint8_t *buf) const override;
+};
+
+template <class LP> uint64_t SymtabSectionImpl<LP>::getRawSize() const {
+  return getNumSymbols() * sizeof(typename LP::nlist);
+}
+
+template <class LP> void SymtabSectionImpl<LP>::writeTo(uint8_t *buf) const {
+  auto *nList = reinterpret_cast<typename LP::nlist *>(buf);
   // Emit the stabs entries before the "real" symbols. We cannot emit them
   // after as that would render Symbol::symtabIndex inaccurate.
   for (const StabsEntry &entry : stabs) {
     nList->n_strx = entry.strx;
     nList->n_type = entry.type;
     nList->n_sect = entry.sect;
     nList->n_desc = entry.desc;
     nList->n_value = entry.value;
if (auto *defined = dyn_cast<Defined>(entry.sym)) {
       n_desc |= dysym->isWeakDef() ? N_WEAK_DEF : 0;
       n_desc |= dysym->isWeakRef() ? N_WEAK_REF : 0;
       nList->n_desc = n_desc;
     }
     ++nList;
   }
 }
 
+template <class LP>
+SymtabSection *
+macho::makeSymtabSection(StringTableSection &stringTableSection) {
+  return make<SymtabSectionImpl<LP>>(stringTableSection);
+}
+
 IndirectSymtabSection::IndirectSymtabSection()
     : LinkEditSection(segment_names::linkEdit,
                       section_names::indirectSymbolTable) {}
 
 uint32_t IndirectSymtabSection::getNumSymbols() const {
   return in.got->getEntries().size() + in.tlvPointers->getEntries().size() +
          in.stubs->getEntries().size();
 }
void macho::createSyntheticSymbols() {
 
   // The Itanium C++ ABI requires dylibs to pass a pointer to __cxa_atexit
   // which does e.g. cleanup of static global variables. The ABI document
   // says that the pointer can point to any address in one of the dylib's
   // segments, but in practice ld64 seems to set it to point to the header,
   // so that's what's implemented here.
   addHeaderSymbol("___dso_handle");
 }
+
+template MachHeaderSection *macho::makeMachHeaderSection<LP64>();
+template MachHeaderSection *macho::makeMachHeaderSection<ILP32>();
+template SymtabSection *macho::makeSymtabSection<LP64>(StringTableSection &);
+template SymtabSection *macho::makeSymtabSection<ILP32>(StringTableSection &);

lld/MachO/Target.h

 //===- Target.h -------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #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 {
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
 class Symbol;
 class DylibSymbol;
 class InputSection;
 
-enum : uint64_t {
-  // We are currently only supporting 64-bit targets since macOS and iOS are
-  // deprecating 32-bit apps.
-  WordSize = 8,
-  PageZeroSize = 1ull << 32, // XXX should be 4096 for 32-bit targets
-  MaxAlignmentPowerOf2 = 32,
-};
-
 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.
+    pageZeroSize = LP::pageZeroSize;
+    wordSize = LP::wordSize;
+  }
+
   virtual ~TargetInfo() = default;
 
   // Validate the relocation structure and get its addend.
   virtual int64_t
-  getEmbeddedAddend(llvm::MemoryBufferRef, const llvm::MachO::section_64 &,
+  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 Symbol &) const = 0;
   virtual void writeStubHelperHeader(uint8_t *buf) const = 0;
public:
 
   bool hasAttr(uint8_t type, RelocAttrBits bit) const {
     return getRelocAttrs(type).hasAttr(bit);
   }
 
   uint32_t cpuType;
   uint32_t cpuSubtype;
 
+  size_t pageZeroSize;
   size_t stubSize;
   size_t stubHelperHeaderSize;
   size_t stubHelperEntrySize;
+  size_t wordSize;
 };
 
 TargetInfo *createX86_64TargetInfo();
 TargetInfo *createARM64TargetInfo();
 
+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;
+
+  static constexpr uint32_t magic = llvm::MachO::MH_MAGIC_64;
+  static constexpr uint32_t segmentLCType = llvm::MachO::LC_SEGMENT_64;
+
+  static constexpr size_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;
+
+  static constexpr uint32_t magic = llvm::MachO::MH_MAGIC;
+  static constexpr uint32_t segmentLCType = llvm::MachO::LC_SEGMENT;
+
+  static constexpr size_t pageZeroSize = 1ull << 12;
+  static constexpr size_t wordSize = 4;
+};
+
 extern TargetInfo *target;
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/UnwindInfoSection.cpp

void UnwindInfoSection::writeTo(uint8_t *buf) const {
 
   // Common encodings
   auto *i32p = reinterpret_cast<uint32_t *>(&uip[1]);
   for (const auto &encoding : commonEncodings)
     *i32p++ = encoding.first;
 
   // Personalities
   for (const uint32_t &personality : personalities)
-    *i32p++ = in.got->addr + (personality - 1) * WordSize;
+    *i32p++ = in.got->addr + (personality - 1) * target->wordSize;
 
   // Level-1 index
   uint32_t lsdaOffset =
       uip->indexSectionOffset +
       uip->indexCount * sizeof(unwind_info_section_header_index_entry);
   uint64_t l2PagesOffset = level2PagesOffset;
   auto *iep = reinterpret_cast<unwind_info_section_header_index_entry *>(i32p);
   for (const SecondLevelPage &page : secondLevelPages) {

lld/MachO/Writer.h

 
 class LoadCommand {
 public:
   virtual ~LoadCommand() = default;
   virtual uint32_t getSize() const = 0;
   virtual void writeTo(uint8_t *buf) const = 0;
 };
 
-void writeResult();
+template <class LP> void writeResult();
 
-void createSyntheticSections();
+template <class LP> void createSyntheticSections();
 
 // Add bindings for symbols that need weak or non-lazy bindings.
 void addNonLazyBindingEntries(const Symbol *, const InputSection *,
                               uint64_t offset, int64_t addend = 0);
 
 extern OutputSection *firstTLVDataSection;
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Writer.cpp

 class LCUuid;
 
 class Writer {
 public:
   Writer() : buffer(errorHandler().outputBuffer) {}
 
   void scanRelocations();
   void scanSymbols();
-  void createOutputSections();
-  void createLoadCommands();
+  template <class LP> void createOutputSections();
+  template <class LP> void createLoadCommands();
   void finalizeAddressses();
   void finalizeLinkEditSegment();
   void assignAddresses(OutputSegment *);
 
   void openFile();
   void writeSections();
   void writeUuid();
   void writeCodeSignature();
   void writeOutputFile();
 
-  void run();
+  template <class LP> void run();
 
   std::unique_ptr<FileOutputBuffer> &buffer;
   uint64_t addr = 0;
   uint64_t fileOff = 0;
   MachHeaderSection *header = nullptr;
   StringTableSection *stringTableSection = nullptr;
   SymtabSection *symtabSection = nullptr;
   IndirectSymtabSection *indirectSymtabSection = nullptr;
void writeTo(uint8_t *buf) const override {
     c->indirectsymoff = indirectSymtabSection->fileOff;
     c->nindirectsyms = indirectSymtabSection->getNumSymbols();
   }
 
   SymtabSection *symtabSection;
   IndirectSymtabSection *indirectSymtabSection;
 };
 
-class LCSegment : public LoadCommand {
+template <class LP> class LCSegment : public LoadCommand {
 public:
   LCSegment(StringRef name, OutputSegment *seg) : name(name), seg(seg) {}
 
-  uint32_t getSize() const override {
-    return sizeof(segment_command_64) +
-           seg->numNonHiddenSections() * sizeof(section_64);
+  uint32_t getSize() const {
+    return sizeof(typename LP::segment_command) +
+           seg->numNonHiddenSections() * sizeof(typename LP::section);
   }
 
-  void writeTo(uint8_t *buf) const override {
-    auto *c = reinterpret_cast<segment_command_64 *>(buf);
-    buf += sizeof(segment_command_64);
+  void writeTo(uint8_t *buf) const {
+    using SegmentCommand = typename LP::segment_command;
+    using Section = typename LP::section;
 
-    c->cmd = LC_SEGMENT_64;
+    auto *c = reinterpret_cast<SegmentCommand *>(buf);
+    buf += sizeof(SegmentCommand);
+
+    c->cmd = LP::segmentLCType;
     c->cmdsize = getSize();
     memcpy(c->segname, name.data(), name.size());
     c->fileoff = seg->fileOff;
     c->maxprot = seg->maxProt;
     c->initprot = seg->initProt;
 
     if (seg->getSections().empty())
       return;
 
     c->vmaddr = seg->firstSection()->addr;
     c->vmsize =
         seg->lastSection()->addr + seg->lastSection()->getSize() - c->vmaddr;
     c->nsects = seg->numNonHiddenSections();
 
     for (const OutputSection *osec : seg->getSections()) {
       if (!isZeroFill(osec->flags)) {
         assert(osec->fileOff >= seg->fileOff);
-        c->filesize = std::max(
+        c->filesize = std::max<uint64_t>(
             c->filesize, osec->fileOff + osec->getFileSize() - seg->fileOff);
       }
 
       if (osec->isHidden())
         continue;
 
-      auto *sectHdr = reinterpret_cast<section_64 *>(buf);
-      buf += sizeof(section_64);
+      auto *sectHdr = reinterpret_cast<Section *>(buf);
+      buf += sizeof(Section);
 
       memcpy(sectHdr->sectname, osec->name.data(), osec->name.size());
       memcpy(sectHdr->segname, name.data(), name.size());
 
       sectHdr->addr = osec->addr;
       sectHdr->offset = osec->fileOff;
       sectHdr->align = Log2_32(osec->align);
       sectHdr->flags = osec->flags;
private:
   const StringRef path = "/usr/lib/dyld";
 };
 
 class LCRPath : public LoadCommand {
 public:
   LCRPath(StringRef path) : path(path) {}
 
   uint32_t getSize() const override {
-    return alignTo(sizeof(rpath_command) + path.size() + 1, WordSize);
+    return alignTo(sizeof(rpath_command) + path.size() + 1, target->wordSize);
   }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<rpath_command *>(buf);
     buf += sizeof(rpath_command);
 
     c->cmd = LC_RPATH;
     c->cmdsize = getSize();

 
 // Adds stubs and bindings where necessary (e.g. if the symbol is a
 // DylibSymbol.)
 static void prepareBranchTarget(Symbol *sym) {
   if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
     if (in.stubs->addEntry(dysym)) {
       if (sym->isWeakDef()) {
         in.binding->addEntry(dysym, in.lazyPointers->isec,
-                             sym->stubsIndex * WordSize);
+                             sym->stubsIndex * target->wordSize);
         in.weakBinding->addEntry(sym, in.lazyPointers->isec,
-                                 sym->stubsIndex * WordSize);
+                                 sym->stubsIndex * target->wordSize);
       } else {
         in.lazyBinding->addEntry(dysym);
       }
     }
   } else if (auto *defined = dyn_cast<Defined>(sym)) {
     if (defined->isExternalWeakDef()) {
       if (in.stubs->addEntry(sym)) {
-        in.rebase->addEntry(in.lazyPointers->isec, sym->stubsIndex * WordSize);
+        in.rebase->addEntry(in.lazyPointers->isec,
+                            sym->stubsIndex * target->wordSize);
         in.weakBinding->addEntry(sym, in.lazyPointers->isec,
-                                 sym->stubsIndex * WordSize);
+                                 sym->stubsIndex * target->wordSize);
       }
     }
   }
 }
 
 // Can a symbol's address can only be resolved at runtime?
 static bool needsBinding(const Symbol *sym) {
   if (isa<DylibSymbol>(sym))
if (const auto *defined = dyn_cast<Defined>(sym)) {
       if (dysym->isDynamicLookup())
         continue;
       dysym->getFile()->refState =
           std::max(dysym->getFile()->refState, dysym->refState);
     }
   }
 }
 
-void Writer::createLoadCommands() {
+template <class LP> void Writer::createLoadCommands() {
   uint8_t segIndex = 0;
   for (OutputSegment *seg : outputSegments) {
-    in.header->addLoadCommand(make<LCSegment>(seg->name, seg));
+    in.header->addLoadCommand(make<LCSegment<LP>>(seg->name, seg));
     seg->index = segIndex++;
   }
 
   in.header->addLoadCommand(make<LCDyldInfo>(
       in.rebase, in.binding, in.weakBinding, in.lazyBinding, in.exports));
   in.header->addLoadCommand(make<LCSymtab>(symtabSection, stringTableSection));
   in.header->addLoadCommand(
       make<LCDysymtab>(symtabSection, indirectSymtabSection));
static NamePair maybeRenameSection(NamePair key) {
   if (newNames != config->sectionRenameMap.end())
     return newNames->second;
   auto newName = config->segmentRenameMap.find(key.first);
   if (newName != config->segmentRenameMap.end())
     return std::make_pair(newName->second, key.second);
   return key;
 }
 
-void Writer::createOutputSections() {
+template <class LP> void Writer::createOutputSections() {
   TimeTraceScope timeScope("Create output sections");
   // First, create hidden sections
   stringTableSection = make<StringTableSection>();
   unwindInfoSection = make<UnwindInfoSection>(); // TODO(gkm): only when no -r
-  symtabSection = make<SymtabSection>(*stringTableSection);
+  symtabSection = makeSymtabSection<LP>(*stringTableSection);
   indirectSymtabSection = make<IndirectSymtabSection>();
   if (config->adhocCodesign)
     codeSignatureSection = make<CodeSignatureSection>();
   if (config->emitFunctionStarts)
     functionStartsSection = make<FunctionStartsSection>();
 
   switch (config->outputType) {
   case MH_EXECUTE:
void Writer::writeOutputFile() {
   writeSections();
   writeUuid();
   writeCodeSignature();
 
   if (auto e = buffer->commit())
     error("failed to write to the output file: " + toString(std::move(e)));
 }
 
-void Writer::run() {
+template <class LP> void Writer::run() {
   prepareBranchTarget(config->entry);
   scanRelocations();
   if (in.stubHelper->isNeeded())
     in.stubHelper->setup();
   scanSymbols();
-  createOutputSections();
+  createOutputSections<LP>();
   // No more sections nor segments are created beyond this point.
   sortSegmentsAndSections();
-  createLoadCommands();
+  createLoadCommands<LP>();
   finalizeAddressses();
   finalizeLinkEditSegment();
   writeMapFile();
   writeOutputFile();
 }
 
-void macho::writeResult() { Writer().run(); }
+template <class LP> void macho::writeResult() { Writer().run<LP>(); }
 
-void macho::createSyntheticSections() {
-  in.header = make<MachHeaderSection>();
+template <class LP> void macho::createSyntheticSections() {
+  in.header = makeMachHeaderSection<LP>();
   in.rebase = make<RebaseSection>();
   in.binding = make<BindingSection>();
   in.weakBinding = make<WeakBindingSection>();
   in.lazyBinding = make<LazyBindingSection>();
   in.exports = make<ExportSection>();
   in.got = make<GotSection>();
   in.tlvPointers = make<TlvPointerSection>();
   in.lazyPointers = make<LazyPointerSection>();
   in.stubs = make<StubsSection>();
   in.stubHelper = make<StubHelperSection>();
   in.imageLoaderCache = make<ImageLoaderCacheSection>();
 }
 
 OutputSection *macho::firstTLVDataSection = nullptr;
+
+template void macho::writeResult<LP64>();
+template void macho::writeResult<ILP32>();
+template void macho::createSyntheticSections<LP64>();
+template void macho::createSyntheticSections<ILP32>();