1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
/* runtime.h -- runtime support for Go.
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. */
#include "config.h"
#define _GNU_SOURCE
#include "go-assert.h"
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
#include "go-alloc.h"
#include "go-panic.h"
#include "go-string.h"
typedef struct __go_string String;
/* This file supports C files copied from the 6g runtime library.
This is a version of the 6g runtime.h rewritten for gccgo's version
of the code. */
typedef signed int int8 __attribute__ ((mode (QI)));
typedef unsigned int uint8 __attribute__ ((mode (QI)));
typedef signed int int16 __attribute__ ((mode (HI)));
typedef unsigned int uint16 __attribute__ ((mode (HI)));
typedef signed int int32 __attribute__ ((mode (SI)));
typedef unsigned int uint32 __attribute__ ((mode (SI)));
typedef signed int int64 __attribute__ ((mode (DI)));
typedef unsigned int uint64 __attribute__ ((mode (DI)));
typedef float float32 __attribute__ ((mode (SF)));
typedef double float64 __attribute__ ((mode (DF)));
typedef unsigned int uintptr __attribute__ ((mode (pointer)));
/* Defined types. */
typedef uint8 bool;
typedef uint8 byte;
typedef struct M M;
typedef struct MCache MCache;
typedef struct Lock Lock;
/* We use mutexes for locks. 6g uses futexes directly, and perhaps
someday we will do that too. */
struct Lock
{
uint32 key;
sem_t sem;
};
/* A Note. */
typedef struct Note Note;
struct Note {
int32 woken;
};
/* Per CPU declarations. */
#ifdef __rtems__
#define __thread
#endif
extern __thread M* m;
extern M m0;
#ifdef __rtems__
#undef __thread
#endif
/* Constants. */
enum
{
true = 1,
false = 0,
};
/* Structures. */
struct M
{
int32 mallocing;
int32 gcing;
int32 locks;
int32 nomemprof;
int32 gcing_for_prof;
int32 holds_finlock;
int32 gcing_for_finlock;
MCache *mcache;
/* For the list of all threads. */
struct __go_thread_id *list_entry;
/* For the garbage collector. */
void *gc_sp;
size_t gc_len;
void *gc_next_segment;
void *gc_next_sp;
void *gc_initial_sp;
struct __go_panic_defer_struct *gc_panic_defer;
};
/* Macros. */
#define nelem(x) (sizeof(x)/sizeof((x)[0]))
#define nil ((void*)0)
#define USED(v) ((void) v)
/* We map throw to assert. */
#define runtime_throw(s) __go_assert(s == 0)
void* runtime_mal(uintptr);
void runtime_mallocinit(void);
void runtime_initfintab(void);
void siginit(void);
bool __go_sigsend(int32 sig);
int64 runtime_nanotime(void);
void runtime_stoptheworld(void);
void runtime_starttheworld(void);
void __go_go(void (*pfn)(void*), void*);
void __go_gc_goroutine_init(void*);
void __go_enable_gc(void);
int __go_run_goroutine_gc(int);
void __go_scanstacks(void (*scan)(byte *, int64));
void __go_stealcache(void);
void __go_cachestats(void);
/*
* 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.
*/
void runtime_initlock(Lock*);
void runtime_lock(Lock*);
void runtime_unlock(Lock*);
void runtime_destroylock(Lock*);
void semacquire (uint32 *) asm ("libgo_runtime.runtime.Semacquire");
void semrelease (uint32 *) asm ("libgo_runtime.runtime.Semrelease");
/*
* sleep and wakeup on one-time events.
* before any calls to notesleep or notewakeup,
* must call noteclear to initialize the Note.
* then, any number of threads can call notesleep
* and exactly one thread can call notewakeup (once).
* once notewakeup has been called, all the notesleeps
* will return. future notesleeps will return immediately.
*/
void noteclear(Note*);
void notesleep(Note*);
void notewakeup(Note*);
/* Functions. */
#define runtime_printf printf
#define runtime_malloc(s) __go_alloc(s)
#define runtime_free(p) __go_free(p)
#define runtime_memclr(buf, size) __builtin_memset((buf), 0, (size))
#define runtime_strcmp(s1, s2) __builtin_strcmp((s1), (s2))
#define runtime_getenv(s) getenv(s)
#define runtime_atoi(s) atoi(s)
#define runtime_mcmp(a, b, s) __builtin_memcmp((a), (b), (s))
#define runtime_memmove(a, b, s) __builtin_memmove((a), (b), (s))
MCache* runtime_allocmcache(void);
void free(void *v);
struct __go_func_type;
void runtime_addfinalizer(void*, void(*fn)(void*), const struct __go_func_type *);
void runtime_walkfintab(void (*fn)(void*), void (*scan)(byte *, int64));
#define runtime_mmap mmap
#define runtime_munmap(p, s) munmap((p), (s))
#define runtime_cas(pval, old, new) __sync_bool_compare_and_swap (pval, old, new)
struct __go_func_type;
void reflect_call(const struct __go_func_type *, const void *, _Bool, void **,
void **)
asm ("libgo_reflect.reflect.call");
#ifdef __rtems__
void __wrap_rtems_task_variable_add(void **);
#endif
|
