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>

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 2efe468700c6e24438f02cd5d58428e4bc0614ba..329342f8e75d104b701df347b16d867ca1ed6d61 100644 (file)
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/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)

diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index d1b4d444718bf1feacb297efb23e1e936443516e..296462cd44bd9bab0fa2766b2593ba87702b6d4f 100644 (file)
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/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])
 }
 
 /*

diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index f42a7204bdf8ba713aabeb54b37fa3d65faca77f..ecf42bd8f78ce2199ac838a734159c32ae4ae8ae 100644 (file)
--- a/src/cmd/compile/internal/gc/order.go
+++ b/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:

diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 8111f8aaf05eea77d0f3d52528439599388b755e..26f05d9d70b89bf5c30f57d63a4a62f7785d9120 100644 (file)
--- a/src/cmd/compile/internal/gc/range.go
+++ b/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

diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index 061711c994142514ebc9f046d523002d79a5c64e..db32932027a5bd17b3eef068f47e2dcda4306158 100644 (file)
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/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 {

diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index f1dd52cec391a35b6bfad65bfe547e4a4a3299cd..02b5e9578d22e742142317e0cac1dbeae6307e15 100644 (file)
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/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

diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 07d13091a75f2b24050110c2d4b5eac4469f9c45..368cd42f4b235a7d99046c373efcb6ae25e226d8 100644 (file)
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/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)