cmd/compile: remove Node.Alloc

$ sizeof -p cmd/compile/internal/gc Node
Node 240
$

Change-Id: Id12710c480ed4e0a5bf4f5006f6bd56ef91a2af1
Reviewed-on: https://go-review.googlesource.com/10525
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

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

@@ -472,11 +472,11 @@ func walkclosure(func_ *Node, init **NodeList) *Node {
 
 	// non-escaping temp to use, if any.
 	// orderexpr did not compute the type; fill it in now.
-	if func_.Alloc != nil {
-		func_.Alloc.Type = clos.Left.Left.Type
-		func_.Alloc.Orig.Type = func_.Alloc.Type
-		clos.Left.Right = func_.Alloc
-		func_.Alloc = nil
+	if x := prealloc[func_]; x != nil {
+		x.Type = clos.Left.Left.Type
+		x.Orig.Type = x.Type
+		clos.Left.Right = x
+		delete(prealloc, func_)
 	}
 
 	walkexpr(&clos, init)
@@ -676,11 +676,11 @@ func walkpartialcall(n *Node, init **NodeList) *Node {
 
 	// non-escaping temp to use, if any.
 	// orderexpr did not compute the type; fill it in now.
-	if n.Alloc != nil {
-		n.Alloc.Type = clos.Left.Left.Type
-		n.Alloc.Orig.Type = n.Alloc.Type
-		clos.Left.Right = n.Alloc
-		n.Alloc = nil
+	if x := prealloc[n]; x != nil {
+		x.Type = clos.Left.Left.Type
+		x.Orig.Type = x.Type
+		clos.Left.Right = x
+		delete(prealloc, n)
 	}
 
 	walkexpr(&clos, init)

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

@@ -259,10 +259,10 @@ func cgen_dcl(n *Node) {
 	if compiling_runtime != 0 {
 		Yyerror("%v escapes to heap, not allowed in runtime.", n)
 	}
-	if n.Alloc == nil {
-		n.Alloc = callnew(n.Type)
+	if prealloc[n] == nil {
+		prealloc[n] = callnew(n.Type)
 	}
-	Cgen_as(n.Name.Heapaddr, n.Alloc)
+	Cgen_as(n.Name.Heapaddr, prealloc[n])
 }
 
 /*

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

@@ -736,7 +736,7 @@ func orderstmt(n *Node, order *Order) {
 			n.Right = ordercopyexpr(r, r.Type, order, 0)
 
 			// n->alloc is the temp for the iterator.
-			n.Alloc = ordertemp(Types[TUINT8], order, true)
+			prealloc[n] = ordertemp(Types[TUINT8], order, true)
 		}
 
 		for l := n.List; l != nil; l = l.Next {
@@ -949,6 +949,9 @@ func orderexprlistinplace(l *NodeList, order *Order) {
 	}
 }
 
+// prealloc[x] records the allocation to use for x.
+var prealloc = map[*Node]*Node{}
+
 // Orderexpr orders a single expression, appending side
 // effects to order->out as needed.
 // If this is part of an assignment lhs = *np, lhs is given.
@@ -980,7 +983,7 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
 			t := typ(TARRAY)
 			t.Bound = int64(count(n.List))
 			t.Type = Types[TSTRING]
-			n.Alloc = ordertemp(t, order, false)
+			prealloc[n] = ordertemp(t, order, false)
 		}
 
 		// Mark string(byteSlice) arguments to reuse byteSlice backing
@@ -1118,7 +1121,7 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
 
 	case OCLOSURE:
 		if n.Noescape && n.Func.Cvars != nil {
-			n.Alloc = ordertemp(Types[TUINT8], order, false) // walk will fill in correct type
+			prealloc[n] = ordertemp(Types[TUINT8], order, false) // walk will fill in correct type
 		}
 
 	case OARRAYLIT, OCALLPART:
@@ -1127,7 +1130,7 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
 		orderexprlist(n.List, order)
 		orderexprlist(n.Rlist, order)
 		if n.Noescape {
-			n.Alloc = ordertemp(Types[TUINT8], order, false) // walk will fill in correct type
+			prealloc[n] = ordertemp(Types[TUINT8], order, false) // walk will fill in correct type
 		}
 
 	case ODDDARG:
@@ -1136,7 +1139,7 @@ func orderexpr(np **Node, order *Order, lhs *Node) {
 			// Allocate a temporary that will be cleaned up when this statement
 			// completes. We could be more aggressive and try to arrange for it
 			// to be cleaned up when the call completes.
-			n.Alloc = ordertemp(n.Type.Type, order, false)
+			prealloc[n] = ordertemp(n.Type.Type, order, false)
 		}
 
 	case ODOTTYPE, ODOTTYPE2:

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

@@ -303,7 +303,7 @@ func walkrange(n *Node) {
 		ha := a
 
 		th := hiter(t)
-		hit := n.Alloc
+		hit := prealloc[n]
 		hit.Type = th
 		n.Left = nil
 		keyname := newname(th.Type.Sym)      // depends on layout of iterator struct.  See reflect.go:hiter

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

@@ -778,17 +778,17 @@ func slicelit(ctxt int, n *Node, var_ *Node, init **NodeList) {
 
 	// set auto to point at new temp or heap (3 assign)
 	var a *Node
-	if n.Alloc != nil {
+	if x := prealloc[n]; x != nil {
 		// temp allocated during order.c for dddarg
-		n.Alloc.Type = t
+		x.Type = t
 
 		if vstat == nil {
-			a = Nod(OAS, n.Alloc, nil)
+			a = Nod(OAS, x, nil)
 			typecheck(&a, Etop)
 			*init = list(*init, a) // zero new temp
 		}
 
-		a = Nod(OADDR, n.Alloc, nil)
+		a = Nod(OADDR, x, nil)
 	} else if n.Esc == EscNone {
 		a = temp(t)
 		if vstat == nil {

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

@@ -32,7 +32,6 @@ type Node struct {
 	Name  *Name
 	Pack  *Node // real package for import . names
 	Curfn *Node // function for local variables
-	Alloc *Node // allocation call
 	Param *Param
 
 	// OPACK

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

@@ -1824,8 +1824,8 @@ func mkdotargslice(lr0 *NodeList, nn *NodeList, l *Type, fp int, init **NodeList
 		n.Type = tslice
 	} else {
 		n = Nod(OCOMPLIT, nil, typenod(tslice))
-		if ddd != nil {
-			n.Alloc = ddd.Alloc // temporary to use
+		if ddd != nil && prealloc[ddd] != nil {
+			prealloc[n] = prealloc[ddd] // temporary to use
 		}
 		n.List = lr0
 		n.Esc = esc
@@ -2682,10 +2682,10 @@ func paramstoheap(argin **Type, out int) *NodeList {
 		if compiling_runtime != 0 {
 			Yyerror("%v escapes to heap, not allowed in runtime.", v)
 		}
-		if v.Alloc == nil {
-			v.Alloc = callnew(v.Type)
+		if prealloc[v] == nil {
+			prealloc[v] = callnew(v.Type)
 		}
-		nn = list(nn, Nod(OAS, v.Name.Heapaddr, v.Alloc))
+		nn = list(nn, Nod(OAS, v.Name.Heapaddr, prealloc[v]))
 		if v.Class&^PHEAP != PPARAMOUT {
 			as = Nod(OAS, v, v.Param.Stackparam)
 			v.Param.Stackparam.Typecheck = 1
@@ -2861,7 +2861,9 @@ func addstr(n *Node, init **NodeList) *Node {
 		t.Type = Types[TSTRING]
 		t.Bound = -1
 		slice := Nod(OCOMPLIT, nil, typenod(t))
-		slice.Alloc = n.Alloc
+		if prealloc[n] != nil {
+			prealloc[slice] = prealloc[n]
+		}
 		slice.List = args.Next // skip buf arg
 		args = list1(buf)
 		args = list(args, slice)