OSDN Git Service

db59be5d062cb7c6af8e05997249fbacdcce1fed
[pf3gnuchains/gcc-fork.git] / libgo / runtime / runtime.h
1 /* runtime.h -- runtime support for Go.
2
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.  */
6
7 #include "config.h"
8
9 #define _GNU_SOURCE
10 #include "go-assert.h"
11 #include <setjmp.h>
12 #include <signal.h>
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <sys/types.h>
17 #include <sys/stat.h>
18 #include <fcntl.h>
19 #include <pthread.h>
20 #include <semaphore.h>
21 #include <ucontext.h>
22
23 #ifdef HAVE_SYS_MMAN_H
24 #include <sys/mman.h>
25 #endif
26
27 #include "array.h"
28 #include "go-alloc.h"
29 #include "go-panic.h"
30 #include "go-string.h"
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 unsigned int uintptr __attribute__ ((mode (pointer)));
47
48 /* Defined types.  */
49
50 typedef uint8                   bool;
51 typedef uint8                   byte;
52 typedef struct  G               G;
53 typedef union   Lock            Lock;
54 typedef struct  M               M;
55 typedef union   Note            Note;
56 typedef struct  MCache          MCache;
57 typedef struct  FixAlloc        FixAlloc;
58 typedef struct  Hchan           Hchan;
59
60 typedef struct  __go_open_array         Slice;
61 typedef struct  __go_string             String;
62 typedef struct  __go_interface          Iface;
63 typedef struct  __go_empty_interface    Eface;
64 typedef struct  __go_type_descriptor    Type;
65 typedef struct  __go_defer_stack        Defer;
66 typedef struct  __go_panic_stack        Panic;
67
68 typedef struct  __go_func_type          FuncType;
69 typedef struct  __go_map_type           MapType;
70
71 /*
72  * per-cpu declaration.
73  */
74 extern M*       runtime_m(void);
75 extern G*       runtime_g(void);
76
77 extern M        runtime_m0;
78 extern G        runtime_g0;
79
80 /*
81  * defined constants
82  */
83 enum
84 {
85         // G status
86         //
87         // If you add to this list, add to the list
88         // of "okay during garbage collection" status
89         // in mgc0.c too.
90         Gidle,
91         Grunnable,
92         Grunning,
93         Gsyscall,
94         Gwaiting,
95         Gmoribund,
96         Gdead,
97 };
98 enum
99 {
100         true    = 1,
101         false   = 0,
102 };
103
104 /*
105  * structures
106  */
107 union   Lock
108 {
109         uint32  key;    // futex-based impl
110         M*      waitm;  // linked list of waiting M's (sema-based impl)
111 };
112 union   Note
113 {
114         uint32  key;    // futex-based impl
115         M*      waitm;  // waiting M (sema-based impl)
116 };
117 struct  G
118 {
119         Defer*  defer;
120         Panic*  panic;
121         void*   exception;      // current exception being thrown
122         bool    is_foreign;     // whether current exception from other language
123         void    *gcstack;       // if status==Gsyscall, gcstack = stackbase to use during gc
124         uintptr gcstack_size;
125         void*   gcnext_segment;
126         void*   gcnext_sp;
127         void*   gcinitial_sp;
128         jmp_buf gcregs;
129         byte*   entry;          // initial function
130         G*      alllink;        // on allg
131         void*   param;          // passed parameter on wakeup
132         bool    fromgogo;       // reached from gogo
133         int16   status;
134         int32   goid;
135         uint32  selgen;         // valid sudog pointer
136         const char*     waitreason;     // if status==Gwaiting
137         G*      schedlink;
138         bool    readyonstop;
139         bool    ispanic;
140         M*      m;              // for debuggers, but offset not hard-coded
141         M*      lockedm;
142         M*      idlem;
143         // int32        sig;
144         // uintptr      sigcode0;
145         // uintptr      sigcode1;
146         // uintptr      sigpc;
147         uintptr gopc;   // pc of go statement that created this goroutine
148
149         ucontext_t      context;
150         void*           stack_context[10];
151 };
152
153 struct  M
154 {
155         G*      g0;             // goroutine with scheduling stack
156         G*      gsignal;        // signal-handling G
157         G*      curg;           // current running goroutine
158         int32   id;
159         int32   mallocing;
160         int32   gcing;
161         int32   locks;
162         int32   nomemprof;
163         int32   waitnextg;
164         int32   dying;
165         int32   profilehz;
166         int32   helpgc;
167         uint32  fastrand;
168         Note    havenextg;
169         G*      nextg;
170         M*      alllink;        // on allm
171         M*      schedlink;
172         MCache  *mcache;
173         G*      lockedg;
174         G*      idleg;
175         M*      nextwaitm;      // next M waiting for lock
176         uintptr waitsema;       // semaphore for parking on locks
177         uint32  waitsemacount;
178         uint32  waitsemalock;
179 };
180
181 /* Macros.  */
182
183 #ifdef __WINDOWS__
184 enum {
185    Windows = 1
186 };
187 #else
188 enum {
189    Windows = 0
190 };
191 #endif
192
193 #define nelem(x)        (sizeof(x)/sizeof((x)[0]))
194 #define nil             ((void*)0)
195 #define USED(v)         ((void) v)
196
197 /*
198  * external data
199  */
200 G*      runtime_allg;
201 G*      runtime_lastg;
202 M*      runtime_allm;
203 extern  int32   runtime_gomaxprocs;
204 extern  bool    runtime_singleproc;
205 extern  uint32  runtime_panicking;
206 extern  int32   runtime_gcwaiting;              // gc is waiting to run
207 int32   runtime_ncpu;
208
209 /*
210  * common functions and data
211  */
212 int32   runtime_findnull(const byte*);
213
214 /*
215  * very low level c-called
216  */
217 void    runtime_args(int32, byte**);
218 void    runtime_osinit();
219 void    runtime_goargs(void);
220 void    runtime_goenvs(void);
221 void    runtime_throw(const char*);
222 void    runtime_panicstring(const char*) __attribute__ ((noreturn));
223 void*   runtime_mal(uintptr);
224 void    runtime_schedinit(void);
225 void    runtime_initsig(int32);
226 String  runtime_gostringnocopy(const byte*);
227 void*   runtime_mstart(void*);
228 G*      runtime_malg(int32, byte**, size_t*);
229 void    runtime_minit(void);
230 void    runtime_mallocinit(void);
231 void    runtime_gosched(void);
232 void    runtime_goexit(void);
233 void    runtime_entersyscall(void) __asm__("libgo_syscall.syscall.entersyscall");
234 void    runtime_exitsyscall(void) __asm__("libgo_syscall.syscall.exitsyscall");
235 void    siginit(void);
236 bool    __go_sigsend(int32 sig);
237 int64   runtime_nanotime(void);
238
239 void    runtime_stoptheworld(void);
240 void    runtime_starttheworld(bool);
241 G*      __go_go(void (*pfn)(void*), void*);
242
243 /*
244  * mutual exclusion locks.  in the uncontended case,
245  * as fast as spin locks (just a few user-level instructions),
246  * but on the contention path they sleep in the kernel.
247  * a zeroed Lock is unlocked (no need to initialize each lock).
248  */
249 void    runtime_lock(Lock*);
250 void    runtime_unlock(Lock*);
251
252 /*
253  * sleep and wakeup on one-time events.
254  * before any calls to notesleep or notewakeup,
255  * must call noteclear to initialize the Note.
256  * then, exactly one thread can call notesleep
257  * and exactly one thread can call notewakeup (once).
258  * once notewakeup has been called, the notesleep
259  * will return.  future notesleep will return immediately.
260  * subsequent noteclear must be called only after
261  * previous notesleep has returned, e.g. it's disallowed
262  * to call noteclear straight after notewakeup.
263  *
264  * notetsleep is like notesleep but wakes up after
265  * a given number of nanoseconds even if the event
266  * has not yet happened.  if a goroutine uses notetsleep to
267  * wake up early, it must wait to call noteclear until it
268  * can be sure that no other goroutine is calling
269  * notewakeup.
270  */
271 void    runtime_noteclear(Note*);
272 void    runtime_notesleep(Note*);
273 void    runtime_notewakeup(Note*);
274 void    runtime_notetsleep(Note*, int64);
275
276 /*
277  * low-level synchronization for implementing the above
278  */
279 uintptr runtime_semacreate(void);
280 int32   runtime_semasleep(int64);
281 void    runtime_semawakeup(M*);
282 // or
283 void    runtime_futexsleep(uint32*, uint32, int64);
284 void    runtime_futexwakeup(uint32*, uint32);
285
286 /*
287  * runtime go-called
288  */
289 void    runtime_panic(Eface);
290
291 /* Functions.  */
292 #define runtime_panic __go_panic
293 #define runtime_printf printf
294 #define runtime_malloc(s) __go_alloc(s)
295 #define runtime_free(p) __go_free(p)
296 #define runtime_memclr(buf, size) __builtin_memset((buf), 0, (size))
297 #define runtime_strcmp(s1, s2) __builtin_strcmp((s1), (s2))
298 #define runtime_mcmp(a, b, s) __builtin_memcmp((a), (b), (s))
299 #define runtime_memmove(a, b, s) __builtin_memmove((a), (b), (s))
300 #define runtime_exit(s) _exit(s)
301 MCache* runtime_allocmcache(void);
302 void    free(void *v);
303 struct __go_func_type;
304 bool    runtime_addfinalizer(void*, void(*fn)(void*), const struct __go_func_type *);
305 #define runtime_mmap mmap
306 #define runtime_munmap(p, s) munmap((p), (s))
307 #define runtime_cas(pval, old, new) __sync_bool_compare_and_swap (pval, old, new)
308 #define runtime_casp(pval, old, new) __sync_bool_compare_and_swap (pval, old, new)
309 #define runtime_xadd(p, v) __sync_add_and_fetch (p, v)
310 #define runtime_xchg(p, v) __atomic_exchange_n (p, v, __ATOMIC_SEQ_CST)
311 #define runtime_atomicload(p) __atomic_load_n (p, __ATOMIC_SEQ_CST)
312 #define runtime_atomicstore(p, v) __atomic_store_n (p, v, __ATOMIC_SEQ_CST)
313 #define runtime_atomicloadp(p) __atomic_load_n (p, __ATOMIC_SEQ_CST)
314 #define runtime_atomicstorep(p, v) __atomic_store_n (p, v, __ATOMIC_SEQ_CST)
315
316 void    runtime_dopanic(int32) __attribute__ ((noreturn));
317 void    runtime_startpanic(void);
318 void    runtime_ready(G*);
319 const byte*     runtime_getenv(const char*);
320 int32   runtime_atoi(const byte*);
321 void    runtime_sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp);
322 void    runtime_resetcpuprofiler(int32);
323 void    runtime_setcpuprofilerate(void(*)(uintptr*, int32), int32);
324 uint32  runtime_fastrand1(void);
325 void    runtime_semacquire(uint32 volatile *);
326 void    runtime_semrelease(uint32 volatile *);
327 int32   runtime_gomaxprocsfunc(int32 n);
328 void    runtime_procyield(uint32);
329 void    runtime_osyield(void);
330 void    runtime_usleep(uint32);
331
332 struct __go_func_type;
333 void reflect_call(const struct __go_func_type *, const void *, _Bool, _Bool,
334                   void **, void **)
335   asm ("libgo_reflect.reflect.call");
336
337 #ifdef __rtems__
338 void __wrap_rtems_task_variable_add(void **);
339 #endif
340
341 /* Temporary.  */
342 void    runtime_cond_wait(pthread_cond_t*, pthread_mutex_t*);