Update NewModule to take an Engine, not a Store (bytecodeallian…

…ce#30)

Closes bytecodealliance#29

doc_test.go

@@ -26,7 +26,7 @@ func Example() {
 
 	// Once we have our binary `wasm` we can compile that into a `*Module`
 	// which represents compiled JIT code.
-	module, err := NewModule(store, wasm)
+	module, err := NewModule(store.Engine, wasm)
 	check(err)
 
 	// Our `hello.wat` file imports one item, so we create that function
@@ -84,7 +84,7 @@ func Example_gcd() {
 	store := NewStore(NewEngine())
 	wasm, err := Wat2Wasm(GcdWat)
 	check(err)
-	module, err := NewModule(store, wasm)
+	module, err := NewModule(store.Engine, wasm)
 	check(err)
 	instance, err := NewInstance(store, module, []*Extern{})
 	check(err)
@@ -116,7 +116,7 @@ func Example_memory() {
           )
         `)
 	check(err)
-	module, err := NewModule(wasmtimeStore, wasm)
+	module, err := NewModule(wasmtimeStore.Engine, wasm)
 	check(err)
 	instance, err := NewInstance(wasmtimeStore, module, []*Extern{})
 	check(err)
@@ -235,7 +235,7 @@ func Example_multi() {
 	  )
         `)
 	check(err)
-	module, err := NewModule(store, wasm)
+	module, err := NewModule(store.Engine, wasm)
 	check(err)
 
 	callback := WrapFunc(store, func(a int32, b int64) (int64, int32) {

freelist.go

@@ -41,7 +41,6 @@ type freeList struct {
 	tables        []*C.wasm_table_t
 	globals       []*C.wasm_global_t
 	instances     []*C.wasm_instance_t
-	modules       []*C.wasm_module_t
 	externs       []*C.wasm_extern_t
 	linkers       []*C.wasmtime_linker_t
 	wasiInstances []*C.wasi_instance_t
@@ -96,11 +95,6 @@ func (f *freeList) clear() {
 	}
 	f.instances = nil
 
-	for _, p := range f.modules {
-		C.wasm_module_delete(p)
-	}
-	f.modules = nil
-
 	for _, p := range f.externs {
 		C.wasm_extern_delete(p)
 	}

instance.go

@@ -35,7 +35,7 @@ func NewInstance(store *Store, module *Module, imports []*Extern) (*Instance, er
 	var trap *C.wasm_trap_t
 	var ptr *C.wasm_instance_t
 	err := C.wasmtime_instance_new(
-		module.Store.ptr(),
+		store.ptr(),
 		module.ptr(),
 		importsRawPtr,
 		C.size_t(len(imports)),
@@ -52,14 +52,14 @@ func NewInstance(store *Store, module *Module, imports []*Extern) (*Instance, er
 	if trap != nil {
 		return nil, mkTrap(trap)
 	}
-	return mkInstance(ptr, module), nil
+	return mkInstance(ptr, store, module), nil
 }
 
-func mkInstance(ptr *C.wasm_instance_t, module *Module) *Instance {
+func mkInstance(ptr *C.wasm_instance_t, store *Store, module *Module) *Instance {
 	instance := &Instance{
 		_ptr:     ptr,
 		exports:  make(map[string]*Extern),
-		freelist: module.Store.freelist,
+		freelist: store.freelist,
 	}
 	runtime.SetFinalizer(instance, func(instance *Instance) {
 		freelist := instance.freelist

instance_test.go

@@ -15,7 +15,7 @@ func TestInstance(t *testing.T) {
 		panic(err)
 	}
 	store := NewStore(NewEngine())
-	module, err := NewModule(store, wasm)
+	module, err := NewModule(store.Engine, wasm)
 	if err != nil {
 		panic(err)
 	}
@@ -93,7 +93,7 @@ func TestInstanceBad(t *testing.T) {
 	store := NewStore(NewEngine())
 	wasm, err := Wat2Wasm(`(module (import "" "" (func)))`)
 	assertNoError(err)
-	module, err := NewModule(NewStore(NewEngine()), wasm)
+	module, err := NewModule(NewEngine(), wasm)
 	assertNoError(err)
 
 	// wrong number of imports

linker.go

@@ -124,5 +124,5 @@ func (l *Linker) Instantiate(module *Module) (*Instance, error) {
 	if trap != nil {
 		return nil, mkTrap(trap)
 	}
-	return mkInstance(ret, module), nil
+	return mkInstance(ret, l.Store, module), nil
 }

linker_test.go

@@ -1,7 +1,9 @@
 package wasmtime
 
-import "fmt"
-import "testing"
+import (
+	"fmt"
+	"testing"
+)
 
 func TestLinker(t *testing.T) {
 	wasm, err := Wat2Wasm(`
@@ -16,11 +18,11 @@ func TestLinker(t *testing.T) {
 		panic(err)
 	}
 	store := NewStore(NewEngine())
-	module, err := NewModule(store, wasm)
+	module, err := NewModule(store.Engine, wasm)
 	if err != nil {
 		panic(err)
 	}
-	linker := NewLinker(module.Store)
+	linker := NewLinker(store)
 	assertNoError(linker.Define("", "f", WrapFunc(store, func() {})))
 	g, err := NewGlobal(store, NewGlobalType(NewValType(KindI32), false), ValI32(0))
 	assertNoError(err)
@@ -31,7 +33,7 @@ func TestLinker(t *testing.T) {
 
 	tableWasm, err := Wat2Wasm(`(module (table (export "") 1 funcref))`)
 	assertNoError(err)
-	tableModule, err := NewModule(store, tableWasm)
+	tableModule, err := NewModule(store.Engine, tableWasm)
 	assertNoError(err)
 	instance, err := NewInstance(store, tableModule, []*Extern{})
 	assertNoError(err)
@@ -76,7 +78,7 @@ func TestLinkerTrap(t *testing.T) {
 	store := NewStore(NewEngine())
 	wasm, err := Wat2Wasm(`(func unreachable) (start 0)`)
 	assertNoError(err)
-	module, err := NewModule(store, wasm)
+	module, err := NewModule(store.Engine, wasm)
 	assertNoError(err)
 
 	linker := NewLinker(store)
@@ -116,9 +118,9 @@ func ExampleLinker() {
 	check(err)
 
 	// Next compile both modules
-	module1, err := NewModule(store, wasm1)
+	module1, err := NewModule(store.Engine, wasm1)
 	check(err)
-	module2, err := NewModule(store, wasm2)
+	module2, err := NewModule(store.Engine, wasm2)
 	check(err)
 
 	linker := NewLinker(store)

module.go

@@ -2,11 +2,11 @@ package wasmtime
 
 // #include <wasmtime.h>
 //
-// wasmtime_error_t *go_module_new(wasm_store_t *store, uint8_t *bytes, size_t len, wasm_module_t **ret) {
+// wasmtime_error_t *go_module_new(wasm_engine_t *engine, uint8_t *bytes, size_t len, wasm_module_t **ret) {
 //    wasm_byte_vec_t vec;
 //    vec.data = (wasm_byte_t*) bytes;
 //    vec.size = len;
-//    return wasmtime_module_new(store, &vec, ret);
+//    return wasmtime_module_new(engine, &vec, ret);
 // }
 //
 // wasmtime_error_t *go_module_validate(wasm_store_t *store, uint8_t *bytes, size_t len) {
@@ -26,13 +26,13 @@ import (
 // In addition, it can declare imports and exports and provide initialization logic in the form of data and element segments or a start function.
 // Modules organized WebAssembly programs as the unit of deployment, loading, and compilation.
 type Module struct {
-	_ptr  *C.wasm_module_t
-	Store *Store
+	_ptr   *C.wasm_module_t
+	Engine *Engine
 }
 
 // NewModule compiles a new `Module` from the `wasm` provided with the given configuration
-// in `store`.
-func NewModule(store *Store, wasm []byte) (*Module, error) {
+// in `engine`.
+func NewModule(engine *Engine, wasm []byte) (*Module, error) {
 	// We can't create the `wasm_byte_vec_t` here and pass it in because
 	// that runs into the error of "passed a pointer to a pointer" because
 	// the vec itself is passed by pointer and it contains a pointer to
@@ -43,22 +43,22 @@ func NewModule(store *Store, wasm []byte) (*Module, error) {
 		wasmPtr = (*C.uint8_t)(unsafe.Pointer(&wasm[0]))
 	}
 	var ptr *C.wasm_module_t
-	err := C.go_module_new(store.ptr(), wasmPtr, C.size_t(len(wasm)), &ptr)
-	runtime.KeepAlive(store)
+	err := C.go_module_new(engine.ptr(), wasmPtr, C.size_t(len(wasm)), &ptr)
+	runtime.KeepAlive(engine)
 	runtime.KeepAlive(wasm)
 
 	if err != nil {
 		return nil, mkError(err)
 	}
 
-	return mkModule(ptr, store), nil
+	return mkModule(ptr, engine), nil
 }
 
 // NewModuleFromFile reads the contents of the `file` provided and interprets them as either the
 // text format or the binary format for WebAssembly.
 //
 // Afterwards delegates to the `NewModule` constructor with the contents read.
-func NewModuleFromFile(store *Store, file string) (*Module, error) {
+func NewModuleFromFile(engine *Engine, file string) (*Module, error) {
 	wasm, err := ioutil.ReadFile(file)
 	if err != nil {
 		return nil, err
@@ -71,7 +71,7 @@ func NewModuleFromFile(store *Store, file string) (*Module, error) {
 			return nil, err
 		}
 	}
-	return NewModule(store, wasm)
+	return NewModule(engine, wasm)
 
 }
 
@@ -92,13 +92,10 @@ func ModuleValidate(store *Store, wasm []byte) error {
 	return mkError(err)
 }
 
-func mkModule(ptr *C.wasm_module_t, store *Store) *Module {
-	module := &Module{_ptr: ptr, Store: store}
+func mkModule(ptr *C.wasm_module_t, engine *Engine) *Module {
+	module := &Module{_ptr: ptr, Engine: engine}
 	runtime.SetFinalizer(module, func(module *Module) {
-		freelist := module.Store.freelist
-		freelist.lock.Lock()
-		defer freelist.lock.Unlock()
-		freelist.modules = append(freelist.modules, module._ptr)
+		C.wasm_module_delete(module._ptr)
 	})
 	return module
 }

module_test.go

@@ -3,11 +3,11 @@ package wasmtime
 import "testing"
 
 func TestModule(t *testing.T) {
-	_, err := NewModule(NewStore(NewEngine()), []byte{})
+	_, err := NewModule(NewEngine(), []byte{})
 	if err == nil {
 		panic("expected an error")
 	}
-	_, err = NewModule(NewStore(NewEngine()), []byte{1})
+	_, err = NewModule(NewEngine(), []byte{1})
 	if err == nil {
 		panic("expected an error")
 	}
@@ -41,7 +41,7 @@ func TestModuleImports(t *testing.T) {
 	if err != nil {
 		panic(err)
 	}
-	module, err := NewModule(NewStore(NewEngine()), wasm)
+	module, err := NewModule(NewEngine(), wasm)
 	if err != nil {
 		panic(err)
 	}
@@ -117,7 +117,7 @@ func TestModuleExports(t *testing.T) {
 	if err != nil {
 		panic(err)
 	}
-	module, err := NewModule(NewStore(NewEngine()), wasm)
+	module, err := NewModule(NewEngine(), wasm)
 	if err != nil {
 		panic(err)
 	}

store.go

@@ -13,13 +13,15 @@ import (
 type Store struct {
 	_ptr     *C.wasm_store_t
 	freelist *freeList
+	Engine   *Engine
 }
 
 // NewStore creates a new `Store` from the configuration provided in `engine`
 func NewStore(engine *Engine) *Store {
 	store := &Store{
 		_ptr:     C.wasm_store_new(engine.ptr()),
 		freelist: newFreeList(),
+		Engine:   engine,
 	}
 	runtime.KeepAlive(engine)
 	runtime.SetFinalizer(store, func(store *Store) {

store_test.go

@@ -45,7 +45,7 @@ func TestInterruptWasm(t *testing.T) {
 	if err != nil {
 		panic(err)
 	}
-	module, err := NewModule(store, wasm)
+	module, err := NewModule(store.Engine, wasm)
 	if err != nil {
 		panic(err)
 	}

trap_test.go

@@ -18,7 +18,7 @@ func TestTrapFrames(t *testing.T) {
 	  (start 0)
 	`)
 	assertNoError(err)
-	module, err := NewModule(store, wasm)
+	module, err := NewModule(store.Engine, wasm)
 	assertNoError(err)
 
 	i, err := NewInstance(store, module, []*Extern{})
@@ -70,7 +70,7 @@ func TestTrapModuleName(t *testing.T) {
 	  (start 0)
 	)`)
 	assertNoError(err)
-	module, err := NewModule(store, wasm)
+	module, err := NewModule(store.Engine, wasm)
 	assertNoError(err)
 
 	i, err := NewInstance(store, module, []*Extern{})