[lld/mac] Implement -needed_framework, -needed_library, -needed-l

[thakis]

Summary

These allow overriding dead_strip_dylibs.

[int3]

lld/MachO/Driver.cpp

333–334

why not just dylibFile->forceNeeded = isNeeded? (actually same question for forceWeakImport below... and I see we don't do that if check for explicitlyLinked above). I believe addFile() returns a new instance each time, so unconditionally setting these values should be fine

[thakis]

Thanks!

lld/MachO/Driver.cpp

333–334

I did it this way for consistency with forceWeakImport, but now that I think about it I think it's needed for correctness:

I believe addFile() returns a new instance each time, so unconditionally setting these values should be fine

That's not true: It always reads the file, but it then calls addDylib() which uses the dylib cache. That's important too: -needed-lFoo -reexport-lFoo marks libFoo.dylib as both needed and reexported. (…I guess I should add a test for this.)

Good point about the explicitilyLinked: I think that's wrong. If you link a dylib both explicitly (say, via an -l flag) and implicitly via LC_LINKER_COMMAND, I think the latter runs later and overwrites explicitlyLinked with false. I'll make a CL for that.

[int3]

lld/MachO/Driver.cpp

333–334

ah I see. Makes sense now!

[thakis]

Thanks!

lld/MachO/Driver.cpp

if (newFile) {
     if (config->printEachFile && magic != file_magic::archive &&
         !isa<DylibFile>(newFile))
       message(toString(newFile));
     inputFiles.insert(newFile);
   }
   return newFile;
 }
 
-static void addLibrary(StringRef name, bool isWeak, bool isReexport,
-                       bool isExplicit) {
+static void addLibrary(StringRef name, bool isNeeded, bool isWeak,
+                       bool isReexport, bool isExplicit) {
   if (Optional<StringRef> path = findLibrary(name)) {
     if (auto *dylibFile = dyn_cast_or_null<DylibFile>(
             addFile(*path, /*forceLoadArchive=*/false, isExplicit))) {
+      if (isNeeded)
+        dylibFile->forceNeeded = true;
       if (isWeak)
         dylibFile->forceWeakImport = true;
       if (isReexport) {
         config->hasReexports = true;
         dylibFile->reexport = true;
       }
     }
     return;
   }
   error("library not found for -l" + name);
 }
 
-static void addFramework(StringRef name, bool isWeak, bool isReexport,
-                         bool isExplicit) {
+static void addFramework(StringRef name, bool isNeeded, bool isWeak,
+                         bool isReexport, bool isExplicit) {
   if (Optional<std::string> path = findFramework(name)) {
     if (auto *dylibFile = dyn_cast_or_null<DylibFile>(
             addFile(*path, /*forceLoadArchive=*/false, isExplicit))) {
+      if (isNeeded)
+        dylibFile->forceNeeded = true;
       if (isWeak)
         dylibFile->forceWeakImport = true;
       if (isReexport) {
         config->hasReexports = true;
         dylibFile->reexport = true;
       }
     }
     return;
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(), /*isWeak=*/false, /*isReexport=*/false,
-                 /*isExplicit=*/false);
+      addLibrary(arg->getValue(), /*isNeeded=*/false, /*isWeak=*/false,
+                 /*isReexport=*/false, /*isExplicit=*/false);
       break;
     case OPT_framework:
-      addFramework(arg->getValue(), /*isWeak=*/false, /*isReexport=*/false,
-                   /*isExplicit=*/false);
+      addFramework(arg->getValue(), /*isNeeded=*/false, /*isWeak=*/false,
+                   /*isReexport=*/false, /*isExplicit=*/false);
       break;
     default:
       error(arg->getSpelling() + " is not allowed in LC_LINKER_OPTION");
     }
   }
 }
 
 static void addFileList(StringRef path) {
for (const Arg *arg : args) {
     const Option &opt = arg->getOption();
     warnIfDeprecatedOption(opt);
     warnIfUnimplementedOption(opt);
 
     switch (opt.getID()) {
     case OPT_INPUT:
       addFile(rerootPath(arg->getValue()), /*forceLoadArchive=*/false);
       break;
+    case OPT_needed_library:
+      if (auto *dylibFile = dyn_cast_or_null<DylibFile>(
+              addFile(rerootPath(arg->getValue()), false)))
+        dylibFile->forceNeeded = true;
+      break;
     case OPT_reexport_library:
       if (auto *dylibFile = dyn_cast_or_null<DylibFile>(addFile(
               rerootPath(arg->getValue()), /*forceLoadArchive=*/false))) {
         config->hasReexports = true;
         dylibFile->reexport = true;
       }
       break;
     case OPT_weak_library:
       if (auto *dylibFile = dyn_cast_or_null<DylibFile>(
               addFile(rerootPath(arg->getValue()), /*forceLoadArchive=*/false)))
         dylibFile->forceWeakImport = true;
       break;
     case OPT_filelist:
       addFileList(arg->getValue());
       break;
     case OPT_force_load:
       addFile(rerootPath(arg->getValue()), /*forceLoadArchive=*/true);
       break;
     case OPT_l:
+    case OPT_needed_l:
     case OPT_reexport_l:
     case OPT_weak_l:
-      addLibrary(arg->getValue(), opt.getID() == OPT_weak_l,
-                 opt.getID() == OPT_reexport_l, /*isExplicit=*/true);
+      addLibrary(arg->getValue(), opt.getID() == OPT_needed_l,
+                 opt.getID() == OPT_weak_l, opt.getID() == OPT_reexport_l,
+                 /*isExplicit=*/true);
       break;
     case OPT_framework:
+    case OPT_needed_framework:
     case OPT_reexport_framework:
     case OPT_weak_framework:
-      addFramework(arg->getValue(), opt.getID() == OPT_weak_framework,
+      addFramework(arg->getValue(), opt.getID() == OPT_needed_framework,
+                   opt.getID() == OPT_weak_framework,
                    opt.getID() == OPT_reexport_framework, /*isExplicit=*/true);
       break;
     default:
       break;
     }
   }
 }
 

lld/MachO/InputFiles.h

public:
 
   StringRef dylibName;
   DylibFile *exportingFile = nullptr;
   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 forceNeeded = false;
   bool forceWeakImport = false;
   bool deadStrippable = false;
   bool explicitlyLinked = false;
 
   unsigned numReferencedSymbols = 0;
 
   bool isReferenced() const {
     return numReferencedSymbols > 0;

lld/MachO/Options.td

 def weak_l : Joined<["-"], "weak-l">,
     MetaVarName<"<name>">,
     HelpText<"Like -l<name>, but mark library and its references as weak imports">,
     Group<grp_libs>;
 def weak_library : Separate<["-"], "weak_library">,
     MetaVarName<"<path>">,
     HelpText<"Like bare <path>, but mark library and its references as weak imports">,
     Group<grp_libs>;
+def needed_l : Joined<["-"], "needed-l">,
+    MetaVarName<"<name>">,
+    HelpText<"Like -l<name>, but link library even if its symbols are not used and -dead_strip_dylibs is active">,
+    Group<grp_libs>;
+def needed_library : Separate<["-"], "needed_library">,
+    MetaVarName<"<path>">,
+    HelpText<"Like bare <path>, but link library even if its symbols are not used and -dead_strip_dylibs is active">,
+    Group<grp_libs>;
 def reexport_l : Joined<["-"], "reexport-l">,
     MetaVarName<"<name>">,
     HelpText<"Like -l<name>, but export all symbols of <name> from newly created library">,
     Group<grp_libs>;
 def reexport_library : Separate<["-"], "reexport_library">,
     MetaVarName<"<path>">,
     HelpText<"Like bare <path>, but export all symbols of <path> from newly created library">,
     Group<grp_libs>;

 def framework : Separate<["-"], "framework">,
     MetaVarName<"<name>">,
     HelpText<"Search for <name>.framework/<name> on the framework search path">,
     Group<grp_libs>;
 def weak_framework : Separate<["-"], "weak_framework">,
     MetaVarName<"<name>">,
     HelpText<"Like -framework <name>, but mark framework and its references as weak imports">,
     Group<grp_libs>;
+def needed_framework : Separate<["-"], "needed_framework">,
+    MetaVarName<"<name>">,
+    HelpText<"Like -framework <name>, but link <name> even if none of its symbols are used and -dead_strip_dylibs is active">,
+    Group<grp_libs>;
 def reexport_framework : Separate<["-"], "reexport_framework">,
     MetaVarName<"<name>">,
     HelpText<"Like -framework <name>, but export all symbols of <name> from the newly created library">,
     Group<grp_libs>;
 def upward_framework : Separate<["-"], "upward_framework">,
     MetaVarName<"<name>">,
     HelpText<"Like -framework <name>, but specify the framework as an upward dependency">,
     Flags<[HelpHidden]>,

lld/MachO/Writer.cpp

if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
       // 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() &&
+      if (!dylibFile->isReferenced() && !dylibFile->forceNeeded &&
           (!dylibFile->explicitlyLinked || dylibFile->deadStrippable ||
            config->deadStripDylibs))
         continue;
 
       // Several DylibFiles can have the same installName. Only emit a single
       // load command for that installName and give all these DylibFiles the
       // same ordinal.
       // This can happen in several cases:

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 %t/bar.o -o %t/libbar.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

 # 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
+## ...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
 
+## But -needed_library and -needed-l win over -dead_strip_dylibs again.
+# RUN: %lld -lSystem %t/main.o -o %t/main %t/foo_with_bar.dylib \
+# RUN:     -needed_library %t/bar.dylib -dead_strip_dylibs
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=BAR %s
+# RUN: %lld -lSystem %t/main.o -o %t/main %t/foo_with_bar.dylib \
+# RUN:     -L%t -needed-lbar -dead_strip_dylibs
+# RUN: llvm-otool -L %t/main | FileCheck --check-prefix=BAR %s
+
 ## LC_LINKER_OPTION does not count as an 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.dylib
 # RUN: llvm-otool -L %t/main | FileCheck --check-prefix=NOLIBBAR %s
 # NOLIBBAR-NOT: libbar.dylib
 # NOLIBBAR: /usr/lib/libSystem.dylib
 # NOLIBBAR-NOT: libbar.dylib
 # NOLIBBAR: foo.dylib
 # NOLIBBAR-NOT: libbar.dylib