code review 6551067: runtime: prepare for 64-bit ints

src/pkg/reflect/value.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package reflect
 
 import (
         "math"
         "runtime"
         "strconv"
@@ skipping 912 matching lines @@
 
 // Len returns v's length.
 // It panics if v's Kind is not Array, Chan, Map, Slice, or String.
 func (v Value) Len() int {
         k := v.kind()
         switch k {
         case Array:
                 tt := (*arrayType)(unsafe.Pointer(v.typ))
                 return int(tt.len)
         case Chan:
-                return int(chanlen(v.iword()))
+                return chanlen(v.iword())
         case Map:
-                return int(maplen(v.iword()))
+                return maplen(v.iword())
         case Slice:
                 // Slice is bigger than a word; assume flagIndir.
                 return (*SliceHeader)(v.val).Len
         case String:
                 // String is bigger than a word; assume flagIndir.
                 return (*StringHeader)(v.val).Len
         }
         panic(&ValueError{"reflect.Value.Len", k})
 }
 
@@ skipping 36 matching lines @@
         tt := (*mapType)(unsafe.Pointer(v.typ))
         keyType := toCommonType(tt.key)
 
         fl := v.flag & flagRO
         fl |= flag(keyType.Kind()) << flagKindShift
         if keyType.size > ptrSize {
                 fl |= flagIndir
         }
 
         m := v.iword()
-        mlen := int32(0)
+        mlen := int(0)
         if m != nil {
                 mlen = maplen(m)
         }
         it := mapiterinit(v.typ.runtimeType(), m)
         a := make([]Value, mlen)
         var i int
         for i = 0; i < len(a); i++ {
                 keyWord, ok := mapiterkey(it)
                 if !ok {
                         break
@@ skipping 1225 matching lines @@
 func cvtI2I(v Value, typ Type) Value {
         if v.IsNil() {
                 ret := Zero(typ)
                 ret.flag |= v.flag & flagRO
                 return ret
         }
         return cvtT2I(v.Elem(), typ)
 }
 
 // implemented in ../pkg/runtime
-func chancap(ch iword) int32

[iant, 2012/09/24 17:17:07]

s/int32/int/

[rsc, 2012/09/24 18:56:42]

Ouch, thanks. Looked for others and didn't find any but maplen (also fixed).

+func chancap(ch iword) int
 func chanclose(ch iword)
-func chanlen(ch iword) int32

[iant, 2012/09/24 17:17:07]

s/int32/int/

[rsc, 2012/09/24 18:56:42]

Done.

+func chanlen(ch iword) int
 func chanrecv(t *runtimeType, ch iword, nb bool) (val iword, selected, received bool)
 func chansend(t *runtimeType, ch iword, val iword, nb bool) bool
 
 func makechan(typ *runtimeType, size uint64) (ch iword)
 func makemap(t *runtimeType) (m iword)
 func mapaccess(t *runtimeType, m iword, key iword) (val iword, ok bool)
 func mapassign(t *runtimeType, m iword, key, val iword, ok bool)
 func mapiterinit(t *runtimeType, m iword) *byte
 func mapiterkey(it *byte) (key iword, ok bool)
 func mapiternext(it *byte)
-func maplen(m iword) int32
+func maplen(m iword) int
 
 func call(fn, arg unsafe.Pointer, n uint32)
 func ifaceE2I(t *runtimeType, src interface{}, dst unsafe.Pointer)
 
 // Dummy annotation marking that the value x escapes,
 // for use in cases where the reflect code is so clever that
 // the compiler cannot follow.
 func escapes(x interface{}) {
         if dummy.b {
                 dummy.x = x
         }
 }
 
 var dummy struct {
         b bool
         x interface{}
 }