diff --git a/config.go b/config.go index 37a632a..96f96e8 100644 --- a/config.go +++ b/config.go @@ -94,6 +94,12 @@ func (cfg *Config) SetWasmMultiValue(enabled bool) { runtime.KeepAlive(cfg) } +// SetWasmModuleLinking configures whether the wasm module linking proposal is enabled +func (cfg *Config) SetWasmModuleLinking(enabled bool) { + C.wasmtime_config_wasm_module_linking_set(cfg.ptr(), C.bool(enabled)) + runtime.KeepAlive(cfg) +} + // SetStrategy configures what compilation strategy is used to compile wasm code func (cfg *Config) SetStrategy(strat Strategy) error { err := C.wasmtime_config_strategy_set(cfg.ptr(), C.wasmtime_strategy_t(strat)) diff --git a/extern.go b/extern.go index 2b3979d..9aee697 100644 --- a/extern.go +++ b/extern.go @@ -1,6 +1,6 @@ package wasmtime -// #include +// #include import "C" import "runtime" @@ -91,6 +91,26 @@ func (e *Extern) Table() *Table { return mkTable(ret, e.freelist, e.owner()) } +// Module returns a Module if this export is a module or nil otherwise +func (e *Extern) Module() *Module { + ret := C.wasm_extern_as_module(e.ptr()) + if ret == nil { + return nil + } + + return mkModule(ret, e.owner()) +} + +// Instance returns a Instance if this export is a module or nil otherwise +func (e *Extern) Instance() *Instance { + ret := C.wasm_extern_as_instance(e.ptr()) + if ret == nil { + return nil + } + + return mkInstance(ret, e.freelist, e.owner()) +} + func (e *Extern) AsExtern() *Extern { return e } diff --git a/importtype.go b/importtype.go index 1c5e402..a8f2fce 100644 --- a/importtype.go +++ b/importtype.go @@ -61,12 +61,18 @@ func (ty *ImportType) Module() string { return ret } -// Name returns the name in the module this import type is importing -func (ty *ImportType) Name() string { +// Name returns the name in the module this import type is importing. +// +// Note that the returned string may be `nil` with the module linking proposal +// where this field is optional in the import type. +func (ty *ImportType) Name() *string { ptr := C.wasm_importtype_name(ty.ptr()) + if ptr == nil { + return nil + } ret := C.GoStringN(ptr.data, C.int(ptr.size)) runtime.KeepAlive(ty) - return ret + return &ret } // Type returns the type of item this import type expects diff --git a/importtype_test.go b/importtype_test.go index cda9b7b..cdba582 100644 --- a/importtype_test.go +++ b/importtype_test.go @@ -8,7 +8,7 @@ func TestImportType(t *testing.T) { if ty.Module() != "a" { panic("invalid module") } - if ty.Name() != "b" { + if *ty.Name() != "b" { panic("invalid name") } if ty.Type().FuncType() == nil { @@ -20,7 +20,7 @@ func TestImportType(t *testing.T) { if ty.Module() != "" { panic("invalid module") } - if ty.Name() != "" { + if *ty.Name() != "" { panic("invalid name") } if ty.Type().GlobalType() == nil { diff --git a/instance.go b/instance.go index 0796527..6b04e81 100644 --- a/instance.go +++ b/instance.go @@ -10,9 +10,11 @@ import ( // Instance is an instantiated module instance. // Once a module has been instantiated as an Instance, any exported function can be invoked externally via its function address funcaddr in the store S and an appropriate list val∗ of argument values. type Instance struct { - _ptr *C.wasm_instance_t - exports map[string]*Extern - freelist *freeList + _ptr *C.wasm_instance_t + exports map[string]*Extern + exportsPopulated bool + freelist *freeList + _owner interface{} } // NewInstance instantiates a WebAssembly `module` with the `imports` provided. @@ -52,24 +54,24 @@ func NewInstance(store *Store, module *Module, imports []*Extern) (*Instance, er if trap != nil { return nil, mkTrap(trap) } - return mkInstance(ptr, store, module), nil + return mkInstance(ptr, store.freelist, nil), nil } -func mkInstance(ptr *C.wasm_instance_t, store *Store, module *Module) *Instance { +func mkInstance(ptr *C.wasm_instance_t, freelist *freeList, owner interface{}) *Instance { instance := &Instance{ - _ptr: ptr, - exports: make(map[string]*Extern), - freelist: store.freelist, + _ptr: ptr, + exports: make(map[string]*Extern), + exportsPopulated: false, + freelist: freelist, + _owner: owner, } - runtime.SetFinalizer(instance, func(instance *Instance) { - freelist := instance.freelist - freelist.lock.Lock() - defer freelist.lock.Unlock() - freelist.instances = append(freelist.instances, instance._ptr) - }) - exports := instance.Exports() - for i, ty := range module.Exports() { - instance.exports[ty.Name()] = exports[i] + if owner == nil { + runtime.SetFinalizer(instance, func(instance *Instance) { + freelist := instance.freelist + freelist.lock.Lock() + defer freelist.lock.Unlock() + freelist.instances = append(freelist.instances, instance._ptr) + }) } return instance } @@ -80,6 +82,20 @@ func (i *Instance) ptr() *C.wasm_instance_t { return ret } +func (i *Instance) owner() interface{} { + if i._owner != nil { + return i._owner + } + return i +} + +// Type returns an `InstanceType` that corresponds for this instance. +func (i *Instance) Type() *InstanceType { + ptr := C.wasm_instance_type(i.ptr()) + runtime.KeepAlive(i) + return mkInstanceType(ptr, nil) +} + type externList struct { vec C.wasm_extern_vec_t } @@ -114,5 +130,20 @@ func (i *Instance) Exports() []*Extern { // // May return `nil` if this instance has no export named `name` func (i *Instance) GetExport(name string) *Extern { + if !i.exportsPopulated { + i.populateExports() + } return i.exports[name] } + +func (i *Instance) populateExports() { + exports := i.Exports() + for j, ty := range i.Type().Exports() { + i.exports[ty.Name()] = exports[j] + } +} + +func (i *Instance) AsExtern() *Extern { + ptr := C.wasm_instance_as_extern(i.ptr()) + return mkExtern(ptr, i.freelist, i.owner()) +} diff --git a/instancetype.go b/instancetype.go new file mode 100644 index 0000000..7164bcb --- /dev/null +++ b/instancetype.go @@ -0,0 +1,49 @@ +package wasmtime + +// #include +import "C" +import "runtime" + +// InstanceType describes the exports of an instance. +type InstanceType struct { + _ptr *C.wasm_instancetype_t + _owner interface{} +} + +func mkInstanceType(ptr *C.wasm_instancetype_t, owner interface{}) *InstanceType { + instancetype := &InstanceType{_ptr: ptr, _owner: owner} + if owner == nil { + runtime.SetFinalizer(instancetype, func(instancetype *InstanceType) { + C.wasm_instancetype_delete(instancetype._ptr) + }) + } + return instancetype +} + +func (ty *InstanceType) ptr() *C.wasm_instancetype_t { + ret := ty._ptr + maybeGC() + return ret +} + +func (ty *InstanceType) owner() interface{} { + if ty._owner != nil { + return ty._owner + } + return ty +} + +// AsExternType converts this type to an instance of `ExternType` +func (ty *InstanceType) AsExternType() *ExternType { + ptr := C.wasm_instancetype_as_externtype_const(ty.ptr()) + return mkExternType(ptr, ty.owner()) +} + +// Exports returns a list of `ExportType` items which are the items that will +// be exported by this instance after instantiation. +func (ty *InstanceType) Exports() []*ExportType { + exports := &exportTypeList{} + C.wasm_instancetype_exports(ty.ptr(), &exports.vec) + runtime.KeepAlive(ty) + return exports.mkGoList() +} diff --git a/linker.go b/linker.go index 05436ec..ae40a90 100644 --- a/linker.go +++ b/linker.go @@ -124,5 +124,5 @@ func (l *Linker) Instantiate(module *Module) (*Instance, error) { if trap != nil { return nil, mkTrap(trap) } - return mkInstance(ret, l.Store, module), nil + return mkInstance(ret, l.Store.freelist, nil), nil } diff --git a/module.go b/module.go index be0d8fa..47f7513 100644 --- a/module.go +++ b/module.go @@ -34,7 +34,7 @@ import ( // Modules organized WebAssembly programs as the unit of deployment, loading, and compilation. type Module struct { _ptr *C.wasm_module_t - Engine *Engine + _owner interface{} } // NewModule compiles a new `Module` from the `wasm` provided with the given configuration @@ -58,7 +58,7 @@ func NewModule(engine *Engine, wasm []byte) (*Module, error) { return nil, mkError(err) } - return mkModule(ptr, engine), nil + return mkModule(ptr, nil), nil } // NewModuleFromFile reads the contents of the `file` provided and interprets them as either the @@ -99,11 +99,13 @@ func ModuleValidate(store *Store, wasm []byte) error { return mkError(err) } -func mkModule(ptr *C.wasm_module_t, engine *Engine) *Module { - module := &Module{_ptr: ptr, Engine: engine} - runtime.SetFinalizer(module, func(module *Module) { - C.wasm_module_delete(module._ptr) - }) +func mkModule(ptr *C.wasm_module_t, owner interface{}) *Module { + module := &Module{_ptr: ptr} + if owner == nil { + runtime.SetFinalizer(module, func(module *Module) { + C.wasm_module_delete(module._ptr) + }) + } return module } @@ -113,10 +115,40 @@ func (m *Module) ptr() *C.wasm_module_t { return ret } +func (m *Module) owner() interface{} { + if m._owner != nil { + return m._owner + } + return m +} + +// Type returns a `ModuleType` that corresponds for this module. +func (m *Module) Type() *ModuleType { + ptr := C.wasm_module_type(m.ptr()) + runtime.KeepAlive(m) + return mkModuleType(ptr, nil) +} + type importTypeList struct { vec C.wasm_importtype_vec_t } +func (list *importTypeList) mkGoList() []*ImportType { + runtime.SetFinalizer(list, func(imports *importTypeList) { + C.wasm_importtype_vec_delete(&imports.vec) + }) + + ret := make([]*ImportType, int(list.vec.size)) + base := unsafe.Pointer(list.vec.data) + var ptr *C.wasm_importtype_t + for i := 0; i < int(list.vec.size); i++ { + ptr := *(**C.wasm_importtype_t)(unsafe.Pointer(uintptr(base) + unsafe.Sizeof(ptr)*uintptr(i))) + ty := mkImportType(ptr, list) + ret[i] = ty + } + return ret +} + // Imports returns a list of `ImportType` items which are the items imported by this // module and are required for instantiation. func (m *Module) Imports() []*ImportType { @@ -142,27 +174,31 @@ type exportTypeList struct { vec C.wasm_exporttype_vec_t } -// Exports returns a list of `ExportType` items which are the items that will -// be exported by this module after instantiation. -func (m *Module) Exports() []*ExportType { - exports := &exportTypeList{} - C.wasm_module_exports(m.ptr(), &exports.vec) - runtime.KeepAlive(m) - runtime.SetFinalizer(exports, func(exports *exportTypeList) { +func (list *exportTypeList) mkGoList() []*ExportType { + runtime.SetFinalizer(list, func(exports *exportTypeList) { C.wasm_exporttype_vec_delete(&exports.vec) }) - ret := make([]*ExportType, int(exports.vec.size)) - base := unsafe.Pointer(exports.vec.data) + ret := make([]*ExportType, int(list.vec.size)) + base := unsafe.Pointer(list.vec.data) var ptr *C.wasm_exporttype_t - for i := 0; i < int(exports.vec.size); i++ { + for i := 0; i < int(list.vec.size); i++ { ptr := *(**C.wasm_exporttype_t)(unsafe.Pointer(uintptr(base) + unsafe.Sizeof(ptr)*uintptr(i))) - ty := mkExportType(ptr, exports) + ty := mkExportType(ptr, list) ret[i] = ty } return ret } +// Exports returns a list of `ExportType` items which are the items that will +// be exported by this module after instantiation. +func (m *Module) Exports() []*ExportType { + exports := &exportTypeList{} + C.wasm_module_exports(m.ptr(), &exports.vec) + runtime.KeepAlive(m) + return exports.mkGoList() +} + // NewModuleDeserialize decodes and deserializes in-memory bytes previously // produced by `module.Serialize()`. // @@ -195,7 +231,7 @@ func NewModuleDeserialize(engine *Engine, encoded []byte) (*Module, error) { return nil, mkError(err) } - return mkModule(ptr, engine), nil + return mkModule(ptr, nil), nil } // Serialize will convert this in-memory compiled module into a list of bytes. @@ -217,3 +253,8 @@ func (m *Module) Serialize() ([]byte, error) { C.wasm_byte_vec_delete(&retVec) return ret, nil } + +func (m *Module) AsExtern() *Extern { + ptr := C.wasm_module_as_extern(m.ptr()) + return mkExtern(ptr, nil, m.owner()) +} diff --git a/module_linking_test.go b/module_linking_test.go new file mode 100644 index 0000000..28b572e --- /dev/null +++ b/module_linking_test.go @@ -0,0 +1,161 @@ +package wasmtime + +import "testing" + +func moduleLinkingStore() *Store { + config := NewConfig() + config.SetWasmModuleLinking(true) + return NewStore(NewEngineWithConfig(config)) +} + +func TestModuleType(t *testing.T) { + wasm, err := Wat2Wasm(` + (module + (import "" "f" (func)) + (import "a" "g" (global i32)) + (import "" (table 1 funcref)) + (import "" "" (memory 1)) + + (func (export "y")) + (global (export "z") i32 (i32.const 0)) + (table (export "x") 1 funcref) + ) + `) + if err != nil { + panic(err) + } + store := moduleLinkingStore() + module, err := NewModule(store.Engine, wasm) + if err != nil { + panic(err) + } + ty := module.Type() + imports := ty.Imports() + if len(imports) != 4 { + panic("wrong number of imports") + } + if imports[2].Name() != nil { + panic("bad import name") + } + exports := ty.Exports() + if len(exports) != 3 { + panic("wrong number of exports") + } +} + +func TestInstanceType(t *testing.T) { + wasm, err := Wat2Wasm(` + (module + (func (export "y")) + (global (export "z") i32 (i32.const 0)) + (table (export "x") 1 funcref) + ) + `) + if err != nil { + panic(err) + } + store := moduleLinkingStore() + module, err := NewModule(store.Engine, wasm) + if err != nil { + panic(err) + } + instance, err := NewInstance(store, module, []*Extern{}) + if err != nil { + panic(err) + } + ty := instance.Type() + exports := ty.Exports() + if len(exports) != 3 { + panic("wrong number of exports") + } +} + +func TestImportModule(t *testing.T) { + wasm, err := Wat2Wasm(`(module (import "" (module)))`) + if err != nil { + panic(err) + } + store := moduleLinkingStore() + module, err := NewModule(store.Engine, wasm) + if err != nil { + panic(err) + } + wasm, err = Wat2Wasm(`(module)`) + if err != nil { + panic(err) + } + module2, err := NewModule(store.Engine, wasm) + if err != nil { + panic(err) + } + _, err = NewInstance(store, module, []*Extern{module2.AsExtern()}) + if err != nil { + panic(err) + } +} + +func TestImportInstance(t *testing.T) { + wasm, err := Wat2Wasm(`(module (import "" (instance)))`) + if err != nil { + panic(err) + } + store := moduleLinkingStore() + module, err := NewModule(store.Engine, wasm) + if err != nil { + panic(err) + } + wasm, err = Wat2Wasm(`(module)`) + if err != nil { + panic(err) + } + module2, err := NewModule(store.Engine, wasm) + if err != nil { + panic(err) + } + instance, err := NewInstance(store, module2, []*Extern{}) + if err != nil { + panic(err) + } + _, err = NewInstance(store, module, []*Extern{instance.AsExtern()}) + if err != nil { + panic(err) + } +} + +func TestExportModule(t *testing.T) { + wasm, err := Wat2Wasm(`(module (module (export "")))`) + if err != nil { + panic(err) + } + store := moduleLinkingStore() + module, err := NewModule(store.Engine, wasm) + if err != nil { + panic(err) + } + instance, err := NewInstance(store, module, []*Extern{}) + if err != nil { + panic(err) + } + if instance.GetExport("").Module() == nil { + panic("expected a module") + } +} + +func TestExportInstance(t *testing.T) { + wasm, err := Wat2Wasm(`(module (module) (instance (export "") (instantiate 0)))`) + if err != nil { + panic(err) + } + store := moduleLinkingStore() + module, err := NewModule(store.Engine, wasm) + if err != nil { + panic(err) + } + instance, err := NewInstance(store, module, []*Extern{}) + if err != nil { + panic(err) + } + if instance.GetExport("").Instance() == nil { + panic("expected a module") + } +} diff --git a/module_test.go b/module_test.go index 7046f5e..dc8541a 100644 --- a/module_test.go +++ b/module_test.go @@ -52,7 +52,7 @@ func TestModuleImports(t *testing.T) { if imports[0].Module() != "" { panic("wrong import module") } - if imports[0].Name() != "f" { + if *imports[0].Name() != "f" { panic("wrong import name") } if imports[0].Type().FuncType() == nil { @@ -68,7 +68,7 @@ func TestModuleImports(t *testing.T) { if imports[1].Module() != "a" { panic("wrong import module") } - if imports[1].Name() != "g" { + if *imports[1].Name() != "g" { panic("wrong import name") } if imports[1].Type().GlobalType() == nil { @@ -81,7 +81,7 @@ func TestModuleImports(t *testing.T) { if imports[2].Module() != "" { panic("wrong import module") } - if imports[2].Name() != "" { + if *imports[2].Name() != "" { panic("wrong import name") } if imports[2].Type().TableType() == nil { @@ -94,7 +94,7 @@ func TestModuleImports(t *testing.T) { if imports[3].Module() != "" { panic("wrong import module") } - if imports[3].Name() != "" { + if *imports[3].Name() != "" { panic("wrong import name") } if imports[3].Type().MemoryType() == nil { diff --git a/moduletype.go b/moduletype.go new file mode 100644 index 0000000..8fb0ba7 --- /dev/null +++ b/moduletype.go @@ -0,0 +1,58 @@ +package wasmtime + +// #include +import "C" +import "runtime" + +// ModuleType describes the imports/exports of a module. +type ModuleType struct { + _ptr *C.wasm_moduletype_t + _owner interface{} +} + +func mkModuleType(ptr *C.wasm_moduletype_t, owner interface{}) *ModuleType { + moduletype := &ModuleType{_ptr: ptr, _owner: owner} + if owner == nil { + runtime.SetFinalizer(moduletype, func(moduletype *ModuleType) { + C.wasm_moduletype_delete(moduletype._ptr) + }) + } + return moduletype +} + +func (ty *ModuleType) ptr() *C.wasm_moduletype_t { + ret := ty._ptr + maybeGC() + return ret +} + +func (ty *ModuleType) owner() interface{} { + if ty._owner != nil { + return ty._owner + } + return ty +} + +// AsExternType converts this type to an instance of `ExternType` +func (ty *ModuleType) AsExternType() *ExternType { + ptr := C.wasm_moduletype_as_externtype_const(ty.ptr()) + return mkExternType(ptr, ty.owner()) +} + +// Imports returns a list of `ImportType` items which are the items imported by +// this module and are required for instantiation. +func (m *ModuleType) Imports() []*ImportType { + imports := &importTypeList{} + C.wasm_moduletype_imports(m.ptr(), &imports.vec) + runtime.KeepAlive(m) + return imports.mkGoList() +} + +// Exports returns a list of `ExportType` items which are the items that will +// be exported by this module after instantiation. +func (m *ModuleType) Exports() []*ExportType { + exports := &exportTypeList{} + C.wasm_moduletype_exports(m.ptr(), &exports.vec) + runtime.KeepAlive(m) + return exports.mkGoList() +} diff --git a/trap_test.go b/trap_test.go index 1a6f55a..5ce14f4 100644 --- a/trap_test.go +++ b/trap_test.go @@ -54,9 +54,9 @@ func TestTrapFrames(t *testing.T) { expected := `wasm trap: unreachable wasm backtrace: - 0: 0x26 - !bar - 1: 0x21 - !foo - 2: 0x1c - ! + 0: 0x26 - !bar + 1: 0x21 - !foo + 2: 0x1c - ! ` if trap.Error() != expected { t.Fatalf("expected\n%s\ngot\n%s", trap.Error(), expected)