cmd/compile: compute second method type at runtime

The type information for a method includes two variants: a func
without the receiver, and a func with the receiver as the first
parameter. The former is used as part of the dynamic interface
checks, but the latter is only returned as a type in the
reflect.Method struct.

Instead of computing it at compile time, construct it at run time
with reflect.FuncOf.

Using cl/20701 as a baseline,

	cmd/go: -480KB, (4.4%)
	jujud:  -5.6MB, (7.8%)

For #6853.

Change-Id: I1b8c73f3ab894735f53d00cb9c0b506d84d54e92
Reviewed-on: https://go-review.googlesource.com/20709
Run-TryBot: David Crawshaw <crawshaw@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

2 files changed, 8 insertions, 15 deletions

diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go
index 9367375102..9ed9c56f99 100644
--- a/src/cmd/link/internal/ld/deadcode.go
+++ b/src/cmd/link/internal/ld/deadcode.go
@@ -95,7 +95,7 @@ func deadcode(ctxt *Link) {
 				// and setting those fields to nil. Doing so
 				// would reduce the binary size of typical
 				// programs like cmd/go by ~2%.
-				d.markMethodType(m)
+				d.mark(m.mtyp(), m.src)
 				rem = append(rem, m)
 			} else {
 				rem = append(rem, m)
@@ -171,18 +171,17 @@ var markextra = []string{
 }
 
 // methodref holds the relocations from a receiver type symbol to its
-// method. There are four relocations, one for each of the fields in
-// the reflect.method struct: mtyp, typ, ifn, and tfn.
+// method. There are three relocations, one for each of the fields in
+// the reflect.method struct: mtyp, ifn, and tfn.
 type methodref struct {
 	m   methodsig
 	src *LSym     // receiver type symbol
-	r   [4]*Reloc // R_METHOD relocations to fields of runtime.method
+	r   [3]*Reloc // R_METHOD relocations to fields of runtime.method
 }
 
 func (m methodref) mtyp() *LSym { return m.r[0].Sym }
-func (m methodref) typ() *LSym  { return m.r[1].Sym }
-func (m methodref) ifn() *LSym  { return m.r[2].Sym }
-func (m methodref) tfn() *LSym  { return m.r[3].Sym }
+func (m methodref) ifn() *LSym  { return m.r[1].Sym }
+func (m methodref) tfn() *LSym  { return m.r[2].Sym }
 
 func (m methodref) isExported() bool {
 	for _, r := range m.m {
@@ -233,12 +232,6 @@ func (d *deadcodepass) markMethod(m methodref) {
 	}
 }
 
-// markMethodType marks just a method's types as reachable.
-func (d *deadcodepass) markMethodType(m methodref) {
-	d.mark(m.mtyp(), m.src)
-	d.mark(m.typ(), m.src)
-}
-
 // init marks all initial symbols as reachable.
 // In a typical binary, this is INITENTRY.
 func (d *deadcodepass) init() {
diff --git a/src/cmd/link/internal/ld/decodesym.go b/src/cmd/link/internal/ld/decodesym.go
index 98590d3677..00e1a79a83 100644
--- a/src/cmd/link/internal/ld/decodesym.go
+++ b/src/cmd/link/internal/ld/decodesym.go
@@ -350,7 +350,7 @@ func decodetype_methods(s *LSym) []methodsig {
 	if r.Sym != s {
 		panic(fmt.Sprintf("method slice pointer in %q leads to a different symbol", s.Name))
 	}
-	off = int(r.Add) // array of reflect.method values
-	sizeofMethod := 6 * Thearch.Ptrsize
+	off = int(r.Add)                    // array of reflect.method values
+	sizeofMethod := 5 * Thearch.Ptrsize // sizeof reflect.method in program
 	return decode_methodsig(s, off, sizeofMethod, numMethods)
 }