code review 3759042: runtime: windows/amd64 port

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;
@@ skipping 85 matching lines @@
         // If you add to this list, add to the list
         // of "okay during garbage collection" status
         // in mgc0.c too.
         Gidle,
         Grunnable,
         Grunning,
         Gsyscall,
         Gwaiting,
         Gmoribund,
         Gdead,
-        Grecovery,
 };
 enum
 {
         true    = 1,
         false   = 0,
 };
 
 /*
  * structures
  */
@@ skipping 60 matching lines @@
         byte*   pc;
         G*      g;
 };
 struct  G
 {
         byte*   stackguard;     // cannot move - also known to linker, libmach, libcgo
         byte*   stackbase;      // cannot move - also known to libmach, libcgo
         Defer*  defer;
         Panic*  panic;
         Gobuf   sched;
+        byte*   gcstack;                // if status==Gsyscall, gcstack = stackbase to use during gc
+        byte*   gcsp;           // if status==Gsyscall, gcsp = sched.sp to use during gc
+        byte*   gcguard;                // if status==Gsyscall, gcguard = stackguard to use during gc
         byte*   stack0;
         byte*   entry;          // initial function
         G*      alllink;        // on allg
         void*   param;          // passed parameter on wakeup
         int16   status;
         int32   goid;
         uint32  selgen;         // valid sudog pointer
         G*      schedlink;
         bool    readyonstop;
         bool    ispanic;
         M*      m;              // for debuggers, but offset not hard-coded
         M*      lockedm;
+        M*      idlem;
         int32   sig;
         uintptr sigcode0;
         uintptr sigcode1;
         uintptr sigpc;
+        uintptr gopc;   // pc of go statement that created this goroutine
 };
 struct  M
 {
         // The offsets of these fields are known to (hard-coded in) libmach.
         G*      g0;             // goroutine with scheduling stack
         void    (*morepc)(void);
         void*   moreargp;       // argument pointer for more stack
         Gobuf   morebuf;        // gobuf arg to morestack
 
         // Fields not known to debuggers.
         uint32  moreframesize;  // size arguments to morestack
         uint32  moreargsize;
         uintptr cret;           // return value from C
         uint64  procid;         // for debuggers, but offset not hard-coded
         G*      gsignal;        // signal-handling G
         uint32  tls[8];         // thread-local storage (for 386 extern register)
-        Gobuf   sched;  // scheduling stack
         G*      curg;           // current running goroutine
         int32   id;
         int32   mallocing;
         int32   gcing;
         int32   locks;
         int32   nomemprof;
         int32   waitnextg;
+        int32   dying;
+        int32   profilehz;
         Note    havenextg;
         G*      nextg;
         M*      alllink;        // on allm
         M*      schedlink;
         uint32  machport;       // Return address for Mach IPC (OS X)
         MCache  *mcache;
         G*      lockedg;
+        G*      idleg;
         uint32  freglo[16];     // D[i] lsb and F[i]
         uint32  freghi[16];     // D[i] msb and F[i+16]
         uint32  fflag;          // floating point compare flags
 #ifdef __WINDOWS__
         void*   sehframe;
 
 #ifdef _64BIT···
         void*   gostack;

[brainman, 2011/06/29 07:37:19]

I'm sure we could do without it. But let's leave it for now.

 #endif
 
 #endif
 };
+
 struct  Stktop
 {
         // The offsets of these fields are known to (hard-coded in) libmach.
         uint8*  stackguard;
         uint8*  stackbase;
         Gobuf   gobuf;
         uint32  argsize;
 
         uint8*  argp;   // pointer to arguments in old frame
         uintptr free;   // if free>0, call stackfree using free as size
@@ skipping 41 matching lines @@
    Windows = 1
 };
 #else
 enum {
    Windows = 0
 };
 #endif
 
 /*
  * defined macros
- *    you need super-goru privilege
+ *    you need super-gopher-guru privilege
  *    to add this list.
  */
 #define nelem(x)        (sizeof(x)/sizeof((x)[0]))
 #define nil             ((void*)0)
 #define offsetof(s,m)   (uint32)(&(((s*)0)->m))
 
 /*
  * known to compiler
  */
 enum
@@ skipping 38 matching lines @@
 
 /*
  * external data
  */
 extern  Alg     runtime·algarray[Amax];
 extern  String  runtime·emptystring;
 G*      runtime·allg;
 M*      runtime·allm;
 int32   runtime·goidgen;
 extern  int32   runtime·gomaxprocs;
-extern  int32   runtime·panicking;
+extern  uint32  runtime·panicking;
 extern  int32   runtime·gcwaiting;              // gc is waiting to run
 int8*   runtime·goos;
 extern  bool    runtime·iscgo;
 
 /*
  * common functions and data
  */
 int32   runtime·strcmp(byte*, byte*);
 int32   runtime·findnull(byte*);
 int32   runtime·findnullw(uint16*);
 void    runtime·dump(byte*, int32);
 int32   runtime·runetochar(byte*, int32);
 int32   runtime·charntorune(int32*, uint8*, int32);
 
 /*
  * very low level c-called
  */
 #define FLUSH(x)        USED(x)
 
 void    runtime·gogo(Gobuf*, uintptr);
 void    runtime·gogocall(Gobuf*, void(*)(void));
-uintptr runtime·gosave(Gobuf*);
+void    runtime·gosave(Gobuf*);
 void    runtime·lessstack(void);
 void    runtime·goargs(void);
 void    runtime·goenvs(void);
 void    runtime·goenvs_unix(void);
 void*   runtime·getu(void);
 void    runtime·throw(int8*);
 void    runtime·panicstring(int8*);
 uint32  runtime·rnd(uint32, uint32);
 void    runtime·prints(int8*);
 void    runtime·printf(int8*, ...);
 byte*   runtime·mchr(byte*, byte, byte*);
 void    runtime·mcpy(byte*, byte*, uint32);
 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);
 String  runtime·gostringnocopy(byte*);
 String  runtime·gostringw(uint16*);
 void    runtime·initsig(int32);
 int32   runtime·gotraceback(void);
 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*);
 bool    runtime·cas(uint32*, uint32, uint32);
 bool    runtime·casp(void**, void*, void*);
 uint32  runtime·xadd(uint32 volatile*, int32);
 void    runtime·jmpdefer(byte*, void*);
 void    runtime·exit1(int32);
 void    runtime·ready(G*);
 byte*   runtime·getenv(int8*);
 int32   runtime·atoi(byte*);
 void    runtime·newosproc(M *m, G *g, void *stk, void (*fn)(void));
 void    runtime·signalstack(byte*, int32);
@@ skipping 11 matching lines @@
 uintptr runtime·efacehash(Eface);
 uintptr runtime·nohash(uint32, void*);
 uint32  runtime·noequal(uint32, void*, void*);
 void*   runtime·malloc(uintptr size);
 void    runtime·free(void *v);
 void    runtime·addfinalizer(void*, void(*fn)(void*), int32);
 void    runtime·walkfintab(void (*fn)(void*));
 void    runtime·runpanic(Panic*);
 void*   runtime·getcallersp(void*);
 int32   runtime·mcount(void);
+void    runtime·mcall(void(*)(G*));
 
 void    runtime·exit(int32);
 void    runtime·breakpoint(void);
 void    runtime·gosched(void);
 void    runtime·goexit(void);
-void    runtime·runcgo(void (*fn)(void*), void*);
-void    runtime·runcgocallback(G*, void*, void (*fn)());
+void    runtime·asmcgocall(void (*fn)(void*), void*);
 void    runtime·entersyscall(void);
 void    runtime·exitsyscall(void);
-void    runtime·startcgocallback(G*);
-void    runtime·endcgocallback(G*);
-G*      runtime·newproc1(byte*, byte*, int32, int32);
+G*      runtime·newproc1(byte*, byte*, int32, int32, void*);
 void    runtime·siginit(void);
 bool    runtime·sigsend(int32 sig);
 void    runtime·gettime(int64*, int32*);
 int32   runtime·callers(int32, uintptr*, int32);
+int32   runtime·gentraceback(byte*, byte*, byte*, G*, int32, uintptr*, int32);
 int64   runtime·nanotime(void);
 void    runtime·dopanic(int32);
+void    runtime·startpanic(void);
+void    runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp);
+void    runtime·resetcpuprofiler(int32);
+void    runtime·setcpuprofilerate(void(*)(uintptr*, int32), int32);
 
 #pragma varargck        argpos  runtime·printf  1
 #pragma varargck        type    "d"     int32
 #pragma varargck        type    "d"     uint32
 #pragma varargck        type    "D"     int64
 #pragma varargck        type    "D"     uint64
 #pragma varargck        type    "x"     int32
 #pragma varargck        type    "x"     uint32
 #pragma varargck        type    "X"     int64
 #pragma varargck        type    "X"     uint64
@@ skipping 99 matching lines @@
 bool    runtime·isNaN(float64 f);
 float64 runtime·ldexp(float64 d, int32 e);
 float64 runtime·modf(float64 d, float64 *ip);
 void    runtime·semacquire(uint32*);
 void    runtime·semrelease(uint32*);
 String  runtime·signame(int32 sig);
 int32   runtime·gomaxprocsfunc(int32 n);
 
 void    runtime·mapassign(Hmap*, byte*, byte*);
 void    runtime·mapaccess(Hmap*, byte*, byte*, bool*);
-struct hash_iter*       runtime·newmapiterinit(Hmap*);
 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(Type*, Type*, int64);
 
 Hchan*  runtime·makechan_c(Type*, int64);
 void    runtime·chansend(Hchan*, void*, bool*);
 void    runtime·chanrecv(Hchan*, void*, bool*, bool*);
-void    runtime·chanclose(Hchan*);
-bool    runtime·chanclosed(Hchan*);
 int32   runtime·chanlen(Hchan*);
 int32   runtime·chancap(Hchan*);
 
 void    runtime·ifaceE2I(struct InterfaceType*, Eface, Iface*);
 
-/*
- * Stack layout parameters.
- * Known to linkers.
- *
- * The per-goroutine g->stackguard is set to point
- * StackGuard bytes above the bottom of the stack.
- * Each function compares its stack pointer against
- * g->stackguard to check for overflow.  To cut one
- * instruction from the check sequence for functions
- * with tiny frames, the stack is allowed to protrude
- * StackSmall bytes below the stack guard.  Functions
- * with large frames don't bother with the check and
- * always call morestack.  The sequences are
- * (for amd64, others are similar):
- *
- *      guard = g->stackguard
- *      frame = function's stack frame size
- *      argsize = size of function arguments (call + return)
- *
- *      stack frame size <= StackSmall:
- *              CMPQ guard, SP
- *              JHI 3(PC)
- *              MOVQ m->morearg, $(argsize << 32)
- *              CALL morestack(SB)
- *
- *      stack frame size > StackSmall but < StackBig
- *              LEAQ (frame-StackSmall)(SP), R0
- *              CMPQ guard, R0
- *              JHI 3(PC)
- *              MOVQ m->morearg, $(argsize << 32)
- *              CALL morestack(SB)
- *
- *      stack frame size >= StackBig:
- *              MOVQ m->morearg, $((argsize << 32) | frame)
- *              CALL morestack(SB)
- *
- * The bottom StackGuard - StackSmall bytes are important:
- * there has to be enough room to execute functions that
- * refuse to check for stack overflow, either because they
- * need to be adjacent to the actual caller's frame (deferproc)
- * or because they handle the imminent stack overflow (morestack).
- *
- * For example, deferproc might call malloc, which does one
- * of the above checks (without allocating a full frame),
- * which might trigger a call to morestack.  This sequence
- * needs to fit in the bottom section of the stack.  On amd64,
- * morestack's frame is 40 bytes, and deferproc's frame is 56 bytes.
- * That fits well within the StackGuard - StackSmall = 128 bytes
- * at the bottom.  There may be other sequences lurking or yet to
- * be written that require more stack.  Morestack checks to make
- * sure the stack has not completely overflowed and should catch
- * such sequences.
- */
-enum
-{
-#ifdef __WINDOWS__
-        // need enough room in guard area for exception handler.
-        // use larger stacks to compensate for larger stack guard.
-        StackSmall = 256,
-        StackGuard = 2048,
-        StackBig   = 8192,
-        StackExtra = StackGuard,
-#else
-        // byte offset of stack guard (g->stackguard) above bottom of stack.
-        StackGuard = 256,
-
-        // checked frames are allowed to protrude below the guard by
-        // this many bytes.  this saves an instruction in the checking
-        // sequence when the stack frame is tiny.
-        StackSmall = 128,
-
-        // extra space in the frame (beyond the function for which
-        // the frame is allocated) is assumed not to be much bigger
-        // than this amount.  it may not be used efficiently if it is.
-        StackBig = 4096,
-
-        // extra room over frame size when allocating a stack.
-        StackExtra = 1024,
-#endif
-};