[ELF] Don't report error if undefined symbol is not used anywhere

[evgeny777]

Summary

The situation when undefined symbol is not used often takes place, when compiler flags -ffunction-sections -fdata-sections are used in conjunction with linker flag --gc-sections.
In such case we can have undefined symbol which is used by some function collected by linker GC. Both gold and ld add undefined symbol to symtab without reporting any error or warning. This patch makes lld to emit warning instead of error in such cases.

[ruiu]

ELF/Relocations.cpp

560 ↗

(On Diff #73488)

I don't think you need to record whether a symbol is used or not here to use the information later. Instead, you could print out a warning message directly from this context.

ELF/Writer.cpp

320 ↗

(On Diff #73488)

Instead of adding a new bit to the symbol, I'd do this here.

// Ignore symbols in garbage-collected sections.
// We could report them, but we don't because GNU linkers don't.
if (Sym->symbol()->includeInDynsym())
  if (auto *D = dyn_cast<DefinedRegular<ELFT>(Sym))
    if (!D->Section.Live)
      return;

320 ↗

(On Diff #73488)

Ignore this comment -- I deleted it before sending a message but it wasn't removed for some reason.

[evgeny777]

ELF/Relocations.cpp

560 ↗

(On Diff #73488)

Can you please elaborate? If symbol is not a target of any reloc then I won't see it here, will I?

[ruiu]

ELF/Relocations.cpp

560 ↗

(On Diff #73488)

If Body is an undefined symbol we want to warn/error here, no? Then undefined and unreferenced symbols will be ignored completely.

[evgeny777]

ELF/Relocations.cpp

560 ↗

(On Diff #73488)

Do you want to call reportUndefined() here like this:

if (Body.isUndefined())
  reportUndefined(&Body);

I'll check if this works.

[evgeny777]

Addressed review comments

[ruiu]

LGTM

ELF/Relocations.cpp

523 ↗

(On Diff #73623)

Change the type from SymbolBody * to SymbolBody &.

lld/trunk/ELF/Relocations.cpp

 //===----------------------------------------------------------------------===//
 
 #include "Relocations.h"
 #include "Config.h"
 #include "OutputSections.h"
 #include "SymbolTable.h"
 #include "Target.h"
 #include "Thunks.h"
+#include "Strings.h"
 
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support::endian;
if (Expr == R_GOTREL) {
         Addend += File.getMipsGp0();
     }
   }
   if (Config->Pic && Config->EMachine == EM_PPC64 && Type == R_PPC64_TOC)
     Addend += getPPC64TocBase();
   return Addend;
 }
 
+static void reportUndefined(SymbolBody &Sym) {
+  if (Config->UnresolvedSymbols == UnresolvedPolicy::Ignore)
+    return;
+
+  if (Config->Shared && Sym.symbol()->Visibility == STV_DEFAULT &&
+      Config->UnresolvedSymbols != UnresolvedPolicy::NoUndef)
+    return;
+
+  std::string Msg = "undefined symbol: ";
+  Msg += Config->Demangle ? demangle(Sym.getName()) : Sym.getName().str();
+
+  if (Sym.File)
+    Msg += " in " + getFilename(Sym.File);
+  if (Config->UnresolvedSymbols == UnresolvedPolicy::Warn)
+    warn(Msg);
+  else
+    error(Msg);
+}
+
 // The reason we have to do this early scan is as follows
 // * To mmap the output file, we need to know the size
 // * For that, we need to know how many dynamic relocs we will have.
 // It might be possible to avoid this by outputting the file with write:
 // * Write the allocated output sections, computing addresses.
 // * Apply relocations, recording which ones require a dynamic reloc.
 // * Write the dynamic relocations.
 // * Write the rest of the file.
static void scanRelocs(InputSectionBase<ELFT> &C, ArrayRef<RelTy> Rels) {
   ArrayRef<EhSectionPiece>::iterator PieceI = Pieces.begin();
   ArrayRef<EhSectionPiece>::iterator PieceE = Pieces.end();
 
   for (auto I = Rels.begin(), E = Rels.end(); I != E; ++I) {
     const RelTy &RI = *I;
     SymbolBody &Body = File.getRelocTargetSym(RI);
     uint32_t Type = RI.getType(Config->Mips64EL);
 
+    // We only report undefined symbols if they are referenced somewhere in the code.
+    if (!Body.isLocal() && Body.isUndefined() && !Body.symbol()->isWeak())
+      reportUndefined(Body);
+
     RelExpr Expr = Target->getRelExpr(Type, Body);
     bool Preemptible = isPreemptible(Body, Type);
     Expr = adjustExpr(File, Body, IsWrite, Expr, Type, Buf + RI.r_offset);
     if (HasError)
       continue;
 
     // Skip a relocation that points to a dead piece
     // in a eh_frame section.

lld/trunk/ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::run() {
   }
   writeBuildId();
   if (HasError)
     return;
   if (auto EC = Buffer->commit())
     error(EC, "failed to write to the output file");
 }
 
-template <class ELFT> static void reportUndefined(SymbolBody *Sym) {
-  if (Config->UnresolvedSymbols == UnresolvedPolicy::Ignore)
-    return;
-
-  if (Config->Shared && Sym->symbol()->Visibility == STV_DEFAULT &&
-      Config->UnresolvedSymbols != UnresolvedPolicy::NoUndef)
-    return;
-
-  std::string Msg = "undefined symbol: ";
-  Msg += Config->Demangle ? demangle(Sym->getName()) : Sym->getName().str();
-
-  if (Sym->File)
-    Msg += " in " + getFilename(Sym->File);
-  if (Config->UnresolvedSymbols == UnresolvedPolicy::Warn)
-    warn(Msg);
-  else
-    error(Msg);
-}
-
 template <class ELFT>
 static bool shouldKeepInSymtab(InputSectionBase<ELFT> *Sec, StringRef SymName,
                                const SymbolBody &B) {
   if (B.isFile())
     return false;
 
   // We keep sections in symtab for relocatable output.
   if (B.isSection())
template <class ELFT> void Writer<ELFT>::finalizeSections() {
   // we can correctly decide if a dynamic relocation is needed.
   forEachRelSec(scanRelocations<ELFT>);
 
   // Now that we have defined all possible symbols including linker-
   // synthesized ones. Visit all symbols to give the finishing touches.
   for (Symbol *S : Symtab<ELFT>::X->getSymbols()) {
     SymbolBody *Body = S->body();
 
-    // We only report undefined symbols in regular objects. This means that we
-    // will accept an undefined reference in bitcode if it can be optimized out.
-    if (S->IsUsedInRegularObj && Body->isUndefined() && !S->isWeak())
-      reportUndefined<ELFT>(Body);
-
     if (!includeInSymtab<ELFT>(*Body))
       continue;
     if (Out<ELFT>::SymTab)
       Out<ELFT>::SymTab->addSymbol(Body);
 
     if (Out<ELFT>::DynSymTab && S->includeInDynsym()) {
       Out<ELFT>::DynSymTab->addSymbol(Body);
       if (auto *SS = dyn_cast<SharedSymbol<ELFT>>(Body))

lld/trunk/test/ELF/Inputs/use-bar.s

+.section .bar,"a"
+ .quad _bar

lld/trunk/test/ELF/libsearch.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 // RUN:   %p/Inputs/libsearch-dyn.s -o %tdyn.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 // RUN:   %p/Inputs/libsearch-st.s -o %tst.o
+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
+// RUN:   %p/Inputs/use-bar.s -o %tbar.o
 // RUN: mkdir -p %t.dir
 // RUN: ld.lld -shared %tdyn.o -o %t.dir/libls.so
 // RUN: cp -f %t.dir/libls.so %t.dir/libls2.so
 // RUN: rm -f %t.dir/libls.a
 // RUN: llvm-ar rcs %t.dir/libls.a %tst.o
 // REQUIRES: x86
 
 // Should fail if no library specified
 // RUN: not ld.lld -l 2>&1 \
 // RUN:   | FileCheck --check-prefix=NOLIBRARY %s
 // NOLIBRARY: missing arg value for "-l", expected 1 argument.
 
+// Should link normally, because _bar is not used
+// RUN: ld.lld -o %t3 %t.o
 // Should not link because of undefined symbol _bar
-// RUN: not ld.lld -o %t3 %t.o 2>&1 \
+// RUN: not ld.lld -o %t3 %t.o %tbar.o 2>&1 \
 // RUN:   | FileCheck --check-prefix=UNDEFINED %s
 // UNDEFINED: undefined symbol: _bar
 
 // Should fail if cannot find specified library (without -L switch)
 // RUN: not ld.lld -o %t3 %t.o -lls 2>&1 \
 // RUN:   | FileCheck --check-prefix=NOLIB %s
 // NOLIB: unable to find library -lls
 

lld/trunk/test/ELF/linkerscript/edata-etext.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: echo "SECTIONS { }" > %t.script
 # RUN: not ld.lld %t.o -script %t.script -o %t 2>&1 | FileCheck %s
 # CHECK: undefined symbol: _edata
-# CHECK: undefined symbol: _end
 # CHECK: undefined symbol: _etext
+# CHECK: undefined symbol: _end
 
 .global _start,_end,_etext,_edata
 .text
 _start:
  .quad _edata + 0x1
  .quad _etext + 0x1
  .quad _end + 0x1
 
 .data
   .word 1
 .bss
   .align 4
   .space 6

lld/trunk/test/ELF/sysroot.s

 // RUN: ld.lld -o %t/r %t/m.o --sysroot=%t -L=/lib -l:libls.a
 
 // Should not substitute SysRoot if the directory name does not start with '='
 // RUN: not ld.lld -o %t/r %r/m.o --sysroot=%t -Llib -l:libls.a
 // RUN: not ld.lld -o %t/r %r/m.o --sysroot=%t -L/lib -l:libls.a
 
 .globl _start,_bar
 _start:
+  call _bar

lld/trunk/test/ELF/undef-shared.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: not ld.lld %t.o -o %t.so -shared 2>&1 | FileCheck %s
 
 # CHECK: undefined symbol: hidden in {{.*}}
 .global hidden
 .hidden hidden
 
 # CHECK: undefined symbol: internal in {{.*}}
 .global internal
 .internal internal
 
 # CHECK: undefined symbol: protected in {{.*}}
 .global protected
 .protected protected
+
+.section .data, "a"
+ .quad hidden
+ .quad internal
+ .quad protected

lld/trunk/test/ELF/undef.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/undef.s -o %t2.o
 # RUN: llvm-ar rc %t2.a %t2.o
 # RUN: not ld.lld %t.o %t2.a -o %t.exe 2>&1 | FileCheck %s
 # RUN: not ld.lld -pie %t.o %t2.a -o %t.exe 2>&1 | FileCheck %s
-# CHECK: undefined symbol: foo(int) in
-# CHECK: undefined symbol: bar in
 # CHECK: undefined symbol: foo in
+# CHECK: undefined symbol: bar in
+# CHECK: undefined symbol: foo(int) in
 # CHECK: undefined symbol: zed2 in {{.*}}2.a({{.*}}.o)
 
 # RUN: not ld.lld %t.o %t2.a -o %t.exe -no-demangle 2>&1 | \
 # RUN:   FileCheck -check-prefix=NO-DEMANGLE %s
 # NO-DEMANGLE: undefined symbol: _Z3fooi in
 
   .globl _start
 _start:
   call foo
   call bar
   call zed1
   call _Z3fooi