cmd/link: propagate UsedInIface through method descriptor

The linker prunes methods that are not directly reachable if the
receiver type is never converted to interface. A type can be
converted to interface using reflection through other types.
The linker already takes this into consideration but it missed
the case that the intermediate is a method descriptor. Handle
this case.

Change-Id: I590efc5da163c326db8d43583908a2ef67f65d9d
Reviewed-on: https://go-review.googlesource.com/c/go/+/255858
Trust: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Jeremy Faller <jeremy@golang.org>

diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go
index 35545f950ef454ff76ffea95a57bb91ab3ba1885..d2604b27a96af7c7edc2d7efbba608a7ebc6b209 100644 (file)
--- a/src/cmd/link/internal/ld/deadcode.go
+++ b/src/cmd/link/internal/ld/deadcode.go
@@ -130,6 +130,19 @@ func (d *deadcodePass) flood() {
                                }
                                if usedInIface {
                                        methods = append(methods, methodref{src: symIdx, r: i})
+                                       // The method descriptor is itself a type descriptor, and
+                                       // it can be used to reach other types, e.g. by using
+                                       // reflect.Type.Method(i).Type.In(j). We need to traverse
+                                       // its child types with UsedInIface set. (See also the
+                                       // comment below.)
+                                       rs := r.Sym()
+                                       if !d.ldr.AttrUsedInIface(rs) {
+                                               d.ldr.SetAttrUsedInIface(rs, true)
+                                               if d.ldr.AttrReachable(rs) {
+                                                       d.ldr.SetAttrReachable(rs, false)
+                                                       d.mark(rs, symIdx)
+                                               }
+                                       }
                                }
                                i += 2
                                continue
@@ -215,9 +228,15 @@ func (d *deadcodePass) mark(symIdx, parent loader.Sym) {
                if *flagDumpDep {
                        to := d.ldr.SymName(symIdx)
                        if to != "" {
+                               if d.ldr.AttrUsedInIface(symIdx) {
+                                       to += " <UsedInIface>"
+                               }
                                from := "_"
                                if parent != 0 {
                                        from = d.ldr.SymName(parent)
+                                       if d.ldr.AttrUsedInIface(parent) {
+                                               from += " <UsedInIface>"
+                                       }
                                }
                                fmt.Printf("%s -> %s\n", from, to)
                        }

diff --git a/src/cmd/link/internal/ld/deadcode_test.go b/src/cmd/link/internal/ld/deadcode_test.go
index 59122e960382fd2c181597d26761c406d0d5fe01..ab836dc8f89c3d5e938c921be02288b98c619c6e 100644 (file)
--- a/src/cmd/link/internal/ld/deadcode_test.go
+++ b/src/cmd/link/internal/ld/deadcode_test.go
@@ -32,6 +32,7 @@ func TestDeadcode(t *testing.T) {
                {"typedesc", "", "type.main.T"},
                {"ifacemethod", "", "main.T.M"},
                {"ifacemethod2", "main.T.M", ""},
+               {"ifacemethod3", "main.S.M", ""},
        }
        for _, test := range tests {
                test := test

diff --git a/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod3.go b/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod3.go
new file mode 100644 (file)
index 0000000..9a8dfbc
--- /dev/null
+++ b/src/cmd/link/internal/ld/testdata/deadcode/ifacemethod3.go
@@ -0,0 +1,29 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Like ifacemethod2.go, this tests that a method *is* live
+// if the type is "indirectly" converted to an interface
+// using reflection with a method descriptor as intermediate.
+
+package main
+
+import "reflect"
+
+type S int
+
+func (s S) M() { println("S.M") }
+
+type I interface { M() }
+
+type T float64
+
+func (t T) F(s S) {}
+
+func main() {
+       var t T
+       ft := reflect.TypeOf(t).Method(0).Type
+       at := ft.In(1)
+       v := reflect.New(at).Elem()
+       v.Interface().(I).M()
+}