[dev.power64] code review 152570049: all: merge default into dev.power64

src/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 42 matching lines @@
  */
 typedef uint8                   bool;
 typedef uint8                   byte;
 typedef struct  Func            Func;
 typedef struct  G               G;
 typedef struct  Gobuf           Gobuf;
 typedef struct  SudoG           SudoG;
 typedef struct  Mutex           Mutex;
 typedef struct  M               M;
 typedef struct  P               P;
+typedef struct  SchedT  SchedT;
 typedef struct  Note            Note;
 typedef struct  Slice           Slice;
-typedef struct  Stktop          Stktop;
 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  ChanType        ChanType;
 typedef struct  MapType         MapType;
 typedef struct  Defer           Defer;
 typedef struct  Panic           Panic;
 typedef struct  Hmap            Hmap;
-typedef struct  Hiter                   Hiter;
+typedef struct  Hiter           Hiter;
 typedef struct  Hchan           Hchan;
 typedef struct  Complex64       Complex64;
 typedef struct  Complex128      Complex128;
 typedef struct  LibCall         LibCall;
 typedef struct  WinCallbackContext      WinCallbackContext;
 typedef struct  GCStats         GCStats;
 typedef struct  LFNode          LFNode;
 typedef struct  ParFor          ParFor;
 typedef struct  ParForThread    ParForThread;
 typedef struct  CgoMal          CgoMal;
 typedef struct  PollDesc        PollDesc;
 typedef struct  DebugVars       DebugVars;
-typedef struct  ForceGCState    ForceGCState;
+typedef struct  ForceGCState    ForceGCState;
+typedef struct  Stack           Stack;
 
 /*
  * Per-CPU declaration.
  *
  * "extern register" is a special storage class implemented by 6c, 8c, etc.
  * On the ARM, it is an actual register; elsewhere it is a slot in thread-
  * local storage indexed by a pseudo-register TLS. See zasmhdr in
  * src/cmd/dist/buildruntime.c for details, and be aware that the linker may
  * make further OS-specific changes to the compiler's output. For example,
  * 6l/linux rewrites 0(TLS) as -8(FS).
@@ skipping 135 matching lines @@
         // because it is casted to uint64[].
         uint64  nhandoff;
         uint64  nhandoffcnt;
         uint64  nprocyield;
         uint64  nosyield;
         uint64  nsleep;
 };
 
 struct  LibCall
 {
-        void*   fn;
+        uintptr fn;
         uintptr n;      // number of parameters
-        void*   args;   // parameters
+        uintptr args;   // parameters
         uintptr r1;     // return values
         uintptr r2;
         uintptr err;    // error number
 };
 
 // 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;
 };
 
+// Stack describes a Go execution stack.
+// The bounds of the stack are exactly [lo, hi),
+// with no implicit data structures on either side.
+struct  Stack
+{
+        uintptr lo;
+        uintptr hi;
+};
+
 struct  G
 {
-        // stackguard0 can be set to StackPreempt as opposed to stackguard
-        uintptr stackguard0;    // cannot move - also known to liblink, libmach, runtime/cgo
-        uintptr stackbase;      // cannot move - also known to libmach, runtime/cgo
-        Panic*  panic;  // cannot move - also known to liblink
-        Defer*  defer;
+        // Stack parameters.
+        // stack describes the actual stack memory: [stack.lo, stack.hi).
+        // stackguard0 is the stack pointer compared in the Go stack growth prologue.
+        // It is stack.lo+StackGuard normally, but can be StackPreempt to trigger a preemption.
+        // stackguard1 is the stack pointer compared in the C stack growth prologue.
+        // It is stack.lo+StackGuard on g0 and gsignal stacks.
+        // It is ~0 on other goroutine stacks, to trigger a call to morestackc (and crash).
+        Stack   stack;  // offset known to runtime/cgo
+        uintptr stackguard0;    // offset known to liblink
+        uintptr stackguard1;    // offset known to liblink
+
+        Panic*  panic;  // innermost panic - offset known to liblink
+        Defer*  defer;  // innermost defer
         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;
         void*   param;          // passed parameter on wakeup
         uint32  atomicstatus;
         int64   goid;
         int64   waitsince;      // approx time when the G become blocked
         String  waitreason;     // if status==Gwaiting
         G*      schedlink;
         bool    issystem;       // do not output in stack dump, ignore in deadlock detector
         bool    preempt;        // preemption signal, duplicates stackguard0 = StackPreempt
         bool    paniconfault;   // panic (instead of crash) on unexpected fault address
-        bool    preemptscan;    // preempted g does scan for GC
-        bool    gcworkdone;     // debug: cleared at begining of gc work phase cycle, set by gcphasework, tested at end of cycle
+        bool    preemptscan;    // preempted g does scan for GC
+        bool    gcworkdone;     // debug: cleared at begining of gc work phase cycle, set by gcphasework, tested at end of cycle
         bool    throwsplit; // must not split stack
         int8    raceignore;     // ignore race detection events
         M*      m;              // for debuggers, but offset not hard-coded
         M*      lockedm;
         int32   sig;
-        int32   writenbuf;
         Slice   writebuf;
         uintptr sigcode0;
         uintptr sigcode1;
         uintptr sigpc;
         uintptr gopc;           // pc of go statement that created this goroutine
         uintptr racectx;
-        SudoG   *waiting;       // sudog structures this G is waiting on (that have a valid elem ptr)
+        SudoG*  waiting;        // sudog structures this G is waiting on (that have a valid elem ptr)
         uintptr end[];
 };
 
 struct  M
 {
         G*      g0;             // goroutine with scheduling stack
-        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;    // known by amd64 asm to follow moreframesize
-        uintreg cret;           // return value from C
         uint64  procid;         // for debuggers, but offset not hard-coded
         G*      gsignal;        // signal-handling G
         uintptr tls[4];         // thread-local storage (for x86 extern register)
         void    (*mstartfn)(void);
         G*      curg;           // current running goroutine
         G*      caughtsig;      // goroutine running during fatal signal
         P*      p;              // attached P for executing Go code (nil if not executing Go code)
         P*      nextp;
         int32   id;
         int32   mallocing;
@@ skipping 23 matching lines @@
         uint32  locked;         // tracking for LockOSThread
         M*      nextwaitm;      // next M waiting for lock
         uintptr waitsema;       // semaphore for parking on locks
         uint32  waitsemacount;
         uint32  waitsemalock;
         GCStats gcstats;
         bool    needextram;
         uint8   traceback;
         bool    (*waitunlockf)(G*, void*);
         void*   waitlock;
-        uintptr forkstackguard;
         uintptr scalararg[4];   // scalar argument/return for mcall
         void*   ptrarg[4];      // pointer argument/return for mcall
 #ifdef GOOS_windows
-        void*   thread;         // thread handle
+        uintptr thread;         // thread handle
         // these are here because they are too large to be on the stack
         // of low-level NOSPLIT functions.
         LibCall libcall;
         uintptr libcallpc;      // for cpu profiler
         uintptr libcallsp;
         G*      libcallg;
 #endif
 #ifdef GOOS_solaris
         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 {
+        struct MTs {
                 int64   tv_sec;
                 int64   tv_nsec;
         } ts;
-        struct {
+        struct MScratch {
                 uintptr v[6];
         } scratch;
 #endif
 #ifdef GOOS_plan9
         int8*   notesig;
         byte*   errstr;
 #endif
         uintptr end[];
 };
 
@@ skipping 25 matching lines @@
 
         byte    pad[64];
 };
 
 enum {
         // The max value of GOMAXPROCS.
         // There are no fundamental restrictions on the value.
         MaxGomaxprocs = 1<<8,
 };
 
+struct  SchedT
+{
+        Mutex   lock;
+
+        uint64  goidgen;
+
+        M*      midle;   // idle m's waiting for work
+        int32   nmidle;  // number of idle m's waiting for work
+        int32   nmidlelocked; // number of locked m's waiting for work
+        int32   mcount;  // number of m's that have been created
+        int32   maxmcount;      // maximum number of m's allowed (or die)
+
+        P*      pidle;  // idle P's
+        uint32  npidle;
+        uint32  nmspinning;
+
+        // Global runnable queue.
+        G*      runqhead;
+        G*      runqtail;
+        int32   runqsize;
+
+        // Global cache of dead G's.
+        Mutex   gflock;
+        G*      gfree;
+        int32   ngfree;
+
+        uint32  gcwaiting;      // gc is waiting to run
+        int32   stopwait;
+        Note    stopnote;
+        uint32  sysmonwait;
+        Note    sysmonnote;
+        uint64  lastpoll;
+
+        int32   profilehz;      // cpu profiling rate
+};
+
 // 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.
 // External locks are not recursive; a second lock is silently ignored.
 // The upper bits of m->lockedcount record the nesting depth of calls to lockOSThread
 // (counting up by LockInternal), popped by unlockOSThread (counting down by LockInternal).
 // Internal locks can be recursive. For instance, a lock for cgo can occur while the main
 // goroutine is holding the lock during the initialization phase.
 enum
 {
         LockExternal = 1,
         LockInternal = 2,
 };
 
-struct  Stktop
-{
-        // The offsets of these fields are known to (hard-coded in) libmach.
-        uintptr stackguard;
-        uintptr stackbase;
-        Gobuf   gobuf;
-        uint32  argsize;
-
-        uint8*  argp;   // pointer to arguments in old frame
-};
 struct  SigTab
 {
         int32   flags;
         int8    *name;
 };
 enum
 {
         SigNotify = 1<<0,       // let signal.Notify have signal, even if from kernel
         SigKill = 1<<1,         // if signal.Notify doesn't take it, exit quietly
         SigThrow = 1<<2,        // if signal.Notify doesn't take it, exit loudly
@@ skipping 54 matching lines @@
    Windows = 0
 };
 #endif
 #ifdef GOOS_solaris
 enum {
    Solaris = 1
 };
 #else
 enum {
    Solaris = 0
+};
+#endif
+#ifdef GOOS_plan9
+enum {
+   Plan9 = 1
+};
+#else
+enum {
+   Plan9 = 0
 };
 #endif
 
 // Lock-free stack node.
 struct LFNode
 {
         LFNode  *next;
         uintptr pushcnt;
 };
 
@@ skipping 50 matching lines @@
 };
 
 struct ForceGCState
 {
         Mutex   lock;
         G*      g;
         uint32  idle;
 };
 
 extern uint32 runtime·gcphase;
-extern bool runtime·precisestack;
-extern bool runtime·copystack;
 
 /*
  * defined macros
  *    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))
 #define ROUND(x, n)     (((x)+(n)-1)&~(uintptr)((n)-1)) /* all-caps to mark as macro: it evaluates n twice */
@@ skipping 19 matching lines @@
 bool    runtime·stopg(G*);
 void    runtime·restartg(G*);
 void    runtime·gcphasework(G*);
 
 /*
  * deferred subroutine calls
  */
 struct Defer
 {
         int32   siz;
-        bool    special;        // not part of defer frame
+        bool    started;
         uintptr argp;           // where args were copied from
         uintptr pc;
         FuncVal*        fn;
+        Panic*  panic;  // panic that is running defer
         Defer*  link;
-        void*   args[1];        // padded to actual size
 };
 
 // argp used in Defer structs when there is no argp.
 #define NoArgs ((uintptr)-1)
 
 /*
  * panics
  */
 struct Panic
 {
-        uintptr argp;   // pointer to arguments of deferred call run during panic; cannot move - known to liblink
+        void*   argp;   // pointer to arguments of deferred call run during panic; cannot move - known to liblink
         Eface   arg;            // argument to panic
         Panic*  link;           // link to earlier panic
-        Defer*  defer;          // current executing defer
         bool    recovered;      // whether this panic is over
         bool    aborted;        // the panic was aborted
 };
 
 /*
  * stack traces
  */
 typedef struct Stkframe Stkframe;
+typedef struct BitVector BitVector;
 struct Stkframe
 {
         Func*   fn;     // function being run
         uintptr pc;     // program counter within fn
         uintptr continpc;       // program counter where execution can continue, or 0 if not
         uintptr lr;     // program counter at caller aka link register
         uintptr sp;     // stack pointer at pc
         uintptr fp;     // stack pointer at caller aka frame pointer
         uintptr varp;   // top of local variables
         uintptr argp;   // pointer to function arguments
         uintptr arglen; // number of bytes at argp
+        BitVector*      argmap; // force use of this argmap
 };
 
 intgo   runtime·gentraceback(uintptr, uintptr, uintptr, G*, intgo, uintptr*, intgo, bool(**)(Stkframe*, void*), void*, bool);
+void    runtime·tracebackdefers(G*, bool(**)(Stkframe*, void*), void*);
 void    runtime·traceback(uintptr pc, uintptr sp, uintptr lr, G* gp);
 void    runtime·tracebackothers(G*);
 bool    runtime·haszeroargs(uintptr pc);
 bool    runtime·topofstack(Func*);
 enum
 {
         // The maximum number of frames we print for a traceback
         TracebackMaxFrames = 100,
 };
 
 /*
  * external data
  */
 extern  String  runtime·emptystring;
-extern  uintptr runtime·zerobase;
 extern  G**     runtime·allg;
 extern  Slice   runtime·allgs; // []*G
 extern  uintptr runtime·allglen;
 extern  G*      runtime·lastg;
 extern  M*      runtime·allm;
 extern  P*      runtime·allp[MaxGomaxprocs+1];
 extern  int32   runtime·gomaxprocs;
 extern  uint32  runtime·needextram;
 extern  uint32  runtime·panicking;
 extern  int8*   runtime·goos;
 extern  int32   runtime·ncpu;
 extern  bool    runtime·iscgo;
 extern  void    (*runtime·sysargs)(int32, uint8**);
 extern  uintptr runtime·maxstring;
 extern  uint32  runtime·cpuid_ecx;
 extern  uint32  runtime·cpuid_edx;
 extern  DebugVars       runtime·debug;
 extern  uintptr runtime·maxstacksize;
 extern  Note    runtime·signote;
 extern  ForceGCState    runtime·forcegc;
+extern  SchedT  runtime·sched;
+extern  int32           runtime·newprocs;
 
 /*
  * common functions and data
  */
 int32   runtime·strcmp(byte*, byte*);
 int32   runtime·strncmp(byte*, byte*, uintptr);
 byte*   runtime·strstr(byte*, byte*);
 intgo   runtime·findnull(byte*);
 intgo   runtime·findnullw(uint16*);
 void    runtime·dump(byte*, int32);
@@ skipping 24 matching lines @@
  * GoOutput is a type with the same alignment requirements as the
  * initial output argument from a Go function. Only for use in cases
  * where using goc2c is not possible. See comment on FLUSH above.
  */
 typedef uint64 GoOutput;
 
 void    runtime·gogo(Gobuf*);
 void    runtime·gostartcall(Gobuf*, void(*)(void), void*);
 void    runtime·gostartcallfn(Gobuf*, FuncVal*);
 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*);
 bool    runtime·canpanic(G*);
 void    runtime·prints(int8*);
 void    runtime·printf(int8*, ...);
 void    runtime·snprintf(byte*, int32, int8*, ...);
 byte*   runtime·mchr(byte*, byte, byte*);
 int32   runtime·mcmp(byte*, byte*, uintptr);
 void    runtime·memmove(void*, void*, uintptr);
 String  runtime·catstring(String, String);
 String  runtime·gostring(byte*);
+Slice   runtime·makeStringSlice(intgo);
 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);
 void    runtime·sigdisable(uint32 sig);
 int32   runtime·gotraceback(bool *crash);
 void    runtime·goroutineheader(G*);
 int32   runtime·open(int8*, int32, int32);
 int32   runtime·read(int32, void*, int32);
 int32   runtime·write(uintptr, void*, int32); // use uintptr to accommodate windows.
 int32   runtime·close(int32);
 int32   runtime·mincore(void*, uintptr, byte*);
 void    runtime·jmpdefer(FuncVal*, uintptr);
 void    runtime·exit1(int32);
 void    runtime·ready(G*);
 byte*   runtime·getenv(int8*);
 int32   runtime·atoi(byte*);
 void    runtime·newosproc(M *mp, void *stk);
 void    runtime·mstart(void);
 G*      runtime·malg(int32);
 void    runtime·asminit(void);
 void    runtime·mpreinit(M*);
 void    runtime·minit(void);
 void    runtime·unminit(void);
 void    runtime·signalstack(byte*, int32);
+void    runtime·tracebackinit(void);
 void    runtime·symtabinit(void);
 Func*   runtime·findfunc(uintptr);
 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·stackinit(void);
-void*   runtime·stackalloc(G*, uint32);
-void    runtime·stackfree(G*, void*, Stktop*);
+Stack   runtime·stackalloc(uint32);
+void    runtime·stackfree(Stack);
 void    runtime·shrinkstack(G*);
+void    runtime·shrinkfinish(void);
 MCache* runtime·allocmcache(void);
 void    runtime·freemcache(MCache*);
 void    runtime·mallocinit(void);
 void    runtime·gcinit(void);
 void*   runtime·mallocgc(uintptr size, Type* typ, uint32 flag);
 void    runtime·runpanic(Panic*);
 uintptr runtime·getcallersp(void*);
 int32   runtime·mcount(void);
 int32   runtime·gcount(void);
 void    runtime·mcall(void(**)(G*));
 void    runtime·onM(void(**)(void));
+void    runtime·onMsignal(void(**)(void));
 uint32  runtime·fastrand1(void);
 void    runtime·rewindmorestack(Gobuf*);
 int32   runtime·timediv(int64, int32, int32*);
 int32   runtime·round2(int32 x); // round x up to a power of 2.
 
 // atomic operations
 bool    runtime·cas(uint32*, uint32, uint32);
 bool    runtime·cas64(uint64*, uint64, uint64);
 bool    runtime·casp(void**, void*, void*);
 // Don't confuse with XADD x86 instruction,
 // this one is actually 'addx', that is, add-and-fetch.
 uint32  runtime·xadd(uint32 volatile*, int32);
 uint64  runtime·xadd64(uint64 volatile*, int64);
 uint32  runtime·xchg(uint32 volatile*, uint32);
 uint64  runtime·xchg64(uint64 volatile*, uint64);
 void*   runtime·xchgp(void* volatile*, void*);
 uint32  runtime·atomicload(uint32 volatile*);
 void    runtime·atomicstore(uint32 volatile*, uint32);
 void    runtime·atomicstore64(uint64 volatile*, uint64);
 uint64  runtime·atomicload64(uint64 volatile*);
 void*   runtime·atomicloadp(void* volatile*);
+uintptr runtime·atomicloaduintptr(uintptr volatile*);
 void    runtime·atomicstorep(void* volatile*, void*);
+void    runtime·atomicstoreuintptr(uintptr volatile*, uintptr);
 void    runtime·atomicor8(byte volatile*, byte);
 
 void    runtime·setg(G*);
 void    runtime·newextram(void);
 void    runtime·exit(int32);
 void    runtime·breakpoint(void);
-void    runtime·gosched(void);
 void    runtime·gosched_m(G*);
 void    runtime·schedtrace(bool);
 void    runtime·park(bool(*)(G*, void*), void*, String);
 void    runtime·parkunlock(Mutex*, String);
 void    runtime·tsleep(int64, String);
 M*      runtime·newm(void);
 void    runtime·goexit(void);
 void    runtime·asmcgocall(void (*fn)(void*), void*);
 int32   runtime·asmcgocall_errno(void (*fn)(void*), void*);
 void    runtime·entersyscall(void);
+void    runtime·reentersyscall(uintptr, uintptr);
 void    runtime·entersyscallblock(void);
 void    runtime·exitsyscall(void);
 G*      runtime·newproc1(FuncVal*, byte*, int32, int32, void*);
 bool    runtime·sigsend(int32 sig);
 intgo   runtime·callers(intgo, uintptr*, intgo);
 intgo   runtime·gcallers(G*, intgo, uintptr*, intgo);
 int64   runtime·nanotime(void); // monotonic time
 int64   runtime·unixnanotime(void); // real time, can skip
 void    runtime·dopanic(int32);
 void    runtime·startpanic(void);
 void    runtime·freezetheworld(void);
-void    runtime·unwindstack(G*, byte*);
 void    runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp);
 void    runtime·resetcpuprofiler(int32);
 void    runtime·setcpuprofilerate(int32);
 void    runtime·usleep(uint32);
 int64   runtime·cputicks(void);
 int64   runtime·tickspersecond(void);
 void    runtime·blockevent(int64, intgo);
 G*      runtime·netpoll(bool);
 void    runtime·netpollready(G**, PollDesc*, int32);
 uintptr runtime·netpollfd(PollDesc*);
@@ skipping 130 matching lines @@
 void    runtime·gopanic(Eface);
 void    runtime·panicindex(void);
 void    runtime·panicslice(void);
 void    runtime·panicdivide(void);
 
 /*
  * runtime c-called (but written in Go)
  */
 void    runtime·printany(Eface);
 void    runtime·newTypeAssertionError(String*, String*, String*, String*, Eface*);
-void    runtime·newErrorString(String, Eface*);
-void    runtime·newErrorCString(int8*, Eface*);
 void    runtime·fadd64c(uint64, uint64, uint64*);
 void    runtime·fsub64c(uint64, uint64, uint64*);
 void    runtime·fmul64c(uint64, uint64, uint64*);
 void    runtime·fdiv64c(uint64, uint64, uint64*);
 void    runtime·fneg64c(uint64, uint64*);
 void    runtime·f32to64c(uint32, uint64*);
 void    runtime·f64to32c(uint64, uint32*);
 void    runtime·fcmp64c(uint64, uint64, int32*, bool*);
 void    runtime·fintto64c(int64, uint64*);
 void    runtime·f64tointc(uint64, int64*, bool*);
@@ skipping 33 matching lines @@
 extern float64 runtime·neginf;
 extern uint64 ·nan;
 extern uint64 ·posinf;
 extern uint64 ·neginf;
 #define ISNAN(f) ((f) != (f))
 
 enum
 {
         UseSpanType = 1,
 };