[ELF] - Fix handling of weak symbols from static library when using version script.

[grimar]

Summary

This is PR33738.

In short issue is next. Imagine code and script.
Version script:

{ local: *; };

DSO code:

.text
 callq foo@PLT
.weak foo

foo here is a weak undefined symbol that can be found in archive.
Undefined weak will not fetch archive members

During scan of relocations we call isPreemptible() which calls includeInDynsym() inside,
the latter one calls computeBinding() which computed binding as STB_LOCAL for such symbols,
making it non-preemptible what broke output.

[ruiu]

ELF/Symbols.h

69 ↗

(On Diff #106037)

Is this the same as isDefined()?

[ruiu]

Ah, that's right. LGTM.

lld/trunk/ELF/SymbolTable.cpp

 
 // We have a new defined symbol with the specified binding. Return 1 if the new
 // symbol should win, -1 if the new symbol should lose, or 0 if both symbols are
 // strong defined symbols.
 static int compareDefined(Symbol *S, bool WasInserted, uint8_t Binding) {
   if (WasInserted)
     return 1;
   SymbolBody *Body = S->body();
-  if (Body->isLazy() || !Body->isInCurrentDSO())
+  if (!Body->isInCurrentDSO())
     return 1;
   if (Binding == STB_WEAK)
     return -1;
   if (S->isWeak())
     return 1;
   return 0;
 }
 

lld/trunk/ELF/Symbols.h

public:
 
   bool isUndefined() const { return SymbolKind == UndefinedKind; }
   bool isDefined() const { return SymbolKind <= DefinedLast; }
   bool isCommon() const { return SymbolKind == DefinedCommonKind; }
   bool isLazy() const {
     return SymbolKind == LazyArchiveKind || SymbolKind == LazyObjectKind;
   }
   bool isShared() const { return SymbolKind == SharedKind; }
-  bool isInCurrentDSO() const { return !isUndefined() && !isShared(); }
+  bool isInCurrentDSO() const {
+    return !isUndefined() && !isShared() && !isLazy();
+  }
   bool isLocal() const { return IsLocal; }
   bool isPreemptible() const;
   StringRef getName() const { return Name; }
   uint8_t getVisibility() const { return StOther & 0x3; }
   void parseSymbolVersion();
   void copy(SymbolBody *Other);
 
   bool isInGot() const { return GotIndex != -1U; }

lld/trunk/test/ELF/Inputs/version-script-weak.s

+.text
+.globl foo
+.type foo,@function
+foo:

lld/trunk/test/ELF/version-script-weak.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 %S/Inputs/version-script-weak.s -o %tmp.o
+# RUN: rm -f %t.a
+# RUN: llvm-ar rcs %t.a %tmp.o
+# RUN: echo "{ local: *; };" > %t.script
+# RUN: ld.lld -shared --version-script %t.script %t.o %t.a -o %t.so
+# RUN: llvm-readobj -dyn-symbols -r %t.so | FileCheck %s
+
+# CHECK:      Relocations [
+# CHECK-NEXT:   Section ({{.*}}) .rela.plt {
+# CHECK-NEXT:     0x2018 R_X86_64_JUMP_SLOT foo
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+# CHECK:      Symbol {
+# CHECK:        Name: foo@
+# CHECK-NEXT:   Value: 0x0
+# CHECK-NEXT:   Size: 0
+# CHECK-NEXT:   Binding: Weak
+# CHECK-NEXT:   Type: None
+# CHECK-NEXT:   Other: 0
+# CHECK-NEXT:   Section: Undefined
+# CHECK-NEXT: }
+
+.text
+ callq foo@PLT
+.weak foo