runtime: prepare for 64-bit ints

This CL makes the runtime understand that the type of
the len or cap of a map, slice, or string is 'int', not 'int32',
and it is also careful to distinguish between function arguments
and results of type 'int' vs type 'int32'.

In the runtime, the new typedefs 'intgo' and 'uintgo' refer
to Go int and uint. The C types int and uint continue to be
unavailable (cause intentional compile errors).

This CL does not change the meaning of int, but it should make
the eventual change of the meaning of int on amd64 a bit
smoother.

Update #2188.

R=iant, r, dave, remyoudompheng
CC=golang-dev
https://golang.org/cl/6551067

diff --git a/src/cmd/dist/goc2c.c b/src/cmd/dist/goc2c.c
index c64ede95896275a490aa58543c0277dba5478a00..cd14e6bc80d309a2959722e1b61c6d6b545d67cf 100644 (file)
--- a/src/cmd/dist/goc2c.c
+++ b/src/cmd/dist/goc2c.c
@@ -26,6 +26,11 @@ static char *input;
 static Buf *output;
 #define EOF -1
 
+enum
+{
+       use64bitint = 0,
+};
+
 static int
 xgetchar(void)
 {
@@ -86,13 +91,16 @@ static struct {
        char *name;
        int size;
 } type_table[] = {
-       /* variable sized first, for easy replacement */
-       /* order matches enum above */
-       /* default is 32-bit architecture sizes */
-       {"bool",                1},
+       /* 
+        * variable sized first, for easy replacement.
+        * order matches enum above.
+        * default is 32-bit architecture sizes.
+        * spelling as in package runtime, so intgo/uintgo not int/uint.
+        */
+       {"bool",        1},
        {"float",       4},
-       {"int",         4},
-       {"uint",                4},
+       {"intgo",               4},
+       {"uintgo",      4},
        {"uintptr",     4},
        {"String",      8},
        {"Slice",       12},
@@ -101,12 +109,13 @@ static struct {
        /* fixed size */
        {"float32",     4},
        {"float64",     8},
-       {"byte",                1},
-       {"int8",                1},
+       {"byte",        1},
+       {"int8",        1},
        {"uint8",       1},
        {"int16",       2},
        {"uint16",      2},
        {"int32",       4},
+       {"rune",        4},
        {"uint32",      4},
        {"int64",       8},
        {"uint64",      8},
@@ -328,7 +337,7 @@ read_type(void)
        unsigned int len;
 
        p = read_token_no_eof();
-       if (*p != '*')
+       if (*p != '*' && !streq(p, "int") && !streq(p, "uint"))
                return p;
        op = p;
        pointer_count = 0;
@@ -337,13 +346,18 @@ read_type(void)
                ++p;
        }
        len = xstrlen(p);
-       q = xmalloc(len + pointer_count + 1);
+       q = xmalloc(len + 2 + pointer_count + 1);
        xmemmove(q, p, len);
-       while (pointer_count > 0) {
-               q[len] = '*';
-               ++len;
-               --pointer_count;
+
+       // Turn int/uint into intgo/uintgo.
+       if((len == 3 && xmemcmp(q, "int", 3) == 0) || (len == 4 && xmemcmp(q, "uint", 4) == 0)) {
+               q[len++] = 'g';
+               q[len++] = 'o';
        }
+
+       while (pointer_count-- > 0)
+               q[len++] = '*';
+       
        q[len] = '\0';
        xfree(op);
        return q;
@@ -713,15 +727,25 @@ goc2c(char *goc, char *c)
        if(!gcc) {
                if(streq(goarch, "amd64")) {
                        type_table[Uintptr].size = 8;
-                       type_table[String].size = 16;
-                       type_table[Slice].size = 8+4+4;
                        type_table[Eface].size = 8+8;
+                       type_table[String].size = 16;
+                       if(use64bitint) {
+                               type_table[Int].size = 8;
+                               type_table[Uint].size = 8;
+                       }
+                       type_table[Slice].size = 8+2*type_table[Int].size;
                        structround = 8;
                } else {
+                       // NOTE: These are set in the initializer,
+                       // but they might have been changed by a
+                       // previous invocation of goc2c, so we have
+                       // to restore them.
                        type_table[Uintptr].size = 4;
                        type_table[String].size = 8;
                        type_table[Slice].size = 16;
                        type_table[Eface].size = 4+4;
+                       type_table[Int].size = 4;
+                       type_table[Uint].size = 4;
                        structround = 4;
                }
        }

diff --git a/src/pkg/reflect/value.go b/src/pkg/reflect/value.go
index 4d5e38677699fcb02209fa107abefaa47d7cb8d5..45af13dd08a87992d5e24c24a56841d12f131dbc 100644 (file)
--- a/src/pkg/reflect/value.go
+++ b/src/pkg/reflect/value.go
@@ -930,9 +930,9 @@ func (v Value) Len() int {
                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
@@ -989,7 +989,7 @@ func (v Value) MapKeys() []Value {
        }
 
        m := v.iword()
-       mlen := int32(0)
+       mlen := int(0)
        if m != nil {
                mlen = maplen(m)
        }
@@ -1821,7 +1821,7 @@ func MakeChan(typ Type, buffer int) Value {
        if typ.ChanDir() != BothDir {
                panic("reflect.MakeChan: unidirectional channel type")
        }
-       ch := makechan(typ.runtimeType(), uint32(buffer))
+       ch := makechan(typ.runtimeType(), uint64(buffer))
        return Value{typ.common(), unsafe.Pointer(ch), flag(Chan) << flagKindShift}
 }
 
@@ -2235,20 +2235,20 @@ func cvtI2I(v Value, typ Type) Value {
 }
 
 // implemented in ../pkg/runtime
-func chancap(ch iword) int32
+func chancap(ch iword) int
 func chanclose(ch iword)
-func chanlen(ch iword) int32
+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 uint32) (ch iword)
+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)

diff --git a/src/pkg/runtime/alg.c b/src/pkg/runtime/alg.c
index 4691b5c9c8ec34122e09700ccc223547a48fac9d..c7424bc26242897e94ae3980356dc868188dc253 100644 (file)
--- a/src/pkg/runtime/alg.c
+++ b/src/pkg/runtime/alg.c
@@ -316,7 +316,7 @@ runtime·strhash(uintptr *h, uintptr s, void *a)
 void
 runtime·strequal(bool *eq, uintptr s, void *a, void *b)
 {
-       int32 alen;
+       intgo alen;
 
        USED(s);
        alen = ((String*)a)->len;

diff --git a/src/pkg/runtime/chan.c b/src/pkg/runtime/chan.c
index f2e49c62e852691d8f8f8ea7733582420235d532..77ad4142ae0dc069275349bba8dd8139d76f09e6 100644 (file)
--- a/src/pkg/runtime/chan.c
+++ b/src/pkg/runtime/chan.c
@@ -3,7 +3,9 @@
 // license that can be found in the LICENSE file.
 
 #include "runtime.h"
+#include "arch_GOARCH.h"
 #include "type.h"
+#include "malloc.h"
 
 #define        MAXALIGN        7
 #define        NOSELGEN        1
@@ -31,14 +33,14 @@ struct      WaitQ
 
 struct Hchan
 {
-       uint32  qcount;                 // total data in the q
-       uint32  dataqsiz;               // size of the circular q
+       uintgo  qcount;                 // total data in the q
+       uintgo  dataqsiz;               // size of the circular q
        uint16  elemsize;
        bool    closed;
        uint8   elemalign;
        Alg*    elemalg;                // interface for element type
-       uint32  sendx;                  // send index
-       uint32  recvx;                  // receive index
+       uintgo  sendx;                  // send index
+       uintgo  recvx;                  // receive index
        WaitQ   recvq;                  // list of recv waiters
        WaitQ   sendq;                  // list of send waiters
        Lock;
@@ -84,12 +86,16 @@ Hchan*
 runtime·makechan_c(ChanType *t, int64 hint)
 {
        Hchan *c;
-       int32 n;
+       uintptr n;
        Type *elem;
 
        elem = t->elem;
 
-       if(hint < 0 || (int32)hint != hint || (elem->size > 0 && hint > ((uintptr)-1) / elem->size))
+       // compiler checks this but be safe.
+       if(elem->size >= (1<<16))
+               runtime·throw("makechan: invalid channel element type");
+
+       if(hint < 0 || (intgo)hint != hint || (elem->size > 0 && hint > MaxMem / elem->size))
                runtime·panicstring("makechan: size out of range");
 
        // calculate rounded size of Hchan
@@ -105,16 +111,16 @@ runtime·makechan_c(ChanType *t, int64 hint)
        c->dataqsiz = hint;
 
        if(debug)
-               runtime·printf("makechan: chan=%p; elemsize=%D; elemalg=%p; elemalign=%d; dataqsiz=%d\n",
-                       c, (int64)elem->size, elem->alg, elem->align, c->dataqsiz);
+               runtime·printf("makechan: chan=%p; elemsize=%D; elemalg=%p; elemalign=%d; dataqsiz=%D\n",
+                       c, (int64)elem->size, elem->alg, elem->align, (int64)c->dataqsiz);
 
        return c;
 }
 
 // For reflect
-//     func makechan(typ *ChanType, size uint32) (chan)
+//     func makechan(typ *ChanType, size uint64) (chan)
 void
-reflect·makechan(ChanType *t, uint32 size, Hchan *c)
+reflect·makechan(ChanType *t, uint64 size, Hchan *c)
 {
        c = runtime·makechan_c(t, size);
        FLUSH(&c);
@@ -1038,7 +1044,7 @@ enum SelectDir {
 
 // func rselect(cases []runtimeSelect) (chosen int, word uintptr, recvOK bool)
 void
-reflect·rselect(Slice cases, int32 chosen, uintptr word, bool recvOK)
+reflect·rselect(Slice cases, intgo chosen, uintptr word, bool recvOK)
 {
        int32 i;
        Select *sel;
@@ -1091,7 +1097,7 @@ reflect·rselect(Slice cases, int32 chosen, uintptr word, bool recvOK)
                }
        }
 
-       chosen = (int32)(uintptr)selectgo(&sel);
+       chosen = (intgo)(uintptr)selectgo(&sel);
        if(rcase[chosen].dir == SelectRecv && rcase[chosen].typ->elem->size > sizeof(void*))
                word = (uintptr)recvptr;
 
@@ -1153,9 +1159,9 @@ reflect·chanclose(Hchan *c)
 }
 
 // For reflect
-//     func chanlen(c chan) (len int32)
+//     func chanlen(c chan) (len int)
 void
-reflect·chanlen(Hchan *c, int32 len)
+reflect·chanlen(Hchan *c, intgo len)
 {
        if(c == nil)
                len = 0;
@@ -1165,9 +1171,9 @@ reflect·chanlen(Hchan *c, int32 len)
 }
 
 // For reflect
-//     func chancap(c chan) (cap int32)
+//     func chancap(c chan) int
 void
-reflect·chancap(Hchan *c, int32 cap)
+reflect·chancap(Hchan *c, intgo cap)
 {
        if(c == nil)
                cap = 0;

diff --git a/src/pkg/runtime/cpuprof.c b/src/pkg/runtime/cpuprof.c
index eded073320c65ba48f8e09c58aaa716fccd75957..1bb768085d9c427dd9af1f44d40082482c560ab4 100644 (file)
--- a/src/pkg/runtime/cpuprof.c
+++ b/src/pkg/runtime/cpuprof.c
@@ -121,7 +121,7 @@ static void LostProfileData(void) {
 // SetCPUProfileRate sets the CPU profiling rate.
 // The user documentation is in debug.go.
 void
-runtime·SetCPUProfileRate(int32 hz)
+runtime·SetCPUProfileRate(intgo hz)
 {
        uintptr *p;
        uintptr n;

diff --git a/src/pkg/runtime/hashmap.c b/src/pkg/runtime/hashmap.c
index e8965a68d5d026e6e6dae94f7d3100c12ae59bd8..dbb944c3fec00f04fd91c9922bd4fbe7dffc0d27 100644 (file)
--- a/src/pkg/runtime/hashmap.c
+++ b/src/pkg/runtime/hashmap.c
@@ -13,7 +13,7 @@
 #define CanFreeKey (1<<3)      /* okay to free pointers to keys */
 
 struct Hmap {     /* a hash table; initialize with hash_init() */
-       uint32 count;     /* elements in table - must be first */
+       uintgo count;     /* elements in table - must be first */
        uint8 datasize;   /* amount of data to store in entry */
        uint8 flag;
        uint8 valoff;   /* offset of value in key+value data block */
@@ -728,7 +728,6 @@ hash_keyptr(Hmap *h, void *p)
 
 static int32   debug   = 0;
 
-// makemap(typ *Type, hint uint32) (hmap *map[any]any);
 Hmap*
 runtime·makemap_c(MapType *typ, int64 hint)
 {
@@ -1152,10 +1151,10 @@ reflect·mapiterkey(struct hash_iter *it, uintptr key, bool ok)
 }
 
 // For reflect:
-//     func maplen(h map) (len int32)
+//     func maplen(h map) (len int)
 // Like len(m) in the actual language, we treat the nil map as length 0.
 void
-reflect·maplen(Hmap *h, int32 len)
+reflect·maplen(Hmap *h, intgo len)
 {
        if(h == nil)
                len = 0;

diff --git a/src/pkg/runtime/iface.c b/src/pkg/runtime/iface.c
index 8e0150d07b91c90d98ed4a29b93207ab59a2f8b9..a3c5f1b045a44b75ff7f80bf7e47ce4a1170d38a 100644 (file)
--- a/src/pkg/runtime/iface.c
+++ b/src/pkg/runtime/iface.c
@@ -703,7 +703,7 @@ reflect·unsafe_New(Eface typ, void *ret)
 }
 
 void
-reflect·unsafe_NewArray(Eface typ, uint32 n, void *ret)
+reflect·unsafe_NewArray(Eface typ, intgo n, void *ret)
 {
        uint64 size;
        Type *t;

diff --git a/src/pkg/runtime/malloc.goc b/src/pkg/runtime/malloc.goc
index babe4d2f4ccb13d2075d28f6d84b15bc2dc22e0b..294dad8f3409f8a8a00dccbb241e14b4afc0bd10 100644 (file)
--- a/src/pkg/runtime/malloc.goc
+++ b/src/pkg/runtime/malloc.goc
@@ -20,7 +20,7 @@ MHeap runtime·mheap;
 
 extern MStats mstats;  // defined in extern.go
 
-extern volatile int32 runtime·MemProfileRate;
+extern volatile intgo runtime·MemProfileRate;
 
 // Allocate an object of at least size bytes.
 // Small objects are allocated from the per-thread cache's free lists.
@@ -28,7 +28,8 @@ extern volatile int32 runtime·MemProfileRate;
 void*
 runtime·mallocgc(uintptr size, uint32 flag, int32 dogc, int32 zeroed)
 {
-       int32 sizeclass, rate;
+       int32 sizeclass;
+       intgo rate;
        MCache *c;
        uintptr npages;
        MSpan *s;
@@ -226,7 +227,7 @@ runtime·mlookup(void *v, byte **base, uintptr *size, MSpan **sp)
 MCache*
 runtime·allocmcache(void)
 {
-       int32 rate;
+       intgo rate;
        MCache *c;
 
        runtime·lock(&runtime·mheap);
@@ -507,7 +508,8 @@ func SetFinalizer(obj Eface, finalizer Eface) {
        byte *base;
        uintptr size;
        FuncType *ft;
-       int32 i, nret;
+       int32 i;
+       uintptr nret;
        Type *t;
 
        if(obj.type == nil) {

diff --git a/src/pkg/runtime/malloc.h b/src/pkg/runtime/malloc.h
index fee6e0178909634d8158497c1d31516eb4c4803f..c00bd4599f6255a210fd1198bb465be351be0647 100644 (file)
--- a/src/pkg/runtime/malloc.h
+++ b/src/pkg/runtime/malloc.h
@@ -128,6 +128,15 @@ enum
        MaxGcproc = 8,
 };
 
+// Maximum memory allocation size, a hint for callers.
+// This must be a #define instead of an enum because it
+// is so large.
+#ifdef _64BIT
+#define        MaxMem  (16ULL<<30)     /* 16 GB */
+#else
+#define        MaxMem  ((uintptr)-1)
+#endif
+
 // A generic linked list of blocks.  (Typically the block is bigger than sizeof(MLink).)
 struct MLink
 {
@@ -418,5 +427,5 @@ int32       runtime·gcprocs(void);
 void   runtime·helpgc(int32 nproc);
 void   runtime·gchelper(void);
 
-bool   runtime·getfinalizer(void *p, bool del, void (**fn)(void*), int32 *nret);
+bool   runtime·getfinalizer(void *p, bool del, void (**fn)(void*), uintptr *nret);
 void   runtime·walkfintab(void (*fn)(void*));

diff --git a/src/pkg/runtime/mfinal.c b/src/pkg/runtime/mfinal.c
index 1fa5ea401d42031ecb5cd085b1a95fd0c28300dd..ab450717ab04b89343e73260b886d52696a08fa1 100644 (file)
--- a/src/pkg/runtime/mfinal.c
+++ b/src/pkg/runtime/mfinal.c
@@ -12,7 +12,7 @@ typedef struct Fin Fin;
 struct Fin
 {
        void (*fn)(void*);
-       int32 nret;
+       uintptr nret;
 };
 
 // Finalizer hash table.  Direct hash, linear scan, at most 3/4 full.
@@ -42,7 +42,7 @@ static struct {
 } fintab[TABSZ];
 
 static void
-addfintab(Fintab *t, void *k, void (*fn)(void*), int32 nret)
+addfintab(Fintab *t, void *k, void (*fn)(void*), uintptr nret)
 {
        int32 i, j;
 
@@ -137,7 +137,7 @@ resizefintab(Fintab *tab)
 }
 
 bool
-runtime·addfinalizer(void *p, void (*f)(void*), int32 nret)
+runtime·addfinalizer(void *p, void (*f)(void*), uintptr nret)
 {
        Fintab *tab;
        byte *base;
@@ -175,7 +175,7 @@ runtime·addfinalizer(void *p, void (*f)(void*), int32 nret)
 // get finalizer; if del, delete finalizer.
 // caller is responsible for updating RefHasFinalizer (special) bit.
 bool
-runtime·getfinalizer(void *p, bool del, void (**fn)(void*), int32 *nret)
+runtime·getfinalizer(void *p, bool del, void (**fn)(void*), uintptr *nret)
 {
        Fintab *tab;
        bool res;

diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 91ed5088da05ac1c3dc1909a022cd42881f3e81f..d94a722c7a999762163854f9f16b9d02daa8bbe9 100644 (file)
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -82,7 +82,7 @@ struct Finalizer
 {
        void (*fn)(void*);
        void *arg;
-       int32 nret;
+       uintptr nret;
 };
 
 typedef struct FinBlock FinBlock;
@@ -633,7 +633,7 @@ static bool
 handlespecial(byte *p, uintptr size)
 {
        void (*fn)(void*);
-       int32 nret;
+       uintptr nret;
        FinBlock *block;
        Finalizer *f;
 

diff --git a/src/pkg/runtime/mprof.goc b/src/pkg/runtime/mprof.goc
index e9b13d253154a303bcde33757cd575353a8478f4..50aa0fe487b743fe3f3f5f205f6f8d7f12cd0aa6 100644 (file)
--- a/src/pkg/runtime/mprof.goc
+++ b/src/pkg/runtime/mprof.goc
@@ -284,7 +284,7 @@ record(Record *r, Bucket *b)
                r->stk[i] = 0;
 }
 
-func MemProfile(p Slice, include_inuse_zero bool) (n int32, ok bool) {
+func MemProfile(p Slice, include_inuse_zero bool) (n int, ok bool) {
        Bucket *b;
        Record *r;
 
@@ -310,7 +310,7 @@ struct TRecord {
        uintptr stk[32];
 };
 
-func ThreadCreateProfile(p Slice) (n int32, ok bool) {
+func ThreadCreateProfile(p Slice) (n int, ok bool) {
        TRecord *r;
        M *first, *m;
        
@@ -329,7 +329,7 @@ func ThreadCreateProfile(p Slice) (n int32, ok bool) {
        }
 }
 
-func Stack(b Slice, all bool) (n int32) {
+func Stack(b Slice, all bool) (n int) {
        byte *pc, *sp;
        
        sp = runtime·getcallersp(&b);
@@ -372,7 +372,7 @@ saveg(byte *pc, byte *sp, G *g, TRecord *r)
                r->stk[n] = 0;
 }
 
-func GoroutineProfile(b Slice) (n int32, ok bool) {
+func GoroutineProfile(b Slice) (n int, ok bool) {
        byte *pc, *sp;
        TRecord *r;
        G *gp;

diff --git a/src/pkg/runtime/print.c b/src/pkg/runtime/print.c
index fe21f1691a805c6b7aee54059929929a5d6e5323..b642999a1d59a6b9d002b757cc9d82331ecfbfd4 100644 (file)
--- a/src/pkg/runtime/print.c
+++ b/src/pkg/runtime/print.c
@@ -343,7 +343,7 @@ runtime·printstring(String v)
        extern uint32 runtime·maxstring;
 
        if(v.len > runtime·maxstring) {
-               gwrite("[invalid string]", 16);
+               gwrite("[string too long]", 17);
                return;
        }
        if(v.len > 0)

diff --git a/src/pkg/runtime/proc.c b/src/pkg/runtime/proc.c
index d763d01b085e414762ea64fcbd1383f93c83d087..36a362e7e2aeaa89ead4767c7b79a32458bea033 100644 (file)
--- a/src/pkg/runtime/proc.c
+++ b/src/pkg/runtime/proc.c
@@ -1451,7 +1451,7 @@ runtime·mid(uint32 ret)
 }
 
 void
-runtime·NumGoroutine(int32 ret)
+runtime·NumGoroutine(intgo ret)
 {
        ret = runtime·sched.gcount;
        FLUSH(&ret);

diff --git a/src/pkg/runtime/runtime.c b/src/pkg/runtime/runtime.c
index 8c1ee28bdeb2ebaaa98992ce6b3510fa646a02e8..080343fb9eaf6281032da2a00a992bb1ad9d784a 100644 (file)
--- a/src/pkg/runtime/runtime.c
+++ b/src/pkg/runtime/runtime.c
@@ -290,7 +290,7 @@ runtime·check(void)
 }
 
 void
-runtime·Caller(int32 skip, uintptr retpc, String retfile, int32 retline, bool retbool)
+runtime·Caller(intgo skip, uintptr retpc, String retfile, intgo retline, bool retbool)
 {
        Func *f, *g;
        uintptr pc;
@@ -327,7 +327,7 @@ runtime·Caller(int32 skip, uintptr retpc, String retfile, int32 retline, bool r
 }
 
 void
-runtime·Callers(int32 skip, Slice pc, int32 retn)
+runtime·Callers(intgo skip, Slice pc, intgo retn)
 {
        // runtime.callers uses pc.array==nil as a signal
        // to print a stack trace.  Pick off 0-length pc here

diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 37427fb92d3a8805d4b4591c79f33b0ed247dbe6..a8639f499e305a7ed8b2fa0fa431b27f175de976 100644 (file)
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -19,9 +19,13 @@ typedef      double                  float64;
 #ifdef _64BIT
 typedef        uint64          uintptr;
 typedef        int64           intptr;
+typedef        int32           intgo; // Go's int
+typedef        uint32          uintgo; // Go's uint
 #else
 typedef        uint32          uintptr;
-typedef int32          intptr;
+typedef        int32           intptr;
+typedef        int32           intgo; // Go's int
+typedef        uint32          uintgo; // Go's uint
 #endif
 
 /*
@@ -139,7 +143,7 @@ union       Note
 struct String
 {
        byte*   str;
-       int32   len;
+       intgo   len;
 };
 struct Iface
 {
@@ -165,8 +169,8 @@ struct Complex128
 struct Slice
 {                              // must not move anything
        byte*   array;          // actual data
-       uint32  len;            // number of elements
-       uint32  cap;            // allocated number of elements
+       uintgo  len;            // number of elements
+       uintgo  cap;            // allocated number of elements
 };
 struct Gobuf
 {
@@ -518,7 +522,8 @@ extern      int32   runtime·gcwaiting;             // gc is waiting to run
 int8*  runtime·goos;
 int32  runtime·ncpu;
 extern bool    runtime·iscgo;
-extern  void (*runtime·sysargs)(int32, uint8**);
+extern         void    (*runtime·sysargs)(int32, uint8**);
+extern uint32  runtime·maxstring;
 
 /*
  * common functions and data
@@ -554,8 +559,8 @@ void        runtime·memmove(void*, void*, uint32);
 void*  runtime·mal(uintptr);
 String runtime·catstring(String, String);
 String runtime·gostring(byte*);
-String  runtime·gostringn(byte*, int32);
-Slice  runtime·gobytes(byte*, int32);
+String  runtime·gostringn(byte*, intgo);
+Slice  runtime·gobytes(byte*, intgo);
 String runtime·gostringnocopy(byte*);
 String runtime·gostringw(uint16*);
 void   runtime·initsig(void);
@@ -603,7 +608,7 @@ uintptr     runtime·ifacehash(Iface);
 uintptr        runtime·efacehash(Eface);
 void*  runtime·malloc(uintptr size);
 void   runtime·free(void *v);
-bool   runtime·addfinalizer(void*, void(*fn)(void*), int32);
+bool   runtime·addfinalizer(void*, void(*fn)(void*), uintptr);
 void   runtime·runpanic(Panic*);
 void*  runtime·getcallersp(void*);
 int32  runtime·mcount(void);
@@ -807,8 +812,6 @@ Hmap*       runtime·makemap_c(MapType*, int64);
 Hchan* runtime·makechan_c(ChanType*, int64);
 void   runtime·chansend(ChanType*, Hchan*, byte*, bool*);
 void   runtime·chanrecv(ChanType*, Hchan*, byte*, bool*, bool*);
-int32  runtime·chanlen(Hchan*);
-int32  runtime·chancap(Hchan*);
 bool   runtime·showframe(Func*);
 
 void   runtime·ifaceE2I(struct InterfaceType*, Eface, Iface*);

diff --git a/src/pkg/runtime/runtime1.goc b/src/pkg/runtime/runtime1.goc
index 667131c1eee1eaed75b08aa63d3f6e639bb5248c..d2c38dfefba263458cff96533e145bb192975ea9 100644 (file)
--- a/src/pkg/runtime/runtime1.goc
+++ b/src/pkg/runtime/runtime1.goc
@@ -5,10 +5,10 @@
 package runtime
 #include "runtime.h"
 
-func GOMAXPROCS(n int32) (ret int32) {
+func GOMAXPROCS(n int) (ret int) {
        ret = runtime·gomaxprocsfunc(n);
 }
 
-func NumCPU() (ret int32) {
+func NumCPU() (ret int) {
        ret = runtime·ncpu;
 }

diff --git a/src/pkg/runtime/slice.c b/src/pkg/runtime/slice.c
index 9cb1ccb78822670a4dcdbeebc3289c3257cc5505..d2cc1684ee9bf69ac25eb0dc08de136d021418d5 100644 (file)
--- a/src/pkg/runtime/slice.c
+++ b/src/pkg/runtime/slice.c
@@ -8,20 +8,21 @@
 #include "typekind.h"
 #include "malloc.h"
 
-static int32   debug   = 0;
+static bool    debug   = 0;
 
-static void    makeslice1(SliceType*, int32, int32, Slice*);
-static void    growslice1(SliceType*, Slice, int32, Slice *);
-       void    runtime·copy(Slice to, Slice fm, uintptr width, int32 ret);
+static void    makeslice1(SliceType*, intgo, intgo, Slice*);
+static void    growslice1(SliceType*, Slice, intgo, Slice *);
+       void    runtime·copy(Slice to, Slice fm, uintptr width, intgo ret);
 
 // see also unsafe·NewArray
 // makeslice(typ *Type, len, cap int64) (ary []any);
 void
 runtime·makeslice(SliceType *t, int64 len, int64 cap, Slice ret)
 {
-       if(len < 0 || (int32)len != len)
+       if(len < 0 || (intgo)len != len)
                runtime·panicstring("makeslice: len out of range");
-       if(cap < len || (int32)cap != cap || t->elem->size > 0 && cap > ((uintptr)-1) / t->elem->size)
+       
+       if(cap < len || (intgo)cap != cap || t->elem->size > 0 && cap > MaxMem / t->elem->size)
                runtime·panicstring("makeslice: cap out of range");
 
        makeslice1(t, len, cap, &ret);
@@ -39,7 +40,7 @@ runtime·makeslice(SliceType *t, int64 len, int64 cap, Slice ret)
 static uintptr zerobase;
 
 static void
-makeslice1(SliceType *t, int32 len, int32 cap, Slice *ret)
+makeslice1(SliceType *t, intgo len, intgo cap, Slice *ret)
 {
        uintptr size;
 
@@ -60,7 +61,7 @@ makeslice1(SliceType *t, int32 len, int32 cap, Slice *ret)
 void
 runtime·appendslice(SliceType *t, Slice x, Slice y, Slice ret)
 {
-       int32 m;
+       intgo m;
        uintptr w;
 
        m = x.len+y.len;
@@ -84,7 +85,7 @@ runtime·appendslice(SliceType *t, Slice x, Slice y, Slice ret)
 void
 runtime·appendstr(SliceType *t, Slice x, String y, Slice ret)
 {
-       int32 m;
+       intgo m;
 
        m = x.len+y.len;
 
@@ -113,7 +114,7 @@ runtime·growslice(SliceType *t, Slice old, int64 n, Slice ret)
 
        cap = old.cap + n;
 
-       if((int32)cap != cap || cap > ((uintptr)-1) / t->elem->size)
+       if((intgo)cap != cap || cap < old.cap || cap > MaxMem / t->elem->size)
                runtime·panicstring("growslice: cap out of range");
 
        growslice1(t, old, cap, &ret);
@@ -129,12 +130,17 @@ runtime·growslice(SliceType *t, Slice old, int64 n, Slice ret)
 }
 
 static void
-growslice1(SliceType *t, Slice x, int32 newcap, Slice *ret)
+growslice1(SliceType *t, Slice x, intgo newcap, Slice *ret)
 {
-       int32 m;
+       intgo m;
 
        m = x.cap;
-       if(m == 0)
+       
+       // Using newcap directly for m+m < newcap handles
+       // both the case where m == 0 and also the case where
+       // m+m/4 wraps around, in which case the loop
+       // below might never terminate.
+       if(m+m < newcap)
                m = newcap;
        else {
                do {
@@ -148,9 +154,9 @@ growslice1(SliceType *t, Slice x, int32 newcap, Slice *ret)
        runtime·memmove(ret->array, x.array, ret->len * t->elem->size);
 }
 
-// copy(to any, fr any, wid uint32) int
+// copy(to any, fr any, wid uintptr) int
 void
-runtime·copy(Slice to, Slice fm, uintptr width, int32 ret)
+runtime·copy(Slice to, Slice fm, uintptr width, intgo ret)
 {
        if(fm.len == 0 || to.len == 0 || width == 0) {
                ret = 0;
@@ -184,7 +190,7 @@ out:
 }
 
 void
-runtime·slicestringcopy(Slice to, String fm, int32 ret)
+runtime·slicestringcopy(Slice to, String fm, intgo ret)
 {
        if(fm.len == 0 || to.len == 0) {
                ret = 0;

diff --git a/src/pkg/runtime/string.goc b/src/pkg/runtime/string.goc
index b72a1aa5e7578edb41760d085f368091de7c3a54..cafcdb6cedcabe2edfaf960cdc35e3b16926582b 100644 (file)
--- a/src/pkg/runtime/string.goc
+++ b/src/pkg/runtime/string.goc
@@ -33,10 +33,10 @@ runtime·findnullw(uint16 *s)
        return l;
 }
 
-uint32 runtime·maxstring = 256;
+uint32 runtime·maxstring = 256; // a hint for print
 
 static String
-gostringsize(int32 l)
+gostringsize(intgo l)
 {
        String s;
        uint32 ms;
@@ -58,7 +58,7 @@ gostringsize(int32 l)
 String
 runtime·gostring(byte *str)
 {
-       int32 l;
+       intgo l;
        String s;
 
        l = runtime·findnull(str);
@@ -68,7 +68,7 @@ runtime·gostring(byte *str)
 }
 
 String
-runtime·gostringn(byte *str, int32 l)
+runtime·gostringn(byte *str, intgo l)
 {
        String s;
 
@@ -78,7 +78,7 @@ runtime·gostringn(byte *str, int32 l)
 }
 
 Slice
-runtime·gobytes(byte *p, int32 n)
+runtime·gobytes(byte *p, intgo n)
 {
        Slice sl;
 
@@ -102,7 +102,7 @@ runtime·gostringnocopy(byte *str)
 String
 runtime·gostringw(uint16 *str)
 {
-       int32 n1, n2, i;
+       intgo n1, n2, i;
        byte buf[8];
        String s;
 
@@ -139,9 +139,9 @@ runtime·catstring(String s1, String s2)
 }
 
 static String
-concatstring(int32 n, String *s)
+concatstring(intgo n, String *s)
 {
-       int32 i, l, count;
+       intgo i, l, count;
        String out;
 
        l = 0;
@@ -172,14 +172,14 @@ concatstring(int32 n, String *s)
 #pragma textflag 7
 // s1 is the first of n strings.
 // the output string follows.
-func concatstring(n int32, s1 String) {
+func concatstring(n int, s1 String) {
        (&s1)[n] = concatstring(n, &s1);
 }
 
 static int32
 cmpstring(String s1, String s2)
 {
-       uint32 i, l;
+       uintgo i, l;
        byte c1, c2;
 
        l = s1.len;
@@ -200,12 +200,12 @@ cmpstring(String s1, String s2)
        return 0;
 }
 
-func cmpstring(s1 String, s2 String) (v int32) {
+func cmpstring(s1 String, s2 String) (v int) {
        v = cmpstring(s1, s2);
 }
 
 func eqstring(s1 String, s2 String) (v bool) {
-       uint32 i, l;
+       uintgo i, l;
 
        if(s1.len != s2.len) {
                v = false;
@@ -227,7 +227,7 @@ func eqstring(s1 String, s2 String) (v bool) {
 int32
 runtime·strcmp(byte *s1, byte *s2)
 {
-       uint32 i;
+       uintptr i;
        byte c1, c2;
 
        for(i=0;; i++) {
@@ -283,7 +283,7 @@ func stringtoslicebyte(s String) (b Slice) {
 }
 
 func slicerunetostring(b Slice) (s String) {
-       int32 siz1, siz2, i;
+       intgo siz1, siz2, i;
        int32 *a;
        byte dum[8];
 
@@ -306,7 +306,7 @@ func slicerunetostring(b Slice) (s String) {
 }
 
 func stringtoslicerune(s String) (b Slice) {
-       int32 n;
+       intgo n;
        int32 dum, *r;
        uint8 *p, *ep;
 
@@ -334,7 +334,7 @@ enum
        Runeself        = 0x80,
 };
 
-func stringiter(s String, k int32) (retk int32) {
+func stringiter(s String, k int) (retk int) {
        int32 l;
 
        if(k >= s.len) {
@@ -355,7 +355,7 @@ func stringiter(s String, k int32) (retk int32) {
 out:
 }
 
-func stringiter2(s String, k int32) (retk int32, retv int32) {
+func stringiter2(s String, k int) (retk int, retv int32) {
        if(k >= s.len) {
                // retk=0 is end of iteration
                retk = 0;

diff --git a/src/pkg/runtime/symtab.c b/src/pkg/runtime/symtab.c
index 97d7a54e3cfe23e80d20b3837eee5556f964f61b..74b00714760bdf740a0002fd699141b28d52626c 100644 (file)
--- a/src/pkg/runtime/symtab.c
+++ b/src/pkg/runtime/symtab.c
@@ -411,7 +411,7 @@ runtime·funcline(Func *f, uintptr targetpc)
 }
 
 void
-runtime·funcline_go(Func *f, uintptr targetpc, String retfile, int32 retline)
+runtime·funcline_go(Func *f, uintptr targetpc, String retfile, intgo retline)
 {
        retfile = f->src;
        retline = runtime·funcline(f, targetpc);