Passing all spectests

lib/runtime/build/spectests.rs

@@ -98,7 +98,7 @@ pub fn generate_imports() -> Imports {
     let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new())
         .expect("WASM can't be compiled");
     let instance = module
-        .instantiate(&mut Imports::new())
+        .instantiate(Imports::new())
         .expect("WASM can't be instantiated");
     let mut imports = Imports::new();
     imports.register("spectest", instance);
@@ -353,7 +353,7 @@ fn test_module_{}() {{
     println!(\"{{}}\", module_str);
     let wasm_binary = wat2wasm(module_str.as_bytes()).expect(\"WAST not valid or malformed\");
     let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect(\"WASM can't be compiled\");
-    module.instantiate(&mut generate_imports()).expect(\"WASM can't be instantiated\")
+    module.instantiate(generate_imports()).expect(\"WASM can't be instantiated\")
 }}\n",
                 self.last_module,
                 // We do this to ident four spaces, so it looks aligned to the function body

lib/runtime/examples/simple/main.rs

@@ -29,13 +29,13 @@ fn main() -> Result<(), String> {
     let mut imports = Imports::new();
     imports.register("env", env_namespace);
 
-    let inner_instance = inner_module.instantiate(&mut imports)?;
+    let inner_instance = inner_module.instantiate(imports)?;
 
     let mut outer_imports = Imports::new();
     outer_imports.register("env", inner_instance);
 
     let outer_module = runtime::compile(EXAMPLE_WASM, &CraneliftCompiler::new())?;
-    let mut outer_instance = outer_module.instantiate(&mut outer_imports)?;
+    let mut outer_instance = outer_module.instantiate(outer_imports)?;
     let ret = outer_instance.call("main", &[Value::I32(42)])?;
     println!("ret: {:?}", ret);
 

lib/runtime/examples/test.rs

@@ -4,7 +4,7 @@ use wasmer_runtime::{import::Imports, Instance};
 
 fn main() {
     let mut instance = create_module_1();
-    let result = instance.call("get-0-ref", &[]);
+    let result = instance.call("get-0", &[]);
     println!("result: {:?}", result);
 }
 
@@ -33,7 +33,7 @@ fn create_module_1() -> Instance {
     let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new())
         .expect("WASM can't be compiled");
     module
-        .instantiate(&mut generate_imports())
+        .instantiate(generate_imports())
         .expect("WASM can't be instantiated")
 }
 
@@ -53,7 +53,7 @@ pub fn generate_imports() -> Imports {
     let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new())
         .expect("WASM can't be compiled");
     let instance = module
-        .instantiate(&mut Imports::new())
+        .instantiate(Imports::new())
         .expect("WASM can't be instantiated");
     let mut imports = Imports::new();
     imports.register("spectest", instance);

lib/runtime/src/instance.rs

@@ -26,16 +26,18 @@ pub(crate) struct InstanceInner {
 pub struct Instance {
     pub(crate) module: Rc<ModuleInner>,
     inner: Box<InstanceInner>,
+    #[allow(dead_code)]
+    imports: Box<Imports>,
 }
 
 impl Instance {
-    pub(crate) fn new(module: Rc<ModuleInner>, imports: &mut Imports) -> Result<Instance, String> {
+    pub(crate) fn new(module: Rc<ModuleInner>, mut imports: Box<Imports>) -> Result<Instance, String> {
         // We need the backing and import_backing to create a vm::Ctx, but we need
         // a vm::Ctx to create a backing and an import_backing. The solution is to create an
         // uninitialized vm::Ctx and then initialize it in-place.
         let mut vmctx = unsafe { Box::new(mem::uninitialized()) };
 
-        let import_backing = ImportBacking::new(&module, imports, &mut *vmctx)?;
+        let import_backing = ImportBacking::new(&module, &mut imports, &mut *vmctx)?;
         let backing = LocalBacking::new(&module, &import_backing, &mut *vmctx);
 
         // When Pin is stablized, this will use `Box::pinned` instead of `Box::new`.
@@ -49,7 +51,11 @@ impl Instance {
         // has been boxed.
         *inner.vmctx = unsafe { vm::Ctx::new(&mut inner.backing, &mut inner.import_backing) };
 
-        let mut instance = Instance { module, inner };
+        let mut instance = Instance {
+            module,
+            inner,
+            imports,
+        };
 
         if let Some(start_index) = instance.module.start_func {
             instance.call_with_index(start_index, &[])?;

lib/runtime/src/module.rs

@@ -47,8 +47,8 @@ impl Module {
     }
 
     /// Instantiate a webassembly module with the provided imports.
-    pub fn instantiate(&self, imports: &mut Imports) -> Result<Instance, String> {
+    pub fn instantiate(&self, imports: Imports) -> Result<Instance, String> {
-        Instance::new(Rc::clone(&self.0), imports)
+        Instance::new(Rc::clone(&self.0), Box::new(imports))
     }
 }
 

lib/runtime/src/vm.rs

@@ -1,6 +1,7 @@
-pub use crate::backing::{ImportBacking, LocalBacking};
+pub use crate::{
-use crate::types::LocalMemoryIndex;
+    backing::{LocalBacking, ImportBacking},
-use std::ffi::c_void;
+    types::LocalMemoryIndex,
+};
 use std::{mem, ptr};
 
 #[derive(Debug)]
@@ -27,23 +28,9 @@ pub struct Ctx {
     /// A pointer to an array of imported functions, indexed by `FuncIndex`.
     pub(crate) imported_funcs: *mut ImportedFunc,
 
-    /// The local backing of the instance that created this vmctx.
+    /// The parent instance.
     pub local_backing: *mut LocalBacking,
-    /// The import backing of the parent instance.
     pub import_backing: *mut ImportBacking,
-
-    /// Host data
-    pub data: *mut c_void,
-    /// Host data finalizer
-    pub data_finalizer: Option<extern "C" fn(data: *mut c_void)>,
-}
-
-impl Drop for Ctx {
-    fn drop(&mut self) {
-        if let Some(finalizer) = self.data_finalizer {
-            finalizer(self.data);
-        }
-    }
 }
 
 impl Ctx {
@@ -63,33 +50,6 @@ impl Ctx {
 
             local_backing,
             import_backing,
-
-            data: ptr::null_mut(),
-            data_finalizer: None,
-        }
-    }
-
-    pub unsafe fn new_with_data(
-        local_backing: &mut LocalBacking,
-        import_backing: &mut ImportBacking,
-        data: *mut c_void,
-        data_finalizer: Option<extern "C" fn(data: *mut c_void)>,
-    ) -> Self {
-        Self {
-            memories: local_backing.vm_memories.as_mut_ptr(),
-            tables: local_backing.vm_tables.as_mut_ptr(),
-            globals: local_backing.vm_globals.as_mut_ptr(),
-
-            imported_memories: import_backing.memories.as_mut_ptr(),
-            imported_tables: import_backing.tables.as_mut_ptr(),
-            imported_globals: import_backing.globals.as_mut_ptr(),
-            imported_funcs: import_backing.functions.as_mut_ptr(),
-
-            local_backing,
-            import_backing,
-
-            data,
-            data_finalizer,
         }
     }
 
@@ -471,67 +431,3 @@ mod vm_offset_tests {
         );
     }
 }
-
-#[cfg(test)]
-mod vm_ctx_tests {
-    use super::{Ctx, ImportBacking, LocalBacking};
-    use crate::structures::Map;
-    use std::ffi::c_void;
-
-    struct TestData {
-        x: u32,
-        y: bool,
-        str: String,
-    }
-
-    extern "C" fn test_data_finalizer(data: *mut c_void) {
-        let test_data: &mut TestData = unsafe { &mut *(data as *mut TestData) };
-        assert_eq!(test_data.x, 10);
-        assert_eq!(test_data.y, true);
-        assert_eq!(test_data.str, "Test".to_string());
-        println!("hello from finalizer");
-        drop(test_data);
-    }
-
-    #[test]
-    fn test_callback_on_drop() {
-        let mut data = TestData {
-            x: 10,
-            y: true,
-            str: "Test".to_string(),
-        };
-        let mut local_backing = LocalBacking {
-            memories: Map::new().into_boxed_map(),
-            tables: Map::new().into_boxed_map(),
-            vm_memories: Map::new().into_boxed_map(),
-            vm_tables: Map::new().into_boxed_map(),
-            vm_globals: Map::new().into_boxed_map(),
-        };
-        let mut import_backing = ImportBacking {
-            functions: Map::new().into_boxed_map(),
-            memories: Map::new().into_boxed_map(),
-            tables: Map::new().into_boxed_map(),
-            globals: Map::new().into_boxed_map(),
-        };
-        let data = &mut data as *mut _ as *mut c_void;
-        let ctx = unsafe {
-            Ctx::new_with_data(
-                &mut local_backing,
-                &mut import_backing,
-                data,
-                Some(test_data_finalizer),
-            )
-        };
-        let ctx_test_data = cast_test_data(ctx.data);
-        assert_eq!(ctx_test_data.x, 10);
-        assert_eq!(ctx_test_data.y, true);
-        assert_eq!(ctx_test_data.str, "Test".to_string());
-        drop(ctx);
-    }
-
-    fn cast_test_data(data: *mut c_void) -> &'static mut TestData {
-        let test_data: &mut TestData = unsafe { &mut *(data as *mut TestData) };
-        test_data
-    }
-
-}

lib/runtime/tests/semantics.rs

@@ -22,7 +22,7 @@ mod tests {
         let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new())
             .expect("WASM can't be compiled");
         let mut instance = module
-            .instantiate(&mut Imports::new())
+            .instantiate(Imports::new())
             .expect("WASM can't be instantiated");
         let result = instance.call("stack-overflow", &[]);
         assert!(