From: Russ Cox Date: Wed, 27 May 2015 03:05:35 +0000 (-0400) Subject: cmd/compile: remove Node.Alloc X-Git-Tag: go1.5beta1~402 X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=60e5f5bdff1b176b749bf04816179d712411d0a6;p=gostls13.git 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 Reviewed-by: Josh Bleecher Snyder --- diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go index 2efe468700..329342f8e7 100644 --- 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 d1b4d44471..296462cd44 100644 --- 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 f42a7204bd..ecf42bd8f7 100644 --- 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 8111f8aaf0..26f05d9d70 100644 --- 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 061711c994..db32932027 100644 --- 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 f1dd52cec3..02b5e9578d 100644 --- 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 07d13091a7..368cd42f4b 100644 --- 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)