[ELF] Don't emit weak undefined symbols in .dynsym for static executables

[MaskRay]

Summary

D59275 added the following clause to Symbol::includeInDynsym()

if (isUndefWeak() && Config->Pie && SharedFiles.empty())
  return false;

It seems we don't have to differentiate non-PIE from PIE, thus we can
generalize it to weak undefined symbols in any static executable:

if (!Config->Shared && isUndefWeak() && SharedFiles.empty())
  return false;

Note !Config->Shared && isUndefWeak() is used to decide whether a
relocation which is not a constant at link time should resolve to 0.
This patch adjusts the order of clauses to make the code simpler.

ld.bfd has complex and architecture-varying rules. We try to provide
reasonable semantics to exclude some weak undefined symbols but not be
too smart. Future improvement may include the refinement of
ExportDynamic assignment.

In the updated tests, weak-undef-rw.s is folded into
weak-undef-exported.s as they are checking the same thing except that
the former checks a writable section.

[MaskRay]

Improve weak-undef-no-shared-libs.s

[MaskRay]

Re-title :)

[MaskRay]

I surveyed ld.bfd's architecture-varying rules:

• x86 uses UNDEFINED_WEAK_RESOLVED_TO_ZERO which basicaly does isLocal() || (!Shared && zero_undefweak). zero_undefweak has two bits:

- Bit 0: Symbol has no GOT nor PLT relocations.
- Bit 1: Symbol has non-GOT/non-PLT relocations in text sections.

• Other architectures mostly use UNDEFWEAK_NO_DYNAMIC_RELOC which checks Visibility != STV_DEFAULT || dynamic_undefined_weak. The variable has different initial values on different architectures and is controlled by -z {,no-}dynamic-undefined-weak.

The GOT/PLT relocation type differentiation is only implemented on x86.

I definitely missed some rules but just wanted to give you an impression why following it in every corner case is unreasonable :)

I've found a previous attempt that is related: https://reviews.llvm.org/D39392

ELF/Symbols.cpp

uint8_t Symbol::computeBinding() const {
   return Binding;
 }
 
 bool Symbol::includeInDynsym() const {
   if (!Config->HasDynSymTab)
     return false;
   if (computeBinding() == STB_LOCAL)
     return false;
-  // If a PIE binary was not linked against any shared libraries, then we can
-  // safely drop weak undef symbols from .dynsym.
-  if (isUndefWeak() && Config->Pie && SharedFiles.empty())
-    return false;
-  if (!isDefined())
-    return true;
+  if (isDefined())
     return ExportDynamic;
+  // When linking a static executable (emulated by SharedFiles.empty()), weak
+  // undef symbols can be safely dropped from .dynsym.
+  return Config->Shared || !isUndefWeak() || !SharedFiles.empty();
 }
 
 // Print out a log message for --trace-symbol.
 void elf::printTraceSymbol(Symbol *Sym) {
   std::string S;
   if (Sym->isUndefined())
     S = ": reference to ";
   else if (Sym->isLazy())

test/ELF/weak-undef-export.s

 # CHECK-NEXT:     Name:
 # CHECK-NEXT:     Value: 0x0
 # CHECK-NEXT:     Size: 0
 # CHECK-NEXT:     Binding: Local (0x0)
 # CHECK-NEXT:     Type: None (0x0)
 # CHECK-NEXT:     Other: 0
 # CHECK-NEXT:     Section: Undefined (0x0)
 # CHECK-NEXT:   }
-# CHECK-NEXT:   Symbol {
-# CHECK-NEXT:     Name: foo
-# CHECK-NEXT:     Value: 0x0
-# CHECK-NEXT:     Size: 0
-# CHECK-NEXT:     Binding: Weak (0x2)
-# CHECK-NEXT:     Type: None (0x0)
-# CHECK-NEXT:     Other: 0
-# CHECK-NEXT:     Section: Undefined (0x0)
-# CHECK-NEXT:  }
 # CHECK-NEXT: ]
 
+        .text
+        .weak foo
+        .quad foo
+
+        .data
         .weak foo
         .quad foo

test/ELF/weak-undef-no-shared-libs.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+// RUN: ld.lld %t.o -o %t
+// RUN: llvm-readobj -dyn-symbols %t | FileCheck %s
 // RUN: ld.lld -pie %t.o -o %t
-// RUN: llvm-readobj -V -dyn-symbols %t | FileCheck %s
+// RUN: llvm-readobj -dyn-symbols %t | FileCheck %s
 
         .globl _start
 _start:
         .type foo,@function
         .weak foo
         .long foo@gotpcrel
 
 // Test that an entry for weak undefined symbols is NOT emitted in .dynsym as
-// the PIE was not linked with any shared libraries. There are other tests which
-// ensure that the weak undefined symbols do get emitted in .dynsym for PIEs
-// linked against dynamic libraries.
+// the executable was not linked with any shared libraries. There are other
+// tests which ensure that the weak undefined symbols do get emitted in .dynsym
+// for executables linked against dynamic libraries.
 
-
-// CHECK:      DynamicSymbols [
-// CHECK-NEXT:   Symbol {
-// CHECK-NEXT:     Name:
-// CHECK-NEXT:     Value: 0x0
-// CHECK-NEXT:     Size: 0
-// CHECK-NEXT:     Binding: Local (0x0)
-// CHECK-NEXT:     Type: None (0x0)
-// CHECK-NEXT:     Other: 0
-// CHECK-NEXT:     Section: Undefined (0x0)
-// CHECK-NEXT:   }
-// CHECK-NEXT: ]
+// CHECK-NOT: foo

test/ELF/weak-undef-rw.s

-# REQUIRES: x86
-# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
-# RUN: ld.lld %t.o -o %t --export-dynamic
-# RUN: llvm-readobj -r %t | FileCheck %s
-
-# CHECK: R_X86_64_64 foobar 0x0
-
-        .global _start
-_start:
-        .data
-        .weak foobar
-        .quad foobar