feat(vm) Ability to use exports after the instance has been freed

CHANGELOG.md

@@ -9,6 +9,7 @@
 
 ### Added
 
+- [#1837](https://github.com/wasmerio/wasmer/pull/1837) It is now possible to use exports of an `Intance` even after the `Instance` has been freed
 - [#1831](https://github.com/wasmerio/wasmer/pull/1831) Added support for Apple Silicon chips (`arm64-apple-darwin`)
 - [#1649](https://github.com/wasmerio/wasmer/pull/1649) Add outline of migration to 1.0.0 docs.
 

lib/api/src/externals/function.rs

@@ -110,6 +110,7 @@ impl Function {
                     vmctx,
                     signature: ty.clone(),
                     call_trampoline: None,
+                    instance_allocator: None,
                 },
             },
         }
@@ -172,6 +173,7 @@ impl Function {
                     vmctx,
                     signature: ty.clone(),
                     call_trampoline: None,
+                    instance_allocator: None,
                 },
             },
         }
@@ -225,6 +227,7 @@ impl Function {
                     signature,
                     kind: VMFunctionKind::Static,
                     call_trampoline: None,
+                    instance_allocator: None,
                 },
             },
         }
@@ -294,6 +297,7 @@ impl Function {
                     vmctx,
                     signature,
                     call_trampoline: None,
+                    instance_allocator: None,
                 },
             },
         }
@@ -346,6 +350,7 @@ impl Function {
                     vmctx,
                     signature,
                     call_trampoline: None,
+                    instance_allocator: None,
                 },
             },
         }
@@ -528,7 +533,7 @@ impl Function {
         Ok(results.into_boxed_slice())
     }
 
-    pub(crate) fn from_export(store: &Store, wasmer_export: ExportFunction) -> Self {
+    pub(crate) fn from_vm_export(store: &Store, wasmer_export: ExportFunction) -> Self {
         if let Some(trampoline) = wasmer_export.vm_function.call_trampoline {
             Self {
                 store: store.clone(),

lib/api/src/externals/global.rs

@@ -181,7 +181,7 @@ impl Global {
         Ok(())
     }
 
-    pub(crate) fn from_export(store: &Store, wasmer_export: ExportGlobal) -> Self {
+    pub(crate) fn from_vm_export(store: &Store, wasmer_export: ExportGlobal) -> Self {
         Self {
             store: store.clone(),
             global: wasmer_export.vm_global.from,
@@ -220,6 +220,7 @@ impl<'a> Exportable<'a> for Global {
         ExportGlobal {
             vm_global: VMExportGlobal {
                 from: self.global.clone(),
+                instance_allocator: None,
             },
         }
         .into()

lib/api/src/externals/memory.rs

@@ -221,7 +221,7 @@ impl Memory {
         unsafe { MemoryView::new(base as _, length as u32) }
     }
 
-    pub(crate) fn from_export(store: &Store, wasmer_export: ExportMemory) -> Self {
+    pub(crate) fn from_vm_export(store: &Store, wasmer_export: ExportMemory) -> Self {
         Self {
             store: store.clone(),
             memory: wasmer_export.vm_memory.from,
@@ -250,6 +250,7 @@ impl<'a> Exportable<'a> for Memory {
         ExportMemory {
             vm_memory: VMExportMemory {
                 from: self.memory.clone(),
+                instance_allocator: None,
             },
         }
         .into()

lib/api/src/externals/mod.rs

@@ -46,13 +46,13 @@ impl Extern {
         }
     }
 
-    /// Create an `Extern` from an `Export`.
-    pub fn from_export(store: &Store, export: Export) -> Self {
+    /// Create an `Extern` from an `wasmer_vm::Export`.
+    pub fn from_vm_export(store: &Store, export: Export) -> Self {
         match export {
-            Export::Function(f) => Self::Function(Function::from_export(store, f)),
-            Export::Memory(m) => Self::Memory(Memory::from_export(store, m)),
-            Export::Global(g) => Self::Global(Global::from_export(store, g)),
-            Export::Table(t) => Self::Table(Table::from_export(store, t)),
+            Export::Function(f) => Self::Function(Function::from_vm_export(store, f)),
+            Export::Memory(m) => Self::Memory(Memory::from_vm_export(store, m)),
+            Export::Global(g) => Self::Global(Global::from_vm_export(store, g)),
+            Export::Table(t) => Self::Table(Table::from_vm_export(store, t)),
         }
     }
 }

lib/api/src/externals/table.rs

@@ -140,7 +140,7 @@ impl Table {
         Ok(())
     }
 
-    pub(crate) fn from_export(store: &Store, wasmer_export: ExportTable) -> Self {
+    pub(crate) fn from_vm_export(store: &Store, wasmer_export: ExportTable) -> Self {
         Self {
             store: store.clone(),
             table: wasmer_export.vm_table.from,
@@ -158,6 +158,7 @@ impl<'a> Exportable<'a> for Table {
         ExportTable {
             vm_table: VMExportTable {
                 from: self.table.clone(),
+                instance_allocator: None,
             },
         }
         .into()

lib/api/src/instance.rs

@@ -119,7 +119,7 @@ impl Instance {
             .map(|export| {
                 let name = export.name().to_string();
                 let export = handle.lookup(&name).expect("export");
-                let extern_ = Extern::from_export(store, export.into());
+                let extern_ = Extern::from_vm_export(store, export.into());
                 (name, extern_)
             })
             .collect::<Exports>();

lib/api/src/native.rs

@@ -73,6 +73,7 @@ where
             signature,
             kind: other.arg_kind,
             call_trampoline: None,
+            instance_allocator: None,
         }
     }
 }*/
@@ -93,6 +94,7 @@ where
                 signature,
                 kind: other.arg_kind,
                 call_trampoline: None,
+                instance_allocator: None,
             },
         }
     }
@@ -117,6 +119,7 @@ where
                     signature,
                     kind: other.arg_kind,
                     call_trampoline: None,
+                    instance_allocator: None,
                 },
             },
         }

lib/api/src/types.rs

@@ -85,9 +85,10 @@ impl ValFuncRef for Val {
                 kind: wasmer_vm::VMFunctionKind::Static,
                 vmctx: item.vmctx,
                 call_trampoline: None,
+                instance_allocator: None,
             },
         };
-        let f = Function::from_export(store, export);
+        let f = Function::from_vm_export(store, export);
         Self::FuncRef(f)
     }
 }

lib/api/tests/instance.rs

@@ -0,0 +1,39 @@
+use anyhow::Result;
+use wasmer::*;
+
+#[test]
+fn exports_work_after_multiple_instances_have_been_freed() -> Result<()> {
+    let store = Store::default();
+    let module = Module::new(
+        &store,
+        "
+    (module
+      (type $sum_t (func (param i32 i32) (result i32)))
+      (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+        local.get $x
+        local.get $y
+        i32.add)
+      (export \"sum\" (func $sum_f)))
+",
+    )?;
+
+    let import_object = ImportObject::new();
+    let instance = Instance::new(&module, &import_object)?;
+    let instance2 = instance.clone();
+    let instance3 = instance.clone();
+
+    // The function is cloned to “break” the connection with `instance`.
+    let sum = instance.exports.get_function("sum")?.clone();
+
+    drop(instance);
+    drop(instance2);
+    drop(instance3);
+
+    // All instances have been dropped, but `sum` continues to work!
+    assert_eq!(
+        sum.call(&[Value::I32(1), Value::I32(2)])?.into_vec(),
+        vec![Value::I32(3)],
+    );
+
+    Ok(())
+}

lib/c-api/src/wasm_c_api/wasi/mod.rs

@@ -345,7 +345,7 @@ unsafe fn wasi_get_imports_inner(
                         import_type.name()
                     ),
                 }));
-            let inner = Extern::from_export(store, export);
+            let inner = Extern::from_vm_export(store, export);
 
             Some(Box::new(wasm_extern_t {
                 instance: None,

lib/deprecated/runtime-core/src/module.rs

@@ -163,12 +163,12 @@ impl Module {
 
                         (
                             (namespace, name),
-                            new::wasmer::Extern::from_export(store, Export::Function(function)),
+                            new::wasmer::Extern::from_vm_export(store, Export::Function(function)),
                         )
                     }
                     export => (
                         (namespace, name),
-                        new::wasmer::Extern::from_export(store, export),
+                        new::wasmer::Extern::from_vm_export(store, export),
                     ),
                 })
                 .for_each(|((namespace, name), extern_)| {

lib/vm/src/export.rs

@@ -2,6 +2,7 @@
 // Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
 
 use crate::global::Global;
+use crate::instance::InstanceAllocator;
 use crate::memory::{Memory, MemoryStyle};
 use crate::table::{Table, TableStyle};
 use crate::vmcontext::{VMFunctionBody, VMFunctionEnvironment, VMFunctionKind, VMTrampoline};
@@ -29,15 +30,27 @@ pub enum VMExport {
 pub struct VMExportFunction {
     /// The address of the native-code function.
     pub address: *const VMFunctionBody,
+
     /// Pointer to the containing `VMContext`.
     pub vmctx: VMFunctionEnvironment,
+
     /// The function type, used for compatibility checking.
     pub signature: FunctionType,
-    /// The function kind (specifies the calling convention for the function).
+
+    /// The function kind (specifies the calling convention for the
+    /// function).
     pub kind: VMFunctionKind,
-    /// Address of the function call trampoline owned by the same VMContext that owns the VMFunctionBody.
-    /// May be None when the function is a host-function (FunctionType == Dynamic or vmctx == nullptr).
+
+    /// Address of the function call trampoline owned by the same
+    /// VMContext that owns the VMFunctionBody.
+    ///
+    /// May be `None` when the function is a host function (`FunctionType`
+    /// == `Dynamic` or `vmctx` == `nullptr`).
     pub call_trampoline: Option<VMTrampoline>,
+
+    /// A “reference” to the instance through the
+    /// `InstanceAllocator`. `None` if it is a host function.
+    pub instance_allocator: Option<InstanceAllocator>,
 }
 
 /// # Safety
@@ -59,13 +72,18 @@ impl From<VMExportFunction> for VMExport {
 pub struct VMExportTable {
     /// Pointer to the containing `Table`.
     pub from: Arc<dyn Table>,
+
+    /// A “reference” to the instance through the
+    /// `InstanceAllocator`. `None` if it is a host function.
+    pub instance_allocator: Option<InstanceAllocator>,
 }
 
 /// # Safety
 /// This is correct because there is no non-threadsafe logic directly in this type;
 /// correct use of the raw table from multiple threads via `definition` requires `unsafe`
 /// and is the responsibilty of the user of this type.
 unsafe impl Send for VMExportTable {}
+
 /// # Safety
 /// This is correct because the values directly in `definition` should be considered immutable
 /// and the type is both `Send` and `Clone` (thus marking it `Sync` adds no new behavior, it
@@ -100,13 +118,18 @@ impl From<VMExportTable> for VMExport {
 pub struct VMExportMemory {
     /// Pointer to the containing `Memory`.
     pub from: Arc<dyn Memory>,
+
+    /// A “reference” to the instance through the
+    /// `InstanceAllocator`. `None` if it is a host function.
+    pub instance_allocator: Option<InstanceAllocator>,
 }
 
 /// # Safety
 /// This is correct because there is no non-threadsafe logic directly in this type;
 /// correct use of the raw memory from multiple threads via `definition` requires `unsafe`
 /// and is the responsibilty of the user of this type.
 unsafe impl Send for VMExportMemory {}
+
 /// # Safety
 /// This is correct because the values directly in `definition` should be considered immutable
 /// and the type is both `Send` and `Clone` (thus marking it `Sync` adds no new behavior, it
@@ -141,13 +164,18 @@ impl From<VMExportMemory> for VMExport {
 pub struct VMExportGlobal {
     /// The global declaration, used for compatibility checking.
     pub from: Arc<Global>,
+
+    /// A “reference” to the instance through the
+    /// `InstanceAllocator`. `None` if it is a host function.
+    pub instance_allocator: Option<InstanceAllocator>,
 }
 
 /// # Safety
 /// This is correct because there is no non-threadsafe logic directly in this type;
 /// correct use of the raw global from multiple threads via `definition` requires `unsafe`
 /// and is the responsibilty of the user of this type.
 unsafe impl Send for VMExportGlobal {}
+
 /// # Safety
 /// This is correct because the values directly in `definition` should be considered immutable
 /// from the perspective of users of this type and the type is both `Send` and `Clone` (thus