[lld-macho] Add option for ld64 autolink behavior

[keith]

Summary

By default ld64 ignores invalid LC_LINKER_OPTION warnings unless the
link fails at which point it prints them. This adds that same behavior
behind --ignore-auto-link-options. We could flip this on by default
matching ld64 but it allows these issues to go in unnoticed. At the very
least this option allows folks who have existing violations of this
that are not easy to fix to use lld.

[keith]

This is one of the options being discussed on https://reviews.llvm.org/D140225

[int3]

Superseded by D140491: [lld-macho] Use ld64's LC_LINKER_OPTIONS behavior by default

[keith]

https://reviews.llvm.org/D140491

lld/MachO/Config.h

struct Configuration {
   bool deadStrip = false;
   bool errorForArchMismatch = false;
   bool ignoreAutoLink = false;
   // ld64 allows invalid auto link options as long as the link succeeds. LLD
   // does not, but there are cases in the wild where the invalid linker options
   // exist. This allows users to ignore the specific invalid options in the case
   // they can't easily fix them.
   llvm::StringSet<> ignoreAutoLinkOptions;
+  // This is the more relaxed option to ignore all framework not found errors.
+  // In some cases, it's not practical to find and list all the framework names
+  // with --ignore-auto-link-options.
+  bool ignoreAutoLinkErrors = false;
   PlatformInfo platformInfo;
   std::optional<PlatformInfo> secondaryPlatformInfo;
   NamespaceKind namespaceKind = NamespaceKind::twolevel;
   UndefinedSymbolTreatment undefinedSymbolTreatment =
       UndefinedSymbolTreatment::error;
   ICFLevel icfLevel = ICFLevel::none;
   ObjCStubsMode objcStubsMode = ObjCStubsMode::fast;
   llvm::MachO::HeaderFileType outputType;

lld/MachO/Driver.cpp

if (auto *dylibFile = dyn_cast_or_null<DylibFile>(
       }
     }
     return;
   }
   error("library not found for -l" + name);
 }
 
 static DenseSet<StringRef> loadedObjectFrameworks;
+static DenseSet<StringRef> missingAutolinkFrameworks;
 static void addFramework(StringRef name, bool isNeeded, bool isWeak,
                          bool isReexport, bool isExplicit, LoadType loadType) {
   if (std::optional<StringRef> path = findFramework(name)) {
     if (loadedObjectFrameworks.contains(*path))
       return;
 
     InputFile *file =
         addFile(*path, loadType, /*isLazy=*/false, isExplicit, false);
if (auto *dylibFile = dyn_cast_or_null<DylibFile>(file)) {
       // symbols. Frameworks containing static archives are cached separately
       // in addFile() to share caching with libraries, and frameworks
       // containing dylibs should allow overwriting of attributes such as
       // forceNeeded by subsequent loads
       loadedObjectFrameworks.insert(*path);
     }
     return;
   }
+  if (loadType == LoadType::LCLinkerOption && config->ignoreAutoLinkErrors) {
+    missingAutolinkFrameworks.insert(name);
+    return;
+  }
   error("framework not found for -framework " + name);
 }
 
 // Parses LC_LINKER_OPTION contents, which can add additional command line
 // flags. This directly parses the flags instead of using the standard argument
 // parser to improve performance.
 void macho::parseLCLinkerOption(InputFile *f, unsigned argc, StringRef data) {
   if (config->ignoreAutoLink)
ctx->e.cleanupCallback = []() {
     resolvedFrameworks.clear();
     resolvedLibraries.clear();
     cachedReads.clear();
     concatOutputSections.clear();
     inputFiles.clear();
     inputSections.clear();
     loadedArchives.clear();
     loadedObjectFrameworks.clear();
+    missingAutolinkFrameworks.clear();
     syntheticSections.clear();
     thunkMap.clear();
 
     firstTLVDataSection = nullptr;
     tar = nullptr;
     memset(&in, 0, sizeof(in));
 
     resetLoadedDylibs();
bool macho::link(ArrayRef<const char *> argsArr, llvm::raw_ostream &stdoutOS,
   config->printSymbolOrder = args.getLastArgValue(OPT_print_symbol_order_eq);
   config->forceExactCpuSubtypeMatch =
       getenv("LD_DYLIB_CPU_SUBTYPES_MUST_MATCH");
   config->objcStubsMode = getObjCStubsMode(args);
   config->ignoreAutoLink = args.hasArg(OPT_ignore_auto_link);
   for (const Arg *arg : args.filtered(OPT_ignore_auto_link_option))
     config->ignoreAutoLinkOptions.insert(arg->getValue());
 
+  config->ignoreAutoLinkErrors = args.hasArg(OPT_ignore_auto_link_errors);
+
   for (const Arg *arg : args.filtered(OPT_alias)) {
     config->aliasedSymbols.push_back(
         std::make_pair(arg->getValue(0), arg->getValue(1)));
   }
 
   // FIXME: Add a commandline flag for this too.
   if (const char *zero = getenv("ZERO_AR_DATE"))
     config->zeroModTime = strcmp(zero, "0") != 0;
#endif
   }
 
   if (config->timeTraceEnabled) {
     checkError(timeTraceProfilerWrite(
         args.getLastArgValue(OPT_time_trace_eq).str(), config->outputFile));
 
     timeTraceProfilerCleanup();
   }
-  return errorCount() == 0;
+
+  bool hasErrors = errorCount() != 0;
+  if (hasErrors)
+    for (const auto &framework : missingAutolinkFrameworks)
+      warn("framework not found for -framework " + framework);
+
+  return !hasErrors;
 }

lld/MachO/Options.td

def print_symbol_order_eq: Joined<["--"], "print-symbol-order=">,
     HelpText<"Print a symbol order specified by --call-graph-profile-sort into the specified file">,
     Group<grp_lld>;
 def ignore_auto_link_option : Separate<["--"], "ignore-auto-link-option">,
     Group<grp_lld>;
 def ignore_auto_link_option_eq : Joined<["--"], "ignore-auto-link-option=">,
     Alias<!cast<Separate>(ignore_auto_link_option)>,
     HelpText<"Ignore a single auto-linked library or framework. Useful to ignore invalid options that ld64 ignores">,
     Group<grp_lld>;
+def ignore_auto_link_errors : Flag<["--"], "ignore-auto-link-errors">,
+    HelpText<"Ignore framework or library not found errors if they are loaded via LC_LINKER_OPTIONS">,
+    Group<grp_lld>;
 
 // This is a complete Options.td compiled from Apple's ld(1) manpage
 // dated 2018-03-07 and cross checked with ld64 source code in repo
 // https://github.com/apple-opensource/ld64 at git tag "512.4" dated
 // 2018-03-18.
 
 // Flags<[HelpHidden]> marks options that are not yet ported to lld,
 // and serve as a scoreboard for annotating our progress toward

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

 ;; under ASAN.
 ; RUN: llc %t/foo.ll -o %t/foo.o -filetype=obj
 ; RUN: mkdir -p %t/Foo.framework
 ;; In a proper framework, this is technically supposed to be a symlink to the
 ;; actual archive at Foo.framework/Versions/Current, but we skip that here so
 ;; that this test can run on Windows.
 ; RUN: llvm-ar rcs %t/Foo.framework/Foo %t/foo.o
 ; RUN: llc %t/load-framework-foo.ll -o %t/load-framework-foo.o -filetype=obj
+; RUN: llc %t/load-framework-undefined-symbol.ll -o %t/load-framework-undefined-symbol.o -filetype=obj
 ; RUN: llc %t/main.ll -o %t/main.o -filetype=obj
 ; RUN: %lld %t/load-framework-foo.o %t/main.o -o %t/main -F%t
 ; RUN: llvm-objdump --macho --syms %t/main | FileCheck %s --check-prefix=SYMS
 
 ;; Make sure -all_load and -ObjC have no effect on libraries loaded via
 ;; LC_LINKER_OPTION flags.
 ; RUN: llc %t/load-library-foo.ll -o %t/load-library-foo.o -filetype=obj
 ; RUN: llvm-ar rcs %t/libfoo.a %t/foo.o

 ; RUN: %lld -F %t -framework Foo -framework Foo %t/main -o /dev/null
 
 ; RUN: llvm-as %t/foo.ll -o %t/Foo.framework/Foo
 ; RUN: llvm-as %t/load-framework-twice.ll -o %t/main
 ;; Order of the object with the LC_LINKER_OPTION vs -framework arg is important.
 ; RUN: %lld %t/main -F %t -framework Foo -framework Foo -o /dev/null
 ; RUN: %lld -F %t -framework Foo -framework Foo %t/main -o /dev/null
 
+;; Checks that "framework not found" errors from LC_LINKER_OPTIONS are not emitted when
+;; -ignore-auto-link-errors is set.
+; RUN: %lld --ignore-auto-link-errors -ObjC %t/load-framework-foo.o %t/main.o -o %t/main-no-foo.out
+; RUN: llvm-objdump --macho --syms %t/main-no-foo.out | FileCheck %s --check-prefix=SYMS_NO_FOO
+; RUN: not %lld --ignore-auto-link-errors -ObjC %t/load-framework-undefined-symbol.o %t/main.o -o %t/main-no-foo.out 2>&1 \
+; RUN:   | FileCheck %s --check-prefix=MISSING_FRAMEWORK
+
+;; Verify that nothing from the framework is included.
+; SYMS_NO_FOO:       SYMBOL TABLE:
+; SYMS_NO_FOO-NEXT:  g     F __TEXT,__text _main
+; SYMS_NO_FOO-NOT:   g     O __DATA,__objc_data _OBJC_CLASS_$_TestClass
+
+; MISSING_FRAMEWORK: undefined symbol: __SomeUndefinedSymbol
+; MISSING_FRAMEWORK: framework not found for -framework Foo
+
 ;--- 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(...)

 
 ;--- load-framework-foo.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", !"Foo"}
 !llvm.linker.options = !{!0}
 
+;--- load-framework-undefined-symbol.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"
+
+declare void @_SomeUndefinedSymbol(...)
+define void @foo() {
+  call void @_SomeUndefinedSymbol()
+  ret void
+}
+
+!0 = !{!"-framework", !"Foo"}
+!llvm.linker.options = !{!0}
+
 ;--- load-framework-twice.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", !"Foo"}
 !llvm.linker.options = !{!0, !0}
 
 define void @main() {