From bfe0cbdc50cbc6a632d1e5ebbdcc625d69451935 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 19 Apr 2016 15:38:59 -0700 Subject: [PATCH] cmd/compile,runtime: pass elem type to {make,grow}slice No point in passing the slice type to these functions. All they need is the element type. One less indirection, maybe a few less []T type descriptors in the binary. Change-Id: Ib0b83b5f14ca21d995ecc199ce8ac00c4eb375e6 Reviewed-on: https://go-review.googlesource.com/22275 Reviewed-by: Josh Bleecher Snyder --- src/cmd/compile/internal/gc/cgen.go | 2 +- src/cmd/compile/internal/gc/ssa.go | 2 +- src/cmd/compile/internal/gc/walk.go | 8 ++++---- src/runtime/slice.go | 16 +++++++--------- 4 files changed, 13 insertions(+), 15 deletions(-) diff --git a/src/cmd/compile/internal/gc/cgen.go b/src/cmd/compile/internal/gc/cgen.go index 658cc8a50ef..5c5bedaa314 100644 --- a/src/cmd/compile/internal/gc/cgen.go +++ b/src/cmd/compile/internal/gc/cgen.go @@ -2876,7 +2876,7 @@ func cgen_append(n, res *Node) { arg.Addable = true arg.Xoffset = Ctxt.FixedFrameSize() arg.Type = Ptrto(Types[TUINT8]) - Cgen(typename(res.Type), &arg) + Cgen(typename(res.Type.Elem()), &arg) arg.Xoffset += int64(Widthptr) arg.Type = Types[Tptr] diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index c4008c9ce1c..11e362c1161 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -2185,7 +2185,7 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value { // Call growslice s.startBlock(grow) - taddr := s.newValue1A(ssa.OpAddr, Types[TUINTPTR], &ssa.ExternSymbol{Types[TUINTPTR], typenamesym(n.Type)}, s.sb) + taddr := s.newValue1A(ssa.OpAddr, Types[TUINTPTR], &ssa.ExternSymbol{Types[TUINTPTR], typenamesym(n.Type.Elem())}, s.sb) r := s.rtcall(growslice, true, []*Type{pt, Types[TINT], Types[TINT]}, taddr, p, l, c, nl) diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go index e4d93339a92..82ac74ae336 100644 --- a/src/cmd/compile/internal/gc/walk.go +++ b/src/cmd/compile/internal/gc/walk.go @@ -1420,11 +1420,11 @@ opswitch: r = walkexpr(r, init) n = r } else { - // makeslice(t *Type, nel int64, max int64) (ary []any) + // makeslice(et *Type, nel int64, max int64) (ary []any) fn := syslook("makeslice") fn = substArgTypes(fn, t.Elem()) // any-1 - n = mkcall1(fn, n.Type, init, typename(n.Type), conv(l, Types[TINT64]), conv(r, Types[TINT64])) + n = mkcall1(fn, n.Type, init, typename(t.Elem()), conv(l, Types[TINT64]), conv(r, Types[TINT64])) } case ORUNESTR: @@ -2799,7 +2799,7 @@ func appendslice(n *Node, init *Nodes) *Node { fn = substArgTypes(fn, s.Type.Elem(), s.Type.Elem()) // s = growslice(T, s, n) - nif.Nbody.Set1(Nod(OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(s.Type), s, nn))) + nif.Nbody.Set1(Nod(OAS, s, mkcall1(fn, s.Type, &nif.Ninit, typename(s.Type.Elem()), s, nn))) l = append(l, nif) // s = s[:n] @@ -2929,7 +2929,7 @@ func walkappend(n *Node, init *Nodes, dst *Node) *Node { fn = substArgTypes(fn, ns.Type.Elem(), ns.Type.Elem()) nx.Nbody.Set1(Nod(OAS, ns, - mkcall1(fn, ns.Type, &nx.Ninit, typename(ns.Type), ns, + mkcall1(fn, ns.Type, &nx.Ninit, typename(ns.Type.Elem()), ns, Nod(OADD, Nod(OLEN, ns, nil), na)))) l = append(l, nx) diff --git a/src/runtime/slice.go b/src/runtime/slice.go index 873e97ebff3..e86c1ce2c85 100644 --- a/src/runtime/slice.go +++ b/src/runtime/slice.go @@ -37,14 +37,14 @@ func maxSliceCap(elemsize uintptr) uintptr { } // TODO: take uintptrs instead of int64s? -func makeslice(t *slicetype, len64, cap64 int64) slice { +func makeslice(et *_type, len64, cap64 int64) slice { // NOTE: The len > maxElements check here is not strictly necessary, // but it produces a 'len out of range' error instead of a 'cap out of range' error // when someone does make([]T, bignumber). 'cap out of range' is true too, // but since the cap is only being supplied implicitly, saying len is clearer. // See issue 4085. - maxElements := maxSliceCap(t.elem.size) + maxElements := maxSliceCap(et.size) len := int(len64) if len64 < 0 || int64(len) != len64 || uintptr(len) > maxElements { panic(errorString("makeslice: len out of range")) @@ -55,7 +55,6 @@ func makeslice(t *slicetype, len64, cap64 int64) slice { panic(errorString("makeslice: cap out of range")) } - et := t.elem var flags uint32 if et.kind&kindNoPointers != 0 { flags = flagNoScan @@ -65,7 +64,7 @@ func makeslice(t *slicetype, len64, cap64 int64) slice { } // growslice handles slice growth during append. -// It is passed the slice type, the old slice, and the desired new minimum capacity, +// It is passed the slice element type, the old slice, and the desired new minimum capacity, // and it returns a new slice with at least that capacity, with the old data // copied into it. // The new slice's length is set to the old slice's length, @@ -74,16 +73,15 @@ func makeslice(t *slicetype, len64, cap64 int64) slice { // to calculate where to write new values during an append. // TODO: When the old backend is gone, reconsider this decision. // The SSA backend might prefer the new length or to return only ptr/cap and save stack space. -func growslice(t *slicetype, old slice, cap int) slice { +func growslice(et *_type, old slice, cap int) slice { if raceenabled { - callerpc := getcallerpc(unsafe.Pointer(&t)) - racereadrangepc(old.array, uintptr(old.len*int(t.elem.size)), callerpc, funcPC(growslice)) + callerpc := getcallerpc(unsafe.Pointer(&et)) + racereadrangepc(old.array, uintptr(old.len*int(et.size)), callerpc, funcPC(growslice)) } if msanenabled { - msanread(old.array, uintptr(old.len*int(t.elem.size))) + msanread(old.array, uintptr(old.len*int(et.size))) } - et := t.elem if et.size == 0 { if cap < old.cap { panic(errorString("growslice: cap out of range"))