Add --warn-unresolved-symbols and --error-unresolved-symbols options

[dmikulin]

Summary

Added the following options for compatibility with binutils ld:

--warn-unresolved-symbols   Report unresolved symbols as warnings
--error-unresolved-symbols  Report unresolved symbols as errors

[ruiu]

ELF/Driver.cpp

347 ↗

(On Diff #85809)

You don't need to check if it is OPT_error_undef because it always have to be that. You can just return ReportError.

[dmikulin]

Added test points to make sure errors/warnings are not issued in relocatable and shared links.
Removed the unnecessary check to return ReportError.

[davide]

Some comments inline.

test/ELF/warn-unresolved-symbols.s

2–3 ↗

(On Diff #85847)

Do you really need two object files? If not, you can probably simplify this test a bit.

23–32 ↗

(On Diff #85847)

gold and bfd accept both the single dash and the double dash variant of this option.
You can change some of the invocations here to - in order to make sure we support it correctly.

[emaste]

test/ELF/warn-unresolved-symbols.s

23–32 ↗

(On Diff #85847)

In general gold and bfd accept - and -- for everything except options starting with 'o'.

[dmikulin]

Got rid of the second file in the test case and added single - test points for options.

[davide]

LGTM. Rui?

[ruiu]

LGTM

[davide]

Committed as r293139. Thanks for your contribution. I'll close the related PR for you as you don't have a bugzilla account yet (*sigh*). You may want to reference the PR number (if any) in the summary of your future reviews, FWIW.

lld/trunk/ELF/Driver.cpp

 static UnresolvedPolicy getUnresolvedSymbolOption(opt::InputArgList &Args) {
   if (Args.hasArg(OPT_noinhibit_exec))
     return UnresolvedPolicy::Warn;
   if (Args.hasArg(OPT_no_undefined) || hasZOption(Args, "defs"))
     return UnresolvedPolicy::NoUndef;
   if (Config->Relocatable)
     return UnresolvedPolicy::Ignore;
 
+  if (auto *Arg = Args.getLastArg(OPT_warn_undef, OPT_error_undef)) {
+    if (Arg->getOption().getID() == OPT_warn_undef)
+      return UnresolvedPolicy::Warn;
+
+    return UnresolvedPolicy::ReportError;
+  }
+
   if (auto *Arg = Args.getLastArg(OPT_unresolved_symbols)) {
     StringRef S = Arg->getValue();
     if (S == "ignore-all" || S == "ignore-in-object-files")
       return UnresolvedPolicy::Ignore;
     if (S == "ignore-in-shared-libs" || S == "report-all")
       return UnresolvedPolicy::ReportError;
     error("unknown --unresolved-symbols value: " + S);
   }

lld/trunk/ELF/Options.td

def end_lib: F<"end-lib">,
   HelpText<"End a grouping of objects that should be treated as if they were together in an archive">;
 
 def entry: S<"entry">, MetaVarName<"<entry>">,
   HelpText<"Name of entry point symbol">;
 
 def error_limit: S<"error-limit">,
   HelpText<"Maximum number of errors to emit before stopping (0 = no limit)">;
 
+def error_undef: F<"error-unresolved-symbols">,
+  HelpText<"Report unresolved symbols as errors">;
+
 def export_dynamic: F<"export-dynamic">,
   HelpText<"Put symbols in the dynamic symbol table">;
 
 def export_dynamic_symbol: S<"export-dynamic-symbol">,
   HelpText<"Put a symbol in the dynamic symbol table">;
 
 def fatal_warnings: F<"fatal-warnings">,
   HelpText<"Treat warnings as errors">;

 def version: F<"version">, HelpText<"Display the version number and exit">;
 
 def version_script: S<"version-script">,
   HelpText<"Read a version script">;
 
 def warn_common: F<"warn-common">,
   HelpText<"Warn about duplicate common symbols">;
 
+def warn_undef: F<"warn-unresolved-symbols">,
+  HelpText<"Report unresolved symbols as warnings">;
+
 def whole_archive: F<"whole-archive">,
   HelpText<"Force load of all members in a static library">;
 
 def wrap: S<"wrap">, MetaVarName<"<symbol>">,
   HelpText<"Use wrapper functions for symbol">;
 
 def z: JoinedOrSeparate<["-"], "z">, MetaVarName<"<option>">,
   HelpText<"Linker option extensions">;

lld/trunk/test/ELF/warn-unresolved-symbols.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t1.o
+
+## The link should fail with an undef error by default
+# RUN: not ld.lld %t1.o -o %t3 2>&1 | \
+# RUN: FileCheck -check-prefix=ERRUND %s
+
+## --error-unresolved-symbols should generate an error
+# RUN: not ld.lld %t1.o -o %t4 --error-unresolved-symbols 2>&1 | \
+# RUN: FileCheck -check-prefix=ERRUND %s
+
+## --warn-unresolved-symbols should generate a warning
+# RUN: ld.lld %t1.o -o %t5 --warn-unresolved-symbols 2>&1 | \
+# RUN: FileCheck -check-prefix=WARNUND %s
+
+## Test that the last option wins
+# RUN: ld.lld %t1.o -o %t5 --error-unresolved-symbols --warn-unresolved-symbols 2>&1 | \
+# RUN:  FileCheck -check-prefix=WARNUND %s
+# RUN: not ld.lld %t1.o -o %t6 --warn-unresolved-symbols --error-unresolved-symbols 2>&1 | \
+# RUN:  FileCheck -check-prefix=ERRUND %s
+
+## Do not report undefines if linking relocatable or shared.
+## And while we're at it, check that we can accept single -
+## variants of these options.
+# RUN: ld.lld -r %t1.o -o %t7 -error-unresolved-symbols 2>&1 | \
+# RUN:  FileCheck -allow-empty -check-prefix=NOERR %s
+# RUN: ld.lld -shared %t1.o -o %t8.so --error-unresolved-symbols 2>&1 | \
+# RUN:  FileCheck -allow-empty -check-prefix=NOERR %s
+# RUN: ld.lld -r %t1.o -o %t9 -warn-unresolved-symbols 2>&1 | \
+# RUN:  FileCheck -allow-empty -check-prefix=NOWARN %s
+# RUN: ld.lld -shared %t1.o -o %t10.so --warn-unresolved-symbols 2>&1 | \
+# RUN:  FileCheck -allow-empty -check-prefix=NOWARN %s
+
+# ERRUND: error: {{.*}}:(.text+0x1): undefined symbol 'undef'
+# WARNUND: warning: {{.*}}:(.text+0x1): undefined symbol 'undef'
+# NOERR-NOT: error: {{.*}}:(.text+0x1): undefined symbol 'undef'
+# NOWARN-NOT: warning: {{.*}}:(.text+0x1): undefined symbol 'undef'
+
+.globl _start
+_start:
+
+.globl _shared
+_shared:
+ callq undef@PLT