fluencelabs/wasmer
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasmer synced 2025-06-27 07:31:33 +00:00
Code Issues Projects Releases Wiki Activity

Passing all spectests

Browse Source
This commit is contained in:
Lachlan Sneff
2019-01-17 14:13:28 -08:00
parent 1dbbaa30b6
commit 93d0918122
7 changed files with 24 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
lib/runtime/build/spectests.rs
View File

@ -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

4
lib/runtime/examples/simple/main.rs
View File

@ -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);

6
lib/runtime/examples/test.rs
View File

@ -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);

12
lib/runtime/src/instance.rs
View File

@ -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, &[])?;

4
lib/runtime/src/module.rs
View File

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

114
lib/runtime/src/vm.rs
View File

@ -1,6 +1,7 @@
pub use crate::backing::{ImportBacking, LocalBacking};
use crate::types::LocalMemoryIndex;
use std::ffi::c_void;
pub use crate::{
backing::{LocalBacking, ImportBacking},
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
}
}

2
lib/runtime/tests/semantics.rs
View File

@ -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!(