Merge branch 'master'

Conflicts:
	Cargo.lock
	Cargo.toml
	lib/emscripten/Cargo.toml
	lib/emscripten/src/syscalls/unix.rs
	lib/runtime-core/Cargo.toml

lib/runtime-core/src/backend.rs

@@ -22,6 +22,7 @@ pub use crate::sig_registry::SigRegistry;
 #[derive(Serialize, Deserialize, Debug, Copy, Clone, PartialEq, Eq)]
 pub enum Backend {
     Cranelift,
+    Dynasm,
     LLVM,
 }
 

lib/runtime-core/src/cache.rs

@@ -207,3 +207,7 @@ pub trait Cache {
     fn load(&self, key: WasmHash) -> Result<Module, Self::LoadError>;
     fn store(&mut self, key: WasmHash, module: Module) -> Result<(), Self::StoreError>;
 }
+
+/// A unique ID generated from the version of Wasmer for use with cache versioning
+pub const WASMER_VERSION_HASH: &'static str =
+    include_str!(concat!(env!("OUT_DIR"), "/wasmer_version_hash.txt"));

lib/runtime-core/src/error.rs

@@ -1,6 +1,10 @@
-use crate::types::{FuncSig, GlobalDescriptor, MemoryDescriptor, TableDescriptor, Type, Value};
+use crate::types::{
+    FuncSig, GlobalDescriptor, MemoryDescriptor, MemoryIndex, TableDescriptor, TableIndex, Type,
+    Value,
+};
 use core::borrow::Borrow;
 use std::any::Any;
+use std::sync::Arc;
 
 pub type Result<T> = std::result::Result<T, Error>;
 pub type CompileResult<T> = std::result::Result<T, CompileError>;

lib/runtime-core/src/types.rs

@@ -1,4 +1,8 @@
-use crate::{memory::MemoryType, module::ModuleInfo, structures::TypedIndex, units::Pages};
+use crate::error::{CompileError, CompileResult};
+use crate::{
+    memory::MemoryType, module::ModuleInfo, module::ModuleInner, structures::TypedIndex,
+    units::Pages,
+};
 use std::{borrow::Cow, mem};
 
 /// Represents a WebAssembly type.

lib/runtime-core/src/vm.rs

@@ -13,32 +13,8 @@ use std::{ffi::c_void, mem, ptr};
 #[derive(Debug)]
 #[repr(C)]
 pub struct Ctx {
-    /// A pointer to an array of locally-defined memories, indexed by `MemoryIndex`.
-    pub(crate) memories: *mut *mut LocalMemory,
-
-    /// A pointer to an array of locally-defined tables, indexed by `TableIndex`.
-    pub(crate) tables: *mut *mut LocalTable,
-
-    /// A pointer to an array of locally-defined globals, indexed by `GlobalIndex`.
-    pub(crate) globals: *mut *mut LocalGlobal,
-
-    /// A pointer to an array of imported memories, indexed by `MemoryIndex,
-    pub(crate) imported_memories: *mut *mut LocalMemory,
-
-    /// A pointer to an array of imported tables, indexed by `TableIndex`.
-    pub(crate) imported_tables: *mut *mut LocalTable,
-
-    /// A pointer to an array of imported globals, indexed by `GlobalIndex`.
-    pub(crate) imported_globals: *mut *mut LocalGlobal,
-
-    /// A pointer to an array of imported functions, indexed by `FuncIndex`.
-    pub(crate) imported_funcs: *mut ImportedFunc,
-
-    /// A pointer to an array of signature ids. Conceptually, this maps
-    /// from a static, module-local signature id to a runtime-global
-    /// signature id. This is used to allow call-indirect to other
-    /// modules safely.
-    pub(crate) dynamic_sigindices: *const SigId,
+    // `internal` must be the first field of `Ctx`.
+    pub(crate) internal: InternalCtx,
 
     pub(crate) local_functions: *const *const Func,
 
@@ -50,6 +26,41 @@ pub struct Ctx {
     pub data_finalizer: Option<extern "C" fn(data: *mut c_void)>,
 }
 
+/// The internal context of the currently running WebAssembly instance.
+///
+///
+#[doc(hidden)]
+#[derive(Debug)]
+#[repr(C)]
+pub struct InternalCtx {
+    /// A pointer to an array of locally-defined memories, indexed by `MemoryIndex`.
+    pub memories: *mut *mut LocalMemory,
+
+    /// A pointer to an array of locally-defined tables, indexed by `TableIndex`.
+    pub tables: *mut *mut LocalTable,
+
+    /// A pointer to an array of locally-defined globals, indexed by `GlobalIndex`.
+    pub globals: *mut *mut LocalGlobal,
+
+    /// A pointer to an array of imported memories, indexed by `MemoryIndex,
+    pub imported_memories: *mut *mut LocalMemory,
+
+    /// A pointer to an array of imported tables, indexed by `TableIndex`.
+    pub imported_tables: *mut *mut LocalTable,
+
+    /// A pointer to an array of imported globals, indexed by `GlobalIndex`.
+    pub imported_globals: *mut *mut LocalGlobal,
+
+    /// A pointer to an array of imported functions, indexed by `FuncIndex`.
+    pub imported_funcs: *mut ImportedFunc,
+
+    /// A pointer to an array of signature ids. Conceptually, this maps
+    /// from a static, module-local signature id to a runtime-global
+    /// signature id. This is used to allow call-indirect to other
+    /// modules safely.
+    pub dynamic_sigindices: *const SigId,
+}
+
 impl Ctx {
     #[doc(hidden)]
     pub unsafe fn new(
@@ -58,16 +69,18 @@ impl Ctx {
         module: &ModuleInner,
     ) -> 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(),
+            internal: InternalCtx {
+                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.vm_memories.as_mut_ptr(),
-            imported_tables: import_backing.vm_tables.as_mut_ptr(),
-            imported_globals: import_backing.vm_globals.as_mut_ptr(),
-            imported_funcs: import_backing.vm_functions.as_mut_ptr(),
+                imported_memories: import_backing.vm_memories.as_mut_ptr(),
+                imported_tables: import_backing.vm_tables.as_mut_ptr(),
+                imported_globals: import_backing.vm_globals.as_mut_ptr(),
+                imported_funcs: import_backing.vm_functions.as_mut_ptr(),
 
-            dynamic_sigindices: local_backing.dynamic_sigindices.as_ptr(),
+                dynamic_sigindices: local_backing.dynamic_sigindices.as_ptr(),
+            },
             local_functions: local_backing.local_functions.as_ptr(),
 
             local_backing,
@@ -88,16 +101,18 @@ impl Ctx {
         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(),
+            internal: InternalCtx {
+                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.vm_memories.as_mut_ptr(),
-            imported_tables: import_backing.vm_tables.as_mut_ptr(),
-            imported_globals: import_backing.vm_globals.as_mut_ptr(),
-            imported_funcs: import_backing.vm_functions.as_mut_ptr(),
+                imported_memories: import_backing.vm_memories.as_mut_ptr(),
+                imported_tables: import_backing.vm_tables.as_mut_ptr(),
+                imported_globals: import_backing.vm_globals.as_mut_ptr(),
+                imported_funcs: import_backing.vm_functions.as_mut_ptr(),
 
-            dynamic_sigindices: local_backing.dynamic_sigindices.as_ptr(),
+                dynamic_sigindices: local_backing.dynamic_sigindices.as_ptr(),
+            },
             local_functions: local_backing.local_functions.as_ptr(),
 
             local_backing,
@@ -333,43 +348,45 @@ impl Anyfunc {
 
 #[cfg(test)]
 mod vm_offset_tests {
-    use super::{Anyfunc, Ctx, ImportedFunc, LocalGlobal, LocalMemory, LocalTable};
+    use super::{Anyfunc, Ctx, ImportedFunc, InternalCtx, LocalGlobal, LocalMemory, LocalTable};
 
     #[test]
     fn vmctx() {
+        assert_eq!(0usize, offset_of!(Ctx => internal).get_byte_offset(),);
+
         assert_eq!(
             Ctx::offset_memories() as usize,
-            offset_of!(Ctx => memories).get_byte_offset(),
+            offset_of!(InternalCtx => memories).get_byte_offset(),
         );
 
         assert_eq!(
             Ctx::offset_tables() as usize,
-            offset_of!(Ctx => tables).get_byte_offset(),
+            offset_of!(InternalCtx => tables).get_byte_offset(),
         );
 
         assert_eq!(
             Ctx::offset_globals() as usize,
-            offset_of!(Ctx => globals).get_byte_offset(),
+            offset_of!(InternalCtx => globals).get_byte_offset(),
         );
 
         assert_eq!(
             Ctx::offset_imported_memories() as usize,
-            offset_of!(Ctx => imported_memories).get_byte_offset(),
+            offset_of!(InternalCtx => imported_memories).get_byte_offset(),
         );
 
         assert_eq!(
             Ctx::offset_imported_tables() as usize,
-            offset_of!(Ctx => imported_tables).get_byte_offset(),
+            offset_of!(InternalCtx => imported_tables).get_byte_offset(),
         );
 
         assert_eq!(
             Ctx::offset_imported_globals() as usize,
-            offset_of!(Ctx => imported_globals).get_byte_offset(),
+            offset_of!(InternalCtx => imported_globals).get_byte_offset(),
         );
 
         assert_eq!(
             Ctx::offset_imported_funcs() as usize,
-            offset_of!(Ctx => imported_funcs).get_byte_offset(),
+            offset_of!(InternalCtx => imported_funcs).get_byte_offset(),
         );
 
         assert_eq!(

lib/runtime-core/src/vmcalls.rs

@@ -17,7 +17,7 @@ pub unsafe extern "C" fn local_static_memory_grow(
     memory_index: LocalMemoryIndex,
     delta: Pages,
 ) -> i32 {
-    let local_memory = *ctx.memories.add(memory_index.index());
+    let local_memory = *ctx.internal.memories.add(memory_index.index());
     let memory = (*local_memory).memory as *mut StaticMemory;
 
     match (*memory).grow(delta, &mut *local_memory) {
@@ -30,7 +30,7 @@ pub unsafe extern "C" fn local_static_memory_size(
     ctx: &vm::Ctx,
     memory_index: LocalMemoryIndex,
 ) -> Pages {
-    let local_memory = *ctx.memories.add(memory_index.index());
+    let local_memory = *ctx.internal.memories.add(memory_index.index());
     let memory = (*local_memory).memory as *mut StaticMemory;
 
     (*memory).size()
@@ -41,7 +41,7 @@ pub unsafe extern "C" fn local_dynamic_memory_grow(
     memory_index: LocalMemoryIndex,
     delta: Pages,
 ) -> i32 {
-    let local_memory = *ctx.memories.add(memory_index.index());
+    let local_memory = *ctx.internal.memories.add(memory_index.index());
     let memory = (*local_memory).memory as *mut DynamicMemory;
 
     match (*memory).grow(delta, &mut *local_memory) {
@@ -54,7 +54,7 @@ pub unsafe extern "C" fn local_dynamic_memory_size(
     ctx: &vm::Ctx,
     memory_index: LocalMemoryIndex,
 ) -> Pages {
-    let local_memory = *ctx.memories.add(memory_index.index());
+    let local_memory = *ctx.internal.memories.add(memory_index.index());
     let memory = (*local_memory).memory as *mut DynamicMemory;
 
     (*memory).size()
@@ -69,7 +69,10 @@ pub unsafe extern "C" fn imported_static_memory_grow(
     import_memory_index: ImportedMemoryIndex,
     delta: Pages,
 ) -> i32 {
-    let local_memory = *ctx.imported_memories.add(import_memory_index.index());
+    let local_memory = *ctx
+        .internal
+        .imported_memories
+        .add(import_memory_index.index());
     let memory = (*local_memory).memory as *mut StaticMemory;
 
     match (*memory).grow(delta, &mut *local_memory) {
@@ -82,7 +85,10 @@ pub unsafe extern "C" fn imported_static_memory_size(
     ctx: &vm::Ctx,
     import_memory_index: ImportedMemoryIndex,
 ) -> Pages {
-    let local_memory = *ctx.imported_memories.add(import_memory_index.index());
+    let local_memory = *ctx
+        .internal
+        .imported_memories
+        .add(import_memory_index.index());
     let memory = (*local_memory).memory as *mut StaticMemory;
 
     (*memory).size()
@@ -93,7 +99,7 @@ pub unsafe extern "C" fn imported_dynamic_memory_grow(
     memory_index: ImportedMemoryIndex,
     delta: Pages,
 ) -> i32 {
-    let local_memory = *ctx.imported_memories.add(memory_index.index());
+    let local_memory = *ctx.internal.imported_memories.add(memory_index.index());
     let memory = (*local_memory).memory as *mut DynamicMemory;
 
     match (*memory).grow(delta, &mut *local_memory) {
@@ -106,7 +112,7 @@ pub unsafe extern "C" fn imported_dynamic_memory_size(
     ctx: &vm::Ctx,
     memory_index: ImportedMemoryIndex,
 ) -> Pages {
-    let local_memory = *ctx.imported_memories.add(memory_index.index());
+    let local_memory = *ctx.internal.imported_memories.add(memory_index.index());
     let memory = (*local_memory).memory as *mut DynamicMemory;
 
     (*memory).size()