cmd/link: don't mark shared library symbols reachable unconditionally

During the transitioning period, we mark symbols from Go shared
libraries reachable unconditionally. That might be useful when
there was still a large portion of the linker using sym.Symbols,
and only reachable symbols were converted to sym.Symbols. Marking
them reachable brings them to the dynamic symbol table, even if
they are not needed, increased the binary size unexpectedly.

That time has passed. Now we largely operate on loader symbols,
and it is not needed to mark them reachable anymore.

Fixes #40416.

Change-Id: I1e2bdb93a960ba7dc96575fabe15af93d8e95329
Reviewed-on: https://go-review.googlesource.com/c/go/+/244839
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Austin Clements <austin@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>

diff --git a/misc/cgo/testshared/shared_test.go b/misc/cgo/testshared/shared_test.go
index f8dabbe7a01f2ced2c840375a37253a5f10abaff..5e0893784b69d74cca9350719c313748121c2230 100644 (file)
--- a/misc/cgo/testshared/shared_test.go
+++ b/misc/cgo/testshared/shared_test.go
@@ -462,6 +462,7 @@ func TestTrivialExecutable(t *testing.T) {
        run(t, "trivial executable", "../../bin/trivial")
        AssertIsLinkedTo(t, "../../bin/trivial", soname)
        AssertHasRPath(t, "../../bin/trivial", gorootInstallDir)
+       checkSize(t, "../../bin/trivial", 100000) // it is 19K on linux/amd64, 100K should be enough
 }
 
 // Build a trivial program in PIE mode that links against the shared runtime and check it runs.
@@ -470,6 +471,18 @@ func TestTrivialExecutablePIE(t *testing.T) {
        run(t, "trivial executable", "./trivial.pie")
        AssertIsLinkedTo(t, "./trivial.pie", soname)
        AssertHasRPath(t, "./trivial.pie", gorootInstallDir)
+       checkSize(t, "./trivial.pie", 100000) // it is 19K on linux/amd64, 100K should be enough
+}
+
+// Check that the file size does not exceed a limit.
+func checkSize(t *testing.T, f string, limit int64) {
+       fi, err := os.Stat(f)
+       if err != nil {
+               t.Fatalf("stat failed: %v", err)
+       }
+       if sz := fi.Size(); sz > limit {
+               t.Errorf("file too large: got %d, want <= %d", sz, limit)
+       }
 }
 
 // Build a division test program and check it runs.

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index b0a9613e4f478fda55a44b3c5dad81432a30ae33..0366bc7a6f456aa13b49481376091935ab55301a 100644 (file)
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -2191,17 +2191,6 @@ func ldshlibsyms(ctxt *Link, shlib string) {
                l.SetSymElfType(s, elf.ST_TYPE(elfsym.Info))
                su.SetSize(int64(elfsym.Size))
                if elfsym.Section != elf.SHN_UNDEF {
-                       // If it's not undefined, mark the symbol as reachable
-                       // so as to protect it from dead code elimination,
-                       // even if there aren't any explicit references to it.
-                       // Under the previous sym.Symbol based regime this
-                       // wasn't necessary, but for the loader-based deadcode
-                       // it is definitely needed.
-                       //
-                       // FIXME: have a more general/flexible mechanism for this?
-                       //
-                       l.SetAttrReachable(s, true)
-
                        // Set .File for the library that actually defines the symbol.
                        l.SetSymPkg(s, libpath)