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

[smeenai]

Summary

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 in
order for the wrapping logic to correctly set referencedAfterWrap and
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.

[MaskRay]

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

10

The more common suffixes are .lds, .t, and .script

16

Change the section index to [[#]]

24

[smeenai]

Address review comments

[MaskRay]

in order for the wrapping logic to correctly set referencedAfterWrap and prevent LTO from eliminating them.

Perhaps elaborate which symbol's referencedAfterWrap is set (sym's).

[MaskRay]

LGTM.

[smeenai]

In D124433#3476160, @MaskRay wrote:

in order for the wrapping logic to correctly set referencedAfterWrap and prevent LTO from eliminating them.

Perhaps elaborate which symbol's referencedAfterWrap is set (sym's).

Thanks for the quick review. I updated the wording in the commit message before pushing.

lld/ELF/Driver.cpp

void LinkerDriver::link(opt::InputArgList &args) {
   // producing a shared library.
   // We also need one if any shared libraries are used and for pie executables
   // (probably because the dynamic linker needs it).
   config->hasDynSymTab =
       !sharedFiles.empty() || config->isPic || config->exportDynamic;
 
   // 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)
     if (Defined *sym = dyn_cast_or_null<Defined>(symtab->find(name)))
       sym->isUsedInRegularObj = true;
 
   // If an entry symbol is in a static archive, pull out that file now.
   if (Symbol *sym = symtab->find(config->entry))

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

+;; 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
+}