[lld-macho] Initial scaffolding for ARM32 support

[int3]

Summary

This just parses the -arch armv7 and emits the right header flags.
The rest will be slowly fleshed out in upcoming diffs.

[gkm]

💪🏼

lld/MachO/Arch/ARM.cpp

+//===- ARM.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 "InputFiles.h"
+#include "Symbols.h"
+#include "SyntheticSections.h"
+#include "Target.h"
+
+#include "lld/Common/ErrorHandler.h"
+#include "llvm/BinaryFormat/MachO.h"
+#include "llvm/Support/Endian.h"
+
+using namespace llvm::MachO;
+using namespace llvm::support::endian;
+using namespace lld;
+using namespace lld::macho;
+
+namespace {
+
+struct ARM : TargetInfo {
+  ARM(uint32_t cpuSubtype);
+
+  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;
+
+  void relaxGotLoad(uint8_t *loc, uint8_t type) const override;
+  const RelocAttrs &getRelocAttrs(uint8_t type) const override;
+  uint64_t getPageSize() const override { return 4 * 1024; }
+};
+
+} // namespace
+
+const RelocAttrs &ARM::getRelocAttrs(uint8_t type) const {
+  static const std::array<RelocAttrs, 10> relocAttrsArray{{
+#define B(x) RelocAttrBits::x
+      {"VANILLA", /* FIXME populate this */ B(_0)},
+      {"PAIR", /* FIXME populate this */ B(_0)},
+      {"SECTDIFF", /* FIXME populate this */ B(_0)},
+      {"LOCAL_SECTDIFF", /* FIXME populate this */ B(_0)},
+      {"PB_LA_PTR", /* FIXME populate this */ B(_0)},
+      {"BR24", /* FIXME populate this */ B(_0)},
+      {"BR22", /* FIXME populate this */ B(_0)},
+      {"32BIT_BRANCH", /* FIXME populate this */ B(_0)},
+      {"HALF", /* FIXME populate this */ B(_0)},
+      {"HALF_SECTDIFF", /* FIXME populate this */ B(_0)},
+#undef B
+  }};
+  assert(type < relocAttrsArray.size() && "invalid relocation type");
+  if (type >= relocAttrsArray.size())
+    return invalidRelocAttrs;
+  return relocAttrsArray[type];
+}
+
+int64_t ARM::getEmbeddedAddend(MemoryBufferRef mb, uint64_t offset,
+                               relocation_info rel) const {
+  fatal("TODO: implement this");
+}
+
+void ARM::relocateOne(uint8_t *loc, const Reloc &r, uint64_t value,
+                      uint64_t relocVA) const {
+  fatal("TODO: implement this");
+}
+
+void ARM::writeStub(uint8_t *buf, const Symbol &sym) const {
+  fatal("TODO: implement this");
+}
+
+void ARM::writeStubHelperHeader(uint8_t *buf) const {
+  fatal("TODO: implement this");
+}
+
+void ARM::writeStubHelperEntry(uint8_t *buf, const DylibSymbol &sym,
+                               uint64_t entryAddr) const {
+  fatal("TODO: implement this");
+}
+
+void ARM::relaxGotLoad(uint8_t *loc, uint8_t type) const {
+  fatal("TODO: implement this");
+}
+
+ARM::ARM(uint32_t cpuSubtype) : TargetInfo(ILP32()) {
+  cpuType = CPU_TYPE_ARM;
+  this->cpuSubtype = cpuSubtype;
+
+  stubSize = 0 /* FIXME */;
+  stubHelperHeaderSize = 0 /* FIXME */;
+  stubHelperEntrySize = 0 /* FIXME */;
+}
+
+TargetInfo *macho::createARMTargetInfo(uint32_t cpuSubtype) {
+  static ARM t(cpuSubtype);
+  return &t;
+}

lld/MachO/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(MachOOptionsTableGen)
 
 include_directories(${LLVM_MAIN_SRC_DIR}/../libunwind/include)
 
 add_lld_library(lldMachO2
-  Arch/X86_64.cpp
+  Arch/ARM.cpp
   Arch/ARM64.cpp
   Arch/ARM64Common.cpp
   Arch/ARM64_32.cpp
+  Arch/X86_64.cpp
   UnwindInfoSection.cpp
   Driver.cpp
   DriverUtils.cpp
   Dwarf.cpp
   ExportTrie.cpp
   InputFiles.cpp
   InputSection.cpp
   LTO.cpp

lld/MachO/Driver.cpp

static TargetInfo *createTargetInfo(InputArgList &args) {
   StringRef archName = args.getLastArgValue(OPT_arch);
   if (archName.empty())
     fatal("must specify -arch");
   PlatformKind platform = parsePlatformVersion(args);
 
   config->platformInfo.target =
       MachO::Target(getArchitectureFromName(archName), platform);
 
-  switch (getCPUTypeFromArchitecture(config->arch()).first) {
+  uint32_t cpuType;
+  uint32_t cpuSubtype;
+  std::tie(cpuType, cpuSubtype) = getCPUTypeFromArchitecture(config->arch());
+
+  switch (cpuType) {
   case CPU_TYPE_X86_64:
     return createX86_64TargetInfo();
   case CPU_TYPE_ARM64:
     return createARM64TargetInfo();
   case CPU_TYPE_ARM64_32:
     return createARM64_32TargetInfo();
+  case CPU_TYPE_ARM:
+    return createARMTargetInfo(cpuSubtype);
   default:
     fatal("missing or unsupported -arch " + archName);
   }
 }
 
 static UndefinedSymbolTreatment
 getUndefinedSymbolTreatment(const ArgList &args) {
   StringRef treatmentStr = args.getLastArgValue(OPT_undefined);

lld/MachO/Target.h

public:
   size_t stubHelperHeaderSize;
   size_t stubHelperEntrySize;
   size_t wordSize;
 };
 
 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;
 

lld/test/MachO/Inputs/WatchOS.sdk/usr/lib/libSystem.tbd

 --- !tapi-tbd
 tbd-version:     4
-targets:         [ armv7k-watchos, arm64_32-watchos ]
+targets:         [ armv7k-watchos, arm64_32-watchos, armv7-watchos ]
 uuids:
   - target:          armv7k-watchos
     value:           00000000-0000-0000-0000-000000000001
   - target:          arm64_32-watchos
     value:           00000000-0000-0000-0000-000000000002
 install-name:    '/usr/lib/libSystem.dylib'
 current-version: 1.0.0
 exports:
-  - targets:         [ arm64_32-watchos, armv7k-watchos ]
+  - targets:         [ arm64_32-watchos, armv7k-watchos, armv7-watchos ]
     symbols:         [ dyld_stub_binder ]
 ...

lld/test/MachO/Inputs/WatchOS.sdk/usr/lib/libc++.tbd

 --- !tapi-tbd
 tbd-version:     4
-targets:         [ armv7k-watchos, arm64_32-watchos ]
+targets:         [ armv7k-watchos, arm64_32-watchos, armv7-watchos ]
 uuids:
   - target:          armv7k-watchos
     value:           00000000-0000-0000-0000-000000000001
   - target:          arm64_32-watchos
     value:           00000000-0000-0000-0000-000000000002
 install-name:    '/usr/lib/libc++.dylib'
 current-version: 1.0.0
 reexported-libraries:
-  - targets:         [ arm64_32-watchos, armv7k-watchos ]
+  - targets:         [ arm64_32-watchos, armv7k-watchos, armv7-watchos ]
     libraries:       [ '/usr/lib/libc++abi.dylib' ]
 ...

lld/test/MachO/Inputs/WatchOS.sdk/usr/lib/libc++abi.tbd

 --- !tapi-tbd
 tbd-version:     4
-targets:         [ armv7k-watchos, arm64_32-watchos ]
+targets:         [ armv7k-watchos, arm64_32-watchos, armv7-watchos ]
 uuids:
   - target:          armv7k-watchos
     value:           00000000-0000-0000-0000-000000000001
   - target:          arm64_32-watchos
     value:           00000000-0000-0000-0000-000000000002
 install-name:    '/usr/lib/libc++abi.dylib'
 current-version: 1.0.0
 exports:
-  - targets:         [ arm64_32-watchos, armv7k-watchos ]
+  - targets:         [ arm64_32-watchos, armv7k-watchos, armv7-watchos ]
     symbols:         [ ___gxx_personality_v0 ]
 ...

lld/test/MachO/header.s

 # REQUIRES: x86, aarch64, arm
 # RUN: rm -rf %t && mkdir -p %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/x86-64-test.o
 # RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin %s -o %t/arm64-test.o
 # RUN: llvm-mc -filetype=obj -triple=arm64_32-apple-watchos %s -o %t/arm64-32-test.o
 # RUN: llvm-mc -filetype=obj -triple=arm64_32-apple-watchos %s -o %t/arm64-32-test.o
+# RUN: llvm-mc -filetype=obj -triple=armv7-apple-watchos %s -o %t/arm-test.o
 
 # RUN: %lld -lSystem -arch x86_64 -o %t/x86-64-executable %t/x86-64-test.o
 # RUN: %lld -lSystem -arch arm64 -o %t/arm64-executable %t/arm64-test.o
 # RUN: %lld-watchos -lSystem -o %t/arm64-32-executable %t/arm64-32-test.o
+# RUN: %lld-watchos -lSystem -arch armv7 -o %t/arm-executable %t/arm-test.o
+
 # RUN: %lld -arch x86_64 -dylib -o %t/x86-64-dylib %t/x86-64-test.o
 
 ## NOTE: recent versions of ld64 don't emit LIB64 for x86-64-executable, maybe we should follow suit
 # RUN: llvm-objdump --macho --private-header %t/x86-64-executable | FileCheck %s --check-prefix=EXEC -DCPU=X86_64 -DSUBTYPE=ALL -DCAPS=LIB64
 # RUN: llvm-objdump --macho --private-header %t/arm64-executable | FileCheck %s --check-prefix=EXEC -DCPU=ARM64 -DSUBTYPE=ALL -DCAPS=0x00
 # RUN: llvm-objdump --macho --private-header %t/arm64-32-executable | FileCheck %s --check-prefix=EXEC -DCPU=ARM64_32 -DSUBTYPE=V8 -DCAPS=0x00
+# RUN: llvm-objdump --macho --private-header %t/arm-executable | FileCheck %s  --check-prefix=EXEC -DCPU=ARM -DSUBTYPE=V7 -DCAPS=0x00
+
 # RUN: llvm-objdump --macho --private-header %t/x86-64-dylib | FileCheck %s --check-prefix=DYLIB -DCPU=X86_64 -DSUBTYPE=ALL -DCAPS=0x00
 
 # EXEC:      magic               cputype  cpusubtype   caps     filetype {{.*}} flags
 # EXEC-NEXT: MH_MAGIC{{(_64)?}}  [[CPU]]  [[SUBTYPE]]  [[CAPS]] EXECUTE  {{.*}} NOUNDEFS DYLDLINK TWOLEVEL PIE{{$}}
 
 # DYLIB:      magic                  cputype  cpusubtype   caps      filetype {{.*}} flags
 # DYLIB-NEXT: MH_MAGIC_64{{(_64)?}}  [[CPU]]  [[SUBTYPE]]  [[CAPS]]  DYLIB    {{.*}} NOUNDEFS DYLDLINK TWOLEVEL NO_REEXPORTED_DYLIBS{{$}}
 
 .globl _main
 _main: