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
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
|
// Copyright 2023 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.
//go:build wasip1
package runtime
import "unsafe"
// GOARCH=wasm currently has 64 bits pointers, but the WebAssembly host expects
// pointers to be 32 bits so we use this type alias to represent pointers in
// structs and arrays passed as arguments to WASI functions.
//
// Note that the use of an integer type prevents the compiler from tracking
// pointers passed to WASI functions, so we must use KeepAlive to explicitly
// retain the objects that could otherwise be reclaimed by the GC.
type uintptr32 = uint32
// https://github.com/WebAssembly/WASI/blob/a2b96e81c0586125cc4dc79a5be0b78d9a059925/legacy/preview1/docs.md#-size-u32
type size = uint32
// https://github.com/WebAssembly/WASI/blob/a2b96e81c0586125cc4dc79a5be0b78d9a059925/legacy/preview1/docs.md#-errno-variant
type errno = uint32
// https://github.com/WebAssembly/WASI/blob/a2b96e81c0586125cc4dc79a5be0b78d9a059925/legacy/preview1/docs.md#-filesize-u64
type filesize = uint64
// https://github.com/WebAssembly/WASI/blob/a2b96e81c0586125cc4dc79a5be0b78d9a059925/legacy/preview1/docs.md#-timestamp-u64
type timestamp = uint64
// https://github.com/WebAssembly/WASI/blob/a2b96e81c0586125cc4dc79a5be0b78d9a059925/legacy/preview1/docs.md#-clockid-variant
type clockid = uint32
const (
clockRealtime clockid = 0
clockMonotonic clockid = 1
)
// https://github.com/WebAssembly/WASI/blob/a2b96e81c0586125cc4dc79a5be0b78d9a059925/legacy/preview1/docs.md#-iovec-record
type iovec struct {
buf uintptr32
bufLen size
}
//go:wasmimport wasi_snapshot_preview1 proc_exit
func exit(code int32)
//go:wasmimport wasi_snapshot_preview1 args_get
//go:noescape
func args_get(argv, argvBuf unsafe.Pointer) errno
//go:wasmimport wasi_snapshot_preview1 args_sizes_get
//go:noescape
func args_sizes_get(argc, argvBufLen unsafe.Pointer) errno
//go:wasmimport wasi_snapshot_preview1 clock_time_get
//go:noescape
func clock_time_get(clock_id clockid, precision timestamp, time unsafe.Pointer) errno
//go:wasmimport wasi_snapshot_preview1 environ_get
//go:noescape
func environ_get(environ, environBuf unsafe.Pointer) errno
//go:wasmimport wasi_snapshot_preview1 environ_sizes_get
//go:noescape
func environ_sizes_get(environCount, environBufLen unsafe.Pointer) errno
//go:wasmimport wasi_snapshot_preview1 fd_write
//go:noescape
func fd_write(fd int32, iovs unsafe.Pointer, iovsLen size, nwritten unsafe.Pointer) errno
//go:wasmimport wasi_snapshot_preview1 random_get
//go:noescape
func random_get(buf unsafe.Pointer, bufLen size) errno
type eventtype = uint8
const (
eventtypeClock eventtype = iota
eventtypeFdRead
eventtypeFdWrite
)
type eventrwflags = uint16
const (
fdReadwriteHangup eventrwflags = 1 << iota
)
type userdata = uint64
// The go:wasmimport directive currently does not accept values of type uint16
// in arguments or returns of the function signature. Most WASI imports return
// an errno value, which we have to define as uint32 because of that limitation.
// However, the WASI errno type is intended to be a 16 bits integer, and in the
// event struct the error field should be of type errno. If we used the errno
// type for the error field it would result in a mismatching field alignment and
// struct size because errno is declared as a 32 bits type, so we declare the
// error field as a plain uint16.
type event struct {
userdata userdata
error uint16
typ eventtype
fdReadwrite eventFdReadwrite
}
type eventFdReadwrite struct {
nbytes filesize
flags eventrwflags
}
type subclockflags = uint16
const (
subscriptionClockAbstime subclockflags = 1 << iota
)
type subscriptionClock struct {
id clockid
timeout timestamp
precision timestamp
flags subclockflags
}
type subscriptionFdReadwrite struct {
fd int32
}
type subscription struct {
userdata userdata
u subscriptionUnion
}
type subscriptionUnion [5]uint64
func (u *subscriptionUnion) eventtype() *eventtype {
return (*eventtype)(unsafe.Pointer(&u[0]))
}
func (u *subscriptionUnion) subscriptionClock() *subscriptionClock {
return (*subscriptionClock)(unsafe.Pointer(&u[1]))
}
func (u *subscriptionUnion) subscriptionFdReadwrite() *subscriptionFdReadwrite {
return (*subscriptionFdReadwrite)(unsafe.Pointer(&u[1]))
}
//go:wasmimport wasi_snapshot_preview1 poll_oneoff
//go:noescape
func poll_oneoff(in, out unsafe.Pointer, nsubscriptions size, nevents unsafe.Pointer) errno
func write1(fd uintptr, p unsafe.Pointer, n int32) int32 {
iov := iovec{
buf: uintptr32(uintptr(p)),
bufLen: size(n),
}
var nwritten size
if fd_write(int32(fd), unsafe.Pointer(&iov), 1, unsafe.Pointer(&nwritten)) != 0 {
throw("fd_write failed")
}
return int32(nwritten)
}
func usleep(usec uint32) {
var in subscription
var out event
var nevents size
eventtype := in.u.eventtype()
*eventtype = eventtypeClock
subscription := in.u.subscriptionClock()
subscription.id = clockMonotonic
subscription.timeout = timestamp(usec) * 1e3
subscription.precision = 1e3
if poll_oneoff(unsafe.Pointer(&in), unsafe.Pointer(&out), 1, unsafe.Pointer(&nevents)) != 0 {
throw("wasi_snapshot_preview1.poll_oneoff")
}
}
func readRandom(r []byte) int {
if random_get(unsafe.Pointer(&r[0]), size(len(r))) != 0 {
return 0
}
return len(r)
}
func goenvs() {
// arguments
var argc size
var argvBufLen size
if args_sizes_get(unsafe.Pointer(&argc), unsafe.Pointer(&argvBufLen)) != 0 {
throw("args_sizes_get failed")
}
argslice = make([]string, argc)
if argc > 0 {
argv := make([]uintptr32, argc)
argvBuf := make([]byte, argvBufLen)
if args_get(unsafe.Pointer(&argv[0]), unsafe.Pointer(&argvBuf[0])) != 0 {
throw("args_get failed")
}
for i := range argslice {
start := argv[i] - uintptr32(uintptr(unsafe.Pointer(&argvBuf[0])))
end := start
for argvBuf[end] != 0 {
end++
}
argslice[i] = string(argvBuf[start:end])
}
}
// environment
var environCount size
var environBufLen size
if environ_sizes_get(unsafe.Pointer(&environCount), unsafe.Pointer(&environBufLen)) != 0 {
throw("environ_sizes_get failed")
}
envs = make([]string, environCount)
if environCount > 0 {
environ := make([]uintptr32, environCount)
environBuf := make([]byte, environBufLen)
if environ_get(unsafe.Pointer(&environ[0]), unsafe.Pointer(&environBuf[0])) != 0 {
throw("environ_get failed")
}
for i := range envs {
start := environ[i] - uintptr32(uintptr(unsafe.Pointer(&environBuf[0])))
end := start
for environBuf[end] != 0 {
end++
}
envs[i] = string(environBuf[start:end])
}
}
}
func walltime() (sec int64, nsec int32) {
return walltime1()
}
func walltime1() (sec int64, nsec int32) {
var time timestamp
if clock_time_get(clockRealtime, 0, unsafe.Pointer(&time)) != 0 {
throw("clock_time_get failed")
}
return int64(time / 1000000000), int32(time % 1000000000)
}
func nanotime1() int64 {
var time timestamp
if clock_time_get(clockMonotonic, 0, unsafe.Pointer(&time)) != 0 {
throw("clock_time_get failed")
}
return int64(time)
}
|
