[lld-macho] Infer machine type from input files

[int3]

Summary

I initially tried to do this by mirroring LLD-ELF's architecture of having
InputFile construction separated from parsing of the file contents. However, I
think that model is a bit more of an awkward fit for Mach-O with its .tbd files --
since one TBD file can generate multiple corresponding InputFiles, there
isn't a 1:1 mapping between unparsed buffers and InputFile objects. Moreover, I
found having files in an unparsed state & having to remember to parse them
before use was confusing in general.

As such, I've decided to have us infer the machine type by scanning the input
object files without constructing them. While this does mean that we read in one
extra page per file in the worst case, I think there should be almost no
overhead in practice, since 1. we'll usually succeed in inferring the type from
the first file we examine, 2. we're only reading in one page, and 3. this entire
logic can be bypassed by specifying -arch on the command line.

Note that we only look at object files (and not bitcode) when doing this
inference. This matches ld64's behavior, though I suppose it would be nice to
support inference from bitcode in the future.

[int3]

lld/test/MachO/reproduce-thin-archives.s

9

since we no longer default to x86_64, tests which do not pass in an object file will have to specify the arch manually

[thakis]

I think there should be almost no
overhead in practice, since 1. we'll usually succeed in inferring the type from
the first file we examine, 2. we're only reading in one page, and 3. this entire
logic can be bypassed by specifying -arch on the command line.

Hm, 1 isn't true if most files are fat .o files. 2. isn't really true since it's kind of bad for the disk cache to open the first page of every obj and then walk all of them again (especially on spinning disks), and if we believe 3 is the way to go, maybe we should just always require -arch? Usually the linker is called through clang anyways, which passes it in.

[int3]

Hmm good point about #1, I wasn't sure how common fat binary builds were but @smeenai pointed out that with the introduction of M1 they're going to be more likely. Re #2, I think the same issue plagues LLD-ELF, at least if my mental model of the disk cache is right: even though it doesn't mmap the input files twice, it checks the machine type by reading the first page, then goes back later and reads in the rest of the file, which results in similar disk cache effects. But you do make a good point about this not being a super useful feature given that LLD is not typically invoked directly... this just saves us some boilerplate in tests for questionable code complexity.

[thakis]

Sounds like we should require -arch, at least for now :)

(https://bugs.llvm.org/show_bug.cgi?id=38965 has a years-long monologue of me looking at a tangentially-related problem every now and then.)

[int3]

I realize we should actually validate against the platform as well. ld64 likewise can infer the platform from its inputs. We could make lld require the platform to be explicitly specified, however I think sprinkling -platform_version all over our tests is going to be pretty ugly. How do you feel about aliases like %lld-x86_64 and %lld-arm64 that expand into include both an arch and a platform flag? I expect that most of our tests will be fine with using e.g. just the macOS platform.

[thakis]

In D97426#2595362, @int3 wrote:

I realize we should actually validate against the platform as well. ld64 likewise can infer the platform from its inputs. We could make lld require the platform to be explicitly specified, however I think sprinkling -platform_version all over our tests is going to be pretty ugly. How do you feel about aliases like %lld-x86_64 and %lld-arm64 that expand into include both an arch and a platform flag? I expect that most of our tests will be fine with using e.g. just the macOS platform.

Sounds fine. Maybe just %lld can expand to ... -arch x86_64 -platform_version macos ... and if a test wants something else they can add another flag, which should win over the earlier one?

[int3]

Yup, sounds good :)

[oontvoo]

lld/MachO/Driver.cpp

148

But isn't this still technically UB? Would the UBSAN builds complain?

[int3]

lld/MachO/Driver.cpp

148

hm, why would it be UB?

In any case, per the other comments, I'm going to kill all this inferMachineType logic and just have things specified explicitly.

[int3]

Replaced by D97799

lld/MachO/Driver.cpp

for (StringRef dir : config->frameworkSearchPaths) {
     }
 
     if (Optional<std::string> path = resolveDylibPath(symlink))
       return path;
   }
   return {};
 }
 
-static TargetInfo *createTargetInfo(opt::InputArgList &args) {
-  // TODO: should unspecified arch be an error rather than defaulting?
-  // Jez: ld64 seems to make unspecified arch an error when LTO is
-  // being used. I'm not sure why though. Feels like we should be able
-  // to infer the arch from our input files regardless
-  StringRef archName = args.getLastArgValue(OPT_arch, "x86_64");
+// Read the first few bytes of \p path and try to determine its type.
+static MachO::Architecture inferMachineType(StringRef path) {
+  auto mbOrErr = MemoryBuffer::getFileSlice(
+      path, /*MapSize=*/sizeof(mach_header_64), /*Offset=*/0);
+  if (auto ec = mbOrErr.getError()) {
+    error("cannot open " + path + ": " + ec.message());
+    return AK_unknown;
+  }
+
+  std::unique_ptr<MemoryBuffer> &mb = *mbOrErr;
+  MemoryBufferRef mbref = mb->getMemBufferRef();
+
+  const char *buf = mbref.getBufferStart();
+  auto *hdr = reinterpret_cast<const MachO::fat_header *>(buf);
+  if (support::endian::read32be(&hdr->magic) == MachO::FAT_MAGIC)
+    return AK_unknown;
+
+  if (identify_magic(mbref.getBuffer()) == file_magic::macho_object) {
+    // It doesn't matter whether we cast to the 32- or 64-bit versions of the
+    // mach header, the two fields we care about have the same size & layout.
+    auto *hdr = reinterpret_cast<const mach_header_64 *>(buf);
+    return MachO::getArchitectureFromCpuType(hdr->cputype, hdr->cpusubtype);
+  }
+
+  return AK_unknown;
+}
+
+// We only consider non-fat object files when inferring the machine type.
+static MachO::Architecture inferMachineType(const opt::InputArgList &args) {
+  for (const auto &arg : args) {
+    const auto &opt = arg->getOption();
+    switch (opt.getID()) {
+    case OPT_INPUT: {
+      auto arch = inferMachineType(arg->getValue());
+      if (arch != AK_unknown)
+        return arch;
+      break;
+    }
+    case OPT_filelist:
+      Optional<MemoryBufferRef> buffer = readFile(arg->getValue());
+      if (!buffer)
+        continue;
+      for (StringRef path : args::getLines(*buffer)) {
+        auto arch = inferMachineType(path);
+        if (arch != AK_unknown)
+          return arch;
+      }
+      break;
+    }
+  }
+  return AK_unknown;
+}
+
+static TargetInfo *createTargetInfo(const opt::InputArgList &args) {
+  if (args.hasArg(OPT_arch)) {
+    StringRef archName = args.getLastArgValue(OPT_arch);
     config->arch = MachO::getArchitectureFromName(archName);
-  switch (MachO::getCPUTypeFromArchitecture(config->arch).first) {
-  case MachO::CPU_TYPE_X86_64:
+    if (config->arch == AK_unknown)
+      error("invalid -arch " + archName);
+  } else {
+    config->arch = inferMachineType(args);
+    if (config->arch == AK_unknown)
+      error("unable to infer architecture from input files, please use -arch "
+            "to specify");
+  }
+
+  switch (config->arch) {
+  case MachO::AK_x86_64:
+  case MachO::AK_x86_64h:
     return createX86_64TargetInfo();
-  case MachO::CPU_TYPE_ARM64:
+  case MachO::AK_arm64:
+  case MachO::AK_arm64e:
     return createARM64TargetInfo();
+  case MachO::AK_unknown:
+    return createUnknownTargetInfo();
   default:
-    fatal("missing or unsupported -arch " + archName);
+    error("unsupported architecture " + getArchitectureName(config->arch));
+    config->arch = AK_unknown;
+    return createUnknownTargetInfo();
   }
 }
 
 static bool warnIfNotDirectory(StringRef option, StringRef path) {
   if (!fs::exists(path)) {
     warn("directory not found for option -" + option + path);
     return false;
   } else if (!fs::is_directory(path)) {

 static bool isPie(opt::InputArgList &args) {
   if (config->outputType != MH_EXECUTE || args.hasArg(OPT_no_pie))
     return false;
   if (config->arch == AK_arm64 || config->arch == AK_arm64e)
     return true;
 
   // TODO: add logic here as we support more archs. E.g. i386 should default
   // to PIE from 10.7
-  assert(config->arch == AK_x86_64 || config->arch == AK_x86_64h);
+  assert(config->arch == AK_unknown || config->arch == AK_x86_64 ||
+         config->arch == AK_x86_64h);
 
   PlatformKind kind = config->platform.kind;
   if (kind == PlatformKind::macOS &&
       config->platform.minimum >= VersionTuple(10, 6))
     return true;
 
   if (kind == PlatformKind::iOSSimulator || kind == PlatformKind::driverKit)
     return true;
if (errOrWriter) {
       tar->append("version.txt", getLLDVersion() + "\n");
     } else {
       error("--reproduce: " + toString(errOrWriter.takeError()));
     }
   }
 
   config = make<Configuration>();
   symtab = make<SymbolTable>();
-  target = createTargetInfo(args);
 
   config->entry = symtab->addUndefined(args.getLastArgValue(OPT_e, "_main"),
                                        /*file=*/nullptr,
                                        /*isWeakRef=*/false);
   for (auto *arg : args.filtered(OPT_u)) {
     config->explicitUndefineds.push_back(symtab->addUndefined(
         arg->getValue(), /*file=*/nullptr, /*isWeakRef=*/false));
   }
if (args.hasArg(OPT_v)) {
     message(StringRef("Framework search paths:") +
             (config->frameworkSearchPaths.size()
                  ? "\n\t" + join(config->frameworkSearchPaths, "\n\t")
                  : ""));
     freeArena();
     return !errorCount();
   }
 
-  initLLVM(); // must be run before any call to addFile()
+  // These must be run before any call to addFile().
+  target = createTargetInfo(args);
+  initLLVM();
 
   for (const auto &arg : args) {
     const auto &opt = arg->getOption();
     warnIfDeprecatedOption(opt);
     warnIfUnimplementedOption(opt);
 
     // TODO: are any of these better handled via filtered() or getLastArg()?
     switch (opt.getID()) {

lld/MachO/Target.h

public:
 
   size_t stubSize;
   size_t stubHelperHeaderSize;
   size_t stubHelperEntrySize;
 };
 
 TargetInfo *createX86_64TargetInfo();
 TargetInfo *createARM64TargetInfo();
+TargetInfo *createUnknownTargetInfo();
 
 extern TargetInfo *target;
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Target.cpp

bool TargetInfo::validateSymbolRelocation(const Symbol *sym,
   if (relocAttrs.hasAttr(RelocAttrBits::DYSYM8) && isa<DylibSymbol>(sym) &&
       r.length != 3)
     error(message("has width " + std::to_string(1 << r.length) +
                   " bytes, but must be 8 bytes"));
 
   return valid;
 }
 
+// Dummy target that we use when we cannot figure out the right target. We
+// obviously cannot emit any valid binaries with this target; it's just
+// initialized in order that we can emit additional error messages before
+// exiting.
+class UnknownTarget : public TargetInfo {
+public:
+  UnknownTarget();
+
+  uint64_t
+  getEmbeddedAddend(llvm::MemoryBufferRef, const llvm::MachO::section_64 &,
+                    const llvm::MachO::relocation_info) const override {
+    return 0;
+  }
+
+  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 {
+    llvm_unreachable("unknown arch has no relocations");
+  }
+
+  uint64_t getPageSize() const override { return 1024; }
+};
+
+UnknownTarget::UnknownTarget() {
+  cpuType = 0;
+  cpuSubtype = 0;
+}
+
+TargetInfo *macho::createUnknownTargetInfo() {
+  static UnknownTarget t;
+  return &t;
+}
+
 TargetInfo *macho::target = nullptr;

lld/test/MachO/arch.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-darwin %s -o %t.o
 # RUN: %lld -o /dev/null %t.o
-# RUN: not %lld -arch i386 -o /dev/null %t.o 2>&1 | FileCheck %s
-# CHECK: error: missing or unsupported -arch i386
+# RUN: not %lld -arch i386 -o /dev/null %t.o 2>&1 | FileCheck %s --check-prefix=I386
+# RUN: not %lld -arch foo -o /dev/null %t.o 2>&1 | FileCheck %s --check-prefix=FOO
+# RUN: rm -f %t.a
+# RUN: llvm-ar rcs %t.a %t.o
+# RUN: not %lld -o /dev/null %t.a 2>&1 | FileCheck %s --check-prefix=ARCHIVE
+
+# I386: error: unsupported architecture i386
+# FOO: error: invalid -arch foo
+# ARCHIVE: error: unable to infer architecture from input files, please use -arch to specify
 
 .text
 .global _main
 _main:
   mov $0, %rax
   ret

lld/test/MachO/arm64-reloc-got-load.s

 # REQUIRES: aarch64
 
 # RUN: rm -rf %t; split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin %t/main.s -o %t/main.o
 # RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin %t/foobar.s -o %t/foobar.o
 
-# RUN: %lld -lSystem -arch arm64 -o %t/static %t/main.o %t/foobar.o
+# RUN: %lld -lSystem -o %t/static %t/main.o %t/foobar.o
 # RUN: llvm-objdump --macho -d --no-show-raw-insn --syms %t/static | FileCheck %s --check-prefix=STATIC
 
-# RUN: %lld -lSystem -arch arm64 -dylib -o %t/libfoo.dylib %t/foobar.o
-# RUN: %lld -lSystem -arch arm64 -o %t/main %t/main.o %t/libfoo.dylib
+# RUN: %lld -lSystem -dylib -o %t/libfoo.dylib %t/foobar.o
+# RUN: %lld -lSystem -o %t/main %t/main.o %t/libfoo.dylib
 # RUN: llvm-objdump --macho -d --no-show-raw-insn --section-headers %t/main | FileCheck %s --check-prefix=DYLIB
 
 # STATIC-LABEL: _main:
 # STATIC-NEXT:  adrp  x8, [[#]] ; 0x[[#%x,PAGE:]]
 # STATIC-NEXT:  add x8, x8, #[[#%u,FOO_OFF:]]
 # STATIC-NEXT:  adrp  x8, [[#]] ; 0x[[#PAGE]]
 # STATIC-NEXT:  add x8, x8, #[[#%u,BAR_OFF:]]
 # STATIC-NEXT:  ret

lld/test/MachO/arm64-reloc-pointer-to-got.s

 # REQUIRES: aarch64
 
 # RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin %s -o %t.o
-# RUN: %lld -lSystem -arch arm64 -o %t %t.o
+# RUN: %lld -lSystem -o %t %t.o
 # RUN: llvm-objdump --macho -d --full-contents --section-headers %t | FileCheck %s
 
 ## FIXME: Even though we have reserved a GOT slot for _foo due to
 ## POINTER_TO_GOT, we should still be able to relax this GOT_LOAD reference to
 ## it.
 # CHECK:      _main:
 # CHECK-NEXT: adrp  x8, [[#]] ;
 # CHECK-NEXT: ldr x8, [x8] ; literal pool symbol address: _foo

lld/test/MachO/arm64-relocs.s

 # REQUIRES: aarch64, shell
 # RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin %s -o %t.o
-# RUN: %lld -dylib -arch arm64 -lSystem -o %t %t.o
+# RUN: %lld -dylib -lSystem -o %t %t.o
 # RUN: (llvm-objdump --syms %t; llvm-objdump --macho -d --section=__const %t) | FileCheck %s
 
 # CHECK-LABEL: SYMBOL TABLE:
 # CHECK-DAG:   [[#%x,PTR_1:]] l     O __DATA_CONST,__const _ptr_1
 # CHECK-DAG:   [[#%x,PTR_2:]] l     O __DATA_CONST,__const _ptr_2
 # CHECK-DAG:   [[#%x,BAR:]]   g     F __TEXT,__text _bar
 # CHECK-DAG:   [[#%x,BAZ:]]   g     O __DATA,__data _baz
 

lld/test/MachO/codemodel.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
-; RUN: %lld -lSystem %t.o -o %ts -mllvm -code-model=small
-; RUN: %lld -lSystem %t.o -o %tl -mllvm -code-model=large
+; RUN: %lld -arch x86_64 -lSystem %t.o -o %ts -mllvm -code-model=small
+; RUN: %lld -arch x86_64 -lSystem %t.o -o %tl -mllvm -code-model=large
 ; RUN: llvm-objdump -d %ts | FileCheck %s --check-prefix=CHECK-SMALL
 ; RUN: llvm-objdump -d %tl | FileCheck %s --check-prefix=CHECK-LARGE
 
 target triple = "x86_64-apple-darwin"
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 @data = internal constant [0 x i32] []
 
 define i32* @main() nounwind readonly {
 entry:
 ; CHECK-SMALL-LABEL: <_main>:
 ; CHECK-SMALL:       leaq    [[#]](%rip), %rax
 ; CHECK-LARGE-LABEL: <_main>:
 ; CHECK-LARGE:       movabsq $[[#]], %rax
   ret i32* getelementptr ([0 x i32], [0 x i32]* @data, i64 0, i64 0)
 }

lld/test/MachO/cpu-string.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 
-; RUN: %lld %t.o -o %t.dylib -dylib
+; RUN: %lld -arch x86_64 %t.o -o %t.dylib -dylib
 ; RUN: llvm-objdump -d --section="__text" --no-leading-addr --no-show-raw-insn %t.dylib | FileCheck %s
 ; CHECK: nop{{$}}
 
-; RUN: %lld -mcpu znver1 %t.o -o %t.znver1.dylib -dylib
+; RUN: %lld -arch x86_64 -mcpu znver1 %t.o -o %t.znver1.dylib -dylib
 ; RUN: llvm-objdump -d --section="__text" --no-leading-addr --no-show-raw-insn %t.znver1.dylib | FileCheck %s --check-prefix=ZNVER1
 
 ; ZNVER1: nopw
 ; ZNVER1-NOT: nop{{$}}
 
 target triple = "x86_64-apple-darwin"
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @foo() #0 {
 entry:
   call void asm sideeffect ".p2align        4, 0x90", "~{dirflag},~{fpsr},~{flags}"()
   ret void
 }
 
 attributes #0 = { "frame-pointer"="all" }

lld/test/MachO/fat-arch.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=i386-apple-darwin %s -o %t.i386.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.x86_64.o
 # RUN: llvm-lipo %t.i386.o %t.x86_64.o -create -o %t.fat.o
-# RUN: %lld -o /dev/null %t.fat.o
+# RUN: %lld -arch x86_64 -o /dev/null %t.fat.o
 
 # RUN: llvm-lipo %t.i386.o -create -o %t.noarch.o
-# RUN: not %lld -o /dev/null %t.noarch.o 2>&1 | \
+# RUN: not %lld -arch x86_64 -o /dev/null %t.noarch.o 2>&1 | \
 # RUN:    FileCheck %s -DFILE=%t.noarch.o
 # CHECK: error: unable to find matching architecture in [[FILE]]
 
 .text
 .global _main
 _main:
   mov $0, %eax
   ret

lld/test/MachO/header.s

 # REQUIRES: x86, aarch64
 # 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: %lld -arch x86_64 -platform_version macos 10.5.0 11.0 -o %t/x86-64-executable %t/x86_64-test.o
-# RUN: %lld -arch arm64 -o %t/arm64-executable %t/arm64-test.o
-# RUN: %lld -arch x86_64 -dylib -o %t/x86-64-dylib %t/x86_64-test.o
-# RUN: %lld -arch arm64  -dylib -o %t/arm64-dylib %t/arm64-test.o
+# RUN: %lld -platform_version macos 10.5.0 11.0 -o %t/x86-64-executable %t/x86_64-test.o
+# RUN: %lld -o %t/arm64-executable %t/arm64-test.o
+# RUN: %lld -dylib -o %t/x86-64-dylib %t/x86_64-test.o
+# RUN: %lld -dylib -o %t/arm64-dylib %t/arm64-test.o
 
 # RUN: llvm-objdump --macho --all-headers %t/x86-64-executable | FileCheck %s -DCAPS=LIB64
 # RUN: llvm-objdump --macho --all-headers %t/arm64-executable | FileCheck %s -DCAPS=0x00
 # RUN: llvm-objdump --macho --all-headers %t/x86-64-dylib | FileCheck %s -DCAPS=0x00
 # RUN: llvm-objdump --macho --all-headers %t/arm64-dylib | FileCheck %s -DCAPS=0x00
 
 # CHECK:      magic        cputype cpusubtype  caps    filetype
 # CHECK-NEXT: MH_MAGIC_64  {{.*}}         ALL  [[CAPS]]   {{.*}}
 
 .globl _main
 _main:
   ret

lld/test/MachO/invalid/invalid-executable.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-darwin %s -o %t.o
-# RUN: %lld -o %t %t.o
-# RUN: not %lld -o /dev/null %t 2>&1 | FileCheck %s -DFILE=%t
+# RUN: %lld -lSystem -o %t %t.o
+# RUN: not %lld -lSystem -o /dev/null %t 2>&1 | FileCheck %s -DFILE=%t
 # CHECK: error: [[FILE]]: unhandled file type
 
 .text
 .global _main
 _main:
   mov $0, %rax
   ret

lld/test/MachO/invalid/invalid-fat-offset.s

 # REQUIRES: x86
 # RUN: yaml2obj %s -o %t.o
-# RUN: not %lld -o /dev/null %t.o 2>&1 | \
+# RUN: not %lld -arch x86_64 -o /dev/null %t.o 2>&1 | \
 # RUN:    FileCheck %s -DFILE=%t.o
 # CHECK: error: [[FILE]]: slice extends beyond end of file
 
 !fat-mach-o
 FatHeader:
   magic:           0xCAFEBABE
   nfat_arch:       2
 FatArchs:

lld/test/MachO/invalid/invalid-relocation-pcrel.yaml

 # REQUIRES: x86
 # RUN: rm -rf %t; mkdir %t
 # RUN: yaml2obj %s -o %t/test.o
 # RUN: llvm-ar rcs %t/test.a %t/test.o
-# RUN: not %lld -o /dev/null %t/test.a 2>&1 | FileCheck %s
+# RUN: not %lld -arch x86_64 -o /dev/null %t/test.a 2>&1 | FileCheck %s
 #
 # CHECK: error: UNSIGNED relocation must not be PC-relative at offset 1 of __TEXT,__text in {{.*}}test.a(test.o)
 
 !mach-o
 FileHeader:
   magic:           0xFEEDFACF
   cputype:         0x01000007
   cpusubtype:      0x00000003

lld/test/MachO/lc-linker-option.ll

 # REQUIRES: x86
 # RUN: rm -rf %t
 # RUN: split-file %s %t
 
 # RUN: llvm-as %t/framework.ll -o %t/framework.o
-# RUN: %lld %t/framework.o -o %t/frame
+# RUN: %lld -arch x86_64 %t/framework.o -o %t/frame
 # RUN: llvm-objdump --macho --all-headers %t/frame | FileCheck --check-prefix=FRAME %s \
 # RUN:  --implicit-check-not LC_LOAD_DYLIB
 # FRAME:          cmd LC_LOAD_DYLIB
 # FRAME-NEXT: cmdsize
 # FRAME-NEXT:    name /System/Library/Frameworks/CoreFoundation.framework/CoreFoundation
 
 # RUN: llvm-as %t/l.ll -o %t/l.o
-# RUN: %lld %t/l.o -o %t/l
+# RUN: %lld -arch x86_64 %t/l.o -o %t/l
 # RUN: llvm-objdump --macho --all-headers %t/l | FileCheck --check-prefix=LIB %s \
 # RUN:  --implicit-check-not LC_LOAD_DYLIB
 
 ## Check that we don't create duplicate LC_LOAD_DYLIBs.
-# RUN: %lld -lSystem %t/l.o -o %t/l
+# RUN: %lld -arch x86_64 -lSystem %t/l.o -o %t/l
 # RUN: llvm-objdump --macho --all-headers %t/l | FileCheck --check-prefix=LIB %s \
 # RUN:  --implicit-check-not LC_LOAD_DYLIB
 # LIB:          cmd LC_LOAD_DYLIB
 # LIB-NEXT: cmdsize
 # LIB-NEXT:    name /usr/lib/libSystem.B.dylib
 
 # RUN: llvm-as %t/invalid.ll -o %t/invalid.o
-# RUN: not %lld %t/invalid.o -o /dev/null 2>&1 | FileCheck --check-prefix=INVALID %s
+# RUN: not %lld -arch x86_64 %t/invalid.o -o /dev/null 2>&1 | FileCheck --check-prefix=INVALID %s
 # INVALID: error: -why_load is not allowed in LC_LINKER_OPTION
 
 #--- framework.ll
 target triple = "x86_64-apple-macosx10.15.0"
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 !0 = !{!"-framework", !"CoreFoundation"}
 !llvm.linker.options = !{!0}

lld/test/MachO/linkonce.ll

 ; REQUIRES: x86
 ; RUN: rm -rf %t; split-file %s %t
 ; RUN: opt -module-summary %t/first.ll -o %t/first.o
 ; RUN: opt -module-summary %t/second.ll -o %t/second.o
-; RUN: %lld -dylib -lSystem %t/first.o %t/second.o -o %t/12
+; RUN: %lld -arch x86_64 -dylib -lSystem %t/first.o %t/second.o -o %t/12
 ; RUN: llvm-objdump --syms %t/12 | FileCheck %s --check-prefix=FIRST
-; RUN: %lld -dylib -lSystem %t/second.o %t/first.o -o %t/21
+; RUN: %lld -arch x86_64 -dylib -lSystem %t/second.o %t/first.o -o %t/21
 ; RUN: llvm-objdump --syms %t/21 | FileCheck %s --check-prefix=SECOND
 
 ; FIRST:  w    O __TEXT,first  _foo
 ; SECOND: w    O __TEXT,second _foo
 
 #--- first.ll
 
 target triple = "x86_64-apple-macosx10.15.0"

lld/test/MachO/lto-object-path.ll

 ; REQUIRES: x86
 ; UNSUPPORTED: system-windows
 
 ; RUN: rm -rf %t; mkdir %t
 ; RUN: llvm-as %s -o %t/test.o
 
-; RUN: %lld %t/test.o -o %t/test
+; RUN: %lld -arch x86_64 %t/test.o -o %t/test
 ; RUN: llvm-nm -pa %t/test | FileCheck %s --check-prefixes CHECK,NOOBJPATH
 
-; RUN: %lld %t/test.o -o %t/test -object_path_lto %t/lto-temps
+; RUN: %lld -arch x86_64 %t/test.o -o %t/test -object_path_lto %t/lto-temps
 ; RUN: llvm-nm -pa %t/test | FileCheck %s --check-prefixes CHECK,OBJPATH -DDIR=%t/lto-temps
 
 ; CHECK:          0000000000000000                - 00 0000    SO /tmp/test.cpp
 ; NOOBJPATH-NEXT: 0000000000000000                - 03 0001   OSO /tmp/lto.tmp
 ;; check that modTime is nonzero when `-object_path_lto` is provided
 ; OBJPATH-NEXT:   {{[0-9a-f]*[1-9a-f]+[0-9a-f]*}} - 03 0001   OSO [[DIR]]/0.x86_64.lto.o
 ; CHECK-NEXT:     {{[0-9a-f]+}}                   - 01 0000   FUN _main
 ; CHECK-NEXT:     0000000000000001                - 00 0000   FUN

lld/test/MachO/lto-save-temps.ll

 ; REQUIRES: x86
 
 ; Test that we compile regular LTO inputs in a single task but handle ThinLTO
 ; modules in separate tasks.
 
 ; RUN: rm -rf %t; split-file %s %t
 ; RUN: llvm-as %t/foo.ll -o %t/foo.o
 ; RUN: llvm-as %t/test.ll -o %t/test.o
-; RUN: %lld -save-temps %t/foo.o %t/test.o -o %t/test
+; RUN: %lld -arch x86_64 -save-temps %t/foo.o %t/test.o -o %t/test
 ; RUN: llvm-objdump -d --no-show-raw-insn %t/test.lto.o | FileCheck %s --check-prefix=ALL
 ; RUN: llvm-objdump -d --no-show-raw-insn %t/test | FileCheck %s --check-prefix=ALL
 
 ; RUN: rm -rf %t; split-file %s %t
 ; RUN: opt -module-summary %t/foo.ll -o %t/foo.o
 ; RUN: opt -module-summary %t/test.ll -o %t/test.o
-; RUN: %lld -save-temps %t/foo.o %t/test.o -o %t/test
+; RUN: %lld -arch x86_64 -save-temps %t/foo.o %t/test.o -o %t/test
 ; RUN: llvm-objdump -d --no-show-raw-insn %t/test1.lto.o | FileCheck %s --check-prefix=FOO
 ; RUN: llvm-objdump -d --no-show-raw-insn %t/test2.lto.o | FileCheck %s --check-prefix=MAIN
 ; RUN: llvm-objdump -d --no-show-raw-insn %t/test | FileCheck %s --check-prefix=ALL
 
 ; FOO:      <_foo>:
 ; FOO-NEXT: retq
 
 ; MAIN:      <_main>:

lld/test/MachO/mattrs.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 
 ;; Verify that LTO behavior can be tweaked using -mattr.
 
-; RUN: %lld -mcpu haswell -mllvm -mattr=+fma %t.o -o %t.dylib -dylib
+; RUN: %lld -arch x86_64 -mcpu haswell -mllvm -mattr=+fma %t.o -o %t.dylib -dylib
 ; RUN: llvm-objdump -d --section="__text" --no-leading-addr --no-show-raw-insn %t.dylib | FileCheck %s --check-prefix=FMA
 
-; RUN: %lld -mcpu haswell -mllvm -mattr=-fma %t.o -o %t.dylib -dylib
+; RUN: %lld -arch x86_64 -mcpu haswell -mllvm -mattr=-fma %t.o -o %t.dylib -dylib
 ; RUN: llvm-objdump -d --section="__text" --no-leading-addr --no-show-raw-insn %t.dylib | FileCheck %s --check-prefix=NO-FMA
 
 ; FMA:      <_foo>:
 ; FMA-NEXT: vrcpss  %xmm0, %xmm0, %xmm1
 ; FMA-NEXT: vfmsub213ss 7(%rip), %xmm1, %xmm0
 ; FMA-NEXT: vfnmadd132ss  %xmm1, %xmm1, %xmm0
 ; FMA-NEXT: retq
 

lld/test/MachO/module-asm.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
-; RUN: %lld %t.o -o %t
+; RUN: %lld -arch x86_64 %t.o -o %t
 ; RUN: llvm-objdump -d %t | FileCheck %s
 
 ; CHECK:      <_foo>:
 ; CHECK-NEXT: retq
 
 ; CHECK:      <_main>:
 ; CHECK-NEXT: jmp {{.*}} <_foo>
 

lld/test/MachO/objc-arc-contract.ll

 ; REQUIRES: x86
 
 ;; Verify that we run the ObjCARCContractPass during LTO. Without that, the
 ;; objc.clang.arc.use intrinsic will get passed to the instruction selector,
 ;; which doesn't know how to handle it.
 
 ; RUN: llvm-as %s -o %t.o
-; RUN: %lld -dylib -lSystem %t.o -o %t --lto-legacy-pass-manager
+; RUN: %lld -arch x86_64 -dylib -lSystem %t.o -o %t --lto-legacy-pass-manager
 ; RUN: llvm-objdump -d %t | FileCheck %s
-; RUN: %lld -dylib -lSystem %t.o -o %t --no-lto-legacy-pass-manager
+; RUN: %lld -arch x86_64 -dylib -lSystem %t.o -o %t --no-lto-legacy-pass-manager
 ; RUN: llvm-objdump -d %t | FileCheck %s
 
 ; RUN: opt -module-summary %s -o %t.o
-; RUN: %lld -dylib -lSystem %t.o -o %t --lto-legacy-pass-manager
+; RUN: %lld -arch x86_64 -dylib -lSystem %t.o -o %t --lto-legacy-pass-manager
 ; RUN: llvm-objdump -d %t | FileCheck %s
-; RUN: %lld -dylib -lSystem %t.o -o %t --no-lto-legacy-pass-manager
+; RUN: %lld -arch x86_64 -dylib -lSystem %t.o -o %t --no-lto-legacy-pass-manager
 ; RUN: llvm-objdump -d %t | FileCheck %s
 
 ; CHECK:      <_foo>:
 ; CHECK-NEXT: retq
 
 target triple = "x86_64-apple-darwin"
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @foo(i8* %a, i8* %b) {
   call void (...) @llvm.objc.clang.arc.use(i8* %a, i8* %b) nounwind
   ret void
 }
 
 declare void @llvm.objc.clang.arc.use(...) nounwind

lld/test/MachO/reloc-subtractor.s

 # REQUIRES: x86, aarch64
 # RUN: rm -rf %t; mkdir %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/x86_64.o
 # RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin %s -o %t/arm64.o
 # RUN: %lld -lSystem %t/x86_64.o -o %t/x86_64
 # RUN: llvm-objdump --syms --full-contents --rebase %t/x86_64 | FileCheck %s
-# RUN: %lld -arch arm64 -lSystem %t/arm64.o -o %t/arm64
+# RUN: %lld -lSystem %t/arm64.o -o %t/arm64
 # RUN: llvm-objdump --syms --full-contents --rebase %t/arm64 | FileCheck %s
 
 # CHECK-LABEL: SYMBOL TABLE:
 # CHECK:       {{0*}}[[#%x, SUB1ADDR:]] l {{.*}} __DATA,__data _sub1
 # CHECK:       {{0*}}[[#%x, SUB2ADDR:]] l {{.*}} __DATA,__data _sub2
 # CHECK:       {{0*}}[[#%x, SUB3ADDR:]] l {{.*}} __DATA,__data _sub3
 # CHECK:       {{0*}}[[#%x, SUB4ADDR:]] l {{.*}} __DATA,__data _sub4
 # CHECK-LABEL: Contents of section __DATA,__data:

lld/test/MachO/reproduce-thin-archives.s

 # REQUIRES: x86
 
 # RUN: rm -rf %t.dir
 # RUN: mkdir -p %t.dir
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos %s -o %t.dir/foo.o
 # RUN: cd %t.dir
 # RUN: llvm-ar rcsT foo.a foo.o
 
-# RUN: %lld foo.a -o /dev/null --reproduce repro.tar
+# RUN: %lld -arch x86_64 foo.a -o /dev/null --reproduce repro.tar
 # RUN: tar tf repro.tar | FileCheck -DPATH='repro/%:t.dir' %s
 
-# RUN: %lld -all_load foo.a -o /dev/null --reproduce repro2.tar
+# RUN: %lld -arch x86_64 -all_load foo.a -o /dev/null --reproduce repro2.tar
 # RUN: tar tf repro2.tar | FileCheck -DPATH='repro2/%:t.dir' %s
 
 # CHECK-DAG: [[PATH]]/foo.a
 # CHECK-DAG: [[PATH]]/foo.o
 
 .globl _main
 _main:
   nop