[lld/mac] Implement removal of unused dylibs

[thakis]

Summary

This omits load commands for unreferenced dylibs if:

• the dylib was loaded implicitly,
• it is marked MH_DEAD_STRIPPABLE_DYLIB
• or -dead_strip_dylibs is passed

This matches ld64.

Currently, the "is dylib referenced" state is computed before dead code
stripping and is not updated after dead code stripping. This too matches ld64.
We should do better here.

With this, clang-format linked with lld (like with ld64) no longer has
libobjc.A.dylib in otool -L output. (It was implicitly loaded as a reexport
of CoreFoundation.framework, but it's not needed.)

[int3]

lld/MachO/InputFiles.h

162

why not just make it unsigned, and check that we don't call unreference() if it's already zero?

lld/MachO/Symbols.h

251

can we have a comment about why the && file check is necessary?

255

ultra nit: can we have a newline between multi-line functions?

lld/test/MachO/dead-strip-dylibs.s

48

lld/test/MachO/implicit-dylibs.s

77

this seems kind of sketch since this line could appear elsewhere in the output... --implicit-check-not LC_LOAD_DYLIB (like the other test is using) seems better

[thakis]

comments

[thakis]

Thanks! All done.

[int3]

Thanks!

lld/MachO/Config.h

struct Configuration {
   uint32_t dylibCurrentVersion = 0;
   uint32_t timeTraceGranularity = 500;
   std::string progName;
   llvm::StringRef installName;
   llvm::StringRef mapFile;
   llvm::StringRef outputFile;
   llvm::StringRef ltoObjPath;
   llvm::StringRef thinLTOJobs;
+  bool deadStripDylibs = false;
   bool demangle = false;
   PlatformInfo platformInfo;
   NamespaceKind namespaceKind = NamespaceKind::twolevel;
   UndefinedSymbolTreatment undefinedSymbolTreatment =
       UndefinedSymbolTreatment::error;
   llvm::MachO::HeaderFileType outputType;
   std::vector<llvm::StringRef> systemLibraryRoots;
   std::vector<llvm::StringRef> librarySearchPaths;

lld/MachO/Driver.cpp

case file_magic::archive: {
     break;
   }
   case file_magic::macho_object:
     newFile = make<ObjFile>(mbref, getModTime(path), "");
     break;
   case file_magic::macho_dynamically_linked_shared_lib:
   case file_magic::macho_dynamically_linked_shared_lib_stub:
   case file_magic::tapi_file:
-    if (Optional<DylibFile *> dylibFile = loadDylib(mbref))
+    if (Optional<DylibFile *> dylibFile = loadDylib(mbref)) {
+      (*dylibFile)->explicitlyLinked = true;
       newFile = *dylibFile;
+    }
     break;
   case file_magic::bitcode:
     newFile = make<BitcodeFile>(mbref);
     break;
   case file_magic::macho_executable:
   case file_magic::macho_bundle:
     // We only allow executable and bundle type here if it is used
     // as a bundle loader.
if (newFile) {
     // print the .a name here.
     if (config->printEachFile && magic != file_magic::archive)
       message(toString(newFile));
     inputFiles.insert(newFile);
   }
   return newFile;
 }
 
-static void addLibrary(StringRef name, bool isWeak) {
+static void addLibrary(StringRef name, bool isWeak, bool isExplicit = true) {
   if (Optional<StringRef> path = findLibrary(name)) {
-    auto *dylibFile = dyn_cast_or_null<DylibFile>(addFile(*path, false));
-    if (isWeak && dylibFile)
+    if (auto *dylibFile = dyn_cast_or_null<DylibFile>(addFile(*path, false))) {
+      dylibFile->explicitlyLinked = isExplicit;
+      if (isWeak)
         dylibFile->forceWeakImport = true;
+    }
     return;
   }
   error("library not found for -l" + name);
 }
 
-static void addFramework(StringRef name, bool isWeak) {
+static void addFramework(StringRef name, bool isWeak, bool isExplicit = true) {
   if (Optional<std::string> path = findFramework(name)) {
-    auto *dylibFile = dyn_cast_or_null<DylibFile>(addFile(*path, false));
-    if (isWeak && dylibFile)
+    if (auto *dylibFile = dyn_cast_or_null<DylibFile>(addFile(*path, false))) {
+      dylibFile->explicitlyLinked = isExplicit;
+      if (isWeak)
         dylibFile->forceWeakImport = true;
+    }
     return;
   }
   error("framework not found for -framework " + name);
 }
 
 // Parses LC_LINKER_OPTION contents, which can add additional command line
 // flags.
 void macho::parseLCLinkerOption(InputFile *f, unsigned argc, StringRef data) {
void macho::parseLCLinkerOption(InputFile *f, unsigned argc, StringRef data) {
   if (missingCount)
     fatal(Twine(args.getArgString(missingIndex)) + ": missing argument");
   for (const Arg *arg : args.filtered(OPT_UNKNOWN))
     error("unknown argument: " + arg->getAsString(args));
 
   for (const Arg *arg : args) {
     switch (arg->getOption().getID()) {
     case OPT_l:
-      addLibrary(arg->getValue(), false);
+      addLibrary(arg->getValue(), /*isWeak=*/false, /*isExplicit=*/false);
       break;
     case OPT_framework:
-      addFramework(arg->getValue(), false);
+      addFramework(arg->getValue(), /*isWeak=*/false, /*isExplicit=*/false);
       break;
     default:
       error(arg->getSpelling() + " is not allowed in LC_LINKER_OPTION");
     }
   }
 }
 
 static void addFileList(StringRef path) {
bool macho::link(ArrayRef<const char *> argsArr, bool canExitEarly,
   }
   config->ltoObjPath = args.getLastArgValue(OPT_object_path_lto);
   config->ltoNewPassManager =
       args.hasFlag(OPT_no_lto_legacy_pass_manager, OPT_lto_legacy_pass_manager,
                    LLVM_ENABLE_NEW_PASS_MANAGER);
   config->runtimePaths = args::getStrings(args, OPT_rpath);
   config->allLoad = args.hasArg(OPT_all_load);
   config->forceLoadObjC = args.hasArg(OPT_ObjC);
+  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.hasArg(OPT_no_function_starts);
   config->emitBitcodeBundle = args.hasArg(OPT_bitcode_bundle);
 
   std::array<PlatformKind, 3> encryptablePlatforms{
       PlatformKind::iOS, PlatformKind::watchOS, PlatformKind::tvOS};
   config->emitEncryptionInfo =

lld/MachO/InputFiles.h

public:
 
   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;
+  bool deadStrippable = false;
+  bool explicitlyLinked = false;
+
+  int numReferencedSymbols = 0;
+
+  bool isReferenced() const {
+    assert(numReferencedSymbols >= 0);
+    return numReferencedSymbols > 0;
+  }
 
   // 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;
 };
 

lld/MachO/InputFiles.cpp

if (const load_command *cmd = findCommand(hdr, LC_ID_DYLIB)) {
     dylibName = reinterpret_cast<const char *>(cmd) + read32le(&c->dylib.name);
   } else if (!isBundleLoader) {
     // macho_executable and macho_bundle don't have LC_ID_DYLIB,
     // so it's OK.
     error("dylib " + toString(this) + " missing LC_ID_DYLIB load command");
     return;
   }
 
+  deadStrippable = hdr->flags & MH_DEAD_STRIPPABLE_DYLIB;
+
   if (!checkCompatibility(this))
     return;
 
   // Initialize symbols.
   DylibFile *exportingFile = isImplicitlyLinked(dylibName) ? this : umbrella;
   if (const load_command *cmd = findCommand(hdr, LC_DYLD_INFO_ONLY)) {
     auto *c = reinterpret_cast<const dyld_info_command *>(cmd);
     parseTrie(buf + c->export_off, c->export_size,

lld/MachO/Options.td

def objc_gc : Flag<["-"], "objc_gc">,
     Flags<[HelpHidden]>,
     Group<grp_rare>;
 def objc_gc_only : Flag<["-"], "objc_gc_only">,
     HelpText<"Verify that all code was compiled with -fobjc-gc-only">,
     Flags<[HelpHidden]>,
     Group<grp_rare>;
 def dead_strip_dylibs : Flag<["-"], "dead_strip_dylibs">,
     HelpText<"Remove dylibs that are unreachable by the entry point or exported symbols">,
-    Flags<[HelpHidden]>,
     Group<grp_rare>;
 def allow_sub_type_mismatches : Flag<["-"], "allow_sub_type_mismatches">,
     HelpText<"Permit mixing objects compiled for different ARM CPU subtypes">,
     Flags<[HelpHidden]>,
     Group<grp_rare>;
 def no_uuid : Flag<["-"], "no_uuid">,
     HelpText<"Do not generate the LC_UUID load command">,
     Flags<[HelpHidden]>,

lld/MachO/SymbolTable.cpp

if (auto *defined = dyn_cast<Defined>(s)) {
         return defined;
       }
       if (!defined->isWeakDef())
         error("duplicate symbol: " + name + "\n>>> defined in " +
               toString(defined->getFile()) + "\n>>> defined in " +
               toString(file));
     } else if (auto *dysym = dyn_cast<DylibSymbol>(s)) {
       overridesWeakDef = !isWeakDef && dysym->isWeakDef();
+      dysym->unreference();
     }
     // Defined symbols take priority over other types of symbols, so in case
     // of a name conflict, we fall through to the replaceSymbol() call below.
   }
 
   Defined *defined = replaceSymbol<Defined>(
       s, name, file, isec, value, size, isWeakDef, /*isExternal=*/true,
       isPrivateExtern, isThumb, isReferencedDynamically);
Symbol *SymbolTable::addUndefined(StringRef name, InputFile *file,
 
   RefState refState = isWeakRef ? RefState::Weak : RefState::Strong;
 
   if (wasInserted)
     replaceSymbol<Undefined>(s, name, file, refState);
   else if (auto *lazy = dyn_cast<LazySymbol>(s))
     lazy->fetchArchiveMember();
   else if (auto *dynsym = dyn_cast<DylibSymbol>(s))
-    dynsym->refState = std::max(dynsym->refState, refState);
+    dynsym->reference(refState);
   else if (auto *undefined = dyn_cast<Undefined>(s))
     undefined->refState = std::max(undefined->refState, refState);
   return s;
 }
 
 Symbol *SymbolTable::addCommon(StringRef name, InputFile *file, uint64_t size,
                                uint32_t align, bool isPrivateExtern) {
   Symbol *s;
Symbol *SymbolTable::addDylib(StringRef name, DylibFile *file, bool isWeakDef,
   RefState refState = RefState::Unreferenced;
   if (!wasInserted) {
     if (auto *defined = dyn_cast<Defined>(s)) {
       if (isWeakDef && !defined->isWeakDef())
         defined->overridesWeakDef = true;
     } else if (auto *undefined = dyn_cast<Undefined>(s)) {
       refState = undefined->refState;
     } else if (auto *dysym = dyn_cast<DylibSymbol>(s)) {
-      refState = dysym->refState;
+      refState = dysym->getRefState();
     }
   }
 
   bool isDynamicLookup = file == nullptr;
   if (wasInserted || isa<Undefined>(s) ||
       (isa<DylibSymbol>(s) &&
        ((!isWeakDef && s->isWeakDef()) ||
-        (!isDynamicLookup && cast<DylibSymbol>(s)->isDynamicLookup()))))
+        (!isDynamicLookup && cast<DylibSymbol>(s)->isDynamicLookup())))) {
+    if (auto *dynsym = dyn_cast<DylibSymbol>(s))
+      dynsym->unreference();
     replaceSymbol<DylibSymbol>(s, file, name, isWeakDef, refState, isTlv);
+  }
 
   return s;
 }
 
 Symbol *SymbolTable::addDynamicLookup(StringRef name) {
   return addDylib(name, /*file=*/nullptr, /*isWeakDef=*/false, /*isTlv=*/false);
 }
 

lld/MachO/Symbols.h

public:
   const bool privateExtern;
 };
 
 class DylibSymbol : public Symbol {
 public:
   DylibSymbol(DylibFile *file, StringRefZ name, bool isWeakDef,
               RefState refState, bool isTlv)
       : Symbol(DylibKind, name, file), refState(refState), weakDef(isWeakDef),
-        tlv(isTlv) {}
+        tlv(isTlv) {
+    if (file && refState > RefState::Unreferenced)
+      file->numReferencedSymbols++;
+  }
 
   uint64_t getVA() const override;
   bool isWeakDef() const override { return weakDef; }
   bool isWeakRef() const override { return refState == RefState::Weak; }
   bool isReferenced() const { return refState != RefState::Unreferenced; }
   bool isTlv() const override { return tlv; }
   bool isDynamicLookup() const { return file == nullptr; }
   bool hasStubsHelper() const { return stubsHelperIndex != UINT32_MAX; }
 
   DylibFile *getFile() const {
     assert(!isDynamicLookup());
     return cast<DylibFile>(file);
   }
 
   static bool classof(const Symbol *s) { return s->kind() == DylibKind; }
 
   uint32_t stubsHelperIndex = UINT32_MAX;
   uint32_t lazyBindOffset = UINT32_MAX;
 
-  RefState refState : 2;
+  RefState getRefState() const { return refState; }
+
+  void reference(RefState newState) {
+    assert(newState > RefState::Unreferenced);
+    if (refState == RefState::Unreferenced && file)
+      getFile()->numReferencedSymbols++;
+    refState = std::max(refState, newState);
+  }
+  void unreference() {
+    if (refState > RefState::Unreferenced && file)
+      getFile()->numReferencedSymbols--;
+  }
 
 private:
+  RefState refState : 2;
   const bool weakDef : 1;
   const bool tlv : 1;
 };
 
 class LazySymbol : public Symbol {
 public:
   LazySymbol(ArchiveFile *file, const llvm::object::Archive::Symbol &sym)
       : Symbol(LazyKind, sym.getName(), file), sym(sym) {}

lld/MachO/SyntheticSections.cpp

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 += 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;
+  if (config->namespaceKind == NamespaceKind::flat || dysym.isDynamicLookup())
+    return static_cast<int16_t>(BIND_SPECIAL_DYLIB_FLAT_LOOKUP);
+  assert(dysym.getFile()->isReferenced());
+  return dysym.getFile()->ordinal;
 }
 
 static void encodeDylibOrdinal(int16_t ordinal, raw_svector_ostream &os) {
   if (ordinal <= 0) {
     os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_SPECIAL_IMM |
                                (ordinal & BIND_IMMEDIATE_MASK));
   } else if (ordinal <= BIND_IMMEDIATE_MASK) {
     os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM | ordinal);

 
 void StubHelperSection::setup() {
   stubBinder = dyn_cast_or_null<DylibSymbol>(symtab->find("dyld_stub_binder"));
   if (stubBinder == nullptr) {
     error("symbol dyld_stub_binder not found (normally in libSystem.dylib). "
           "Needed to perform lazy binding.");
     return;
   }
-  stubBinder->refState = RefState::Strong;
+  stubBinder->reference(RefState::Strong);
   in.got->addEntry(stubBinder);
 
   inputSections.push_back(in.imageLoaderCache);
   dyldPrivate =
       make<Defined>("__dyld_private", nullptr, in.imageLoaderCache, 0, 0,
                     /*isWeakDef=*/false,
                     /*isExternal=*/false, /*isPrivateExtern=*/false,
                     /*isThumb=*/false, /*isReferencedDynamically=*/false);

lld/MachO/Writer.cpp

void Writer::scanSymbols() {
   for (const Symbol *sym : symtab->getSymbols()) {
     if (const auto *defined = dyn_cast<Defined>(sym)) {
       if (defined->overridesWeakDef)
         in.weakBinding->addNonWeakDefinition(defined);
     } else if (const auto *dysym = dyn_cast<DylibSymbol>(sym)) {
       if (dysym->isDynamicLookup())
         continue;
       dysym->getFile()->refState =
-          std::max(dysym->getFile()->refState, dysym->refState);
+          std::max(dysym->getFile()->refState, dysym->getRefState());
     }
   }
 }
 
 // TODO: ld64 enforces the old load commands in a few other cases.
 static bool useLCBuildVersion(const PlatformInfo &platformInfo) {
   static const std::map<PlatformKind, llvm::VersionTuple> minVersion = {
       {PlatformKind::macOS, llvm::VersionTuple(10, 14)},
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.
 
         dylibFile->reexport = false;
         continue;
       }
 
+      // Don't emit load commands for a dylib that is not referenced if:
+      // - it was added implicitly (via a reexport, an LC_LOAD_DYLINKER --
+      //   if it's on the linker command line, it's explicit)
+      // - or it's marked MH_DEAD_STRIPPABLE_DYLIB
+      // - or the flag -dead_strip_dylibs is used
+      // FIXME: `isReferenced()` is currently computed before dead code
+      // stripping, so references from dead code keep a dylib alive. This
+      // matches ld64, but it's something we should do better.
+      if (!dylibFile->isReferenced() &&
+          (!dylibFile->explicitlyLinked || dylibFile->deadStrippable ||
+           config->deadStripDylibs))
+        continue;
+
       dylibFile->ordinal = dylibOrdinal++;
       LoadCommandType lcType =
           dylibFile->forceWeakImport || dylibFile->refState == RefState::Weak
               ? LC_LOAD_WEAK_DYLIB
               : LC_LOAD_DYLIB;
       in.header->addLoadCommand(make<LCDylib>(lcType, dylibFile->dylibName,
                                               dylibFile->compatibilityVersion,
                                               dylibFile->currentVersion));

lld/test/MachO/dead-strip-dylibs.s

+# REQUIRES: x86
+
+# RUN: rm -rf %t; split-file %s %t
+
+# RUN: llvm-mc %t/bar.s -triple=x86_64-apple-macos -filetype=obj -o %t/bar.o
+# RUN: %lld -dylib %t/bar.o -o %t/bar.dylib
+# RUN: %lld -dylib -mark_dead_strippable_dylib %t/bar.o -o %t/bar-strip.dylib
+
+# RUN: llvm-mc %t/foo.s -triple=x86_64-apple-macos -filetype=obj -o %t/foo.o
+# RUN: %lld -dylib %t/foo.o -o %t/foo_with_bar.dylib %t/bar.dylib -sub_library bar
+# RUN: %lld -dylib %t/foo.o -o %t/foo.dylib
+
+# RUN: llvm-mc %t/weak-foo.s -triple=x86_64-apple-macos -filetype=obj -o %t/weak-foo.o
+# RUN: %lld -dylib %t/weak-foo.o -o %t/weak-foo.dylib
+
+# RUN: llvm-mc %t/main.s -triple=x86_64-apple-macos -filetype=obj -o %t/main.o
+
+## foo_with_bar.dylib's reexport should be dropped since it's linked implicitly.
+# RUN: %lld -lSystem %t/main.o -o %t/main %t/foo_with_bar.dylib
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOBAR %s
+# NOBAR-NOT: bar.dylib
+# NOBAR: /usr/lib/libSystem.dylib
+# NOBAR-NOT: bar.dylib
+# NOBAR: foo_with_bar.dylib
+# NOBAR-NOT: bar.dylib
+
+## If bar.dylib is linked explicitly, it should not be dropped.
+# RUN: %lld -lSystem %t/main.o -o %t/main %t/foo_with_bar.dylib %t/bar.dylib
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=BAR %s
+# BAR: /usr/lib/libSystem.dylib
+# BAR: foo_with_bar.dylib
+# BAR: bar.dylib
+
+## ...except if -dead-strip_dylibs is passed...
+# RUN: %lld -lSystem %t/main.o -o %t/main %t/foo_with_bar.dylib %t/bar.dylib \
+# RUN:      -dead_strip_dylibs
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOBAR %s
+
+## ...or bar is explicitly marked dead-strippable
+# RUN: %lld -lSystem %t/main.o -o %t/main %t/foo.dylib %t/bar-strip.dylib
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOBARSTRIP %s
+# NOBARSTRIP-NOT: bar-strip.dylib
+# NOBARSTRIP: /usr/lib/libSystem.dylib
+# NOBARSTRIP-NOT: bar-strip.dylib
+# NOBARSTRIP: foo.dylib
+# NOBARSTRIP-NOT: bar-strip.dylib
+
+## LC_LINKER_OPTION does not count as explicit reference.
+# RUN: llvm-mc %t/linkopt_bar.s -triple=x86_64-apple-macos -filetype=obj -o %t/linkopt_bar.o
+# RUN: %lld -dylib %t/bar.o -o %t/libbar.dylib
+# RUN: %lld -lSystem %t/main.o %t/linkopt_bar.o -o %t/main -L %t %t/foo_with_bar.dylib
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOBAR %s
+
+## Test that a DylibSymbol being replaced by a DefinedSymbol marks the
+## dylib as unreferenced.
+## (Note: Since there's no dynamic linking in this example, libSystem is
+## stripped too. Since libSystem.dylib is needed to run an executable for
+## LC_MAIN, the output would crash when run. This matches ld64's behavior (!)
+## In practice, every executable uses dynamic linking, which uses
+## dyld_stub_binder, which keeps libSystem alive.)
+## Test all permutations of (Undefined, Defined, DylibSymbol).
+# RUN: %lld -lSystem -dead_strip_dylibs %t/main.o %t/foo.o %t/foo.dylib -o %t/main
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOFOO %s
+# RUN: %lld -lSystem -dead_strip_dylibs %t/main.o %t/foo.dylib %t/foo.dylib %t/foo.o -o %t/main
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOFOO %s
+
+# RUN: %lld -lSystem -dead_strip_dylibs %t/foo.o %t/main.o %t/foo.dylib -o %t/main
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOFOO %s
+# RUN: %lld -lSystem -dead_strip_dylibs %t/foo.dylib %t/foo.dylib %t/main.o %t/foo.o -o %t/main
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOFOO %s
+
+# RUN: %lld -lSystem -dead_strip_dylibs %t/foo.o %t/foo.dylib %t/main.o -o %t/main
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOFOO %s
+# RUN: %lld -lSystem -dead_strip_dylibs %t/foo.dylib %t/foo.dylib %t/foo.o %t/main.o -o %t/main
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOFOO %s
+# NOFOO-NOT: foo.dylib
+
+## When linking a weak and a strong symbol from two dylibs, we should keep the
+## strong one.
+# RUN: %lld -lSystem -dead_strip_dylibs %t/main.o %t/foo.dylib %t/weak-foo.dylib -o %t/main
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOWEAK %s
+# RUN: %lld -lSystem -dead_strip_dylibs %t/main.o %t/weak-foo.dylib %t/foo.dylib -o %t/main
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOWEAK %s
+# RUN: %lld -lSystem -dead_strip_dylibs %t/foo.dylib %t/weak-foo.dylib %t/main.o -o %t/main
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOWEAK %s
+# RUN: %lld -lSystem -dead_strip_dylibs %t/weak-foo.dylib %t/foo.dylib %t/main.o -o %t/main
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOWEAK %s
+# NOWEAK-NOT: weak-foo.dylib
+# NOWEAK: /foo.dylib
+# NOWEAK-NOT: weak-foo.dylib
+
+#--- main.s
+.globl _foo, _main
+_main:
+  callq _foo
+  retq
+
+#--- foo.s
+.globl _foo
+_foo:
+  retq
+
+#--- bar.s
+.globl _bar
+_bar:
+  retq
+
+#--- linkopt_bar.s
+.linker_option "-lbar"
+
+#--- weak-foo.s
+.globl _foo
+.weak_definition _foo
+_foo:
+  retq

lld/test/MachO/implicit-dylibs.s

 # CHECK-DAG: __DATA __data {{.*}} pointer 0 libreexporter _foo
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 libtoplevel   _toplevel
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 libreexporter _sublevel
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 Foo           _framework_foo
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 Foo           _framework_bar
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 libreexporter _framework_baz
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 libc++abi     ___gxx_personality_v0
 
-# RUN: llvm-objdump --macho --all-headers %t/test | FileCheck %s \
+# RUN: llvm-otool -l %t/test | FileCheck %s \
 # RUN:   --check-prefix=LOAD -DDIR=%t --implicit-check-not LC_LOAD_DYLIB
 ## Check that we don't create duplicate LC_LOAD_DYLIBs.
 # RUN: %lld -syslibroot %t -o %t/test -lSystem -L%t -lreexporter -ltoplevel %t/test.o
-# RUN: llvm-objdump --macho --all-headers %t/test | FileCheck %s \
+# RUN: llvm-otool -l %t/test | FileCheck %s \
 # RUN:   --check-prefix=LOAD -DDIR=%t --implicit-check-not LC_LOAD_DYLIB
 
 # LOAD:          cmd LC_LOAD_DYLIB
 # LOAD-NEXT: cmdsize
 # LOAD-NEXT:    name /usr/lib/libSystem.dylib
 # LOAD:          cmd LC_LOAD_DYLIB
 # LOAD-NEXT: cmdsize
 # LOAD-NEXT:    name /System/Library/Frameworks/Foo.framework/Versions/A/Foo
 # LOAD:          cmd LC_LOAD_DYLIB
 # LOAD-NEXT: cmdsize
 # LOAD-NEXT:    name /usr/lib/libc++abi.dylib
-# LOAD:          cmd LC_LOAD_DYLIB
-# LOAD-NEXT: cmdsize
-# LOAD-NEXT:    name /usr/lib/libc++.dylib
+# LOAD-NOT:    name /usr/lib/libc++.dylib
 # LOAD:          cmd LC_LOAD_DYLIB
 # LOAD-NEXT: cmdsize
 # LOAD-NEXT:    name /usr/lib/libtoplevel.dylib
-# LOAD:          cmd LC_LOAD_DYLIB
-# LOAD-NEXT: cmdsize
-# LOAD-NEXT:    name /usr/lib/libunused.dylib
+# LOAD-NOT:    name /usr/lib/libunused.dylib
 # LOAD:          cmd LC_LOAD_DYLIB
 # LOAD-NEXT: cmdsize
 # LOAD-NEXT:    name [[DIR]]/libreexporter.dylib
 
 # RUN: %lld -no_implicit_dylibs -syslibroot %t -o %t/no-implicit -lSystem -L%t -lreexporter %t/test.o
 # RUN: llvm-objdump --bind --no-show-raw-insn -d %t/no-implicit | FileCheck %s --check-prefix=NO-IMPLICIT
 # NO-IMPLICIT:     Bind table:
 # NO-IMPLICIT-DAG: __DATA __data {{.*}} pointer 0 libreexporter _foo

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

 ; REQUIRES: x86
 ; RUN: rm -rf %t; split-file %s %t
 ;
 ; RUN: llvm-as %t/framework.ll -o %t/framework.o
-; RUN: %lld %t/framework.o -o %t/frame
-; RUN: llvm-objdump --macho --all-headers %t/frame | FileCheck --check-prefix=FRAME %s \
+; RUN: %lld -lSystem %t/framework.o -o %t/frame
+; RUN: llvm-otool -l %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 /usr/lib/libSystem.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: 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: llvm-objdump --macho --all-headers %t/l | FileCheck --check-prefix=LIB %s \
+;; The dynamic call to _CFBigNumGetInt128 uses dyld_stub_binder,
+;; which needs -lSystem from LC_LINKER_OPTION to get resolved.
+; RUN: %lld %t/l.o -o %t/l -framework CoreFoundation
+; RUN: llvm-otool -l %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 /System/Library/Frameworks/CoreFoundation.framework/CoreFoundation
+; LIB:          cmd LC_LOAD_DYLIB
+; LIB-NEXT: cmdsize
 ; LIB-NEXT:    name /usr/lib/libSystem.dylib
+
+;; Check that we don't create duplicate LC_LOAD_DYLIBs.
+; RUN: %lld -lSystem %t/l.o -o %t/l -framework CoreFoundation
+; RUN: llvm-otool -l %t/l | FileCheck --check-prefix=FRAME %s \
+; RUN:  --implicit-check-not LC_LOAD_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
 ; 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}
 
+declare void @_CFBigNumGetInt128(...)
+
 define void @main() {
+  call void bitcast (void (...)* @_CFBigNumGetInt128 to void ()*)()
   ret void
 }
 
 ;--- l.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 = !{!"-lSystem"}
 !llvm.linker.options = !{!0, !0}
 
+declare void @_CFBigNumGetInt128(...)
+
 define void @main() {
+  call void bitcast (void (...)* @_CFBigNumGetInt128 to void ()*)()
   ret void
 }
 
 ;--- invalid.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 = !{!"-why_load"}
 !llvm.linker.options = !{!0}
 
 define void @main() {
   ret void
 }