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

src/pkg/runtime/runtime.h

 // 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.
 
 /*
  * basic types
  */
 typedef signed char             int8;
 typedef unsigned char           uint8;
 typedef signed short            int16;
 typedef unsigned short          uint16;
 typedef signed int              int32;
 typedef unsigned int            uint32;
 typedef signed long long int    int64;
 typedef unsigned long long int  uint64;
 typedef float                   float32;
 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
 
 /*
  * get rid of C types
  * the / / / forces a syntax error immediately,
  * which will show "last name: XXunsigned".
  */
 #define unsigned                XXunsigned / / /
 #define signed                  XXsigned / / /
 #define char                    XXchar / / /
@@ skipping 97 matching lines @@
         M*      waitm;  // linked list of waiting M's (sema-based impl)
 };
 union   Note
 {
         uint32  key;    // futex-based impl
         M*      waitm;  // waiting M (sema-based impl)
 };
 struct String
 {
         byte*   str;
-        int32   len;
+        intgo   len;
 };
 struct Iface
 {
         Itab*   tab;
         void*   data;
 };
 struct Eface
 {
         Type*   type;
         void*   data;
 };
 struct Complex64
 {
         float32 real;
         float32 imag;
 };
 struct Complex128
 {
         float64 real;
         float64 imag;
 };
 
 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
 {
         // The offsets of these fields are known to (hard-coded in) libmach.
         uintptr sp;
         byte*   pc;
         G*      g;
 };
 struct  GCStats
 {
@@ skipping 331 matching lines @@
 G*      runtime·allg;
 G*      runtime·lastg;
 M*      runtime·allm;
 extern  int32   runtime·gomaxprocs;
 extern  bool    runtime·singleproc;
 extern  uint32  runtime·panicking;
 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
  */
 int32   runtime·strcmp(byte*, byte*);
 byte*   runtime·strstr(byte*, byte*);
 int32   runtime·findnull(byte*);
 int32   runtime·findnullw(uint16*);
 void    runtime·dump(byte*, int32);
 int32   runtime·runetochar(byte*, int32);
@@ skipping 15 matching lines @@
 void    runtime·throw(int8*);
 void    runtime·panicstring(int8*);
 void    runtime·prints(int8*);
 void    runtime·printf(int8*, ...);
 byte*   runtime·mchr(byte*, byte, byte*);
 int32   runtime·mcmp(byte*, byte*, uint32);
 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);
 void    runtime·sigenable(uint32 sig);
 int32   runtime·gotraceback(void);
 void    runtime·goroutineheader(G*);
 void    runtime·traceback(uint8 *pc, uint8 *sp, uint8 *lr, G* gp);
 void    runtime·tracebackothers(G*);
 int32   runtime·write(int32, void*, int32);
 int32   runtime·mincore(void*, uintptr, byte*);
@@ skipping 27 matching lines @@
 void    runtime·stackfree(void*, uintptr);
 MCache* runtime·allocmcache(void);
 void    runtime·freemcache(MCache*);
 void    runtime·mallocinit(void);
 bool    runtime·ifaceeq_c(Iface, Iface);
 bool    runtime·efaceeq_c(Eface, Eface);
 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);
 int32   runtime·gcount(void);
 void    runtime·mcall(void(*)(G*));
 uint32  runtime·fastrand1(void);
 
 void    runtime·exit(int32);
 void    runtime·breakpoint(void);
 void    runtime·gosched(void);
@@ skipping 183 matching lines @@
 void    runtime·mapassign(MapType*, Hmap*, byte*, byte*);
 void    runtime·mapaccess(MapType*, Hmap*, byte*, byte*, bool*);
 void    runtime·mapiternext(struct hash_iter*);
 bool    runtime·mapiterkey(struct hash_iter*, void*);
 void    runtime·mapiterkeyvalue(struct hash_iter*, void*, void*);
 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*);
 
 uintptr runtime·memlimit(void);
 
 // If appropriate, ask the operating system to control whether this
 // thread should receive profiling signals.  This is only necessary on OS X.
 // An operating system should not deliver a profiling signal to a
 // thread that is not actually executing (what good is that?), but that's
 // what OS X prefers to do.  When profiling is turned on, we mask
 // away the profiling signal when threads go to sleep, so that OS X
 // is forced to deliver the signal to a thread that's actually running.
 // This is a no-op on other systems.
 void    runtime·setprof(bool);
 
 // float.c
 extern float64 runtime·nan;
 extern float64 runtime·posinf;
 extern float64 runtime·neginf;
 extern uint64 ·nan;
 extern uint64 ·posinf;
 extern uint64 ·neginf;
 #define ISNAN(f) ((f) != (f))