Readd vmctx host data and data finalizer

lib/runtime/src/vm.rs

@@ -2,7 +2,7 @@ pub use crate::{
     backing::{ImportBacking, LocalBacking},
     types::LocalMemoryIndex,
 };
-use std::{mem, ptr};
+use std::{ffi::c_void, mem, ptr};
 
 #[derive(Debug)]
 #[repr(C)]
@@ -28,9 +28,13 @@ pub struct Ctx {
     /// A pointer to an array of imported functions, indexed by `FuncIndex`.
     pub(crate) imported_funcs: *mut ImportedFunc,
 
-    /// The parent instance.
+    /// The local backing of the parent instance.
     pub local_backing: *mut LocalBacking,
+    /// The import backing of the parent instance.
     pub import_backing: *mut ImportBacking,
+
+    pub data: *mut c_void,
+    pub data_finalizer: Option<extern "C" fn(data: *mut c_void)>,
 }
 
 impl Ctx {
@@ -50,6 +54,33 @@ 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: extern "C" fn(*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: Some(data_finalizer),
         }
     }
 
@@ -431,3 +462,66 @@ 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,
+                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
+    }
+}