cmd/compile: pass an hmap to makemap when initializing static maps

DO NOT SUBMIT

[I am not sure the best way to identify whether
a particular OMAPLIT is safe for a static hmap;
see the TODO in the CL]

Prior to this CL, we did code generation for a map literal like this:

m := make(maptype, number of elements)
m[k] = v // for all elements, sometimes using a loop

The assignment to m generates a write barrier.
Each write barrier generates a new SSA block.
In giant composite literals, this can lead to lots of blocks.
This led to a panic when compiling the code in golang#19751.

This CL changes code generation when compiling a static
composite literal to do:

var stat hmap // static symbol
hp := &stat
m := (map)(hp)
initmap(hp, number of elements)
m[k] = v

This involves no assignments, and thus no write barriers.
As a result, the code in golang#19751 compiles.
Slowly still, but the compilation completes.

Change-Id: Ic0c05f5892e50fadc5e6d6adb5a3f5275ec38224

Author: josharian

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

@@ -929,12 +929,9 @@ func slicelit(ctxt initContext, n *Node, var_ *Node, init *Nodes) {
 	init.Append(a)
 }
 
+// maplit populates the map m with the values in n.
+// m must already have been created.
 func maplit(n *Node, m *Node, init *Nodes) {
-	// make the map var
-	a := nod(OMAKE, nil, nil)
-	a.List.Set2(typenod(n.Type), nodintconst(int64(n.List.Len())))
-	litas(m, a, init)
-
 	// Split the initializers into static and dynamic.
 	var stat, dyn []*Node
 	for _, r := range n.List.Slice() {
@@ -1150,6 +1147,11 @@ func anylit(n *Node, var_ *Node, init *Nodes) {
 		if !t.IsMap() {
 			Fatalf("anylit: not map")
 		}
+		// make the map var
+		a := nod(OMAKE, nil, nil)
+		a.List.Set2(typenod(n.Type), nodintconst(int64(n.List.Len())))
+		litas(var_, a, init)
+		// populate it
 		maplit(n, var_, init)
 	}
 }

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

@@ -1509,6 +1509,11 @@ func (s *state) expr(n *Node) *ssa.Value {
 			return v
 		}
 
+		// Conversion of *hmap to map.
+		if to.Etype == TMAP && from.IsPtr() && from.Elem().StructType().Map != nil {
+			return v
+		}
+
 		// named <--> unnamed type or typed <--> untyped const
 		if from.Etype == to.Etype {
 			return v

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

@@ -1634,6 +1634,35 @@ opswitch:
 			n = typecheck(n, Erv)
 			break
 		}
+		// TODO: checking Curfn.funcname() == "init" is not the right way,
+		// if for no other reason than we're trying to eliminate Curfn.
+		// But what to replace it with?
+		if n.Op == OMAPLIT && Curfn.funcname() == "init" {
+			// Construct a static hmap.
+			t := n.Type
+			ht := hmap(t)
+			h := staticname(ht)
+			// Take its address, to pass as *hmap to makemap.
+			mp := nod(OCONVNOP, nod(OADDR, h, nil), nil)
+			mp.Type = types.NewPtr(ht)
+			// Pass a nil bucket pointer to makemap.
+			b := nodnil()
+			// Call makemap.
+			fn := syslook("makemap") // TODO(josharian): refactor out constructing a makemap call?
+			fn = substArgTypes(fn, hmap(t), mapbucket(t), t.Key(), t.Val())
+			call := mkcall1(fn, n.Type, init, typename(n.Type), nodintconst(int64(n.List.Len())), mp, b)
+			call = typecheck(call, Etop)
+			call = walkexpr(call, init)
+			init.Append(call)
+
+			// Convert the *hmap to a map for use in maplit.
+			m := nod(OCONVNOP, mp, nil)
+			m.Type = t
+			// Populate the map and return it.
+			maplit(n, m, init)
+			n = m
+			break
+		}
 		var_ := temp(n.Type)
 		anylit(n, var_, init)
 		n = var_