cmd/compile: statically initialize some interface values

When possible, emit static data rather than
init functions for interface values.

This:

* cuts 32k off cmd/go
* removes several error values from runtime init
* cuts the size of the image/color/palette compiled package from 103k to 34k
* reduces the time to build the package in golang#15520 from 8s to 1.5s

Fixes golang#6289
Fixes golang#15528

Change-Id: I317112da17aadb180c958ea328ab380f83e640b4

Author: josharian

src/cmd/compile/internal/gc/sinit.go

@@ -4,9 +4,7 @@
 
 package gc
 
-import (
-	"fmt"
-)
+import "fmt"
 
 // static initialization
 const (
@@ -489,6 +487,68 @@ func staticassign(l *Node, r *Node, out *[]*Node) bool {
 		} else {
 			closuredebugruntimecheck(r)
 		}
+
+	case OCONVIFACE:
+		// This logic is mirrored in isStaticCompositeLiteral.
+		// If you change something here, change it there, and vice versa.
+
+		// Determine the underlying concrete type and value we are converting from.
+		val := r
+		for val.Op == OCONVIFACE {
+			val = val.Left
+		}
+		if Isconst(val, CTNIL) && r.Left.Type.IsInterface() {
+			// The whole thing is nil, so both words
+			// are zero, so there's nothing to do.
+			return true
+		}
+
+		var itab *Node
+		if l.Type.IsEmptyInterface() {
+			itab = typename(val.Type)
+		} else {
+			if val.Type.IsInterface() {
+				// No concrete type, and we won't be able to staticly initialize its value. Bail.
+				return false
+			}
+			itab = itabname(val.Type, l.Type)
+		}
+
+		// Create a copy of l to modify while we emit data.
+		n := *l
+
+		// Emit itab, advance offset.
+		gdata(&n, itab, Widthptr)
+		n.Xoffset += int64(Widthptr)
+
+		// Emit data.
+		if isdirectiface(val.Type) {
+			if Isconst(val, CTNIL) {
+				// Nil is zero, nothing to do.
+				return true
+			}
+			// Copy val directly into n.
+			n.Type = val.Type
+			setlineno(val)
+			a := Nod(OXXX, nil, nil)
+			*a = n
+			a.Orig = a
+			if !staticassign(a, val, out) {
+				*out = append(*out, Nod(OAS, a, val))
+			}
+		} else {
+			// Construct temp to hold val, write pointer to temp into n.
+			a := staticname(val.Type, 1)
+			inittemps[val] = a
+			if !staticassign(a, val, out) {
+				*out = append(*out, Nod(OAS, a, val))
+			}
+			ptr := Nod(OADDR, a, nil)
+			n.Type = Ptrto(val.Type)
+			gdata(&n, ptr, Widthptr)
+		}
+
+		return true
 	}
 
 	//dump("not static", r);
@@ -568,26 +628,42 @@ func isStaticCompositeLiteral(n *Node) bool {
 		if n.Type.IsSlice() {
 			return false
 		}
+		fallthrough
 	case OSTRUCTLIT:
+		for _, r := range n.List.Slice() {
+			if r.Op != OKEY {
+				Fatalf("isStaticCompositeLiteral: rhs not OKEY: %v", r)
+			}
+			index := r.Left
+			if n.Op == OARRAYLIT && index.Op != OLITERAL {
+				return false
+			}
+			value := r.Right
+			if !isStaticCompositeLiteral(value) {
+				return false
+			}
+		}
+		return true
 	case OLITERAL:
 		return true
-	default:
-		return false
-	}
-	for _, r := range n.List.Slice() {
-		if r.Op != OKEY {
-			Fatalf("isStaticCompositeLiteral: rhs not OKEY: %v", r)
+	case OCONVIFACE:
+		// See staticassign's OCONVIFACE case for comments.
+		val := n
+		for val.Op == OCONVIFACE {
+			val = val.Left
 		}
-		index := r.Left
-		if n.Op == OARRAYLIT && index.Op != OLITERAL {
-			return false
+		if Isconst(val, CTNIL) && n.Left.Type.IsInterface() {
+			return true
 		}
-		value := r.Right
-		if !isStaticCompositeLiteral(value) {
+		if !n.Type.IsEmptyInterface() && val.Type.IsInterface() {
 			return false
 		}
+		if Isconst(val, CTNIL) {
+			return true
+		}
+		return isStaticCompositeLiteral(val)
 	}
-	return true
+	return false
 }
 
 func structlit(ctxt int, pass int, n *Node, var_ *Node, init *Nodes) {

test/fixedbugs/issue15528.go

@@ -0,0 +1,116 @@
+// run
+
+// Copyright 2016 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.
+
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"unsafe"
+)
+
+type RWS struct{}
+
+func (x *RWS) Read(p []byte) (n int, err error)                   { return }
+func (x *RWS) Write(p []byte) (n int, err error)                  { return }
+func (x *RWS) Seek(offset int64, whence int) (n int64, err error) { return }
+
+// Test correct construction of static empty interface values
+var efaces = [...]struct {
+	x interface{}
+	s string
+}{
+	{nil, "<nil> <nil>"},
+	{1, "int 1"},
+	{[1]int{2}, "[1]int [2]"},
+	{io.Reader(io.ReadWriter(io.ReadWriteSeeker(nil))), "<nil> <nil>"},
+	{io.Reader(io.ReadWriter(io.ReadWriteSeeker(&RWS{}))), "*main.RWS &{}"},
+	{map[string]string{"here": "there"}, "map[string]string map[here:there]"},
+	{chan bool(nil), "chan bool <nil>"},
+	{unsafe.Pointer(uintptr(0)), "unsafe.Pointer <nil>"},
+}
+
+type Int int
+
+func (i Int) String() string { return fmt.Sprintf("Int=%d", i) }
+func (i Int) Strung()        {}
+
+type Strunger interface {
+	fmt.Stringer
+	Strung()
+}
+
+// Test correct construction of static non-empty interface values
+var ifaces = [...]struct {
+	x fmt.Stringer
+	s string
+}{
+	{nil, "<nil> <nil> %!s(<nil>)"},
+	{Int(3), "main.Int 3 Int=3"},
+	{Int(int(Int(4))), "main.Int 4 Int=4"},
+	{Strunger(Int(5)), "main.Int 5 Int=5"},
+}
+
+// Test correct handling of direct interface values
+var (
+	one  int         = 1
+	iptr interface{} = &one
+	clos int
+	f    interface{} = func() { clos++ }
+	deep interface{} = [1]struct{ a *[2]byte }{{a: &[2]byte{'z', 'w'}}}
+	ch   interface{} = make(chan bool, 1)
+)
+
+func main() {
+	var fail bool
+	for i, test := range efaces {
+		s := fmt.Sprintf("%[1]T %[1]v", test.x)
+		if s != test.s {
+			fmt.Printf("eface(%d)=%q want %q\n", i, s, test.s)
+			fail = true
+		}
+	}
+
+	for i, test := range ifaces {
+		s := fmt.Sprintf("%[1]T %#[1]v %[1]s", test.x)
+		if s != test.s {
+			fmt.Printf("iface(%d)=%q want %q\n", i, s, test.s)
+			fail = true
+		}
+	}
+
+	if got := *(iptr.(*int)); got != 1 {
+		fmt.Printf("bad int ptr %d\n", got)
+		fail = true
+	}
+
+	f.(func())()
+	f.(func())()
+	f.(func())()
+	if clos != 3 {
+		fmt.Printf("bad closure exec %d\n", clos)
+		fail = true
+	}
+
+	if !reflect.DeepEqual(*(deep.([1]struct{ a *[2]byte })[0].a), [2]byte{'z', 'w'}) {
+		fmt.Printf("bad deep directiface\n")
+		fail = true
+	}
+
+	cc := ch.(chan bool)
+	cc <- true
+	if got := <-cc; !got {
+		fmt.Printf("bad chan\n")
+		fail = true
+	}
+
+	if fail {
+		fmt.Println("BUG")
+		os.Exit(1)
+	}
+}