1 /* runtime.h -- runtime support for Go.
3 Copyright 2009 The Go Authors. All rights reserved.
4 Use of this source code is governed by a BSD-style
5 license that can be found in the LICENSE file. */
14 #include <sys/types.h>
19 #include <semaphore.h>
22 #ifdef HAVE_SYS_MMAN_H
29 #include "go-string.h"
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
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 unsigned int uintptr
__attribute__ ((mode (pointer
)));
51 typedef struct Func Func
;
53 typedef union Lock Lock
;
55 typedef union Note Note
;
56 typedef struct SigTab SigTab
;
57 typedef struct MCache MCache
;
58 typedef struct FixAlloc FixAlloc
;
59 typedef struct Hchan Hchan
;
60 typedef struct Timers Timers
;
61 typedef struct Timer Timer
;
63 typedef struct __go_open_array Slice
;
64 typedef struct __go_string String
;
65 typedef struct __go_interface Iface
;
66 typedef struct __go_empty_interface Eface
;
67 typedef struct __go_type_descriptor Type
;
68 typedef struct __go_defer_stack Defer
;
69 typedef struct __go_panic_stack Panic
;
71 typedef struct __go_func_type FuncType
;
72 typedef struct __go_map_type MapType
;
75 * per-cpu declaration.
77 extern M
* runtime_m(void);
78 extern G
* runtime_g(void);
90 // If you add to this list, add to the list
91 // of "okay during garbage collection" status
112 uint32 key
; // futex-based impl
113 M
* waitm
; // linked list of waiting M's (sema-based impl)
117 uint32 key
; // futex-based impl
118 M
* waitm
; // waiting M (sema-based impl)
124 void* exception
; // current exception being thrown
125 bool is_foreign
; // whether current exception from other language
126 void *gcstack
; // if status==Gsyscall, gcstack = stackbase to use during gc
127 uintptr gcstack_size
;
128 void* gcnext_segment
;
132 byte
* entry
; // initial function
133 G
* alllink
; // on allg
134 void* param
; // passed parameter on wakeup
135 bool fromgogo
; // reached from gogo
138 uint32 selgen
; // valid sudog pointer
139 const char* waitreason
; // if status==Gwaiting
143 M
* m
; // for debuggers, but offset not hard-coded
152 uintptr gopc
; // pc of go statement that created this goroutine
157 void* stack_context
[10];
162 G
* g0
; // goroutine with scheduling stack
163 G
* gsignal
; // signal-handling G
164 G
* curg
; // current running goroutine
177 M
* alllink
; // on allm
182 uintptr createstack
[32]; // Stack that created this thread.
183 M
* nextwaitm
; // next M waiting for lock
184 uintptr waitsema
; // semaphore for parking on locks
185 uint32 waitsemacount
;
196 SigNotify
= 1<<0, // let signal.Notify have signal, even if from kernel
197 SigKill
= 1<<1, // if signal.Notify doesn't take it, exit quietly
198 SigThrow
= 1<<2, // if signal.Notify doesn't take it, exit loudly
199 SigPanic
= 1<<3, // if the signal is from the kernel, panic
200 SigDefault
= 1<<4, // if the signal isn't explicitly requested, don't monitor it
207 // NOTE(rsc): keep in sync with extern.go:/type.Func.
208 // Eventually, the loaded symbol table should be closer to this form.
212 uintptr entry
; // entry pc
239 // Package time knows the layout of this structure.
240 // If this struct changes, adjust ../time/sleep.go:/runtimeTimer.
243 int32 i
; // heap index
245 // Timer wakes up at when, and then at when+period, ... (period > 0 only)
246 // each time calling f(now, arg) in the timer goroutine, so f must be
247 // a well-behaved function and not block.
250 void (*f
)(int64
, Eface
);
256 * you need super-gopher-guru privilege
259 #define nelem(x) (sizeof(x)/sizeof((x)[0]))
260 #define nil ((void*)0)
261 #define USED(v) ((void) v)
269 extern int32 runtime_gomaxprocs
;
270 extern bool runtime_singleproc
;
271 extern uint32 runtime_panicking
;
272 extern int32 runtime_gcwaiting
; // gc is waiting to run
276 * common functions and data
278 int32
runtime_findnull(const byte
*);
279 void runtime_dump(byte
*, int32
);
282 * very low level c-called
284 void runtime_args(int32
, byte
**);
285 void runtime_osinit();
286 void runtime_goargs(void);
287 void runtime_goenvs(void);
288 void runtime_goenvs_unix(void);
289 void runtime_throw(const char*) __attribute__ ((noreturn
));
290 void runtime_panicstring(const char*) __attribute__ ((noreturn
));
291 void runtime_prints(const char*);
292 void runtime_printf(const char*, ...);
293 void* runtime_mal(uintptr
);
294 void runtime_schedinit(void);
295 void runtime_initsig(void);
296 void runtime_sigenable(uint32 sig
);
297 int32
runtime_gotraceback(void);
298 void runtime_goroutineheader(G
*);
299 void runtime_goroutinetrailer(G
*);
300 void runtime_traceback();
301 void runtime_tracebackothers(G
*);
302 String
runtime_gostringnocopy(const byte
*);
303 void* runtime_mstart(void*);
304 G
* runtime_malg(int32
, byte
**, size_t*);
305 void runtime_minit(void);
306 void runtime_mallocinit(void);
307 void runtime_gosched(void);
308 void runtime_tsleep(int64
);
309 M
* runtime_newm(void);
310 void runtime_goexit(void);
311 void runtime_entersyscall(void) __asm__("syscall.Entersyscall");
312 void runtime_exitsyscall(void) __asm__("syscall.Exitsyscall");
314 bool __go_sigsend(int32 sig
);
315 int32
runtime_callers(int32
, uintptr
*, int32
);
316 int64
runtime_nanotime(void);
317 int64
runtime_cputicks(void);
319 void runtime_stoptheworld(void);
320 void runtime_starttheworld(bool);
321 extern uint32 runtime_worldsema
;
322 G
* __go_go(void (*pfn
)(void*), void*);
325 * mutual exclusion locks. in the uncontended case,
326 * as fast as spin locks (just a few user-level instructions),
327 * but on the contention path they sleep in the kernel.
328 * a zeroed Lock is unlocked (no need to initialize each lock).
330 void runtime_lock(Lock
*);
331 void runtime_unlock(Lock
*);
334 * sleep and wakeup on one-time events.
335 * before any calls to notesleep or notewakeup,
336 * must call noteclear to initialize the Note.
337 * then, exactly one thread can call notesleep
338 * and exactly one thread can call notewakeup (once).
339 * once notewakeup has been called, the notesleep
340 * will return. future notesleep will return immediately.
341 * subsequent noteclear must be called only after
342 * previous notesleep has returned, e.g. it's disallowed
343 * to call noteclear straight after notewakeup.
345 * notetsleep is like notesleep but wakes up after
346 * a given number of nanoseconds even if the event
347 * has not yet happened. if a goroutine uses notetsleep to
348 * wake up early, it must wait to call noteclear until it
349 * can be sure that no other goroutine is calling
352 void runtime_noteclear(Note
*);
353 void runtime_notesleep(Note
*);
354 void runtime_notewakeup(Note
*);
355 void runtime_notetsleep(Note
*, int64
);
358 * low-level synchronization for implementing the above
360 uintptr
runtime_semacreate(void);
361 int32
runtime_semasleep(int64
);
362 void runtime_semawakeup(M
*);
364 void runtime_futexsleep(uint32
*, uint32
, int64
);
365 void runtime_futexwakeup(uint32
*, uint32
);
370 #define runtime_mmap mmap
371 #define runtime_munmap munmap
372 #define runtime_madvise madvise
373 #define runtime_memclr(buf, size) __builtin_memset((buf), 0, (size))
374 #define runtime_getcallerpc(p) __builtin_return_address(0)
377 void __wrap_rtems_task_variable_add(void **);
381 * Names generated by gccgo.
383 #define runtime_printbool __go_print_bool
384 #define runtime_printfloat __go_print_double
385 #define runtime_printint __go_print_int64
386 #define runtime_printiface __go_print_interface
387 #define runtime_printeface __go_print_empty_interface
388 #define runtime_printstring __go_print_string
389 #define runtime_printpointer __go_print_pointer
390 #define runtime_printuint __go_print_uint64
391 #define runtime_printslice __go_print_slice
392 #define runtime_printcomplex __go_print_complex
397 void runtime_printbool(_Bool
);
398 void runtime_printfloat(double);
399 void runtime_printint(int64
);
400 void runtime_printiface(Iface
);
401 void runtime_printeface(Eface
);
402 void runtime_printstring(String
);
403 void runtime_printpc(void*);
404 void runtime_printpointer(void*);
405 void runtime_printuint(uint64
);
406 void runtime_printhex(uint64
);
407 void runtime_printslice(Slice
);
408 void runtime_printcomplex(__complex
double);
410 struct __go_func_type
;
411 void reflect_call(const struct __go_func_type
*, const void *, _Bool
, _Bool
,
413 asm ("reflect.call");
416 #define runtime_panic __go_panic
417 #define runtime_write(d, v, n) write((d), (v), (n))
418 #define runtime_malloc(s) __go_alloc(s)
419 #define runtime_free(p) __go_free(p)
420 #define runtime_strcmp(s1, s2) __builtin_strcmp((s1), (s2))
421 #define runtime_mcmp(a, b, s) __builtin_memcmp((a), (b), (s))
422 #define runtime_memmove(a, b, s) __builtin_memmove((a), (b), (s))
423 #define runtime_exit(s) exit(s)
424 MCache
* runtime_allocmcache(void);
426 #define runtime_cas(pval, old, new) __sync_bool_compare_and_swap (pval, old, new)
427 #define runtime_casp(pval, old, new) __sync_bool_compare_and_swap (pval, old, new)
428 #define runtime_xadd(p, v) __sync_add_and_fetch (p, v)
429 #define runtime_xchg(p, v) __atomic_exchange_n (p, v, __ATOMIC_SEQ_CST)
430 #define runtime_atomicload(p) __atomic_load_n (p, __ATOMIC_SEQ_CST)
431 #define runtime_atomicstore(p, v) __atomic_store_n (p, v, __ATOMIC_SEQ_CST)
432 #define runtime_atomicloadp(p) __atomic_load_n (p, __ATOMIC_SEQ_CST)
433 #define runtime_atomicstorep(p, v) __atomic_store_n (p, v, __ATOMIC_SEQ_CST)
435 struct __go_func_type
;
436 bool runtime_addfinalizer(void*, void(*fn
)(void*), const struct __go_func_type
*);
437 #define runtime_getcallersp(p) __builtin_frame_address(1)
438 int32
runtime_mcount(void);
439 int32
runtime_gcount(void);
440 void runtime_dopanic(int32
) __attribute__ ((noreturn
));
441 void runtime_startpanic(void);
442 void runtime_ready(G
*);
443 const byte
* runtime_getenv(const char*);
444 int32
runtime_atoi(const byte
*);
445 uint32
runtime_fastrand1(void);
447 void runtime_sigprof(uint8
*pc
, uint8
*sp
, uint8
*lr
, G
*gp
);
448 void runtime_resetcpuprofiler(int32
);
449 void runtime_setcpuprofilerate(void(*)(uintptr
*, int32
), int32
);
450 void runtime_usleep(uint32
);
453 * runtime c-called (but written in Go)
455 void runtime_printany(Eface
)
456 __asm__("runtime.Printany");
457 void runtime_newTypeAssertionError(const String
*, const String
*, const String
*, const String
*, Eface
*)
458 __asm__("runtime.NewTypeAssertionError");
459 void runtime_newErrorString(String
, Eface
*)
460 __asm__("runtime.NewErrorString");
463 * wrapped for go users
465 bool runtime_isInf(float64 f
, int32 sign
);
466 #define runtime_isNaN(f) __builtin_isnan(f)
467 void runtime_semacquire(uint32
volatile *);
468 void runtime_semrelease(uint32
volatile *);
469 int32
runtime_gomaxprocsfunc(int32 n
);
470 void runtime_procyield(uint32
);
471 void runtime_osyield(void);
472 void runtime_LockOSThread(void) __asm__("runtime.LockOSThread");
473 void runtime_UnlockOSThread(void) __asm__("runtime.UnlockOSThread");
475 bool runtime_showframe(const unsigned char*);
477 uintptr
runtime_memlimit(void);
479 // If appropriate, ask the operating system to control whether this
480 // thread should receive profiling signals. This is only necessary on OS X.
481 // An operating system should not deliver a profiling signal to a
482 // thread that is not actually executing (what good is that?), but that's
483 // what OS X prefers to do. When profiling is turned on, we mask
484 // away the profiling signal when threads go to sleep, so that OS X
485 // is forced to deliver the signal to a thread that's actually running.
486 // This is a no-op on other systems.
487 void runtime_setprof(bool);
489 void runtime_time_scan(void (*)(byte
*, int64
));
491 void runtime_setsig(int32
, bool, bool);
492 #define runtime_setitimer setitimer
494 void runtime_check(void);
496 // A list of global variables that the garbage collector must scan.
498 struct root_list
*next
;
505 void __go_register_gc_roots(struct root_list
*);
507 // Size of stack space allocated using Go's allocator.
508 // This will be 0 when using split stacks, as in that case
509 // the stacks are allocated by the splitstack library.
510 extern uintptr runtime_stacks_sys
;
512 extern _Bool
__go_file_line (uintptr
, String
*, String
*, int *);