[lld] 7cc3286 - [ELF] Prevent LTO stripping of wrapped script-referenced symbols

[Shoaib Meenai via llvm-commits]

Author: Shoaib Meenai
Date: 2022-04-26T18:48:26-07:00
New Revision: 7cc328600e250ef44f86da34e93fcdd0635339e0

URL: https://github.com/llvm/llvm-project/commit/7cc328600e250ef44f86da34e93fcdd0635339e0
DIFF: https://github.com/llvm/llvm-project/commit/7cc328600e250ef44f86da34e93fcdd0635339e0.diff

LOG: [ELF] Prevent LTO stripping of wrapped script-referenced symbols

After 1af25a986069f2ae8c724133fa8649bb795a7925, we stop unconditionally
retaining wrapped symbols, which means that LTO's summary-based global
dead stripping can eliminate them even if they'll be referenced by a
linker script after the wrapping is performed. Mark symbols referenced
in linker scripts as `referenced` in addition to `isUsedInRegularObj`,
so that the wrapping logic correctly sets `referencedAfterWrap` for the
symbols which will be referenced after wrapping, which will prevent LTO
from eliminating them.

An alternative would have been to change the `referencedAfterWrap` logic
to look at `isUsedInRegularObj` in addition to `referenced`, but
`isUsedInRegularObj` is also set in other places (e.g. for the entry
symbol), and it's not clear that we want `referencedAfterWrap` to take
all those places into account, so it seemed better to keep that logic
as-is and instead set `referenced` for linker script-referenced symbols.

Reviewed By: MaskRay

Differential Revision: https://reviews.llvm.org/D124433

Added: 
    lld/test/ELF/lto/wrap-script-referenced.ll

Modified: 
    lld/ELF/Driver.cpp

Removed: 
    


################################################################################
diff  --git a/lld/ELF/Driver.cpp b/lld/ELF/Driver.cpp
index 41620737e1f60..ba24be790186e 100644
--- a/lld/ELF/Driver.cpp
+++ b/lld/ELF/Driver.cpp
@@ -2463,8 +2463,11 @@ void LinkerDriver::link(opt::InputArgList &args) {
 
   // Some symbols (such as __ehdr_start) are defined lazily only when there
   // are undefined symbols for them, so we add these to trigger that logic.
-  for (StringRef name : script->referencedSymbols)
-    addUnusedUndefined(name)->isUsedInRegularObj = true;
+  for (StringRef name : script->referencedSymbols) {
+    Symbol *sym = addUnusedUndefined(name);
+    sym->isUsedInRegularObj = true;
+    sym->referenced = true;
+  }
 
   // Prevent LTO from removing any definition referenced by -u.
   for (StringRef name : config->undefined)

diff  --git a/lld/test/ELF/lto/wrap-script-referenced.ll b/lld/test/ELF/lto/wrap-script-referenced.ll
new file mode 100644
index 0000000000000..8c2f5e23f46c6
--- /dev/null
+++ b/lld/test/ELF/lto/wrap-script-referenced.ll
@@ -0,0 +1,46 @@
+;; Verify that the target of a wrap is kept by LTO's summary-based global dead
+;; stripping if the original symbol is referenced by a linker script or --defsym
+
+; REQUIRES: x86
+; RUN: rm -rf %t && split-file %s %t
+
+;; We need a module summary to trigger summary-based global stripping
+; RUN: opt -module-summary -o %t/foo.bc %t/foo.ll
+; RUN: echo 'alias = __real_foo;' > %t/alias.script
+; RUN: ld.lld -shared -o %t/libalias_foo.so %t/foo.bc %t/alias.script --wrap foo
+; RUN: llvm-readelf --syms %t/libalias_foo.so | FileCheck --check-prefix=FOO %s
+
+; FOO:     Symbol table '.symtab' contains
+; FOO-DAG: [[#]]: [[#%.16x,FOO_VAL:]] 1 FUNC    LOCAL  HIDDEN      [[#]] foo
+; FOO-DAG: [[#]]: [[#FOO_VAL]]        0 FUNC    GLOBAL DEFAULT     [[#]] alias
+
+; RUN: opt -module-summary -o %t/wrap_foo.bc %t/wrap_foo.ll
+; RUN: ld.lld -shared -o %t/libalias_wrap_foo.so %t/wrap_foo.bc --wrap foo --defsym=alias=foo
+; RUN: llvm-readelf --syms %t/libalias_wrap_foo.so | FileCheck --check-prefix=WRAP-FOO %s
+
+; WRAP-FOO:     Symbol table '.symtab' contains
+; WRAP-FOO-DAG: [[#]]: [[#%.16x,WRAP_FOO_VAL:]] 1 FUNC    LOCAL  HIDDEN      [[#]] __wrap_foo
+; WRAP-FOO-DAG: [[#]]: [[#WRAP_FOO_VAL]]        0 FUNC    GLOBAL DEFAULT     [[#]] alias
+
+;--- foo.ll
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+define hidden void @foo() {
+  ret void
+}
+
+;; We need a live root to trigger summary-based global stripping
+define dso_local void @bar() {
+  ret void
+}
+
+;--- wrap_foo.ll
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+define hidden void @__wrap_foo() {
+  ret void
+}
+
+define dso_local void @bar() {
+  ret void
+}