Added LinearMemory trait

lib/api/src/js/export.rs

@@ -7,6 +7,7 @@ use std::fmt;
 use wasm_bindgen::{JsCast, JsValue};
 use wasmer_types::{ExternType, FunctionType, GlobalType, MemoryType, TableType};
 
+/// Represents linear memory that is managed by the javascript runtime
 #[derive(Clone, Debug, PartialEq)]
 pub struct VMMemory {
     pub(crate) memory: Memory,
@@ -20,6 +21,11 @@ impl VMMemory {
     pub(crate) fn new(memory: Memory, ty: MemoryType) -> Self {
         Self { memory, ty }
     }
+
+    /// Attempts to clone this memory (if its clonable)
+    pub(crate) fn try_clone(&self) -> Option<VMMemory> {
+        Some(self.clone())
+    }
 }
 
 #[derive(Clone, Debug, PartialEq)]

lib/api/src/js/externals/memory.rs

@@ -6,7 +6,6 @@ use crate::js::{MemoryAccessError, MemoryType};
 use std::marker::PhantomData;
 use std::mem::MaybeUninit;
 use std::slice;
-use thiserror::Error;
 #[cfg(feature = "tracing")]
 use tracing::warn;
 
@@ -16,22 +15,7 @@ use wasmer_types::Pages;
 
 use super::MemoryView;
 
-/// Error type describing things that can go wrong when operating on Wasm Memories.
-#[derive(Error, Debug, Clone, PartialEq, Hash)]
-pub enum MemoryError {
-    /// The operation would cause the size of the memory to exceed the maximum or would cause
-    /// an overflow leading to unindexable memory.
-    #[error("The memory could not grow: current size {} pages, requested increase: {} pages", current.0, attempted_delta.0)]
-    CouldNotGrow {
-        /// The current size in pages.
-        current: Pages,
-        /// The attempted amount to grow by in pages.
-        attempted_delta: Pages,
-    },
-    /// A user defined error value, used for error cases not listed above.
-    #[error("A user-defined error occurred: {0}")]
-    Generic(String),
-}
+pub use wasmer_types::MemoryError;
 
 #[wasm_bindgen]
 extern "C" {
@@ -116,6 +100,21 @@ impl Memory {
         Ok(Self::from_vm_export(store, vm_memory))
     }
 
+    /// Creates a new host `Memory` from provided JavaScript memory.
+    pub fn new_raw(
+        store: &mut impl AsStoreMut,
+        js_memory: js_sys::WebAssembly::Memory,
+        ty: MemoryType,
+    ) -> Result<Self, MemoryError> {
+        let vm_memory = VMMemory::new(js_memory, ty);
+        Ok(Self::from_vm_export(store, vm_memory))
+    }
+
+    /// Create a memory object from an existing memory and attaches it to the store
+    pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
+        Self::from_vm_export(new_store, memory)
+    }
+
     /// Returns the [`MemoryType`] of the `Memory`.
     ///
     /// # Example
@@ -210,6 +209,12 @@ impl Memory {
         }
     }
 
+    /// Attempts to clone this memory (if its clonable)
+    pub fn try_clone(&self, store: &impl AsStoreRef) -> Option<VMMemory> {
+        let mem = self.handle.get(store.as_store_ref().objects());
+        mem.try_clone()
+    }
+
     /// Checks whether this `Global` can be used with the given context.
     pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
         self.handle.store_id() == store.as_store_ref().objects().id()

lib/api/src/js/function_env.rs

@@ -36,7 +36,7 @@ impl<T> FunctionEnv<T> {
     }
 
     /// Get the data as reference
-    pub fn as_ref<'a>(&self, store: &'a impl AsStoreMut) -> &'a T
+    pub fn as_ref<'a>(&self, store: &'a impl AsStoreRef) -> &'a T
     where
         T: Any + Send + 'static + Sized,
     {
@@ -112,6 +112,11 @@ impl<T: Send + 'static> FunctionEnvMut<'_, T> {
         self.func_env.as_mut(&mut self.store_mut)
     }
 
+    /// Borrows a new immmutable reference
+    pub fn as_ref(&self) -> FunctionEnv<T> {
+        self.func_env.clone()
+    }
+
     /// Borrows a new mutable reference
     pub fn as_mut<'a>(&'a mut self) -> FunctionEnvMut<'a, T> {
         FunctionEnvMut {

lib/api/src/js/imports.rs

@@ -174,6 +174,32 @@ impl Imports {
         }
         imports
     }
+
+    /// Iterates through all the imports in this structure
+    pub fn iter<'a>(&'a self) -> ImportsIterator<'a> {
+        ImportsIterator::new(self)
+    }
+}
+
+pub struct ImportsIterator<'a> {
+    iter: std::collections::hash_map::Iter<'a, (String, String), Extern>,
+}
+
+impl<'a> ImportsIterator<'a> {
+    fn new(imports: &'a Imports) -> Self {
+        let iter = imports.map.iter();
+        Self { iter }
+    }
+}
+
+impl<'a> Iterator for ImportsIterator<'a> {
+    type Item = (&'a str, &'a str, &'a Extern);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter
+            .next()
+            .map(|(k, v)| (k.0.as_str(), k.1.as_str(), v))
+    }
 }
 
 impl IntoIterator for &Imports {

lib/api/src/js/mod.rs

@@ -73,6 +73,12 @@ pub use crate::js::types::{
 pub use crate::js::value::Value;
 pub use crate::js::value::Value as Val;
 
+pub mod vm {
+    //! The `vm` module re-exports wasmer-vm types.
+
+    pub use crate::js::export::VMMemory;
+}
+
 pub use wasmer_types::is_wasm;
 pub use wasmer_types::{
     Bytes, ExportIndex, GlobalInit, LocalFunctionIndex, Pages, ValueType, WASM_MAX_PAGES,

lib/api/src/js/native.rs

@@ -11,7 +11,6 @@ use std::marker::PhantomData;
 
 use crate::js::externals::Function;
 use crate::js::store::{AsStoreMut, AsStoreRef, StoreHandle};
-use crate::js::FunctionEnv;
 use crate::js::{FromToNativeWasmType, RuntimeError, WasmTypeList};
 // use std::panic::{catch_unwind, AssertUnwindSafe};
 use crate::js::export::VMFunction;

lib/api/src/js/store.rs

@@ -263,6 +263,11 @@ mod objects {
             self.id
         }
 
+        /// Sets the ID of this store
+        pub fn set_id(&mut self, id: StoreId) {
+            self.id = id;
+        }
+
         /// Returns a pair of mutable references from two handles.
         ///
         /// Panics if both handles point to the same object.

lib/api/src/sys/externals/memory.rs

@@ -10,7 +10,7 @@ use std::mem::MaybeUninit;
 use std::slice;
 #[cfg(feature = "tracing")]
 use tracing::warn;
-use wasmer_types::Pages;
+use wasmer_types::{LinearMemory, Pages};
 use wasmer_vm::{InternalStoreHandle, MemoryError, StoreHandle, VMExtern, VMMemory};
 
 use super::MemoryView;
@@ -60,6 +60,13 @@ impl Memory {
         })
     }
 
+    /// Create a memory object from an existing memory and attaches it to the store
+    pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
+        Self {
+            handle: StoreHandle::new(new_store.objects_mut(), memory),
+        }
+    }
+
     /// Returns the [`MemoryType`] of the `Memory`.
     ///
     /// # Example
@@ -142,6 +149,12 @@ impl Memory {
         self.handle.store_id() == store.as_store_ref().objects().id()
     }
 
+    /// Attempts to clone this memory (if its clonable)
+    pub fn try_clone(&self, store: &impl AsStoreRef) -> Option<VMMemory> {
+        let mem = self.handle.get(store.as_store_ref().objects());
+        mem.try_clone().map(|mem| mem.into())
+    }
+
     pub(crate) fn to_vm_extern(&self) -> VMExtern {
         VMExtern::Memory(self.handle.internal_handle())
     }

lib/api/src/sys/externals/memory_view.rs

@@ -4,7 +4,7 @@ use std::convert::TryInto;
 use std::marker::PhantomData;
 use std::mem::MaybeUninit;
 use std::slice;
-use wasmer_types::Pages;
+use wasmer_types::{LinearMemory, Pages};
 
 use super::memory::MemoryBuffer;
 use super::Memory;

lib/compiler/src/engine/resolver.rs

@@ -4,7 +4,8 @@ use crate::LinkError;
 use more_asserts::assert_ge;
 use wasmer_types::entity::{BoxedSlice, EntityRef, PrimaryMap};
 use wasmer_types::{
-    ExternType, FunctionIndex, ImportError, ImportIndex, MemoryIndex, ModuleInfo, TableIndex,
+    ExternType, FunctionIndex, ImportError, ImportIndex, LinearMemory, MemoryIndex, ModuleInfo,
+    TableIndex,
 };
 
 use wasmer_vm::{
@@ -149,7 +150,7 @@ pub fn resolve_imports(
                                 bound: import_bound,
                                 ..
                             },
-                        ) = (export_memory_style.clone(), &import_memory_style)
+                        ) = (export_memory_style, &import_memory_style)
                         {
                             assert_ge!(bound, *import_bound);
                         }

lib/types/Cargo.toml

@@ -21,6 +21,9 @@ enum-iterator = "0.7.0"
 target-lexicon = { version = "0.12.2", default-features = false }
 enumset = "1.0"
 
+[dev-dependencies]
+memoffset = "0.6"
+
 [features]
 default = ["std"]
 std = []

lib/types/src/error.rs

@@ -1,5 +1,5 @@
 //! The WebAssembly possible errors
-use crate::ExternType;
+use crate::{ExternType, Pages};
 use std::io;
 use thiserror::Error;
 
@@ -37,6 +37,48 @@ pub enum DeserializeError {
     Compiler(#[from] CompileError),
 }
 
+/// Error type describing things that can go wrong when operating on Wasm Memories.
+#[derive(Error, Debug, Clone, PartialEq, Hash)]
+pub enum MemoryError {
+    /// Low level error with mmap.
+    #[error("Error when allocating memory: {0}")]
+    Region(String),
+    /// The operation would cause the size of the memory to exceed the maximum or would cause
+    /// an overflow leading to unindexable memory.
+    #[error("The memory could not grow: current size {} pages, requested increase: {} pages", current.0, attempted_delta.0)]
+    CouldNotGrow {
+        /// The current size in pages.
+        current: Pages,
+        /// The attempted amount to grow by in pages.
+        attempted_delta: Pages,
+    },
+    /// The operation would cause the size of the memory size exceed the maximum.
+    #[error("The memory is invalid because {}", reason)]
+    InvalidMemory {
+        /// The reason why the provided memory is invalid.
+        reason: String,
+    },
+    /// Caller asked for more minimum memory than we can give them.
+    #[error("The minimum requested ({} pages) memory is greater than the maximum allowed memory ({} pages)", min_requested.0, max_allowed.0)]
+    MinimumMemoryTooLarge {
+        /// The number of pages requested as the minimum amount of memory.
+        min_requested: Pages,
+        /// The maximum amount of memory we can allocate.
+        max_allowed: Pages,
+    },
+    /// Caller asked for a maximum memory greater than we can give them.
+    #[error("The maximum requested memory ({} pages) is greater than the maximum allowed memory ({} pages)", max_requested.0, max_allowed.0)]
+    MaximumMemoryTooLarge {
+        /// The number of pages requested as the maximum amount of memory.
+        max_requested: Pages,
+        /// The number of pages requested as the maximum amount of memory.
+        max_allowed: Pages,
+    },
+    /// A user defined error value, used for error cases not listed above.
+    #[error("A user-defined error occurred: {0}")]
+    Generic(String),
+}
+
 /// An ImportError.
 ///
 /// Note: this error is not standard to WebAssembly, but it's
@@ -52,6 +94,10 @@ pub enum ImportError {
     /// This error occurs when an import was expected but not provided.
     #[error("unknown import. Expected {0:?}")]
     UnknownImport(ExternType),
+
+    /// Memory Error
+    #[error("memory error. {0}")]
+    MemoryError(String),
 }
 
 /// An error while preinstantiating a module.

lib/types/src/lib.rs

@@ -76,8 +76,8 @@ pub use crate::compilation::target::{
 };
 pub use crate::serialize::{MetadataHeader, SerializableCompilation, SerializableModule};
 pub use error::{
-    CompileError, DeserializeError, ImportError, MiddlewareError, ParseCpuFeatureError,
-    PreInstantiationError, SerializeError, WasmError, WasmResult,
+    CompileError, DeserializeError, ImportError, MemoryError, MiddlewareError,
+    ParseCpuFeatureError, PreInstantiationError, SerializeError, WasmError, WasmResult,
 };
 
 /// The entity module, with common helpers for Rust structures
@@ -103,7 +103,7 @@ pub use types::{
 pub use value::{RawValue, ValueType};
 
 pub use crate::libcalls::LibCall;
-pub use crate::memory::MemoryStyle;
+pub use crate::memory::{LinearMemory, MemoryStyle, VMMemoryDefinition};
 pub use crate::table::TableStyle;
 pub use crate::trapcode::TrapCode;
 pub use crate::vmoffsets::{TargetSharedSignatureIndex, VMBuiltinFunctionIndex, VMOffsets};