libgo/runtime/runtime.h

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 #include "config.h"
   6
   7 #include "go-assert.h"
   8 #include <complex.h>
   9 #include <signal.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <sys/types.h>
  14 #include <sys/stat.h>
  15 #include <fcntl.h>
  16 #include <unistd.h>
  17 #include <pthread.h>
  18 #include <semaphore.h>
  19 #include <ucontext.h>
  20
  21 #ifdef HAVE_SYS_MMAN_H
  22 #include <sys/mman.h>
  23 #endif
  24
  25 #include "interface.h"
  26 #include "go-alloc.h"
  27
  28 #define _STRINGIFY2_(x) #x
  29 #define _STRINGIFY_(x) _STRINGIFY2_(x)
  30 #define GOSYM_PREFIX _STRINGIFY_(__USER_LABEL_PREFIX__)
  31
  32 /* This file supports C files copied from the 6g runtime library.
  33    This is a version of the 6g runtime.h rewritten for gccgo's version
  34    of the code.  */
  35
  36 typedef signed int   int8    __attribute__ ((mode (QI)));
  37 typedef unsigned int uint8   __attribute__ ((mode (QI)));
  38 typedef signed int   int16   __attribute__ ((mode (HI)));
  39 typedef unsigned int uint16  __attribute__ ((mode (HI)));
  40 typedef signed int   int32   __attribute__ ((mode (SI)));
  41 typedef unsigned int uint32  __attribute__ ((mode (SI)));
  42 typedef signed int   int64   __attribute__ ((mode (DI)));
  43 typedef unsigned int uint64  __attribute__ ((mode (DI)));
  44 typedef float        float32 __attribute__ ((mode (SF)));
  45 typedef double       float64 __attribute__ ((mode (DF)));
  46 typedef signed int   intptr __attribute__ ((mode (pointer)));
  47 typedef unsigned int uintptr __attribute__ ((mode (pointer)));
  48
  49 typedef intptr          intgo; // Go's int
  50 typedef uintptr         uintgo; // Go's uint
  51
  52 typedef uintptr         uintreg;
  53
  54 /* Defined types.  */
  55
  56 typedef uint8                   bool;
  57 typedef uint8                   byte;
  58 typedef struct  Func            Func;
  59 typedef struct  G               G;
  60 typedef struct  Lock            Lock;
  61 typedef struct  M               M;
  62 typedef struct  P               P;
  63 typedef struct  Note            Note;
  64 typedef struct  String          String;
  65 typedef struct  FuncVal         FuncVal;
  66 typedef struct  SigTab          SigTab;
  67 typedef struct  MCache          MCache;
  68 typedef struct  FixAlloc        FixAlloc;
  69 typedef struct  Hchan           Hchan;
  70 typedef struct  Timers          Timers;
  71 typedef struct  Timer           Timer;
  72 typedef struct  GCStats         GCStats;
  73 typedef struct  LFNode          LFNode;
  74 typedef struct  ParFor          ParFor;
  75 typedef struct  ParForThread    ParForThread;
  76 typedef struct  CgoMal          CgoMal;
  77 typedef struct  PollDesc        PollDesc;
  78 typedef struct  DebugVars       DebugVars;
  79
  80 typedef struct  __go_open_array         Slice;
  81 typedef struct  __go_interface          Iface;
  82 typedef struct  __go_empty_interface    Eface;
  83 typedef struct  __go_type_descriptor    Type;
  84 typedef struct  __go_defer_stack        Defer;
  85 typedef struct  __go_panic_stack        Panic;
  86
  87 typedef struct  __go_ptr_type           PtrType;
  88 typedef struct  __go_func_type          FuncType;
  89 typedef struct  __go_interface_type     InterfaceType;
  90 typedef struct  __go_map_type           MapType;
  91 typedef struct  __go_channel_type       ChanType;
  92
  93 typedef struct  Traceback       Traceback;
  94
  95 typedef struct  Location        Location;
  96
  97 /*
  98  * Per-CPU declaration.
  99  */
 100 extern M*       runtime_m(void);
 101 extern G*       runtime_g(void);
 102
 103 extern M        runtime_m0;
 104 extern G        runtime_g0;
 105
 106 /*
 107  * defined constants
 108  */
 109 enum
 110 {
 111         // G status
 112         //
 113         // If you add to this list, add to the list
 114         // of "okay during garbage collection" status
 115         // in mgc0.c too.
 116         Gidle,
 117         Grunnable,
 118         Grunning,
 119         Gsyscall,
 120         Gwaiting,
 121         Gmoribund_unused,  // currently unused, but hardcoded in gdb scripts
 122         Gdead,
 123 };
 124 enum
 125 {
 126         // P status
 127         Pidle,
 128         Prunning,
 129         Psyscall,
 130         Pgcstop,
 131         Pdead,
 132 };
 133 enum
 134 {
 135         true    = 1,
 136         false   = 0,
 137 };
 138 enum
 139 {
 140         PtrSize = sizeof(void*),
 141 };
 142 enum
 143 {
 144         // Per-M stack segment cache size.
 145         StackCacheSize = 32,
 146         // Global <-> per-M stack segment cache transfer batch size.
 147         StackCacheBatch = 16,
 148 };
 149 /*
 150  * structures
 151  */
 152 struct  Lock
 153 {
 154         // Futex-based impl treats it as uint32 key,
 155         // while sema-based impl as M* waitm.
 156         // Used to be a union, but unions break precise GC.
 157         uintptr key;
 158 };
 159 struct  Note
 160 {
 161         // Futex-based impl treats it as uint32 key,
 162         // while sema-based impl as M* waitm.
 163         // Used to be a union, but unions break precise GC.
 164         uintptr key;
 165 };
 166 struct String
 167 {
 168         const byte*     str;
 169         intgo           len;
 170 };
 171 struct FuncVal
 172 {
 173         void    (*fn)(void);
 174         // variable-size, fn-specific data here
 175 };
 176 struct  GCStats
 177 {
 178         // the struct must consist of only uint64's,
 179         // because it is casted to uint64[].
 180         uint64  nhandoff;
 181         uint64  nhandoffcnt;
 182         uint64  nprocyield;
 183         uint64  nosyield;
 184         uint64  nsleep;
 185 };
 186
 187 // A location in the program, used for backtraces.
 188 struct  Location
 189 {
 190         uintptr pc;
 191         String  filename;
 192         String  function;
 193         intgo   lineno;
 194 };
 195
 196 struct  G
 197 {
 198         Defer*  defer;
 199         Panic*  panic;
 200         void*   exception;      // current exception being thrown
 201         bool    is_foreign;     // whether current exception from other language
 202         void    *gcstack;       // if status==Gsyscall, gcstack = stackbase to use during gc
 203         size_t  gcstack_size;
 204         void*   gcnext_segment;
 205         void*   gcnext_sp;
 206         void*   gcinitial_sp;
 207         ucontext_t gcregs;
 208         byte*   entry;          // initial function
 209         void*   param;          // passed parameter on wakeup
 210         bool    fromgogo;       // reached from gogo
 211         int16   status;
 212         uint32  selgen;         // valid sudog pointer
 213         int64   goid;
 214         int64   waitsince;      // approx time when the G become blocked
 215         const char*     waitreason;     // if status==Gwaiting
 216         G*      schedlink;
 217         bool    ispanic;
 218         bool    issystem;       // do not output in stack dump
 219         bool    isbackground;   // ignore in deadlock detector
 220         bool    paniconfault;   // panic (instead of crash) on unexpected fault address
 221         M*      m;              // for debuggers, but offset not hard-coded
 222         M*      lockedm;
 223         int32   sig;
 224         int32   writenbuf;
 225         byte*   writebuf;
 226         uintptr sigcode0;
 227         uintptr sigcode1;
 228         // uintptr      sigpc;
 229         uintptr gopc;   // pc of go statement that created this goroutine
 230
 231         int32   ncgo;
 232         CgoMal* cgomal;
 233
 234         Traceback* traceback;
 235
 236         ucontext_t      context;
 237         void*           stack_context[10];
 238 };
 239
 240 struct  M
 241 {
 242         G*      g0;             // goroutine with scheduling stack
 243         G*      gsignal;        // signal-handling G
 244         byte*   gsignalstack;
 245         size_t  gsignalstacksize;
 246         void    (*mstartfn)(void);
 247         G*      curg;           // current running goroutine
 248         G*      caughtsig;      // goroutine running during fatal signal
 249         P*      p;              // attached P for executing Go code (nil if not executing Go code)
 250         P*      nextp;
 251         int32   id;
 252         int32   mallocing;
 253         int32   throwing;
 254         int32   gcing;
 255         int32   locks;
 256         int32   softfloat;
 257         int32   dying;
 258         int32   profilehz;
 259         int32   helpgc;
 260         bool    spinning;       // M is out of work and is actively looking for work
 261         bool    blocked;        // M is blocked on a Note
 262         uint32  fastrand;
 263         uint64  ncgocall;       // number of cgo calls in total
 264         int32   ncgo;           // number of cgo calls currently in progress
 265         CgoMal* cgomal;
 266         Note    park;
 267         M*      alllink;        // on allm
 268         M*      schedlink;
 269         MCache  *mcache;
 270         G*      lockedg;
 271         Location createstack[32];       // Stack that created this thread.
 272         uint32  locked; // tracking for LockOSThread
 273         M*      nextwaitm;      // next M waiting for lock
 274         uintptr waitsema;       // semaphore for parking on locks
 275         uint32  waitsemacount;
 276         uint32  waitsemalock;
 277         GCStats gcstats;
 278         bool    needextram;
 279         bool    dropextram;     // for gccgo: drop after call is done.
 280         uint8   traceback;
 281         bool    (*waitunlockf)(G*, void*);
 282         void*   waitlock;
 283         uintptr end[];
 284 };
 285
 286 struct P
 287 {
 288         Lock;
 289
 290         int32   id;
 291         uint32  status;         // one of Pidle/Prunning/...
 292         P*      link;
 293         uint32  schedtick;      // incremented on every scheduler call
 294         uint32  syscalltick;    // incremented on every system call
 295         M*      m;              // back-link to associated M (nil if idle)
 296         MCache* mcache;
 297         Defer*  deferpool;      // pool of available Defer structs (see panic.c)
 298
 299         // Cache of goroutine ids, amortizes accesses to runtime_sched.goidgen.
 300         uint64  goidcache;
 301         uint64  goidcacheend;
 302
 303         // Queue of runnable goroutines.
 304         uint32  runqhead;
 305         uint32  runqtail;
 306         G*      runq[256];
 307
 308         // Available G's (status == Gdead)
 309         G*      gfree;
 310         int32   gfreecnt;
 311
 312         byte    pad[64];
 313 };
 314
 315 // The m->locked word holds two pieces of state counting active calls to LockOSThread/lockOSThread.
 316 // The low bit (LockExternal) is a boolean reporting whether any LockOSThread call is active.
 317 // External locks are not recursive; a second lock is silently ignored.
 318 // The upper bits of m->lockedcount record the nesting depth of calls to lockOSThread
 319 // (counting up by LockInternal), popped by unlockOSThread (counting down by LockInternal).
 320 // Internal locks can be recursive. For instance, a lock for cgo can occur while the main
 321 // goroutine is holding the lock during the initialization phase.
 322 enum
 323 {
 324         LockExternal = 1,
 325         LockInternal = 2,
 326 };
 327
 328 struct  SigTab
 329 {
 330         int32   sig;
 331         int32   flags;
 332         void*   fwdsig;
 333 };
 334 enum
 335 {
 336         SigNotify = 1<<0,       // let signal.Notify have signal, even if from kernel
 337         SigKill = 1<<1,         // if signal.Notify doesn't take it, exit quietly
 338         SigThrow = 1<<2,        // if signal.Notify doesn't take it, exit loudly
 339         SigPanic = 1<<3,        // if the signal is from the kernel, panic
 340         SigDefault = 1<<4,      // if the signal isn't explicitly requested, don't monitor it
 341         SigHandling = 1<<5,     // our signal handler is registered
 342         SigGoExit = 1<<6,       // cause all runtime procs to exit (only used on Plan 9).
 343 };
 344
 345 // Layout of in-memory per-function information prepared by linker
 346 // See http://golang.org/s/go12symtab.
 347 // Keep in sync with linker and with ../../libmach/sym.c
 348 // and with package debug/gosym.
 349 struct  Func
 350 {
 351         String  name;
 352         uintptr entry;  // entry pc
 353 };
 354
 355 #ifdef GOOS_nacl
 356 enum {
 357    NaCl = 1,
 358 };
 359 #else
 360 enum {
 361    NaCl = 0,
 362 };
 363 #endif
 364
 365 #ifdef GOOS_windows
 366 enum {
 367    Windows = 1
 368 };
 369 #else
 370 enum {
 371    Windows = 0
 372 };
 373 #endif
 374 #ifdef GOOS_solaris
 375 enum {
 376    Solaris = 1
 377 };
 378 #else
 379 enum {
 380    Solaris = 0
 381 };
 382 #endif
 383
 384 struct  Timers
 385 {
 386         Lock;
 387         G       *timerproc;
 388         bool            sleeping;
 389         bool            rescheduling;
 390         Note    waitnote;
 391         Timer   **t;
 392         int32   len;
 393         int32   cap;
 394 };
 395
 396 // Package time knows the layout of this structure.
 397 // If this struct changes, adjust ../time/sleep.go:/runtimeTimer.
 398 // For GOOS=nacl, package syscall knows the layout of this structure.
 399 // If this struct changes, adjust ../syscall/net_nacl.go:/runtimeTimer.
 400 struct  Timer
 401 {
 402         intgo   i;      // heap index
 403
 404         // Timer wakes up at when, and then at when+period, ... (period > 0 only)
 405         // each time calling f(now, arg) in the timer goroutine, so f must be
 406         // a well-behaved function and not block.
 407         int64   when;
 408         int64   period;
 409         FuncVal *fv;
 410         Eface   arg;
 411         uintptr seq;
 412 };
 413
 414 // Lock-free stack node.
 415 struct LFNode
 416 {
 417         LFNode  *next;
 418         uintptr pushcnt;
 419 };
 420
 421 // Parallel for descriptor.
 422 struct ParFor
 423 {
 424         const FuncVal *body;            // executed for each element
 425         uint32 done;                    // number of idle threads
 426         uint32 nthr;                    // total number of threads
 427         uint32 nthrmax;                 // maximum number of threads
 428         uint32 thrseq;                  // thread id sequencer
 429         uint32 cnt;                     // iteration space [0, cnt)
 430         bool wait;                      // if true, wait while all threads finish processing,
 431                                         // otherwise parfor may return while other threads are still working
 432         ParForThread *thr;              // array of thread descriptors
 433         // stats
 434         uint64 nsteal;
 435         uint64 nstealcnt;
 436         uint64 nprocyield;
 437         uint64 nosyield;
 438         uint64 nsleep;
 439 };
 440
 441 // Track memory allocated by code not written in Go during a cgo call,
 442 // so that the garbage collector can see them.
 443 struct CgoMal
 444 {
 445         CgoMal  *next;
 446         void    *alloc;
 447 };
 448
 449 // Holds variables parsed from GODEBUG env var.
 450 struct DebugVars
 451 {
 452         int32   allocfreetrace;
 453         int32   cgocheck;
 454         int32   efence;
 455         int32   gccheckmark;
 456         int32   gcpacertrace;
 457         int32   gcshrinkstackoff;
 458         int32   gcstackbarrieroff;
 459         int32   gcstackbarrierall;
 460         int32   gcstoptheworld;
 461         int32   gctrace;
 462         int32   gcdead;
 463         int32   invalidptr;
 464         int32   sbrk;
 465         int32   scavenge;
 466         int32   scheddetail;
 467         int32   schedtrace;
 468         int32   wbshadow;
 469 };
 470
 471 extern bool runtime_precisestack;
 472 extern bool runtime_copystack;
 473
 474 /*
 475  * defined macros
 476  *    you need super-gopher-guru privilege
 477  *    to add this list.
 478  */
 479 #define nelem(x)        (sizeof(x)/sizeof((x)[0]))
 480 #define nil             ((void*)0)
 481 #define USED(v)         ((void) v)
 482 #define ROUND(x, n)     (((x)+(n)-1)&~(uintptr)((n)-1)) /* all-caps to mark as macro: it evaluates n twice */
 483
 484 byte*   runtime_startup_random_data;
 485 uint32  runtime_startup_random_data_len;
 486 void    runtime_get_random_data(byte**, int32*);
 487
 488 enum {
 489         // hashinit wants this many random bytes
 490         HashRandomBytes = 32
 491 };
 492 void    runtime_hashinit(void);
 493
 494 void    runtime_traceback(void);
 495 void    runtime_tracebackothers(G*);
 496 enum
 497 {
 498         // The maximum number of frames we print for a traceback
 499         TracebackMaxFrames = 100,
 500 };
 501
 502 /*
 503  * external data
 504  */
 505 extern  uintptr runtime_zerobase;
 506 extern  G**     runtime_allg;
 507 extern  uintptr runtime_allglen;
 508 extern  G*      runtime_lastg;
 509 extern  M*      runtime_allm;
 510 extern  P**     runtime_allp;
 511 extern  int32   runtime_gomaxprocs;
 512 extern  uint32  runtime_needextram;
 513 extern  uint32  runtime_panicking;
 514 extern  int8*   runtime_goos;
 515 extern  int32   runtime_ncpu;
 516 extern  void    (*runtime_sysargs)(int32, uint8**);
 517 extern  uint32  runtime_Hchansize;
 518 extern  DebugVars       runtime_debug;
 519 extern  uintptr runtime_maxstacksize;
 520
 521 extern  bool    runtime_isstarted;
 522 extern  bool    runtime_isarchive;
 523
 524 /*
 525  * common functions and data
 526  */
 527 #define runtime_strcmp(s1, s2) __builtin_strcmp((s1), (s2))
 528 #define runtime_strncmp(s1, s2, n) __builtin_strncmp((s1), (s2), (n))
 529 #define runtime_strstr(s1, s2) __builtin_strstr((s1), (s2))
 530 intgo   runtime_findnull(const byte*);
 531 intgo   runtime_findnullw(const uint16*);
 532 void    runtime_dump(byte*, int32);
 533
 534 void    runtime_gogo(G*);
 535 struct __go_func_type;
 536 void    runtime_args(int32, byte**);
 537 void    runtime_osinit();
 538 void    runtime_goargs(void);
 539 void    runtime_goenvs(void);
 540 void    runtime_goenvs_unix(void);
 541 void    runtime_throw(const char*) __attribute__ ((noreturn));
 542 void    runtime_panicstring(const char*) __attribute__ ((noreturn));
 543 bool    runtime_canpanic(G*);
 544 void    runtime_prints(const char*);
 545 void    runtime_printf(const char*, ...);
 546 int32   runtime_snprintf(byte*, int32, const char*, ...);
 547 #define runtime_mcmp(a, b, s) __builtin_memcmp((a), (b), (s))
 548 #define runtime_memmove(a, b, s) __builtin_memmove((a), (b), (s))
 549 void*   runtime_mal(uintptr);
 550 String  runtime_gostring(const byte*);
 551 String  runtime_gostringnocopy(const byte*);
 552 void    runtime_schedinit(void);
 553 void    runtime_initsig(bool);
 554 void    runtime_sigenable(uint32 sig);
 555 void    runtime_sigdisable(uint32 sig);
 556 void    runtime_sigignore(uint32 sig);
 557 int32   runtime_gotraceback(bool *crash);
 558 void    runtime_goroutineheader(G*);
 559 void    runtime_printtrace(Location*, int32, bool);
 560 #define runtime_open(p, f, m) open((p), (f), (m))
 561 #define runtime_read(d, v, n) read((d), (v), (n))
 562 #define runtime_write(d, v, n) write((d), (v), (n))
 563 #define runtime_close(d) close(d)
 564 void    runtime_ready(G*);
 565 String  runtime_getenv(const char*);
 566 int32   runtime_atoi(const byte*, intgo);
 567 void*   runtime_mstart(void*);
 568 G*      runtime_malg(int32, byte**, size_t*);
 569 void    runtime_mpreinit(M*);
 570 void    runtime_minit(void);
 571 void    runtime_unminit(void);
 572 void    runtime_needm(void);
 573 void    runtime_dropm(void);
 574 void    runtime_signalstack(byte*, int32);
 575 MCache* runtime_allocmcache(void);
 576 void    runtime_freemcache(MCache*);
 577 void    runtime_mallocinit(void);
 578 void    runtime_mprofinit(void);
 579 #define runtime_malloc(s) __go_alloc(s)
 580 #define runtime_free(p) __go_free(p)
 581 #define runtime_getcallersp(p) __builtin_frame_address(1)
 582 int32   runtime_mcount(void);
 583 int32   runtime_gcount(void);
 584 void    runtime_mcall(void(*)(G*));
 585 uint32  runtime_fastrand1(void);
 586 int32   runtime_timediv(int64, int32, int32*);
 587 int32   runtime_round2(int32 x); // round x up to a power of 2.
 588
 589 // atomic operations
 590 #define runtime_cas(pval, old, new) __sync_bool_compare_and_swap (pval, old, new)
 591 #define runtime_cas64(pval, old, new) __sync_bool_compare_and_swap (pval, old, new)
 592 #define runtime_casp(pval, old, new) __sync_bool_compare_and_swap (pval, old, new)
 593 // Don't confuse with XADD x86 instruction,
 594 // this one is actually 'addx', that is, add-and-fetch.
 595 #define runtime_xadd(p, v) __sync_add_and_fetch (p, v)
 596 #define runtime_xadd64(p, v) __sync_add_and_fetch (p, v)
 597 #define runtime_xchg(p, v) __atomic_exchange_n (p, v, __ATOMIC_SEQ_CST)
 598 #define runtime_xchg64(p, v) __atomic_exchange_n (p, v, __ATOMIC_SEQ_CST)
 599 #define runtime_xchgp(p, v) __atomic_exchange_n (p, v, __ATOMIC_SEQ_CST)
 600 #define runtime_atomicload(p) __atomic_load_n (p, __ATOMIC_SEQ_CST)
 601 #define runtime_atomicstore(p, v) __atomic_store_n (p, v, __ATOMIC_SEQ_CST)
 602 #define runtime_atomicstore64(p, v) __atomic_store_n (p, v, __ATOMIC_SEQ_CST)
 603 #define runtime_atomicload64(p) __atomic_load_n (p, __ATOMIC_SEQ_CST)
 604 #define runtime_atomicloadp(p) __atomic_load_n (p, __ATOMIC_SEQ_CST)
 605 #define runtime_atomicstorep(p, v) __atomic_store_n (p, v, __ATOMIC_SEQ_CST)
 606
 607 void runtime_setmg(M*, G*);
 608 void runtime_newextram(void);
 609 #define runtime_exit(s) exit(s)
 610 #define runtime_breakpoint() __builtin_trap()
 611 void    runtime_gosched(void);
 612 void    runtime_gosched0(G*);
 613 void    runtime_schedtrace(bool);
 614 void    runtime_park(bool(*)(G*, void*), void*, const char*);
 615 void    runtime_parkunlock(Lock*, const char*);
 616 void    runtime_tsleep(int64, const char*);
 617 M*      runtime_newm(void);
 618 void    runtime_goexit(void);
 619 void    runtime_entersyscall(void) __asm__ (GOSYM_PREFIX "syscall.Entersyscall");
 620 void    runtime_entersyscallblock(void);
 621 void    runtime_exitsyscall(void) __asm__ (GOSYM_PREFIX "syscall.Exitsyscall");
 622 G*      __go_go(void (*pfn)(void*), void*);
 623 void    siginit(void);
 624 bool    __go_sigsend(int32 sig);
 625 int32   runtime_callers(int32, Location*, int32, bool keep_callers);
 626 int64   runtime_nanotime(void); // monotonic time
 627 int64   runtime_unixnanotime(void); // real time, can skip
 628 void    runtime_dopanic(int32) __attribute__ ((noreturn));
 629 void    runtime_startpanic(void);
 630 void    runtime_freezetheworld(void);
 631 void    runtime_unwindstack(G*, byte*);
 632 void    runtime_sigprof();
 633 void    runtime_resetcpuprofiler(int32);
 634 void    runtime_setcpuprofilerate(void(*)(uintptr*, int32), int32);
 635 void    runtime_usleep(uint32);
 636 int64   runtime_cputicks(void);
 637 int64   runtime_tickspersecond(void);
 638 void    runtime_blockevent(int64, int32);
 639 extern int64 runtime_blockprofilerate;
 640 void    runtime_addtimer(Timer*);
 641 bool    runtime_deltimer(Timer*);
 642 G*      runtime_netpoll(bool);
 643 void    runtime_netpollinit(void);
 644 int32   runtime_netpollopen(uintptr, PollDesc*);
 645 int32   runtime_netpollclose(uintptr);
 646 void    runtime_netpollready(G**, PollDesc*, int32);
 647 uintptr runtime_netpollfd(PollDesc*);
 648 void    runtime_netpollarm(PollDesc*, int32);
 649 void**  runtime_netpolluser(PollDesc*);
 650 bool    runtime_netpollclosing(PollDesc*);
 651 void    runtime_netpolllock(PollDesc*);
 652 void    runtime_netpollunlock(PollDesc*);
 653 void    runtime_crash(void);
 654 void    runtime_parsedebugvars(void);
 655 void    _rt0_go(void);
 656 void*   runtime_funcdata(Func*, int32);
 657 int32   runtime_setmaxthreads(int32);
 658 G*      runtime_timejump(void);
 659 void    runtime_iterate_finq(void (*callback)(FuncVal*, void*, const FuncType*, const PtrType*));
 660
 661 void    runtime_stoptheworld(void);
 662 void    runtime_starttheworld(void);
 663 extern uint32 runtime_worldsema;
 664
 665 /*
 666  * mutual exclusion locks.  in the uncontended case,
 667  * as fast as spin locks (just a few user-level instructions),
 668  * but on the contention path they sleep in the kernel.
 669  * a zeroed Lock is unlocked (no need to initialize each lock).
 670  */
 671 void    runtime_lock(Lock*);
 672 void    runtime_unlock(Lock*);
 673
 674 /*
 675  * sleep and wakeup on one-time events.
 676  * before any calls to notesleep or notewakeup,
 677  * must call noteclear to initialize the Note.
 678  * then, exactly one thread can call notesleep
 679  * and exactly one thread can call notewakeup (once).
 680  * once notewakeup has been called, the notesleep
 681  * will return.  future notesleep will return immediately.
 682  * subsequent noteclear must be called only after
 683  * previous notesleep has returned, e.g. it's disallowed
 684  * to call noteclear straight after notewakeup.
 685  *
 686  * notetsleep is like notesleep but wakes up after
 687  * a given number of nanoseconds even if the event
 688  * has not yet happened.  if a goroutine uses notetsleep to
 689  * wake up early, it must wait to call noteclear until it
 690  * can be sure that no other goroutine is calling
 691  * notewakeup.
 692  *
 693  * notesleep/notetsleep are generally called on g0,
 694  * notetsleepg is similar to notetsleep but is called on user g.
 695  */
 696 void    runtime_noteclear(Note*);
 697 void    runtime_notesleep(Note*);
 698 void    runtime_notewakeup(Note*);
 699 bool    runtime_notetsleep(Note*, int64);  // false - timeout
 700 bool    runtime_notetsleepg(Note*, int64);  // false - timeout
 701
 702 /*
 703  * low-level synchronization for implementing the above
 704  */
 705 uintptr runtime_semacreate(void);
 706 int32   runtime_semasleep(int64);
 707 void    runtime_semawakeup(M*);
 708 // or
 709 void    runtime_futexsleep(uint32*, uint32, int64);
 710 void    runtime_futexwakeup(uint32*, uint32);
 711
 712 /*
 713  * Lock-free stack.
 714  * Initialize uint64 head to 0, compare with 0 to test for emptiness.
 715  * The stack does not keep pointers to nodes,
 716  * so they can be garbage collected if there are no other pointers to nodes.
 717  */
 718 void    runtime_lfstackpush(uint64 *head, LFNode *node)
 719   __asm__ (GOSYM_PREFIX "runtime.lfstackpush");
 720 LFNode* runtime_lfstackpop(uint64 *head);
 721
 722 /*
 723  * Parallel for over [0, n).
 724  * body() is executed for each iteration.
 725  * nthr - total number of worker threads.
 726  * if wait=true, threads return from parfor() when all work is done;
 727  * otherwise, threads can return while other threads are still finishing processing.
 728  */
 729 ParFor* runtime_parforalloc(uint32 nthrmax);
 730 void    runtime_parforsetup(ParFor *desc, uint32 nthr, uint32 n, bool wait, const FuncVal *body);
 731 void    runtime_parfordo(ParFor *desc);
 732 void    runtime_parforiters(ParFor*, uintptr, uintptr*, uintptr*);
 733
 734 /*
 735  * low level C-called
 736  */
 737 #define runtime_mmap mmap
 738 #define runtime_munmap munmap
 739 #define runtime_madvise madvise
 740 #define runtime_memclr(buf, size) __builtin_memset((buf), 0, (size))
 741 #define runtime_getcallerpc(p) __builtin_return_address(0)
 742
 743 #ifdef __rtems__
 744 void __wrap_rtems_task_variable_add(void **);
 745 #endif
 746
 747 /*
 748  * Names generated by gccgo.
 749  */
 750 #define runtime_printbool       __go_print_bool
 751 #define runtime_printfloat      __go_print_double
 752 #define runtime_printint        __go_print_int64
 753 #define runtime_printiface      __go_print_interface
 754 #define runtime_printeface      __go_print_empty_interface
 755 #define runtime_printstring     __go_print_string
 756 #define runtime_printpointer    __go_print_pointer
 757 #define runtime_printuint       __go_print_uint64
 758 #define runtime_printslice      __go_print_slice
 759 #define runtime_printcomplex    __go_print_complex
 760
 761 /*
 762  * runtime go-called
 763  */
 764 void    runtime_printbool(_Bool);
 765 void    runtime_printbyte(int8);
 766 void    runtime_printfloat(double);
 767 void    runtime_printint(int64);
 768 void    runtime_printiface(Iface);
 769 void    runtime_printeface(Eface);
 770 void    runtime_printstring(String);
 771 void    runtime_printpc(void*);
 772 void    runtime_printpointer(void*);
 773 void    runtime_printuint(uint64);
 774 void    runtime_printhex(uint64);
 775 void    runtime_printslice(Slice);
 776 void    runtime_printcomplex(complex double);
 777 void reflect_call(const struct __go_func_type *, FuncVal *, _Bool, _Bool,
 778                   void **, void **)
 779   __asm__ (GOSYM_PREFIX "reflect.call");
 780 #define runtime_panic __go_panic
 781
 782 /*
 783  * runtime c-called (but written in Go)
 784  */
 785 void    runtime_printany(Eface)
 786      __asm__ (GOSYM_PREFIX "runtime.Printany");
 787 void    runtime_newTypeAssertionError(const String*, const String*, const String*, const String*, Eface*)
 788      __asm__ (GOSYM_PREFIX "runtime.NewTypeAssertionError");
 789 void    runtime_newErrorCString(const char*, Eface*)
 790      __asm__ (GOSYM_PREFIX "runtime.NewErrorCString");
 791
 792 /*
 793  * wrapped for go users
 794  */
 795 void    runtime_semacquire(uint32 volatile *, bool);
 796 void    runtime_semrelease(uint32 volatile *);
 797 int32   runtime_gomaxprocsfunc(int32 n);
 798 void    runtime_procyield(uint32);
 799 void    runtime_osyield(void);
 800 void    runtime_lockOSThread(void);
 801 void    runtime_unlockOSThread(void);
 802 bool    runtime_lockedOSThread(void);
 803
 804 bool    runtime_showframe(String, bool);
 805 void    runtime_printcreatedby(G*);
 806
 807 uintptr runtime_memlimit(void);
 808
 809 #define ISNAN(f) __builtin_isnan(f)
 810
 811 enum
 812 {
 813         UseSpanType = 1,
 814 };
 815
 816 #define runtime_setitimer setitimer
 817
 818 void    runtime_check(void);
 819
 820 // A list of global variables that the garbage collector must scan.
 821 struct root_list {
 822         struct root_list *next;
 823         struct root {
 824                 void *decl;
 825                 size_t size;
 826         } roots[];
 827 };
 828
 829 void    __go_register_gc_roots(struct root_list*);
 830
 831 // Size of stack space allocated using Go's allocator.
 832 // This will be 0 when using split stacks, as in that case
 833 // the stacks are allocated by the splitstack library.
 834 extern uintptr runtime_stacks_sys;
 835
 836 struct backtrace_state;
 837 extern struct backtrace_state *__go_get_backtrace_state(void);
 838 extern _Bool __go_file_line(uintptr, String*, String*, intgo *);
 839 extern byte* runtime_progname();
 840 extern void runtime_main(void*);
 841 extern uint32 runtime_in_callers;
 842
 843 int32 getproccount(void);
 844
 845 #define PREFETCH(p) __builtin_prefetch(p)
 846
 847 bool    runtime_gcwaiting(void);
 848 void    runtime_badsignal(int);
 849 Defer*  runtime_newdefer(void);
 850 void    runtime_freedefer(Defer*);
 851
 852 struct time_now_ret
 853 {
 854   int64_t sec;
 855   int32_t nsec;
 856 };
 857
 858 struct time_now_ret now() __asm__ (GOSYM_PREFIX "time.now")
 859   __attribute__ ((no_split_stack));
 860
 861 extern void _cgo_wait_runtime_init_done (void);
 862 extern void _cgo_notify_runtime_init_done (void);
 863 extern _Bool runtime_iscgo;
 864 extern _Bool runtime_cgoHasExtraM;
 865 extern Hchan *runtime_main_init_done;
 866 extern uintptr __go_end __attribute__ ((weak));