[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

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

719

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

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

719

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

719

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

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

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

113

I think you can make this enum nameless.

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

ELF/Driver.cpp

412

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

ELF/LTO.cpp

242

Move Error inside Config and revert this change.

ELF/Writer.cpp

12

Do you need this?

282–284

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

[grimar]

ELF/Config.h

36

Please see below.

113

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

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

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

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

ELF/Options.td

154

Remove ..

ELF/Writer.cpp

282–283

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

ELF/Config.h

enum ELFKind {
   ELF32LEKind,
   ELF32BEKind,
   ELF64LEKind,
   ELF64BEKind
 };
 
 enum class BuildIdKind { None, Fnv1, Md5, Sha1, Hexstring };
 
+enum HandlingRule { 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.
 };
 
 // This struct contains the global configuration for the linker.
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;
+  HandlingRule UnresolvedSymbols = Error;
   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

ELF/Driver.cpp

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());
 
+  if (Args.hasArg(OPT_noinhibit_exec))
+    Config->UnresolvedSymbols = Warn;
+  else if (Args.hasArg(OPT_no_undefined) || hasZOption(Args, "defs"))
+    Config->UnresolvedSymbols = NoUndef;
+  else if (Config->Relocatable)
+    Config->UnresolvedSymbols = Ignore;
+  else if (auto *Arg = Args.getLastArg(OPT_unresolved_symbols)) {
+    StringRef S = Arg->getValue();
+    if (S == "ignore-all" || S == "ignore-in-object-files")
+      Config->UnresolvedSymbols = Ignore;
+    else if (S == "ignore-in-shared-libs" || S == "report-all")
+      Config->UnresolvedSymbols = Error;
+    else
+      error("unknown --unresolved-symbols value: " + S);
+  }
+
   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)) {

ELF/LTO.cpp

for (const BasicSymbolRef &Sym : Obj->symbols()) {
     case llvm::GlobalValue::LinkOnceODRLinkage:
       GV->setLinkage(GlobalValue::WeakODRLinkage);
       break;
     }
 
     Keep.push_back(GV);
   }
 
-  if (Error E = Mover.move(Obj->takeModule(), Keep,
+  if (llvm::Error E = Mover.move(Obj->takeModule(), Keep,
                                  [](GlobalValue &, IRMover::ValueAdder) {})) {
     handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) {
       fatal("failed to link module " + F.getName() + ": " + EIB.message());
     });
   }
 }
 
 static void internalize(GlobalValue &GV) {
   assert(!GV.hasLocalLinkage() &&

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">,

ELF/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "Config.h"
+#include "InputFiles.h"
 #include "LinkerScript.h"
 #include "OutputSections.h"
 #include "Relocations.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "Target.h"
 
 #include "llvm/ADT/StringMap.h"
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->UnresolvedSymbols == Ignore)
+
+  if (Config->UnresolvedSymbols != NoUndef)
     if (Config->Shared && Sym->symbol()->Visibility == STV_DEFAULT)
       return;
-  }
 
   std::string Msg = "undefined symbol: " + Sym->getName().str();
   if (InputFile *File = Sym->getSourceFile<ELFT>())
     Msg += " in " + getFilename(File);
-  if (Config->NoinhibitExec)
+  if (Config->UnresolvedSymbols == Warn)
     warning(Msg);
   else
     error(Msg);
 }
 
 template <class ELFT>
 static bool shouldKeepInSymtab(InputSectionBase<ELFT> *Sec, StringRef SymName,
                                const SymbolBody &B) {

 
 // Sort input sections by the special rule for .ctors and .dtors.
 template <class ELFT> static void sortCtorsDtors(OutputSectionBase<ELFT> *S) {
   if (S)
     reinterpret_cast<OutputSection<ELFT> *>(S)->sortCtorsDtors();
 }
 
 // Create output section objects and add them to OutputSections.
 template <class ELFT> void Writer<ELFT>::createSections() {
   // Add .interp first because some loaders want to see that section
   // on the first page of the executable file when loaded into memory.
   if (needsInterpSection())
     OutputSections.push_back(Out<ELFT>::Interp);
 
   // A core file does not usually contain unmodified segments except
   // the first page of the executable. Add the build ID section now
   // so that the section is included in the first page.

test/ELF/Inputs/unresolved-symbols.s

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

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: