[lld-macho] Add -static

[Link1J]

Summary

Adds -static (and -add_load_version)

-static drives will probably drive me (or anyone) insane if it is to be completely and correctly implemented. It seems to touch everything, and I don't even know if everything below is all that it does.

Implemented behavior:

• Entry is defined by LC_UNIXTHREAD command
• LC_BUILD_VERSION and LC_VERSION_MIN_* are no longer emitted by default
• LC_FUNCTION_STARTS is no longer emitted by default
• LC_DATA_IN_CODE is no longer emitted by default
• LC_ENCRYPTION_INFO is no longer emitted by default
• LC_LOAD_DYLINKER is no longer emitted
• Default entry becomes start
• Is not PIC by default.

Will be implemented:

• -image_base effecting the __PAGEZERO and not the __TEXT

Not implemented behavior:

• -arch is not needed
• -platform_version is not needed
• Forcing -keep_dwarf_unwind, even if -no_keep_dwarf_unwind is provided (I don't if they are implemented)

Notes within notes:

• The tests for -static will need fixing if LC_SOURCE_VERSION is added

[int3]

-static drives will probably drive me (or anyone) insane if it is to be completely and correctly implemented. It seems to touch everything, and I don't even know if everything below is all that it does.

I guess my question is... why are we implementing this, if it's too much work to implement correctly? Do you foresee a real use case?

lld/MachO/Driver.cpp

1249

lld/MachO/Writer.cpp

361

if you did buf = reinterpret_cast<uint8_t *>(hdr + 1); here, you could replace the calls to get_thread_state with just a reinterpret_cast.

just a matter of opinion though, I'm fine if you want to keep things as-is :)

lld/test/MachO/static.s

51

we should add some checks (via CHECK-NOT) to make sure we aren't emitting the function starts and other unneeded commands

[Link1J]

In D119668#3322860, @int3 wrote:

-static drives will probably drive me (or anyone) insane if it is to be completely and correctly implemented. It seems to touch everything, and I don't even know if everything below is all that it does.

I guess my question is... why are we implementing this, if it's too much work to implement correctly? Do you foresee a real use case?

It isn't making the changes that are hard, as most of the stuff is already in lld. The part that was driving me insane is tracking down what it changes. I was doing very basic code searches in ld64 code, and it was hard to track what it was doing (There are about three different variables to control most flags it has). So it really seems like -static is just making ld64 output older style mach-o binaries, with most of the dynamic linker stuff missing.

In the end, I think that I at least got everything noted down, with most that I implemented being found from linking using ld64. So everything should be listed, so that others could make the changes.
I do plan to make the changes for -image_base, as I already have a patch in the works to add it.

I am going to use it, and it does have uses it OS development. So I thought it would be a good idea to add it upstream, as lld is a lot easier to get working on other platforms then ld64 is.
Also some of the items added (like LC_UNIXTHREAD) do have uses for linking binaries for older macOS versions. So I don't expect this flag to get a lot of use directly, there is a lot that can be used for improvement for linking older macOS binaries, or for building projects like darling.

[int3]

Oops, I realized I'd never replied to this. Ok, if you're going to use it then I'm good with including this. If you can make the requested changes, I'll accept this.

[int3]

clearing queue

[int3]

lgtm

lld/test/MachO/static.s

2–4

can you elaborate here? Are you saying that LC_SOURCE_VERSION should really be emitted for both -static and regular links?

[Link1J]

lld/test/MachO/static.s

2–4

That is correct. But it doesn't appear to be implemented by lld. I don't know what LC_SOURCE_VERSION does, or if it is even useful. But by default ld64 does emit LC_SOURCE_VERSION load command.

[Roger]

I am going to use it, and it does have uses it OS development.

I'm asking out of complete curiosity. How does static linking help with OS development?

lld/MachO/Arch/ARM.cpp

 
 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;
+  threadCommandFlavor = ARM_THREAD_STATE;
 
   stubSize = 0 /* FIXME */;
   stubHelperHeaderSize = 0 /* FIXME */;
   stubHelperEntrySize = 0 /* FIXME */;
 }
 
 TargetInfo *macho::createARMTargetInfo(uint32_t cpuSubtype) {
   static ARM t(cpuSubtype);
   return &t;
 }

lld/MachO/Arch/ARM64.cpp

thunk->relocs.push_back({/*type=*/ARM64_RELOC_PAGE21,
                            /*pcrel=*/true, /*length=*/2,
                            /*offset=*/0, /*addend=*/0,
                            /*referent=*/funcSym});
 }
 
 ARM64::ARM64() : ARM64Common(LP64()) {
   cpuType = CPU_TYPE_ARM64;
   cpuSubtype = CPU_SUBTYPE_ARM64_ALL;
+  threadCommandFlavor = ARM_THREAD_STATE64;
 
   stubSize = sizeof(stubCode);
   thunkSize = sizeof(thunkCode);
 
   // Branch immediate is two's complement 26 bits, which is implicitly
   // multiplied by 4 (since all functions are 4-aligned: The branch range
   // is -4*(2**(26-1))..4*(2**(26-1) - 1).
   backwardBranchRange = 128 * 1024 * 1024;

lld/MachO/Arch/ARM64_32.cpp

 void ARM64_32::writeStubHelperEntry(uint8_t *buf8, const Symbol &sym,
                                     uint64_t entryVA) const {
   ::writeStubHelperEntry(buf8, stubHelperEntryCode, sym, entryVA);
 }
 
 ARM64_32::ARM64_32() : ARM64Common(ILP32()) {
   cpuType = CPU_TYPE_ARM64_32;
   cpuSubtype = CPU_SUBTYPE_ARM64_V8;
+  threadCommandFlavor = ARM_THREAD_STATE64;
 
   modeDwarfEncoding = 0x04000000;              // UNWIND_ARM_MODE_DWARF
   subtractorRelocType = GENERIC_RELOC_INVALID; // FIXME
   unsignedRelocType = GENERIC_RELOC_INVALID;   // FIXME
 
   stubSize = sizeof(stubCode);
   stubHelperHeaderSize = sizeof(stubHelperHeaderCode);
   stubHelperEntrySize = sizeof(stubHelperEntryCode);
 }
 
 TargetInfo *macho::createARM64_32TargetInfo() {
   static ARM64_32 t;
   return &t;
 }

lld/MachO/Arch/X86_64.cpp

void X86_64::relaxGotLoad(uint8_t *loc, uint8_t type) const {
   if (loc[-2] != 0x8b)
     error(getRelocAttrs(type).name + " reloc requires MOVQ instruction");
   loc[-2] = 0x8d;
 }
 
 X86_64::X86_64() : TargetInfo(LP64()) {
   cpuType = CPU_TYPE_X86_64;
   cpuSubtype = CPU_SUBTYPE_X86_64_ALL;
+  threadCommandFlavor = x86_THREAD_STATE64;
 
   modeDwarfEncoding = UNWIND_X86_MODE_DWARF;
   subtractorRelocType = X86_64_RELOC_SUBTRACTOR;
   unsignedRelocType = X86_64_RELOC_UNSIGNED;
 
   stubSize = sizeof(stub);
   stubHelperHeaderSize = sizeof(stubHelperHeader);
   stubHelperEntrySize = sizeof(stubHelperEntry);
 }
 
 TargetInfo *macho::createX86_64TargetInfo() {
   static X86_64 t;
   return &t;
 }

lld/MachO/Config.h

enum class SymtabPresence {
   None,
   SelectivelyIncluded,
   SelectivelyExcluded,
 };
 
 struct Configuration {
   Symbol *entry = nullptr;
   bool hasReexports = false;
+  bool addLoadVersion = true;
   bool allLoad = false;
   bool applicationExtension = false;
   bool archMultiple = false;
   bool exportDynamic = false;
   bool forceLoadObjC = false;
   bool forceLoadSwift = false;
   bool staticLink = false;
   bool implicitDylibs = false;

lld/MachO/Driver.cpp

bool macho::link(ArrayRef<const char *> argsArr, llvm::raw_ostream &stdoutOS,
   for (const Arg *arg : args.filtered(OPT_u)) {
     config->explicitUndefineds.push_back(symtab->addUndefined(
         arg->getValue(), /*file=*/nullptr, /*isWeakRef=*/false));
   }
 
   for (const Arg *arg : args.filtered(OPT_U))
     config->explicitDynamicLookups.insert(arg->getValue());
 
+  if (const Arg *arg = args.getLastArg(OPT_static, OPT_dynamic))
+    config->staticLink = arg->getOption().getID() == OPT_static;
+
   config->mapFile = args.getLastArgValue(OPT_map);
   config->optimize = args::getInteger(args, OPT_O, 1);
   config->outputFile = args.getLastArgValue(OPT_o, "a.out");
   config->finalOutput =
       args.getLastArgValue(OPT_final_output, config->outputFile);
   config->astPaths = args.getAllArgValues(OPT_add_ast_path);
   config->headerPad = args::getHex(args, OPT_headerpad, /*Default=*/32);
   config->headerPadMaxInstallNames =
bool macho::link(ArrayRef<const char *> argsArr, llvm::raw_ostream &stdoutOS,
   config->applicationExtension = args.hasFlag(
       OPT_application_extension, OPT_no_application_extension, false);
   config->exportDynamic = args.hasArg(OPT_export_dynamic);
   config->forceLoadObjC = args.hasArg(OPT_ObjC);
   config->forceLoadSwift = args.hasArg(OPT_force_load_swift_libs);
   config->deadStripDylibs = args.hasArg(OPT_dead_strip_dylibs);
   config->demangle = args.hasArg(OPT_demangle);
   config->implicitDylibs = !args.hasArg(OPT_no_implicit_dylibs);
-  config->emitFunctionStarts =
-      args.hasFlag(OPT_function_starts, OPT_no_function_starts, true);
   config->emitBitcodeBundle = args.hasArg(OPT_bitcode_bundle);
-  config->emitDataInCodeInfo =
-      args.hasFlag(OPT_data_in_code_info, OPT_no_data_in_code_info, true);
   config->icfLevel = getICFLevel(args);
   config->dedupLiterals =
       args.hasFlag(OPT_deduplicate_literals, OPT_icf_eq, false) ||
       config->icfLevel != ICFLevel::none;
   config->warnDylibInstallName = args.hasFlag(
       OPT_warn_dylib_install_name, OPT_no_warn_dylib_install_name, false);
   config->callGraphProfileSort = args.hasFlag(
       OPT_call_graph_profile_sort, OPT_no_call_graph_profile_sort, true);
   config->printSymbolOrder = args.getLastArgValue(OPT_print_symbol_order);
   config->parseEhFrames = static_cast<bool>(getenv("LLD_IN_TEST"));
 
+  config->addLoadVersion =
+      args.hasFlag(OPT_version_load_command, OPT_INVALID, !config->staticLink);
+  config->emitFunctionStarts = args.hasFlag(
+      OPT_function_starts, OPT_no_function_starts, !config->staticLink);
+  config->emitDataInCodeInfo = args.hasFlag(
+      OPT_data_in_code_info, OPT_no_data_in_code_info, !config->staticLink);
+
   // FIXME: Add a commandline flag for this too.
   config->zeroModTime = getenv("ZERO_AR_DATE");
 
   std::array<PlatformType, 3> encryptablePlatforms{
       PLATFORM_IOS, PLATFORM_WATCHOS, PLATFORM_TVOS};
   config->emitEncryptionInfo =
       args.hasFlag(OPT_encryptable, OPT_no_encryption,
-                   is_contained(encryptablePlatforms, config->platform()));
+                   is_contained(encryptablePlatforms, config->platform()) &&
+                       !config->staticLink);
 
 #ifndef LLVM_HAVE_LIBXAR
   if (config->emitBitcodeBundle)
     error("-bitcode_bundle unsupported because LLD wasn't built with libxar");
 #endif
 
   if (const Arg *arg = args.getLastArg(OPT_install_name)) {
     if (config->warnDylibInstallName && config->outputType != MH_DYLIB)
       warn(
           arg->getAsString(args) +
           ": ignored, only has effect with -dylib [--warn-dylib-install-name]");
     else
       config->installName = arg->getValue();
   } else if (config->outputType == MH_DYLIB) {
     config->installName = config->finalOutput;
   }
 
   if (args.hasArg(OPT_mark_dead_strippable_dylib)) {
     if (config->outputType != MH_DYLIB)
       warn("-mark_dead_strippable_dylib: ignored, only has effect with -dylib");
     else
       config->markDeadStrippableDylib = true;
   }
 
-  if (const Arg *arg = args.getLastArg(OPT_static, OPT_dynamic))
-    config->staticLink = (arg->getOption().getID() == OPT_static);
-
   if (const Arg *arg =
           args.getLastArg(OPT_flat_namespace, OPT_twolevel_namespace))
     config->namespaceKind = arg->getOption().getID() == OPT_twolevel_namespace
                                 ? NamespaceKind::twolevel
                                 : NamespaceKind::flat;
 
   config->undefinedSymbolTreatment = getUndefinedSymbolTreatment(args);
 
-  if (config->outputType == MH_EXECUTE)
-    config->entry = symtab->addUndefined(args.getLastArgValue(OPT_e, "_main"),
-                                         /*file=*/nullptr,
-                                         /*isWeakRef=*/false);
+  if (config->outputType == MH_EXECUTE) {
+    const char *entry_point = config->staticLink ? "start" : "_main";
+    config->entry =
+        symtab->addUndefined(args.getLastArgValue(OPT_e, entry_point),
+  }
 
   config->librarySearchPaths =
       getLibrarySearchPaths(args, config->systemLibraryRoots);
   config->frameworkSearchPaths =
       getFrameworkSearchPaths(args, config->systemLibraryRoots);
   if (const Arg *arg =
           args.getLastArg(OPT_search_paths_first, OPT_search_dylibs_first))
     config->searchDylibsFirst =
if (config->timeTraceEnabled)
     TimeTraceScope timeScope("ExecuteLinker");
 
     initLLVM(); // must be run before any call to addFile()
     createFiles(args);
 
     config->isPic = config->outputType == MH_DYLIB ||
                     config->outputType == MH_BUNDLE ||
                     (config->outputType == MH_EXECUTE &&
-                     args.hasFlag(OPT_pie, OPT_no_pie, true));
+                     args.hasFlag(OPT_pie, OPT_no_pie, !config->staticLink));
 
     // Now that all dylibs have been loaded, search for those that should be
     // re-exported.
     {
       auto reexportHandler = [](const Arg *arg,
                                 const std::vector<StringRef> &extensions) {
         config->hasReexports = true;
         StringRef searchName = arg->getValue();

lld/MachO/Options.td

def dylinker : Flag<["-"], "dylinker">,
     HelpText<"Produce a dylinker only used when building dyld">,
     Flags<[HelpHidden]>,
     Group<grp_kind>;
 def dynamic : Flag<["-"], "dynamic">,
     HelpText<"Link dynamically (default)">,
     Group<grp_kind>;
 def static : Flag<["-"], "static">,
     HelpText<"Link statically">,
-    Flags<[HelpHidden]>,
     Group<grp_kind>;
 def preload : Flag<["-"], "preload">,
     HelpText<"Produce an unsegmented binary for embedded systems">,
     Flags<[HelpHidden]>,
     Group<grp_kind>;
 def arch : Separate<["-"], "arch">,
     MetaVarName<"<arch_name>">,
     HelpText<"The architecture (e.g. ppc, ppc64, i386, x86_64)">,
def threaded_starts_section : Flag<["-"], "threaded_starts_section">,
     Flags<[HelpHidden]>,
     Group<grp_undocumented>;
 def verbose_optimization_hints : Flag<["-"], "verbose_optimization_hints">,
     HelpText<"This option is undocumented in ld64">,
     Flags<[HelpHidden]>,
     Group<grp_undocumented>;
 def version_load_command : Flag<["-"], "version_load_command">,
     HelpText<"This option is undocumented in ld64">,
-    Flags<[HelpHidden]>,
     Group<grp_undocumented>;
 
 def grp_ignored : OptionGroup<"ignored">, HelpText<"IGNORED">;
 
 def M : Flag<["-"], "M">,
     HelpText<"This option is ignored in ld64">,
     Flags<[HelpHidden]>,
     Group<grp_ignored>;

lld/MachO/Target.h

bool hasAttr(uint8_t type, RelocAttrBits bit) const {
     return getRelocAttrs(type).hasAttr(bit);
   }
 
   bool usesThunks() const { return thunkSize > 0; }
 
   uint32_t magic;
   llvm::MachO::CPUType cpuType;
   uint32_t cpuSubtype;
+  uint32_t threadCommandFlavor = 0;
 
   uint64_t pageZeroSize;
   size_t headerSize;
   size_t stubSize;
   size_t stubHelperHeaderSize;
   size_t stubHelperEntrySize;
   uint8_t p2WordSize;
   size_t wordSize;

lld/MachO/Writer.cpp

void writeTo(uint8_t *buf) const override {
     c->stroff = stringTableSection->fileOff;
     c->strsize = stringTableSection->getFileSize();
   }
 
   SymtabSection *symtabSection = nullptr;
   StringTableSection *stringTableSection = nullptr;
 };
 
+class LCUnixThread final : public LoadCommand {
+  uint32_t getFlavorSize() const {
+    switch (target->cpuType & ~CPU_ARCH_MASK) {
+    case CPU_TYPE_I386:
+      switch (target->threadCommandFlavor) {
+      case x86_THREAD_STATE64:
+        return sizeof(x86_thread_state64_t);
+      }
+      break;
+    case CPU_TYPE_ARM:
+      switch (target->threadCommandFlavor) {
+      case ARM_THREAD_STATE:
+        return sizeof(arm_thread_state32_t);
+      case ARM_THREAD_STATE64:
+        return sizeof(arm_thread_state64_t);
+      }
+      break;
+    }
+
+    fatal("Unknown flavor " + Twine::utohexstr(target->threadCommandFlavor));
+    return 0;
+  }
+
+  uint32_t getSize() const override {
+    return sizeof(thread_command) + sizeof(x86_state_hdr_t) + getFlavorSize();
+  }
+
+  void writeTo(uint8_t *buf) const override {
+    auto *c = reinterpret_cast<thread_command *>(buf);
+    c->cmd = LC_UNIXTHREAD;
+    c->cmdsize = getSize();
+
+    auto *hdr =
+        reinterpret_cast<x86_state_hdr_t *>(buf + sizeof(thread_command));
+    hdr->flavor = target->threadCommandFlavor;
+
+    // Yes, this is what the macOS SDK does.
+    hdr->count = getFlavorSize() / sizeof(uint32_t);
+    buf = reinterpret_cast<uint8_t *>(hdr + 1);
+    memset(buf, 0, getFlavorSize());
+
+    switch (target->cpuType & ~CPU_ARCH_MASK) {
+    case CPU_TYPE_I386:
+      switch (target->threadCommandFlavor) {
+      case x86_THREAD_STATE64: {
+        auto *state = reinterpret_cast<x86_thread_state64_t *>(buf);
+        state->rip = config->entry->getVA();
+        break;
+      }
+      }
+      break;
+    case CPU_TYPE_ARM:
+      switch (target->threadCommandFlavor) {
+      case ARM_THREAD_STATE: {
+        auto *state = reinterpret_cast<arm_thread_state32_t *>(buf);
+        state->pc = config->entry->getVA();
+        break;
+      }
+      case ARM_THREAD_STATE64: {
+        auto *state = reinterpret_cast<arm_thread_state64_t *>(buf);
+        state->pc = config->entry->getVA();
+        break;
+      }
+      }
+      break;
+    }
+  }
+};
+
 // There are several dylib load commands that share the same structure:
 //   * LC_LOAD_DYLIB
 //   * LC_ID_DYLIB
 //   * LC_REEXPORT_DYLIB
 class LCDylib final : public LoadCommand {
 public:
   LCDylib(LoadCommandType type, StringRef path,
           uint32_t compatibilityVersion = 0, uint32_t currentVersion = 0)

 
 template <class LP> void Writer::createLoadCommands() {
   uint8_t segIndex = 0;
   for (OutputSegment *seg : outputSegments) {
     in.header->addLoadCommand(make<LCSegment<LP>>(seg->name, seg));
     seg->index = segIndex++;
   }
 
+  if (!config->staticLink)
     in.header->addLoadCommand(make<LCDyldInfo>(
         in.rebase, in.binding, in.weakBinding, in.lazyBinding, in.exports));
   in.header->addLoadCommand(make<LCSymtab>(symtabSection, stringTableSection));
+  if (!config->staticLink || (config->staticLink && config->isPic))
     in.header->addLoadCommand(
         make<LCDysymtab>(symtabSection, indirectSymtabSection));
   if (!config->umbrella.empty())
     in.header->addLoadCommand(make<LCSubFramework>(config->umbrella));
   if (config->emitEncryptionInfo)
     in.header->addLoadCommand(make<LCEncryptionInfo<LP>>());
   for (StringRef path : config->runtimePaths)
     in.header->addLoadCommand(make<LCRPath>(path));
 
   switch (config->outputType) {
   case MH_EXECUTE:
+    if (!config->staticLink)
       in.header->addLoadCommand(make<LCLoadDylinker>());
     break;
   case MH_DYLIB:
     in.header->addLoadCommand(make<LCDylib>(LC_ID_DYLIB, config->installName,
                                             config->dylibCompatibilityVersion,
                                             config->dylibCurrentVersion));
     break;
   case MH_BUNDLE:
     break;
   default:
     llvm_unreachable("unhandled output file type");
   }
 
   uuidCommand = make<LCUuid>();
   in.header->addLoadCommand(uuidCommand);
 
+  if (config->addLoadVersion) {
     if (useLCBuildVersion(config->platformInfo))
       in.header->addLoadCommand(make<LCBuildVersion>(config->platformInfo));
     else
       in.header->addLoadCommand(make<LCMinVersion>(config->platformInfo));
+  }
 
   if (config->secondaryPlatformInfo) {
     in.header->addLoadCommand(
         make<LCBuildVersion>(*config->secondaryPlatformInfo));
   }
 
   // This is down here to match ld64's load command order.
-  if (config->outputType == MH_EXECUTE)
+  if (config->outputType == MH_EXECUTE) {
+    if (config->staticLink)
+      in.header->addLoadCommand(make<LCUnixThread>());
+    else
       in.header->addLoadCommand(make<LCMain>());
+  }
 
   int64_t dylibOrdinal = 1;
   DenseMap<StringRef, int64_t> ordinalForInstallName;
   for (InputFile *file : inputFiles) {
     if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
       if (dylibFile->isBundleLoader) {
         dylibFile->ordinal = BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE;
         // Shortcut since bundle-loader does not re-export the symbols.

lld/test/MachO/static.s

+# REQUIRES: x86, aarch64
+## If these tests start failing because `LC_SOURCE_VERSION` is added, please
+## update the `Load command` lines. Not emitting `LC_SOURCE_VERSION` to fix
+## this tests is the wrong behavior.
+
+# 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: llvm-mc -filetype=obj -triple=arm64_32-apple-darwin %s -o %t/arm64_32.o
+
+# RUN: %lld -static -arch x86_64 -o %t/x86_64 %t/x86_64.o
+# RUN: llvm-objdump --macho --private-headers %t/x86_64 | FileCheck %s -DARCH=x86 -D#SIZE=184
+# RUN: %lld -static -arch arm64 -o %t/arm64 %t/arm64.o
+# RUN: llvm-objdump --macho --private-headers %t/arm64 | FileCheck %s -DARCH=ARM -D#SIZE=288
+# RUN: %lld-watchos -static -arch arm64_32 -o %t/arm64_32 %t/arm64_32.o
+# RUN: llvm-objdump --macho --private-headers %t/arm64_32 | FileCheck %s -DARCH=ARM -D#SIZE=288
+
+# CHECK-NOT:          cmd LC_DYSYMTAB
+# CHECK-NOT:          cmd LC_ENCRYPTION_INFO
+# CHECK-NOT:          cmd LC_ENCRYPTION_INFO_64
+# CHECK-NOT:          cmd LC_LOAD_DYLINKER
+# CHECK-NOT:          cmd LC_BUILD_VERSION
+# CHECK-NOT:          cmd LC_VERSION_MIN_MACOSX
+# CHECK-NOT:          cmd LC_VERSION_MIN_IPHONEOS
+# CHECK-NOT:          cmd LC_VERSION_MIN_TVOS
+# CHECK-NOT:          cmd LC_VERSION_MIN_WATCHOS
+# CHECK:      Load command 5
+# CHECK-NEXT:         cmd LC_UNIXTHREAD
+# CHECK-NEXT:     cmdsize [[#%d,SIZE]]
+# CHECK-NEXT:      flavor [[ARCH]]_THREAD_STATE64
+# CHECK-NEXT:       count [[ARCH]]_THREAD_STATE64_COUNT
+# CHECK-NOT:          cmd LC_FUNCTION_STARTS
+# CHECK-NOT:          cmd LC_DATA_IN_CODE
+
+# RUN: %lld -static -arch x86_64 -o %t/x86_64-pie %t/x86_64.o -pie
+# RUN: llvm-objdump --macho --private-headers %t/x86_64-pie | FileCheck %s --check-prefix=CHECK-PIE -DARCH=x86 -D#SIZE=184
+
+# CHECK-PIE:      Load command 4
+# CHECK-PIE-NEXT:         cmd LC_DYSYMTAB
+# CHECK-PIE-NEXT:     cmdsize 80
+# CHECK-PIE:      Load command 6
+# CHECK-PIE-NEXT:         cmd LC_UNIXTHREAD
+# CHECK-PIE-NEXT:     cmdsize [[#%d,SIZE]]
+# CHECK-PIE-NEXT:      flavor [[ARCH]]_THREAD_STATE64
+# CHECK-PIE-NEXT:       count [[ARCH]]_THREAD_STATE64_COUNT
+
+# RUN: %lld -static -arch x86_64 -o %t/x86_64-vlc %t/x86_64.o -version_load_command
+# RUN: llvm-objdump --macho --private-headers %t/x86_64-vlc | FileCheck %s --check-prefix=CHECK-VLC -DARCH=x86 -D#SIZE=184 -DOS=macos
+# RUN: %lld-watchos -static -arch arm64_32 -o %t/arm64_32-vlc %t/arm64_32.o -version_load_command
+# RUN: llvm-objdump --macho --private-headers %t/arm64_32-vlc | FileCheck %s  --check-prefix=CHECK-VLC -DARCH=ARM -D#SIZE=288 -DOS=watchos
+
+# CHECK-VLC:      Load command 5
+# CHECK-VLC-NEXT:         cmd LC_BUILD_VERSION
+# CHECK-VLC-NEXT:     cmdsize 32
+# CHECK-VLC-NEXT:    platform [[OS]]
+# CHECK-VLC:      Load command 6
+# CHECK-VLC-NEXT:         cmd LC_UNIXTHREAD
+# CHECK-VLC-NEXT:     cmdsize [[#%d,SIZE]]
+# CHECK-VLC-NEXT:      flavor [[ARCH]]_THREAD_STATE64
+# CHECK-VLC-NEXT:       count [[ARCH]]_THREAD_STATE64_COUNT
+
+.globl start
+start: