reflect: avoid calling common if type is known to be *rtype

If the type of Type is known to be *rtype than the common
function is a no-op and does not need to be called.

name  old time/op  new time/op  delta
New   31.0ns ± 5%  30.2ns ± 4%  -2.74%  (p=0.008 n=20+20)

Change-Id: I5d00346dbc782e34c530166d1ee0499b24068b51
Reviewed-on: https://go-review.googlesource.com/96115
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

diff --git a/src/reflect/value.go b/src/reflect/value.go
index c39f839714d74e831ac2d1377ab036e8f176a5e8..e466cf711ce3a197f158a2e1a582bb516afa9030 100644 (file)
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -2102,7 +2102,7 @@ func MakeSlice(typ Type, len, cap int) Value {
        }
 
        s := sliceHeader{unsafe_NewArray(typ.Elem().(*rtype), cap), len, cap}
-       return Value{typ.common(), unsafe.Pointer(&s), flagIndir | flag(Slice)}
+       return Value{typ.(*rtype), unsafe.Pointer(&s), flagIndir | flag(Slice)}
 }
 
 // MakeChan creates a new channel with the specified type and buffer size.
@@ -2116,8 +2116,9 @@ func MakeChan(typ Type, buffer int) Value {
        if typ.ChanDir() != BothDir {
                panic("reflect.MakeChan: unidirectional channel type")
        }
-       ch := makechan(typ.(*rtype), buffer)
-       return Value{typ.common(), ch, flag(Chan)}
+       t := typ.(*rtype)
+       ch := makechan(t, buffer)
+       return Value{t, ch, flag(Chan)}
 }
 
 // MakeMap creates a new map with the specified type.
@@ -2131,8 +2132,9 @@ func MakeMapWithSize(typ Type, n int) Value {
        if typ.Kind() != Map {
                panic("reflect.MakeMapWithSize of non-map type")
        }
-       m := makemap(typ.(*rtype), n)
-       return Value{typ.common(), m, flag(Map)}
+       t := typ.(*rtype)
+       m := makemap(t, n)
+       return Value{t, m, flag(Map)}
 }
 
 // Indirect returns the value that v points to.
@@ -2170,10 +2172,10 @@ func Zero(typ Type) Value {
        if typ == nil {
                panic("reflect: Zero(nil)")
        }
-       t := typ.common()
+       t := typ.(*rtype)
        fl := flag(t.Kind())
        if ifaceIndir(t) {
-               return Value{t, unsafe_New(typ.(*rtype)), fl | flagIndir}
+               return Value{t, unsafe_New(t), fl | flagIndir}
        }
        return Value{t, nil, fl}
 }
@@ -2184,16 +2186,18 @@ func New(typ Type) Value {
        if typ == nil {
                panic("reflect: New(nil)")
        }
-       ptr := unsafe_New(typ.(*rtype))
+       t := typ.(*rtype)
+       ptr := unsafe_New(t)
        fl := flag(Ptr)
-       return Value{typ.common().ptrTo(), ptr, fl}
+       return Value{t.ptrTo(), ptr, fl}
 }
 
 // NewAt returns a Value representing a pointer to a value of the
 // specified type, using p as that pointer.
 func NewAt(typ Type, p unsafe.Pointer) Value {
        fl := flag(Ptr)
-       return Value{typ.common().ptrTo(), p, fl}
+       t := typ.(*rtype)
+       return Value{t.ptrTo(), p, fl}
 }
 
 // assignTo returns a value v that can be assigned directly to typ.