root/src/pkg/runtime/runtime.h

INCLUDED FROM

// 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 int64           intgo; // Go's int
typedef uint64          uintgo; // Go's uint
#else
typedef uint32          uintptr;
typedef int32           intptr;
typedef int32           intgo; // Go's int
typedef uint32          uintgo; // Go's uint
#endif

#ifdef _64BITREG
typedef uint64          uintreg;
#else
typedef uint32          uintreg;
#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 / / /
#define short                   XXshort / / /
#define int                     XXint / / /
#define long                    XXlong / / /
#define float                   XXfloat / / /
#define double                  XXdouble / / /

/*
 * defined types
 */
typedef uint8                   bool;
typedef uint8                   byte;
typedef struct  Func            Func;
typedef struct  G               G;
typedef struct  Gobuf           Gobuf;
typedef struct  Lock            Lock;
typedef struct  M               M;
typedef struct  P               P;
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  MapType         MapType;
typedef struct  Defer           Defer;
typedef struct  Panic           Panic;
typedef struct  Hmap            Hmap;
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  Timers          Timers;
typedef struct  Timer           Timer;
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;

/*
 * 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 -16(FS).
 *
 * Every C file linked into a Go program must include runtime.h so that the
 * C compiler (6c, 8c, etc.) knows to avoid other uses of these dedicated
 * registers. The Go compiler (6g, 8g, etc.) knows to avoid them.
 */
extern  register        G*      g;
extern  register        M*      m;

/*
 * defined constants
 */
enum
{
        // G status
        //
        // 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_unused,  // currently unused, but hardcoded in gdb scripts
        Gdead,
};
enum
{
        // P status
        Pidle,
        Prunning,
        Psyscall,
        Pgcstop,
        Pdead,
};
enum
{
        true    = 1,
        false   = 0,
};
enum
{
        PtrSize = sizeof(void*),
};
enum
{
        // Per-M stack segment cache size.
        StackCacheSize = 32,
        // Global <-> per-M stack segment cache transfer batch size.
        StackCacheBatch = 16,
};
/*
 * structures
 */
struct  Lock
{
        // Futex-based impl treats it as uint32 key,
        // while sema-based impl as M* waitm.
        // Used to be a union, but unions break precise GC.
        uintptr key;
};
struct  Note
{
        // Futex-based impl treats it as uint32 key,
        // while sema-based impl as M* waitm.
        // Used to be a union, but unions break precise GC.
        uintptr key;
};
struct String
{
        byte*   str;
        intgo   len;
};
struct FuncVal
{
        void    (*fn)(void);
        // variable-size, fn-specific data here
};
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
        uintgo  len;            // number of elements
        uintgo  cap;            // allocated number of elements
};
struct  Gobuf
{
        // The offsets of sp, pc, and g are known to (hard-coded in) libmach.
        uintptr sp;
        uintptr pc;
        G*      g;
        void*   ctxt;
        uintreg ret;
        uintptr lr;
};
struct  GCStats
{
        // the struct must consist of only uint64's,
        // because it is casted to uint64[].
        uint64  nhandoff;
        uint64  nhandoffcnt;
        uint64  nprocyield;
        uint64  nosyield;
        uint64  nsleep;
};

struct  LibCall
{
        void    (*fn)(void*);
        uintptr n;      // number of parameters
        void*   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;
};

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
        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;
        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
        bool    paniconfault;   // panic (instead of crash) on unexpected fault address
        int8    raceignore;     // ignore race detection events
        M*      m;              // for debuggers, but offset not hard-coded
        M*      lockedm;
        int32   sig;
        int32   writenbuf;
        byte*   writebuf;
        uintptr sigcode0;
        uintptr sigcode1;
        uintptr sigpc;
        uintptr gopc;           // pc of go statement that created this goroutine
        uintptr racectx;
        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;
        int32   throwing;
        int32   gcing;
        int32   locks;
        int32   softfloat;
        int32   dying;
        int32   profilehz;
        int32   helpgc;
        bool    spinning;       // M is out of work and is actively looking for work
        bool    blocked;        // M is blocked on a Note
        uint32  fastrand;
        uint64  ncgocall;       // number of cgo calls in total
        int32   ncgo;           // number of cgo calls currently in progress
        CgoMal* cgomal;
        Note    park;
        M*      alllink;        // on allm
        M*      schedlink;
        uint32  machport;       // Return address for Mach IPC (OS X)
        MCache* mcache;
        int32   stackinuse;
        uint32  stackcachepos;
        uint32  stackcachecnt;
        void*   stackcache[StackCacheSize];
        G*      lockedg;
        uintptr createstack[32];// Stack that created this thread.
        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
        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;
#ifdef GOOS_windows
        void*   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 {
                int64   tv_sec;
                int64   tv_nsec;
        } ts;
        struct {
                uintptr v[6];
        } scratch;
#endif
#ifdef GOOS_plan9
        int8*   notesig;
        byte*   errstr;
#endif
        uintptr end[];
};

struct P
{
        Lock;

        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;
        Defer*  deferpool[5];   // pool of available Defer structs of different sizes (see panic.c)

        // Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen.
        uint64  goidcache;
        uint64  goidcacheend;

        // Queue of runnable goroutines.
        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.
// 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;
        uint32  panicwrap;

        uint8*  argp;   // pointer to arguments in old frame
        bool    panic;  // is this frame the top of a panic?
        bool    malloced;
};
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
        SigPanic = 1<<3,        // if the signal is from the kernel, panic
        SigDefault = 1<<4,      // if the signal isn't explicitly requested, don't monitor it
        SigHandling = 1<<5,     // our signal handler is registered
        SigIgnored = 1<<6,      // the signal was ignored before we registered for it
        SigGoExit = 1<<7,       // cause all runtime procs to exit (only used on Plan 9).
};

// Layout of in-memory per-function information prepared by linker
// See http://golang.org/s/go12symtab.
// Keep in sync with linker and with ../../libmach/sym.c
// and with package debug/gosym.
struct  Func
{
        uintptr entry;  // start pc
        int32   nameoff;// function name
        
        int32   args;   // in/out args size
        int32   frame;  // legacy frame size; use pcsp if possible

        int32   pcsp;
        int32   pcfile;
        int32   pcln;
        int32   npcdata;
        int32   nfuncdata;
};

// layout of Itab known to compilers
// allocated in non-garbage-collected memory
struct  Itab
{
        InterfaceType*  inter;
        Type*   type;
        Itab*   link;
        int32   bad;
        int32   unused;
        void    (*fun[])(void);
};

#ifdef GOOS_nacl
enum {
   NaCl = 1,
};
#else
enum {
   NaCl = 0,
};
#endif

#ifdef GOOS_windows
enum {
   Windows = 1
};
#else
enum {
   Windows = 0
};
#endif
#ifdef GOOS_solaris
enum {
   Solaris = 1
};
#else
enum {
   Solaris = 0
};
#endif

struct  Timers
{
        Lock;
        G       *timerproc;
        bool            sleeping;
        bool            rescheduling;
        Note    waitnote;
        Timer   **t;
        int32   len;
        int32   cap;
};

// Package time knows the layout of this structure.
// If this struct changes, adjust ../time/sleep.go:/runtimeTimer.
// For GOOS=nacl, package syscall knows the layout of this structure.
// If this struct changes, adjust ../syscall/net_nacl.go:/runtimeTimer.
struct  Timer
{
        int32   i;      // heap index

        // Timer wakes up at when, and then at when+period, ... (period > 0 only)
        // each time calling f(now, arg) in the timer goroutine, so f must be
        // a well-behaved function and not block.
        int64   when;
        int64   period;
        FuncVal *fv;
        Eface   arg;
};

// Lock-free stack node.
struct LFNode
{
        LFNode  *next;
        uintptr pushcnt;
};

// Parallel for descriptor.
struct ParFor
{
        void (*body)(ParFor*, uint32);  // executed for each element
        uint32 done;                    // number of idle threads
        uint32 nthr;                    // total number of threads
        uint32 nthrmax;                 // maximum number of threads
        uint32 thrseq;                  // thread id sequencer
        uint32 cnt;                     // iteration space [0, cnt)
        void *ctx;                      // arbitrary user context
        bool wait;                      // if true, wait while all threads finish processing,
                                        // otherwise parfor may return while other threads are still working
        ParForThread *thr;              // array of thread descriptors
        uint32 pad;                     // to align ParForThread.pos for 64-bit atomic operations
        // stats
        uint64 nsteal;
        uint64 nstealcnt;
        uint64 nprocyield;
        uint64 nosyield;
        uint64 nsleep;
};

// Track memory allocated by code not written in Go during a cgo call,
// so that the garbage collector can see them.
struct CgoMal
{
        CgoMal  *next;
        void    *alloc;
};

// Holds variables parsed from GODEBUG env var.
struct DebugVars
{
        int32   allocfreetrace;
        int32   efence;
        int32   gctrace;
        int32   gcdead;
        int32   scheddetail;
        int32   schedtrace;
};

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 */

/*
 * known to compiler
 */
enum {
        Structrnd = sizeof(uintreg),
};

/*
 * type algorithms - known to compiler
 */
enum
{
        AMEM,
        AMEM0,
        AMEM8,
        AMEM16,
        AMEM32,
        AMEM64,
        AMEM128,
        ANOEQ,
        ANOEQ0,
        ANOEQ8,
        ANOEQ16,
        ANOEQ32,
        ANOEQ64,
        ANOEQ128,
        ASTRING,
        AINTER,
        ANILINTER,
        ASLICE,
        AFLOAT32,
        AFLOAT64,
        ACPLX64,
        ACPLX128,
        Amax
};
typedef struct  Alg             Alg;
struct  Alg
{
        void    (*hash)(uintptr*, uintptr, void*);
        void    (*equal)(bool*, uintptr, void*, void*);
        void    (*print)(uintptr, void*);
        void    (*copy)(uintptr, void*, void*);
};

extern  Alg     runtime·algarray[Amax];

byte*   runtime·startup_random_data;
uint32  runtime·startup_random_data_len;
void    runtime·get_random_data(byte**, int32*);

enum {
        // hashinit wants this many random bytes
        HashRandomBytes = 32
};
void    runtime·hashinit(void);

void    runtime·memhash(uintptr*, uintptr, void*);
void    runtime·nohash(uintptr*, uintptr, void*);
void    runtime·strhash(uintptr*, uintptr, void*);
void    runtime·interhash(uintptr*, uintptr, void*);
void    runtime·nilinterhash(uintptr*, uintptr, void*);
void    runtime·aeshash(uintptr*, uintptr, void*);
void    runtime·aeshash32(uintptr*, uintptr, void*);
void    runtime·aeshash64(uintptr*, uintptr, void*);
void    runtime·aeshashstr(uintptr*, uintptr, void*);

void    runtime·memequal(bool*, uintptr, void*, void*);
void    runtime·noequal(bool*, uintptr, void*, void*);
void    runtime·strequal(bool*, uintptr, void*, void*);
void    runtime·interequal(bool*, uintptr, void*, void*);
void    runtime·nilinterequal(bool*, uintptr, void*, void*);

bool    runtime·memeq(void*, void*, uintptr);

void    runtime·memprint(uintptr, void*);
void    runtime·strprint(uintptr, void*);
void    runtime·interprint(uintptr, void*);
void    runtime·nilinterprint(uintptr, void*);

void    runtime·memcopy(uintptr, void*, void*);
void    runtime·memcopy8(uintptr, void*, void*);
void    runtime·memcopy16(uintptr, void*, void*);
void    runtime·memcopy32(uintptr, void*, void*);
void    runtime·memcopy64(uintptr, void*, void*);
void    runtime·memcopy128(uintptr, void*, void*);
void    runtime·strcopy(uintptr, void*, void*);
void    runtime·algslicecopy(uintptr, void*, void*);
void    runtime·intercopy(uintptr, void*, void*);
void    runtime·nilintercopy(uintptr, void*, void*);

/*
 * deferred subroutine calls
 */
struct Defer
{
        int32   siz;
        bool    special;        // not part of defer frame
        byte*   argp;           // where args were copied from
        byte*   pc;
        FuncVal*        fn;
        Defer*  link;
        void*   args[1];        // padded to actual size
};

// argp used in Defer structs when there is no argp.
// TODO(rsc): Maybe we could use nil instead, but we've always used -1
// and I don't want to change this days before the Go 1.3 release.
#define NoArgs ((byte*)-1)

/*
 * panics
 */
struct Panic
{
        Eface   arg;            // argument to panic
        uintptr stackbase;      // g->stackbase in 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;
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
        byte*   varp;   // top of local variables
        byte*   argp;   // pointer to function arguments
        uintptr arglen; // number of bytes at argp
};

int32   runtime·gentraceback(uintptr, uintptr, uintptr, G*, int32, uintptr*, int32, bool(*)(Stkframe*, void*), void*, bool);
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  uintptr runtime·allglen;
extern  G*      runtime·lastg;
extern  M*      runtime·allm;
extern  P**     runtime·allp;
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·Hchansize;
extern  uint32  runtime·cpuid_ecx;
extern  uint32  runtime·cpuid_edx;
extern  DebugVars       runtime·debug;
extern  uintptr runtime·maxstacksize;

/*
 * 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);
int32   runtime·runetochar(byte*, int32);
int32   runtime·charntorune(int32*, uint8*, int32);


/*
 * This macro is used when writing C functions
 * called as if they were Go functions.
 * Passed the address of a result before a return statement,
 * it makes sure the result has been flushed to memory
 * before the return.
 *
 * It is difficult to write such functions portably, because
 * of the varying requirements on the alignment of the
 * first output value. Almost all code should write such
 * functions in .goc files, where goc2c (part of cmd/dist)
 * can arrange the correct alignment for the target system.
 * Goc2c also takes care of conveying to the garbage collector
 * which parts of the argument list are inputs vs outputs.
 *
 * Therefore, do NOT use this macro if at all possible.
 */ 
#define FLUSH(x)        USED(x)

/*
 * 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*, ...);
int32   runtime·snprintf(byte*, int32, int8*, ...);
byte*   runtime·mchr(byte*, byte, byte*);
int32   runtime·mcmp(byte*, byte*, uintptr);
void    runtime·memmove(void*, void*, uintptr);
void*   runtime·mal(uintptr);
String  runtime·catstring(String, String);
String  runtime·gostring(byte*);
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*, void*);
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·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·stackalloc(G*, uint32);
void    runtime·stackfree(G*, void*, Stktop*);
void    runtime·shrinkstack(G*);
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);
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);
void    runtime·mcall(void(*)(G*));
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*);
void    runtime·atomicstorep(void* volatile*, void*);

void    runtime·setmg(M*, G*);
void    runtime·newextram(void);
void    runtime·exit(int32);
void    runtime·breakpoint(void);
void    runtime·gosched(void);
void    runtime·gosched0(G*);
void    runtime·schedtrace(bool);
void    runtime·park(bool(*)(G*, void*), void*, int8*);
void    runtime·parkunlock(Lock*, int8*);
void    runtime·tsleep(int64, int8*);
M*      runtime·newm(void);
void    runtime·goexit(void);
void    runtime·asmcgocall(void (*fn)(void*), void*);
void    runtime·entersyscall(void);
void    runtime·entersyscallblock(void);
void    runtime·exitsyscall(void);
G*      runtime·newproc1(FuncVal*, byte*, int32, int32, void*);
bool    runtime·sigsend(int32 sig);
int32   runtime·callers(int32, uintptr*, int32);
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(void(*)(uintptr*, int32), int32);
void    runtime·usleep(uint32);
int64   runtime·cputicks(void);
int64   runtime·tickspersecond(void);
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·netpollarm(PollDesc*, int32);
void**  runtime·netpolluser(PollDesc*);
bool    runtime·netpollclosing(PollDesc*);
void    runtime·netpolllock(PollDesc*);
void    runtime·netpollunlock(PollDesc*);
void    runtime·crash(void);
void    runtime·parsedebugvars(void);
void    _rt0_go(void);
void*   runtime·funcdata(Func*, int32);
int32   runtime·setmaxthreads(int32);
G*      runtime·timejump(void);
void    runtime·iterate_itabs(void (*callback)(Itab*));
void    runtime·iterate_finq(void (*callback)(FuncVal*, byte*, uintptr, Type*, PtrType*));

#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
#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
#pragma varargck        type    "p"     void*
#pragma varargck        type    "p"     uintptr
#pragma varargck        type    "s"     int8*
#pragma varargck        type    "s"     uint8*
#pragma varargck        type    "S"     String

void    runtime·stoptheworld(void);
void    runtime·starttheworld(void);
extern uint32 runtime·worldsema;

/*
 * mutual exclusion locks.  in the uncontended case,
 * as fast as spin locks (just a few user-level instructions),
 * but on the contention path they sleep in the kernel.
 * a zeroed Lock is unlocked (no need to initialize each lock).
 */
void    runtime·lock(Lock*);
void    runtime·unlock(Lock*);

/*
 * sleep and wakeup on one-time events.
 * before any calls to notesleep or notewakeup,
 * must call noteclear to initialize the Note.
 * then, exactly one thread can call notesleep
 * and exactly one thread can call notewakeup (once).
 * once notewakeup has been called, the notesleep
 * will return.  future notesleep will return immediately.
 * subsequent noteclear must be called only after
 * previous notesleep has returned, e.g. it's disallowed
 * to call noteclear straight after notewakeup.
 *
 * notetsleep is like notesleep but wakes up after
 * a given number of nanoseconds even if the event
 * has not yet happened.  if a goroutine uses notetsleep to
 * wake up early, it must wait to call noteclear until it
 * can be sure that no other goroutine is calling
 * notewakeup.
 *
 * notesleep/notetsleep are generally called on g0,
 * notetsleepg is similar to notetsleep but is called on user g.
 */
void    runtime·noteclear(Note*);
void    runtime·notesleep(Note*);
void    runtime·notewakeup(Note*);
bool    runtime·notetsleep(Note*, int64);  // false - timeout
bool    runtime·notetsleepg(Note*, int64);  // false - timeout

/*
 * low-level synchronization for implementing the above
 */
uintptr runtime·semacreate(void);
int32   runtime·semasleep(int64);
void    runtime·semawakeup(M*);
// or
void    runtime·futexsleep(uint32*, uint32, int64);
void    runtime·futexwakeup(uint32*, uint32);

/*
 * Lock-free stack.
 * Initialize uint64 head to 0, compare with 0 to test for emptiness.
 * The stack does not keep pointers to nodes,
 * so they can be garbage collected if there are no other pointers to nodes.
 */
void    runtime·lfstackpush(uint64 *head, LFNode *node);
LFNode* runtime·lfstackpop(uint64 *head);

/*
 * Parallel for over [0, n).
 * body() is executed for each iteration.
 * nthr - total number of worker threads.
 * ctx - arbitrary user context.
 * if wait=true, threads return from parfor() when all work is done;
 * otherwise, threads can return while other threads are still finishing processing.
 */
ParFor* runtime·parforalloc(uint32 nthrmax);
void    runtime·parforsetup(ParFor *desc, uint32 nthr, uint32 n, void *ctx, bool wait, void (*body)(ParFor*, uint32));
void    runtime·parfordo(ParFor *desc);
void    runtime·parforiters(ParFor*, uintptr, uintptr*, uintptr*);

/*
 * low level C-called
 */
// for mmap, we only pass the lower 32 bits of file offset to the 
// assembly routine; the higher bits (if required), should be provided
// by the assembly routine as 0.
uint8*  runtime·mmap(byte*, uintptr, int32, int32, int32, uint32);
void    runtime·munmap(byte*, uintptr);
void    runtime·madvise(byte*, uintptr, int32);
void    runtime·memclr(byte*, uintptr);
void    runtime·setcallerpc(void*, void*);
void*   runtime·getcallerpc(void*);

/*
 * runtime go-called
 */
void    runtime·printbool(bool);
void    runtime·printbyte(int8);
void    runtime·printfloat(float64);
void    runtime·printint(int64);
void    runtime·printiface(Iface);
void    runtime·printeface(Eface);
void    runtime·printstring(String);
void    runtime·printpc(void*);
void    runtime·printpointer(void*);
void    runtime·printuint(uint64);
void    runtime·printhex(uint64);
void    runtime·printslice(Slice);
void    runtime·printcomplex(Complex128);
void    runtime·newstackcall(FuncVal*, byte*, uint32);
void    reflect·call(FuncVal*, byte*, uint32, uint32);
void    runtime·panic(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*);

/*
 * wrapped for go users
 */
float64 runtime·Inf(int32 sign);
float64 runtime·NaN(void);
float32 runtime·float32frombits(uint32 i);
uint32  runtime·float32tobits(float32 f);
float64 runtime·float64frombits(uint64 i);
uint64  runtime·float64tobits(float64 f);
float64 runtime·frexp(float64 d, int32 *ep);
bool    runtime·isInf(float64 f, int32 sign);
bool    runtime·isNaN(float64 f);
float64 runtime·ldexp(float64 d, int32 e);
float64 runtime·modf(float64 d, float64 *ip);
void    runtime·semacquire(uint32*, bool);
void    runtime·semrelease(uint32*);
int32   runtime·gomaxprocsfunc(int32 n);
void    runtime·procyield(uint32);
void    runtime·osyield(void);
void    runtime·lockOSThread(void);
void    runtime·unlockOSThread(void);
bool    runtime·lockedOSThread(void);

bool    runtime·showframe(Func*, G*);
void    runtime·printcreatedby(G*);

void    runtime·ifaceE2I(InterfaceType*, Eface, Iface*);
bool    runtime·ifaceE2I2(InterfaceType*, Eface, Iface*);
uintptr runtime·memlimit(void);

// 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))

enum
{
        UseSpanType = 1,
};