close_issue_2
/
tools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

go.tools/ssa: fix computation of set of types requiring method sets. 

Motivation:

Previously, we assumed that the set of types for which a
complete method set (containing all synthesized wrapper
functions) is required at runtime was the set of types
used as operands to some *ssa.MakeInterface instruction.

In fact, this is an underapproximation because types can
be derived from other ones via reflection, and some of
these may need methods.  The reflect.Type API allows *T to
be derived from T, and these may have different method
sets.  Reflection also allows almost any subcomponent of a
type to be accessed (with one exception: given T, defined
'type T struct{S}', you can reach S but not struct{S}).

As a result, the pointer analysis was unable to generate
all necessary constraints before running the solver,
causing a crash when reflection derives types whose
methods are unavailable.  (A similar problem would afflict
an ahead-of-time compiler based on ssa.  The ssa/interp
interpreter was immune only because it does not require
all wrapper methods to be created before execution
begins.)

Description:

This change causes the SSA builder to record, for each
package, the set of all types with non-empty method sets that
are referenced within that package.  This set is accessed via
Packages.TypesWithMethodSets().  Program.TypesWithMethodSets()
returns its union across all packages.

The set of references that matter are:
- types of operands to some MakeInterface instruction (as before)
- types of all exported package members
- all subcomponents of the above, recursively.
This is a conservative approximation to the set of types
whose methods may be called dynamically.

We define the owning package of a type as follows:
- the owner of a named type is the package in which it is defined;
- the owner of a pointer-to-named type is the owner of that named type;
- the owner of all other types is nil.

A package must include the method sets for all types that it
owns, and all subcomponents of that type that are not owned by
another package, recursively.  Types with an owner appear in
exactly one package; types with no owner (such as struct{T})
may appear within multiple packages.
(A typical Go compiler would emit multiple copies of these
methods as weak symbols; a typical linker would eliminate
duplicates.)

Also:
- go/types/typemap: implement hash function for *Tuple.
- pointer: generate nodes/constraints for all of
  ssa.Program.TypesWithMethodSets().
  Add rtti.go regression test.
- Add API test of Package.TypesWithMethodSets().
- Set Function.Pkg to nil (again) for wrapper functions,
  since these may be shared by many packages.
- Remove a redundant logging statement.
- Document that ssa CREATE phase is in fact sequential.

Fixes golang/go#6605

R=gri
CC=golang-dev
https://golang.org/cl/14920056
This commit is contained in:
Alan Donovan 2013-10-23 17:07:52 -04:00
parent 93ef310aab
commit 87ced824bd
13 changed files with 402 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
go/types/typemap/typemap.go
View File

@ -295,8 +295,11 @@ func (h Hasher) hashFor(t types.Type) uint32 {
case *types.Named:
// Not safe with a copying GC; objects may move.
return uint32(uintptr(unsafe.Pointer(t.Obj())))
case *types.Tuple:
return h.hashTuple(t)
}
panic("unexpected type")
panic(t)
}
func (h Hasher) hashTuple(tuple *types.Tuple) uint32 {

2
oracle/oracle_test.go
View File

@ -200,7 +200,7 @@ func TestOracle(t *testing.T) {
for _, filename := range []string{
"testdata/src/main/calls.go",
"testdata/src/main/callgraph.go",
"testdata/src/main/callgraph2.go",
// "testdata/src/main/callgraph2.go", // TODO(adonovan): make printing deterministic
"testdata/src/main/describe.go",
"testdata/src/main/freevars.go",
"testdata/src/main/implements.go",

28
pointer/gen.go
View File

@ -845,13 +845,6 @@ func (a *analysis) objectNode(cgn *cgnode, v ssa.Value) nodeid {
case *ssa.MakeInterface:
tConc := v.X.Type()
// Create nodes and constraints for all methods of the type.
// Ascertaining which will be needed is undecidable in general.
mset := tConc.MethodSet()
for i, n := 0, mset.Len(); i < n; i++ {
a.valueNode(a.prog.Method(mset.At(i)))
}
obj = a.makeTagged(tConc, cgn, v)
// Copy the value into it, if nontrivial.
@ -1202,6 +1195,14 @@ func (a *analysis) genFunc(cgn *cgnode) {
a.localobj = nil
}
// genMethodsOf generates nodes and constraints for all methods of type T.
func (a *analysis) genMethodsOf(T types.Type) {
mset := T.MethodSet()
for i, n := 0, mset.Len(); i < n; i++ {
a.valueNode(a.prog.Method(mset.At(i)))
}
}
// generate generates offline constraints for the entire program.
// It returns the synthetic root of the callgraph.
//
@ -1217,17 +1218,18 @@ func (a *analysis) generate() *cgnode {
// (Shared contours are used by dynamic calls to reflect.Type
// methods---typically just String().)
if rtype := a.reflectRtypePtr; rtype != nil {
mset := rtype.MethodSet()
for i, n := 0, mset.Len(); i < n; i++ {
a.valueNode(a.prog.Method(mset.At(i)))
}
a.genMethodsOf(rtype)
}
root := a.genRootCalls()
// Create nodes and constraints for all methods of all types
// that are dynamically accessible via reflection or interfaces.
for _, T := range a.prog.TypesWithMethodSets() {
a.genMethodsOf(T)
}
// Generate constraints for entire program.
// (Actually just the RTA-reachable portion of the program.
// See Bacon & Sweeney, OOPSLA'96).
for len(a.genq) > 0 {
cgn := a.genq[0]
a.genq = a.genq[1:]

1
pointer/pointer_test.go
View File

@ -51,6 +51,7 @@ var inputs = []string{
"testdata/panic.go",
"testdata/recur.go",
"testdata/reflect.go",
"testdata/rtti.go",
"testdata/structreflect.go",
"testdata/structs.go",
}

29
pointer/testdata/rtti.go vendored Normal file
View File

@ -0,0 +1,29 @@
package main
// Regression test for oracle crash
// https://code.google.com/p/go/issues/detail?id=6605
//
// Using reflection, methods may be called on types that are not the
// operand of any ssa.MakeInterface instruction. In this example,
// (Y).F is called by deriving the type Y from *Y. Prior to the fix,
// no RTTI (or method set) for type Y was included in the program, so
// the F() call would crash.
import "reflect"
var a int
type X struct{}
func (X) F() *int {
return &a
}
type I interface {
F() *int
}
func main() {
type Y struct{ X }
print(reflect.Indirect(reflect.ValueOf(new(Y))).Interface().(I).F()) // @pointsto main.a
}

124
ssa/builder.go
View File

@ -10,8 +10,8 @@ package ssa
// (create.go), all packages are constructed and type-checked and
// definitions of all package members are created, method-sets are
// computed, and wrapper methods are synthesized. The create phase
// proceeds in topological order over the import dependency graph,
// initiated by client calls to Program.CreatePackage.
// occurs sequentially (order is unimportant) as the client calls
// Program.CreatePackage.
//
// In the BUILD phase (builder.go), the builder traverses the AST of
// each Go source function and generates SSA instructions for the
@ -2262,11 +2262,6 @@ func (b *builder) buildFuncDecl(pkg *Package, decl *ast.FuncDecl) {
}
var fn *Function
if decl.Recv == nil && id.Name == "init" {
if pkg.Prog.mode&LogSource != 0 {
fmt.Fprintln(os.Stderr, "build init func @",
pkg.Prog.Fset.Position(decl.Pos()))
}
pkg.ninit++
fn = &Function{
name: fmt.Sprintf("init$%d", pkg.ninit),
@ -2324,6 +2319,16 @@ func (p *Package) Build() {
if !atomic.CompareAndSwapInt32(&p.started, 0, 1) {
return // already started
}
// Ensure we have runtime type info for all exported members.
// TODO(adonovan): ideally belongs in memberFromObject, but
// that would require package creation in topological order.
for obj := range p.values {
if obj.IsExported() {
p.needMethodsOf(obj.Type())
}
}
if p.info.Files == nil {
p.info = nil
return // nothing to do
@ -2406,3 +2411,108 @@ func (p *Package) objectOf(id *ast.Ident) types.Object {
func (p *Package) typeOf(e ast.Expr) types.Type {
return p.info.TypeOf(e)
}
// needMethodsOf ensures that runtime type information (including the
// complete method set) is available for the specified type T and all
// its subcomponents.
//
// needMethodsOf must be called for at least every type that is an
// operand of some MakeInterface instruction, and for the type of
// every exported package member.
//
func (p *Package) needMethodsOf(T types.Type) {
p.needMethods(T, false)
}
// Recursive case: skip => don't call makeMethods(T).
func (p *Package) needMethods(T types.Type, skip bool) {
// Each package maintains its own set of types it has visited.
if p.needRTTI.Set(T, true) != nil {
return // already seen
}
// Prune the recursion if we find a named or *named type
// belonging to another package.
var n *types.Named
switch T := T.(type) {
case *types.Named:
n = T
case *types.Pointer:
n, _ = T.Elem().(*types.Named)
}
if n != nil {
owner := n.Obj().Pkg()
if owner == nil {
return // built-in error type
}
if owner != p.Object {
return // belongs to another package
}
}
// All the actual method sets live in the Program so that
// multiple packages can share a single copy in memory of the
// symbols that would be compiled into multiple packages (as
// weak symbols).
if !skip && p.Prog.makeMethods(T) {
p.methodSets = append(p.methodSets, T)
}
switch t := T.(type) {
case *types.Basic:
// nop
case *types.Interface:
for i, n := 0, t.NumMethods(); i < n; i++ {
p.needMethodsOf(t.Method(i).Type())
}
case *types.Pointer:
p.needMethodsOf(t.Elem())
case *types.Slice:
p.needMethodsOf(t.Elem())
case *types.Chan:
p.needMethodsOf(t.Elem())
case *types.Map:
p.needMethodsOf(t.Key())
p.needMethodsOf(t.Elem())
case *types.Signature:
if t.Recv() != nil {
p.needMethodsOf(t.Recv().Type())
}
p.needMethodsOf(t.Params())
p.needMethodsOf(t.Results())
case *types.Named:
// A pointer-to-named type can be derived from a named
// type via reflection. It may have methods too.
p.needMethodsOf(types.NewPointer(T))
// Consider 'type T struct{S}' where S has methods.
// Reflection provides no way to get from T to struct{S},
// only to S, so the method set of struct{S} is unwanted,
// so set 'skip' flag during recursion.
p.needMethods(t.Underlying(), true)
case *types.Array:
p.needMethodsOf(t.Elem())
case *types.Struct:
// TODO(adonovan): must we recur over the types of promoted methods?
for i, n := 0, t.NumFields(); i < n; i++ {
p.needMethodsOf(t.Field(i).Type())
}
case *types.Tuple:
for i, n := 0, t.Len(); i < n; i++ {
p.needMethodsOf(t.At(i).Type())
}
default:
panic(T)
}
}

87
ssa/builder_test.go
View File

@ -6,6 +6,8 @@ package ssa_test
import (
"go/parser"
"reflect"
"sort"
"strings"
"testing"
@ -139,3 +141,88 @@ func main() {
t.Errorf("in main.main: got %d calls, want %d", callNum, 4)
}
}
// TestMethodSets tests that Package.TypesWithMethodSets includes all necessary types.
func TestTypesWithMethodSets(t *testing.T) {
tests := []struct {
input string
want []string
}{
// An exported package-level type is needed.
{`package p; type T struct{}; func (T) f() {}`,
[]string{"*p.T", "p.T"},
},
// An unexported package-level type is not needed.
{`package p; type t struct{}; func (t) f() {}`,
nil,
},
// Subcomponents of type of exported package-level var are needed.
{`package p; import "bytes"; var V struct {*bytes.Buffer}`,
[]string{"struct{*bytes.Buffer}"},
},
// Subcomponents of type of unexported package-level var are not needed.
{`package p; import "bytes"; var v struct {*bytes.Buffer}`,
nil,
},
// Subcomponents of type of exported package-level function are needed.
{`package p; import "bytes"; func F(struct {*bytes.Buffer}) {}`,
[]string{"struct{*bytes.Buffer}"},
},
// Subcomponents of type of unexported package-level function are not needed.
{`package p; import "bytes"; func f(struct {*bytes.Buffer}) {}`,
nil,
},
// Subcomponents of type of exported method are needed.
{`package p; import "bytes"; type x struct{}; func (x) G(struct {*bytes.Buffer}) {}`,
[]string{"*p.x", "p.x", "struct{*bytes.Buffer}"},
},
// Subcomponents of type of unexported method are not needed.
{`package p; import "bytes"; type X struct{}; func (X) G(struct {*bytes.Buffer}) {}`,
[]string{"*p.X", "p.X", "struct{*bytes.Buffer}"},
},
// Local types aren't needed.
{`package p; import "bytes"; func f() { type T struct {*bytes.Buffer}; var t T; _ = t }`,
nil,
},
// ...unless used by MakeInterface.
{`package p; import "bytes"; func f() { type T struct {*bytes.Buffer}; _ = interface{}(T{}) }`,
[]string{"*p.T", "p.T"},
},
// Types used as operand of MakeInterface are needed.
{`package p; import "bytes"; func f() { _ = interface{}(struct{*bytes.Buffer}{}) }`,
[]string{"struct{*bytes.Buffer}"},
},
// MakeInterface is optimized away when storing to a blank.
{`package p; import "bytes"; var _ interface{} = struct{*bytes.Buffer}{}`,
nil,
},
}
for i, test := range tests {
imp := importer.New(new(importer.Config)) // no go/build.Context; uses GC importer
f, err := parser.ParseFile(imp.Fset, "<input>", test.input, 0)
if err != nil {
t.Errorf("test %d: %s", i, err)
continue
}
mainInfo := imp.CreatePackage("p", f)
prog := ssa.NewProgram(imp.Fset, ssa.SanityCheckFunctions)
if err := prog.CreatePackages(imp); err != nil {
t.Errorf("test %d: %s", i, err)
continue
}
mainPkg := prog.Package(mainInfo.Pkg)
prog.BuildAll()
var typstrs []string
for _, T := range mainPkg.TypesWithMethodSets() {
typstrs = append(typstrs, T.String())
}
sort.Strings(typstrs)
if !reflect.DeepEqual(typstrs, test.want) {
t.Errorf("test %d: got %q, want %q", i, typstrs, test.want)
}
}
}

1
ssa/create.go
View File

@ -70,6 +70,7 @@ func memberFromObject(pkg *Package, obj types.Object, syntax ast.Node) {
name := obj.Name()
switch obj := obj.(type) {
case *types.TypeName:
pkg.values[obj] = nil // for needMethods
pkg.Members[name] = &Type{object: obj}
case *types.Const:

1
ssa/emit.go
View File

@ -209,6 +209,7 @@ func emitConv(f *Function, val Value, typ types.Type) Value {
val = emitConv(f, val, DefaultType(ut_src))
}
f.Pkg.needMethodsOf(val.Type())
mi := &MakeInterface{X: val}
mi.setType(typ)
return f.emit(mi)

135
ssa/promote.go
View File

@ -4,7 +4,7 @@
package ssa
// This file defines utilities for method-set computation including
// This file defines utilities for population of method sets and
// synthesis of wrapper methods.
//
// Wrappers include:
@ -12,7 +12,7 @@ package ssa
// - interface method wrappers for expressions I.f.
// - bound method wrappers, for uncalled obj.Method closures.
// TODO(adonovan): rename to wrappers.go.
// TODO(adonovan): split and rename to {methodset,wrappers}.go.
import (
"fmt"
@ -21,11 +21,6 @@ import (
"code.google.com/p/go.tools/go/types"
)
// recvType returns the receiver type of method obj.
func recvType(obj *types.Func) types.Type {
return obj.Type().(*types.Signature).Recv().Type()
}
// Method returns the Function implementing method meth, building
// wrapper methods on demand.
//
@ -37,30 +32,130 @@ func (prog *Program) Method(meth *types.Selection) *Function {
if meth == nil {
panic("Method(nil)")
}
typ := meth.Recv()
T := meth.Recv()
if prog.mode&LogSource != 0 {
defer logStack("Method %s %v", typ, meth)()
defer logStack("Method %s %v", T, meth)()
}
prog.methodsMu.Lock()
defer prog.methodsMu.Unlock()
type methodSet map[string]*Function
mset, _ := prog.methodSets.At(typ).(methodSet)
if mset == nil {
mset = make(methodSet)
prog.methodSets.Set(typ, mset)
return prog.addMethod(prog.createMethodSet(T), meth)
}
// makeMethods ensures that all wrappers in the complete method set of
// T are generated. It is equivalent to calling prog.Method() on all
// members of T.methodSet(), but acquires fewer locks.
//
// It reports whether the type's method set is non-empty.
//
// Thread-safe.
//
// EXCLUSIVE_LOCKS_ACQUIRED(prog.methodsMu)
//
func (prog *Program) makeMethods(T types.Type) bool {
tmset := T.MethodSet()
n := tmset.Len()
if n == 0 {
return false // empty (common case)
}
if prog.mode&LogSource != 0 {
defer logStack("makeMethods %s", T)()
}
prog.methodsMu.Lock()
defer prog.methodsMu.Unlock()
mset := prog.createMethodSet(T)
if !mset.complete {
mset.complete = true
for i := 0; i < n; i++ {
prog.addMethod(mset, tmset.At(i))
}
}
return true
}
type methodSet struct {
mapping map[string]*Function // populated lazily
complete bool // mapping contains all methods
}
// EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu)
func (prog *Program) createMethodSet(T types.Type) *methodSet {
mset, ok := prog.methodSets.At(T).(*methodSet)
if !ok {
mset = &methodSet{mapping: make(map[string]*Function)}
prog.methodSets.Set(T, mset)
}
return mset
}
// EXCLUSIVE_LOCKS_REQUIRED(prog.methodsMu)
func (prog *Program) addMethod(mset *methodSet, meth *types.Selection) *Function {
id := meth.Obj().Id()
fn := mset[id]
fn := mset.mapping[id]
if fn == nil {
fn = findMethod(prog, meth)
mset[id] = fn
mset.mapping[id] = fn
}
return fn
}
// TypesWithMethodSets returns a new unordered slice containing all
// types in the program for which a complete (non-empty) method set is
// required at run-time.
//
// It is the union of pkg.TypesWithMethodSets() for all pkg in
// prog.AllPackages().
//
// Thread-safe.
//
// EXCLUSIVE_LOCKS_ACQUIRED(prog.methodsMu)
//
func (prog *Program) TypesWithMethodSets() []types.Type {
prog.methodsMu.Lock()
defer prog.methodsMu.Unlock()
var res []types.Type
prog.methodSets.Iterate(func(T types.Type, v interface{}) {
if v.(*methodSet).complete {
res = append(res, T)
}
})
return res
}
// TypesWithMethodSets returns a new unordered slice containing the
// set of all types referenced within package pkg and not belonging to
// some other package, for which a complete (non-empty) method set is
// required at run-time.
//
// A type belongs to a package if it is a named type or a pointer to a
// named type, and the name was defined in that package. All other
// types belong to no package.
//
// A type may appear in the TypesWithMethodSets() set of multiple
// distinct packages if that type belongs to no package. Typical
// compilers emit method sets for such types multiple times (using
// weak symbols) into each package that references them, with the
// linker performing duplicate elimination.
//
// This set includes the types of all operands of some MakeInterface
// instruction, the types of all exported members of some package, and
// all types that are subcomponents, since even types that aren't used
// directly may be derived via reflection.
//
// Callers must not mutate the result.
//
func (pkg *Package) TypesWithMethodSets() []types.Type {
return pkg.methodSets
}
// ------------------------------------------------------------------------
// declaredFunc returns the concrete function/method denoted by obj.
// Panic ensues if there is none.
//
@ -71,6 +166,11 @@ func (prog *Program) declaredFunc(obj *types.Func) *Function {
panic("no concrete method: " + obj.String())
}
// recvType returns the receiver type of method obj.
func recvType(obj *types.Func) types.Type {
return obj.Type().(*types.Signature).Recv().Type()
}
// findMethod returns the concrete Function for the method meth,
// synthesizing wrappers as needed.
//
@ -128,7 +228,6 @@ func makeWrapper(prog *Program, typ types.Type, meth *types.Selection) *Function
Signature: changeRecv(oldsig, recv),
Synthetic: description,
Prog: prog,
Pkg: prog.packages[obj.Pkg()],
pos: obj.Pos(),
}
fn.startBody()
@ -235,7 +334,6 @@ func interfaceMethodWrapper(prog *Program, typ types.Type, obj *types.Func) *Fun
Synthetic: description,
pos: obj.Pos(),
Prog: prog,
Pkg: prog.packages[obj.Pkg()],
}
fn.startBody()
fn.addParam("recv", typ, token.NoPos)
@ -289,7 +387,6 @@ func boundMethodWrapper(prog *Program, obj *types.Func) *Function {
Signature: changeRecv(obj.Type().(*types.Signature), nil), // drop receiver
Synthetic: description,
Prog: prog,
Pkg: prog.packages[obj.Pkg()],
pos: obj.Pos(),
}

9
ssa/sanity.go
View File

@ -328,12 +328,13 @@ func (s *sanity) checkFunction(fn *Function) bool {
if fn.Prog == nil {
s.errorf("nil Prog")
}
// All functions have a package, except wrappers for error.Error()
// (and embedding of that method in other interfaces).
// All functions have a package, except wrappers (which are
// shared across packages, or duplicated as weak symbols in a
// separate-compilation model), and error.Error.
if fn.Pkg == nil {
if strings.Contains(fn.Synthetic, "wrapper") &&
if strings.Contains(fn.Synthetic, "wrapper") ||
strings.HasSuffix(fn.name, "Error") {
// wrapper for error.Error() has no package.
// ok
} else {
s.errorf("nil Pkg")
}

22
ssa/ssa.go
View File

@ -40,18 +40,20 @@ type Program struct {
// type-specific accessor methods Func, Type, Var and Const.
//
type Package struct {
Prog *Program // the owning program
Object *types.Package // the type checker's package object for this package
Members map[string]Member // all package members keyed by name
values map[types.Object]Value // package-level vars & funcs (incl. methods), keyed by object
init *Function // Func("init"); the package's init function
debug bool // include full debug info in this package.
Prog *Program // the owning program
Object *types.Package // the type checker's package object for this package
Members map[string]Member // all package members keyed by name
methodSets []types.Type // types whose method sets are included in this package
values map[types.Object]Value // package members (incl. types and methods), keyed by object
init *Function // Func("init"); the package's init function
debug bool // include full debug info in this package.
// The following fields are set transiently, then cleared
// after building.
started int32 // atomically tested and set at start of build phase
ninit int32 // number of init functions
info *importer.PackageInfo // package ASTs and type information
started int32 // atomically tested and set at start of build phase
ninit int32 // number of init functions
info *importer.PackageInfo // package ASTs and type information
needRTTI typemap.M // types for which runtime type info is needed
}
// A Member is a member of a Go package, implemented by *NamedConst,
@ -267,7 +269,7 @@ type Function struct {
Synthetic string // provenance of synthetic function; "" for true source functions
Enclosing *Function // enclosing function if anon; nil if global
Pkg *Package // enclosing package; nil for error.Error() and its wrappers
Pkg *Package // enclosing package; nil for shared funcs (wrappers and error.Error)
Prog *Program // enclosing program
Params []*Parameter // function parameters; for methods, includes receiver
FreeVars []*Capture // free variables whose values must be supplied by closure

39
ssa/visit.go
View File

@ -7,16 +7,13 @@ package ssa
// This file defines utilities for visiting the SSA representation of
// a Program.
//
// TODO(adonovan): improve the API:
// - permit client to supply a callback for each function,
// instruction, type with methods, etc?
// - return graph information about the traversal?
// - test coverage.
// TODO(adonovan): test coverage.
import "code.google.com/p/go.tools/go/types"
// AllFunctions returns the set of all functions (including anonymous
// functions and synthetic wrappers) in program prog.
// AllFunctions finds and returns the set of functions potentially
// needed by program prog, as determined by a simple linker-style
// reachability algorithm starting from the members and method-sets of
// each package. The result may include anonymous functions and
// synthetic wrappers.
//
// Precondition: all packages are built.
//
@ -37,22 +34,16 @@ type visitor struct {
func (visit *visitor) program() {
for _, pkg := range visit.prog.AllPackages() {
for _, mem := range pkg.Members {
switch mem := mem.(type) {
case *Function:
visit.function(mem)
case *Type:
visit.methodSet(mem.Type())
visit.methodSet(types.NewPointer(mem.Type()))
if fn, ok := mem.(*Function); ok {
visit.function(fn)
}
}
}
}
func (visit *visitor) methodSet(typ types.Type) {
mset := typ.MethodSet()
for i, n := 0, mset.Len(); i < n; i++ {
// Side-effect: creates all wrapper methods.
visit.function(visit.prog.Method(mset.At(i)))
for _, T := range visit.prog.TypesWithMethodSets() {
mset := T.MethodSet()
for i, n := 0, mset.Len(); i < n; i++ {
visit.function(visit.prog.Method(mset.At(i)))
}
}
}
@ -61,10 +52,6 @@ func (visit *visitor) function(fn *Function) {
visit.seen[fn] = true
for _, b := range fn.Blocks {
for _, instr := range b.Instrs {
switch instr := instr.(type) {
case *MakeInterface:
visit.methodSet(instr.X.Type())
}
var buf [10]*Value // avoid alloc in common case
for _, op := range instr.Operands(buf[:0]) {
if fn, ok := (*op).(*Function); ok {