1
0
mirror of https://github.com/golang/go synced 2024-11-17 18:14:46 -07:00

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>
This commit is contained in:
Cherry Zhang 2020-09-17 21:34:52 -04:00
parent bf9800c793
commit 789d77a87e
3 changed files with 49 additions and 0 deletions

View File

@ -130,6 +130,19 @@ func (d *deadcodePass) flood() {
} }
if usedInIface { if usedInIface {
methods = append(methods, methodref{src: symIdx, r: i}) 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 i += 2
continue continue
@ -215,9 +228,15 @@ func (d *deadcodePass) mark(symIdx, parent loader.Sym) {
if *flagDumpDep { if *flagDumpDep {
to := d.ldr.SymName(symIdx) to := d.ldr.SymName(symIdx)
if to != "" { if to != "" {
if d.ldr.AttrUsedInIface(symIdx) {
to += " <UsedInIface>"
}
from := "_" from := "_"
if parent != 0 { if parent != 0 {
from = d.ldr.SymName(parent) from = d.ldr.SymName(parent)
if d.ldr.AttrUsedInIface(parent) {
from += " <UsedInIface>"
}
} }
fmt.Printf("%s -> %s\n", from, to) fmt.Printf("%s -> %s\n", from, to)
} }

View File

@ -32,6 +32,7 @@ func TestDeadcode(t *testing.T) {
{"typedesc", "", "type.main.T"}, {"typedesc", "", "type.main.T"},
{"ifacemethod", "", "main.T.M"}, {"ifacemethod", "", "main.T.M"},
{"ifacemethod2", "main.T.M", ""}, {"ifacemethod2", "main.T.M", ""},
{"ifacemethod3", "main.S.M", ""},
} }
for _, test := range tests { for _, test := range tests {
test := test test := test

View File

@ -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()
}