| // 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 getRandomData(r []byte) { | |
| if random_get(unsafe.Pointer(&r[0]), size(len(r))) != 0 { | |
| throw("random_get failed") | |
| } | |
| } | |
| 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) | |
| } |