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