code review 35990043: runtime: add support for GOOS=solaris

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 48 matching lines @@
 typedef struct  String          String;
 typedef struct  FuncVal         FuncVal;
 typedef struct  SigTab          SigTab;
 typedef struct  MCache          MCache;
 typedef struct  FixAlloc        FixAlloc;
 typedef struct  Iface           Iface;
 typedef struct  Itab            Itab;
 typedef struct  InterfaceType   InterfaceType;
 typedef struct  Eface           Eface;
 typedef struct  Type            Type;
+typedef struct  PtrType         PtrType;
 typedef struct  ChanType                ChanType;
 typedef struct  MapType         MapType;
 typedef struct  Defer           Defer;
 typedef struct  DeferChunk      DeferChunk;
 typedef struct  Panic           Panic;
 typedef struct  Hmap            Hmap;
 typedef struct  Hchan           Hchan;
 typedef struct  Complex64       Complex64;
 typedef struct  Complex128      Complex128;
 typedef struct  LibCall         LibCall;
@@ skipping 157 matching lines @@
 {
         void*   prev;
         void*   handler;
 };
 // describes how to handle callback
 struct  WinCallbackContext
 {
         void*   gobody;         // Go function to call
         uintptr argsize;        // callback arguments size (in bytes)
         uintptr restorestack;   // adjust stack on return by (in bytes) (386 only)
+        bool    cleanstack;
 };
 
 struct  G
 {
         // stackguard0 can be set to StackPreempt as opposed to stackguard
         uintptr stackguard0;    // cannot move - also known to linker, libmach, runtime/cgo
         uintptr stackbase;      // cannot move - also known to libmach, runtime/cgo
         uint32  panicwrap;      // cannot move - also known to linker
         uint32  selgen;         // valid sudog pointer
         Defer*  defer;
         Panic*  panic;
         Gobuf   sched;
         uintptr syscallstack;   // if status==Gsyscall, syscallstack = stackbase to use during gc
         uintptr syscallsp;      // if status==Gsyscall, syscallsp = sched.sp to use during gc
         uintptr syscallpc;      // if status==Gsyscall, syscallpc = sched.pc to use during gc
         uintptr syscallguard;   // if status==Gsyscall, syscallguard = stackguard to use during gc
         uintptr stackguard;     // same as stackguard0, but not set to StackPreempt
         uintptr stack0;
         uintptr stacksize;
         G*      alllink;        // on allg
         void*   param;          // passed parameter on wakeup
         int16   status;
         int64   goid;
+        int64   waitsince;      // approx time when the G become blocked
         int8*   waitreason;     // if status==Gwaiting
         G*      schedlink;
         bool    ispanic;
         bool    issystem;       // do not output in stack dump
         bool    isbackground;   // ignore in deadlock detector
         bool    preempt;        // preemption signal, duplicates stackguard0 = StackPreempt
         int8    raceignore;     // ignore race detection events
         M*      m;              // for debuggers, but offset not hard-coded
         M*      lockedm;
         int32   sig;
@@ skipping 62 matching lines @@
         bool    racecall;
         bool    needextram;
         void    (*waitunlockf)(Lock*);
         void*   waitlock;
 
         uintptr settype_buf[1024];
         uintptr settype_bufsize;
 
 #ifdef GOOS_windows
         void*   thread;         // thread handle
-        LibCall libcall;        // put here to avoid large runtime·stdcall stack
+        // these are here because they are too large to be on the stack
+        // of low-level NOSPLIT functions.
+        LibCall libcall;
 #endif
 #ifdef GOOS_solaris
-        void*   perrno;         // pointer to TLS errno
-        // there are here because they are too large to be on the stack
+        int32*  perrno;         // pointer to TLS errno
+        // these are here because they are too large to be on the stack
         // of low-level NOSPLIT functions.
         LibCall libcall;
         struct {
                 int64   tv_sec;
                 int64   tv_nsec;
         } ts;
         struct {
                 uintptr v[6];
         } scratch;
 #endif
@@ skipping 11 matching lines @@
 
         int32   id;
         uint32  status;         // one of Pidle/Prunning/...
         P*      link;
         uint32  schedtick;      // incremented on every scheduler call
         uint32  syscalltick;    // incremented on every system call
         M*      m;              // back-link to associated M (nil if idle)
         MCache* mcache;
 
         // Queue of runnable goroutines.
-        G**     runq;
-        int32   runqhead;
-        int32   runqtail;
-        int32   runqsize;
+        uint32  runqhead;
+        uint32  runqtail;
+        G*      runq[256];
 
         // Available G's (status == Gdead)
         G*      gfree;
         int32   gfreecnt;
 
         byte    pad[64];
 };
 
 // The m->locked word holds two pieces of state counting active calls to LockOSThread/lockOSThread.
 // The low bit (LockExternal) is a boolean reporting whether any LockOSThread call is active.
@@ skipping 72 matching lines @@
 enum {
    Windows = 1
 };
 #else
 enum {
    Windows = 0
 };
 #endif
 #ifdef GOOS_solaris
 enum {
-   Sunos = 1
+   Solaris = 1
 };
 #else
 enum {
-   Sunos = 0
+   Solaris = 0
 };
 #endif
 
 struct  Timers
 {
         Lock;
         G       *timerproc;
         bool            sleeping;
         bool            rescheduling;
         Note    waitnote;
@@ skipping 326 matching lines @@
 int32   runtime·funcline(Func*, uintptr, String*);
 int32   runtime·funcarglen(Func*, uintptr);
 int32   runtime·funcspdelta(Func*, uintptr);
 int8*   runtime·funcname(Func*);
 int32   runtime·pcdatavalue(Func*, int32, uintptr);
 void*   runtime·stackalloc(uint32);
 void    runtime·stackfree(void*, uintptr);
 MCache* runtime·allocmcache(void);
 void    runtime·freemcache(MCache*);
 void    runtime·mallocinit(void);
-void    runtime·mprofinit(void);
 bool    runtime·ifaceeq_c(Iface, Iface);
 bool    runtime·efaceeq_c(Eface, Eface);
 uintptr runtime·ifacehash(Iface, uintptr);
 uintptr runtime·efacehash(Eface, uintptr);
 void*   runtime·malloc(uintptr size);
 void    runtime·free(void *v);
 void    runtime·runpanic(Panic*);
 uintptr runtime·getcallersp(void*);
 int32   runtime·mcount(void);
 int32   runtime·gcount(void);
@@ skipping 34 matching lines @@
 void    runtime·blockevent(int64, int32);
 extern int64 runtime·blockprofilerate;
 void    runtime·addtimer(Timer*);
 bool    runtime·deltimer(Timer*);
 G*      runtime·netpoll(bool);
 void    runtime·netpollinit(void);
 int32   runtime·netpollopen(uintptr, PollDesc*);
 int32   runtime·netpollclose(uintptr);
 void    runtime·netpollready(G**, PollDesc*, int32);
 uintptr runtime·netpollfd(PollDesc*);
+void    runtime·netpollarmread(uintptr fd);
+void    runtime·netpollarmwrite(uintptr fd);
 void    runtime·crash(void);
 void    runtime·parsedebugvars(void);
 void    _rt0_go(void);
 void*   runtime·funcdata(Func*, int32);
 
 #pragma varargck        argpos  runtime·printf  1
 #pragma varargck        type    "c"     int32
 #pragma varargck        type    "d"     int32
 #pragma varargck        type    "d"     uint32
 #pragma varargck        type    "D"     int64
@@ skipping 178 matching lines @@
 extern float64 runtime·neginf;
 extern uint64 ·nan;
 extern uint64 ·posinf;
 extern uint64 ·neginf;
 #define ISNAN(f) ((f) != (f))
 
 enum
 {
         UseSpanType = 1,
 };