GoToSocial/vendor/github.com/tetratelabs/wazero/internal/wasm/gofunc.go

280 lines
7.0 KiB
Go
Raw Normal View History

package wasm
import (
"bytes"
"context"
"errors"
"fmt"
"math"
"reflect"
"github.com/tetratelabs/wazero/api"
)
type paramsKind byte
const (
paramsKindNoContext paramsKind = iota
paramsKindContext
paramsKindContextModule
)
// Below are reflection code to get the interface type used to parse functions and set values.
var (
moduleType = reflect.TypeOf((*api.Module)(nil)).Elem()
goContextType = reflect.TypeOf((*context.Context)(nil)).Elem()
errorType = reflect.TypeOf((*error)(nil)).Elem()
)
// compile-time check to ensure reflectGoModuleFunction implements
// api.GoModuleFunction.
var _ api.GoModuleFunction = (*reflectGoModuleFunction)(nil)
type reflectGoModuleFunction struct {
fn *reflect.Value
params, results []ValueType
}
// Call implements the same method as documented on api.GoModuleFunction.
func (f *reflectGoModuleFunction) Call(ctx context.Context, mod api.Module, stack []uint64) {
callGoFunc(ctx, mod, f.fn, stack)
}
// EqualTo is exposed for testing.
func (f *reflectGoModuleFunction) EqualTo(that interface{}) bool {
if f2, ok := that.(*reflectGoModuleFunction); !ok {
return false
} else {
// TODO compare reflect pointers
return bytes.Equal(f.params, f2.params) && bytes.Equal(f.results, f2.results)
}
}
// compile-time check to ensure reflectGoFunction implements api.GoFunction.
var _ api.GoFunction = (*reflectGoFunction)(nil)
type reflectGoFunction struct {
fn *reflect.Value
pk paramsKind
params, results []ValueType
}
// EqualTo is exposed for testing.
func (f *reflectGoFunction) EqualTo(that interface{}) bool {
if f2, ok := that.(*reflectGoFunction); !ok {
return false
} else {
// TODO compare reflect pointers
return f.pk == f2.pk &&
bytes.Equal(f.params, f2.params) && bytes.Equal(f.results, f2.results)
}
}
// Call implements the same method as documented on api.GoFunction.
func (f *reflectGoFunction) Call(ctx context.Context, stack []uint64) {
if f.pk == paramsKindNoContext {
ctx = nil
}
callGoFunc(ctx, nil, f.fn, stack)
}
// callGoFunc executes the reflective function by converting params to Go
// types. The results of the function call are converted back to api.ValueType.
func callGoFunc(ctx context.Context, mod api.Module, fn *reflect.Value, stack []uint64) {
tp := fn.Type()
var in []reflect.Value
pLen := tp.NumIn()
if pLen != 0 {
in = make([]reflect.Value, pLen)
i := 0
if ctx != nil {
in[0] = newContextVal(ctx)
i++
}
if mod != nil {
in[1] = newModuleVal(mod)
i++
}
for j := 0; i < pLen; i++ {
next := tp.In(i)
val := reflect.New(next).Elem()
k := next.Kind()
raw := stack[j]
j++
switch k {
case reflect.Float32:
val.SetFloat(float64(math.Float32frombits(uint32(raw))))
case reflect.Float64:
val.SetFloat(math.Float64frombits(raw))
case reflect.Uint32, reflect.Uint64, reflect.Uintptr:
val.SetUint(raw)
case reflect.Int32, reflect.Int64:
val.SetInt(int64(raw))
default:
panic(fmt.Errorf("BUG: param[%d] has an invalid type: %v", i, k))
}
in[i] = val
}
}
// Execute the host function and push back the call result onto the stack.
for i, ret := range fn.Call(in) {
switch ret.Kind() {
case reflect.Float32:
stack[i] = uint64(math.Float32bits(float32(ret.Float())))
case reflect.Float64:
stack[i] = math.Float64bits(ret.Float())
case reflect.Uint32, reflect.Uint64, reflect.Uintptr:
stack[i] = ret.Uint()
case reflect.Int32, reflect.Int64:
stack[i] = uint64(ret.Int())
default:
panic(fmt.Errorf("BUG: result[%d] has an invalid type: %v", i, ret.Kind()))
}
}
}
func newContextVal(ctx context.Context) reflect.Value {
val := reflect.New(goContextType).Elem()
val.Set(reflect.ValueOf(ctx))
return val
}
func newModuleVal(m api.Module) reflect.Value {
val := reflect.New(moduleType).Elem()
val.Set(reflect.ValueOf(m))
return val
}
// MustParseGoReflectFuncCode parses Code from the go function or panics.
//
// Exposing this simplifies FunctionDefinition of host functions in built-in host
// modules and tests.
func MustParseGoReflectFuncCode(fn interface{}) Code {
_, _, code, err := parseGoReflectFunc(fn)
if err != nil {
panic(err)
}
return code
}
func parseGoReflectFunc(fn interface{}) (params, results []ValueType, code Code, err error) {
fnV := reflect.ValueOf(fn)
p := fnV.Type()
if fnV.Kind() != reflect.Func {
err = fmt.Errorf("kind != func: %s", fnV.Kind().String())
return
}
pk, kindErr := kind(p)
if kindErr != nil {
err = kindErr
return
}
pOffset := 0
switch pk {
case paramsKindNoContext:
case paramsKindContext:
pOffset = 1
case paramsKindContextModule:
pOffset = 2
}
pCount := p.NumIn() - pOffset
if pCount > 0 {
params = make([]ValueType, pCount)
}
for i := 0; i < len(params); i++ {
pI := p.In(i + pOffset)
if t, ok := getTypeOf(pI.Kind()); ok {
params[i] = t
continue
}
// Now, we will definitely err, decide which message is best
var arg0Type reflect.Type
if hc := pI.Implements(moduleType); hc {
arg0Type = moduleType
} else if gc := pI.Implements(goContextType); gc {
arg0Type = goContextType
}
if arg0Type != nil {
err = fmt.Errorf("param[%d] is a %s, which may be defined only once as param[0]", i+pOffset, arg0Type)
} else {
err = fmt.Errorf("param[%d] is unsupported: %s", i+pOffset, pI.Kind())
}
return
}
rCount := p.NumOut()
if rCount > 0 {
results = make([]ValueType, rCount)
}
for i := 0; i < len(results); i++ {
rI := p.Out(i)
if t, ok := getTypeOf(rI.Kind()); ok {
results[i] = t
continue
}
// Now, we will definitely err, decide which message is best
if rI.Implements(errorType) {
err = fmt.Errorf("result[%d] is an error, which is unsupported", i)
} else {
err = fmt.Errorf("result[%d] is unsupported: %s", i, rI.Kind())
}
return
}
code = Code{}
if pk == paramsKindContextModule {
code.GoFunc = &reflectGoModuleFunction{fn: &fnV, params: params, results: results}
} else {
code.GoFunc = &reflectGoFunction{pk: pk, fn: &fnV, params: params, results: results}
}
return
}
func kind(p reflect.Type) (paramsKind, error) {
pCount := p.NumIn()
if pCount > 0 && p.In(0).Kind() == reflect.Interface {
p0 := p.In(0)
if p0.Implements(moduleType) {
return 0, errors.New("invalid signature: api.Module parameter must be preceded by context.Context")
} else if p0.Implements(goContextType) {
if pCount >= 2 && p.In(1).Implements(moduleType) {
return paramsKindContextModule, nil
}
return paramsKindContext, nil
}
}
// Without context param allows portability with reflective runtimes.
// This allows people to more easily port to wazero.
return paramsKindNoContext, nil
}
func getTypeOf(kind reflect.Kind) (ValueType, bool) {
switch kind {
case reflect.Float64:
return ValueTypeF64, true
case reflect.Float32:
return ValueTypeF32, true
case reflect.Int32, reflect.Uint32:
return ValueTypeI32, true
case reflect.Int64, reflect.Uint64:
return ValueTypeI64, true
case reflect.Uintptr:
return ValueTypeExternref, true
default:
return 0x00, false
}
}