[ELF] - Added support for --unresolved-symbols option.

[grimar]

Summary

Option has next description (http://linux.die.net/man/1/ld):

--unresolved-symbols=method
Determine how to handle unresolved symbols. There are four possible values for method
according to documentation:

ignore-all: Do not report any unresolved symbols.
report-all: Report all unresolved symbols. This is the default.
ignore-in-object-files: Report unresolved symbols that are contained in shared libraries, but ignore them if they come from regular object files.
ignore-in-shared-libs: Report unresolved symbols that come from regular object files, but ignore them if they come from shared libraries.

This is PR24524.
Since report-all is default and we do not report about undefined symbols in lld,
report-all does not report about undefines from DSO.
ignore-in-object-files also does not do that. Handling of that option differs from what gnu linkers do.

Option works in next way in lld:
ignore-all: Do not report any unresolved symbols.
report-all: Report all unresolved symbols except symbols from DSOs. This is the default.
ignore-in-object-files: The same as ignore-all.
gnore-in-shared-libs: The same as report-all.

[ruiu]

ELF/Config.h

40 ↗

(On Diff #62091)

We always ignore undefined symbols in DSOs, so this enum shouldn't have IgnoreInSharedLibs. This also overlaps with NoinhibitExec, so it needs reorganization.

I think you want to define this in Config.

enum { Error, Warn, Ignore };

and

• set to Error by default or if --unresolved-symbols=IgnoreAll
• set to Warn if --noinhibit-exec
• set to Ignore if --unresolved-symbols={IgnoreAll,IgnoreInObjectFiles,IgnoreInSharedLibs}

ELF/Writer.cpp

734 ↗

(On Diff #62091)

We don't want to do this -- we don't care whether undefined symbols in DSOs are resolved or not unlike GNU linkers.

[grimar]

ELF/Config.h

40 ↗

(On Diff #62091)

This enum was for describing possible options for unresolved-symbols initially,
but if you want to remove reportUndefinedFromSharedLibs() that of cource
needs reorganization.

I would also add --no-undefined here then.

So can be:

Error by default or if --no-undefined or --unresolved-symbols={ReportAll, IgnoreInSharedLibs}
Warn if --noinhibit-exec
Ignore if --unresolved-symbols={IgnoreAll,IgnoreInObjectFiles}

ELF/Writer.cpp

734 ↗

(On Diff #62091)

Generally yes, but I was thinking about this option as about the only option that can show this information in lld.
That was key feature of this option for me.

Shouldn't we show warning then ? For example when IgnoreInObjectFiles is used explicitly we probably want to inform user that
it does not do what is expected from documentation ? (does not show eerors for symbols from DSO).

[ruiu]

ELF/Writer.cpp

734 ↗

(On Diff #62091)

We don't care about undefined symbols in DSOs because we think identifying them doesn't make sense. So, I think we don't want to provide an option to detect an "error" that doesn't make sense to us.

[grimar]

• Addressed review comments.

[grimar]

ELF/Config.h

40 ↗

(On Diff #62091)

I had to add NoUndef enum value to handle --no-undefined.
When --no-undefined is set we produce error even when -shared and symbol visibility STV_DEFAULT,
otherwise it is ignored. That was original logic worked before this patch.

[ruiu]

ELF/Config.h

36 ↗

(On Diff #62201)

You want to move this inside Config class so that these enum names don't pollute lld::elf namespace.

113 ↗

(On Diff #62201)

I think you can make this enum nameless.

enum { NoUndef, Error, Warn, Ignore } UnresolvedSymbols = Error;

ELF/Driver.cpp

412 ↗

(On Diff #62201)

Please make a new function for the new code. I'd define getUnresolvedSymbolOption.

ELF/LTO.cpp

242 ↗

(On Diff #62201)

Move Error inside Config and revert this change.

ELF/Writer.cpp

12 ↗

(On Diff #62201)

Do you need this?

282–284 ↗

(On Diff #62201)

I'm not sure if this is what --no-undefined should do. Is this correct?

[grimar]

ELF/Config.h

36 ↗

(On Diff #62201)

Please see below.

113 ↗

(On Diff #62201)

I think I need named one to implement

HandlingRule getUnresolvedSymbolOption().

And because of that may be make it enum class and leave outside ?

ELF/Driver.cpp

412 ↗

(On Diff #62201)

I don't think I can return the value of anonymous enum. I mean I can return unsigned,
but will not be able to assign it then:

Config->UnresolvedSymbols = getUnresolvedSymbolOption(); //error

as there is no type to cast to.

ELF/Writer.cpp

282–284 ↗

(On Diff #62201)

Per manual "--no-undefined Report unresolved symbol references from regular object files. This is done even if the linker is creating a non-symbolic shared library."
So according to that description we should report here if --no-undefined is set. Btw I am not changing the logic here, that is how it worked initially and I think it is correct.

[grimar]

• Addressed comments in according to Rui's suggestions and my answers above.

[ruiu]

LGTM with the following changes.

ELF/Config.h

36 ↗

(On Diff #62206)

This name is too generic. I'd rename UnresolvedPolicy.

ELF/Options.td

154 ↗

(On Diff #62206)

Remove ..

ELF/Writer.cpp

281–282 ↗

(On Diff #62206)

if (Config->Shared && Sym->symbol()->Visitility == STV_DEFAULT &&
    Config->UnresolvedSymbols != HandlingRule::NoUndef)

lld/trunk/ELF/Config.h

enum ELFKind {
   ELF32LEKind,
   ELF32BEKind,
   ELF64LEKind,
   ELF64BEKind
 };
 
 enum class BuildIdKind { None, Fnv1, Md5, Sha1, Hexstring };
 
+enum class UnresolvedPolicy { NoUndef, Error, Warn, Ignore };
+
 // This struct contains symbols version definition that
 // can be found in version script if it is used for link.
 struct Version {
   Version(llvm::StringRef Name) : Name(Name) {}
   llvm::StringRef Name;
   llvm::StringRef Parent;
   std::vector<llvm::StringRef> Globals;
   size_t NameOff; // Offset in string table.
struct Configuration {
   bool EhFrameHdr;
   bool EnableNewDtags;
   bool ExportDynamic;
   bool GcSections;
   bool GnuHash = false;
   bool ICF;
   bool Mips64EL = false;
   bool NoGnuUnique;
-  bool NoUndefined;
   bool NoUndefinedVersion;
-  bool NoinhibitExec;
   bool Pic;
   bool Pie;
   bool PrintGcSections;
   bool Rela;
   bool Relocatable;
   bool SaveTemps;
   bool Shared;
   bool Static = false;
   bool StripAll;
   bool StripDebug;
   bool SysvHash = true;
   bool Threads;
   bool Trace;
   bool Verbose;
   bool VersionScriptGlobalByDefault = true;
   bool WarnCommon;
   bool ZCombreloc;
   bool ZExecStack;
   bool ZNodelete;
   bool ZNow;
   bool ZOrigin;
   bool ZRelro;
+  UnresolvedPolicy UnresolvedSymbols;
   BuildIdKind BuildId = BuildIdKind::None;
   ELFKind EKind = ELFNoneKind;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   uint64_t EntryAddr = -1;
   unsigned LtoJobs;
   unsigned LtoO;
   unsigned Optimize;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/Driver.cpp

void LinkerDriver::main(ArrayRef<const char *> ArgsArr) {
   case ELF64BEKind:
     link<ELF64BE>(Args);
     return;
   default:
     error("-m or at least a .o file required");
   }
 }
 
+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_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::Error;
+    error("unknown --unresolved-symbols value: " + S);
+  }
+  return UnresolvedPolicy::Error;
+}
+
 // Initializes Config members by the command line options.
 void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   for (auto *Arg : Args.filtered(OPT_L))
     Config->SearchPaths.push_back(Arg->getValue());
 
   std::vector<StringRef> RPaths;
   for (auto *Arg : Args.filtered(OPT_rpath))
     RPaths.push_back(Arg->getValue());
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->DiscardLocals = Args.hasArg(OPT_discard_locals);
   Config->DiscardNone = Args.hasArg(OPT_discard_none);
   Config->EhFrameHdr = Args.hasArg(OPT_eh_frame_hdr);
   Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
   Config->ExportDynamic = Args.hasArg(OPT_export_dynamic);
   Config->GcSections = Args.hasArg(OPT_gc_sections);
   Config->ICF = Args.hasArg(OPT_icf);
   Config->NoGnuUnique = Args.hasArg(OPT_no_gnu_unique);
-  Config->NoUndefined =
-      Args.hasArg(OPT_no_undefined) || hasZOption(Args, "defs");
   Config->NoUndefinedVersion = Args.hasArg(OPT_no_undefined_version);
-  Config->NoinhibitExec = Args.hasArg(OPT_noinhibit_exec);
   Config->Pie = Args.hasArg(OPT_pie);
   Config->PrintGcSections = Args.hasArg(OPT_print_gc_sections);
   Config->Relocatable = Args.hasArg(OPT_relocatable);
   Config->SaveTemps = Args.hasArg(OPT_save_temps);
   Config->Shared = Args.hasArg(OPT_shared);
   Config->StripAll = Args.hasArg(OPT_strip_all);
   Config->StripDebug = Args.hasArg(OPT_strip_debug);
   Config->Threads = Args.hasArg(OPT_threads);
if (auto *Arg = Args.getLastArg(OPT_build_id_eq)) {
     } else {
       error("unknown --build-id style: " + S);
     }
   }
 
   for (auto *Arg : Args.filtered(OPT_undefined))
     Config->Undefined.push_back(Arg->getValue());
 
+  Config->UnresolvedSymbols = getUnresolvedSymbolOption(Args);
+
   if (auto *Arg = Args.getLastArg(OPT_dynamic_list))
     if (Optional<MemoryBufferRef> Buffer = readFile(Arg->getValue()))
       parseDynamicList(*Buffer);
 
   for (auto *Arg : Args.filtered(OPT_export_dynamic_symbol))
     Config->DynamicList.push_back(Arg->getValue());
 
   if (auto *Arg = Args.getLastArg(OPT_version_script)) {

lld/trunk/ELF/Options.td

 
 def trace: F<"trace">, HelpText<"Print the names of the input files">;
 
 def trace_symbol : J<"trace-symbol=">, HelpText<"Trace references to symbols">;
 
 def undefined: J<"undefined=">,
   HelpText<"Force undefined symbol during linking">;
 
+def unresolved_symbols: J<"unresolved-symbols=">,
+  HelpText<"Determine how to handle unresolved symbols">;
+
 def verbose: F<"verbose">, HelpText<"Verbose mode">;
 
 def version: F<"version">, HelpText<"Display the version number">;
 
 def version_script: S<"version-script">,
   HelpText<"Read a version script">;
 
 def warn_common: F<"warn-common">,

lld/trunk/ELF/Writer.cpp

return DenseMapInfo<StringRef>::isEqual(LHS.Name, RHS.Name) &&
            LHS.Type == RHS.Type && LHS.Flags == RHS.Flags &&
            LHS.Alignment == RHS.Alignment;
   }
 };
 }
 
 template <class ELFT>
 static void reportUndefined(SymbolTable<ELFT> &Symtab, SymbolBody *Sym) {
-  if (!Config->NoUndefined) {
-    if (Config->Relocatable)
-      return;
-    if (Config->Shared && Sym->symbol()->Visibility == STV_DEFAULT)
-      return;
-  }
+  if (Config->UnresolvedSymbols == UnresolvedPolicy::Ignore)
+
+  if (Config->Shared && Sym->symbol()->Visibility == STV_DEFAULT &&
+      Config->UnresolvedSymbols != UnresolvedPolicy::NoUndef)
 
   std::string Msg = "undefined symbol: " + Sym->getName().str();
   if (InputFile *File = Sym->getSourceFile<ELFT>())
     Msg += " in " + getFilename(File);
-  if (Config->NoinhibitExec)
+  if (Config->UnresolvedSymbols == UnresolvedPolicy::Warn)
     warning(Msg);
   else
     error(Msg);
 }
 
 template <class ELFT>
 static bool shouldKeepInSymtab(InputSectionBase<ELFT> *Sec, StringRef SymName,
                                const SymbolBody &B) {

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

+.globl _shared
+_shared:
+  callq undef@PLT

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

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/unresolved-symbols.s -o %t2.o
+# RUN: ld.lld -shared %t2.o -o %t.so
+
+## Check that %t2.o contains undefined symbol undef.
+# RUN: not ld.lld %t1.o %t2.o -o %t 2>&1 | \
+# RUN:   FileCheck -check-prefix=UNDCHECK %s
+# UNDCHECK: undefined symbol: undef in {{.*}}2.o
+
+## Error out if unknown option value was set.
+# RUN: not ld.lld %t1.o %t2.o -o %t --unresolved-symbols=xxx 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERR1 %s
+# ERR1: unknown --unresolved-symbols value: xxx
+
+## Ignore all should not produce error for symbols from object except
+## case when --no-undefined specified.
+# RUN: ld.lld %t2.o -o %t1_1 --unresolved-symbols=ignore-all
+# RUN: llvm-readobj %t1_1 > /dev/null 2>&1
+# RUN: not ld.lld %t2.o -o %t1_2 --unresolved-symbols=ignore-all --no-undefined 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERRUND %s
+# ERRUND: undefined symbol: undef
+## Also ignore all should not produce error for symbols from DSOs.
+# RUN: ld.lld %t1.o %t.so -o %t1_3 --unresolved-symbols=ignore-all
+# RUN: llvm-readobj %t1_3 > /dev/null 2>&1
+
+## Ignoring undefines in objects should not produce error for symbol from object.
+# RUN: ld.lld %t1.o %t2.o -o %t2 --unresolved-symbols=ignore-in-object-files
+# RUN: llvm-readobj %t2 > /dev/null 2>&1
+## And still should not should produce for undefines from DSOs.
+# RUN: ld.lld %t1.o %t.so -o %t2_1 --unresolved-symbols=ignore-in-object-files
+# RUN: llvm-readobj %t2 > /dev/null 2>&1
+
+## Ignoring undefines in shared should produce error for symbol from object.
+# RUN: not ld.lld %t2.o -o %t3 --unresolved-symbols=ignore-in-shared-libs 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERRUND %s
+## And should not produce errors for symbols from DSO.
+# RUN: ld.lld %t1.o %t.so -o %t3_1 --unresolved-symbols=ignore-in-shared-libs
+# RUN: llvm-readobj %t3_1 > /dev/null 2>&1
+
+## Ignoring undefines in shared libs should not produce error for symbol from object
+## if we are linking DSO.
+# RUN: ld.lld -shared %t1.o -o %t4 --unresolved-symbols=ignore-in-shared-libs
+# RUN: llvm-readobj %t4 > /dev/null 2>&1
+
+## Do not report undefines if linking relocatable.
+# RUN: ld.lld -r %t1.o %t2.o -o %t5 --unresolved-symbols=report-all
+# RUN: llvm-readobj %t5 > /dev/null 2>&1
+
+## report-all is the default one. Check that we do not report
+## undefines from DSO and do report undefines from object. With
+## report-all specified and without.
+# RUN: ld.lld -shared %t1.o %t.so -o %t6 --unresolved-symbols=report-all
+# RUN: llvm-readobj %t6 > /dev/null 2>&1
+# RUN: ld.lld -shared %t1.o %t.so -o %t6_1
+# RUN: llvm-readobj %t6_1 > /dev/null 2>&1
+# RUN: not ld.lld %t2.o -o %t7 --unresolved-symbols=report-all 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERRUND %s
+# RUN: not ld.lld %t2.o -o %t7_1 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERRUND %s
+
+.globl _start
+_start: