diff --git a/benches/interpreter.rs b/benches/interpreter.rs index e1711f5..6b05753 100644 --- a/benches/interpreter.rs +++ b/benches/interpreter.rs @@ -41,7 +41,7 @@ fn export_entry_performance(b: &mut Bencher) { .build(); // add both modules to program - let program = ProgramInstance::new().unwrap(); + let program = ProgramInstance::new(); program.add_module("callee_module", callee_module, None).unwrap(); let caller_module = program.add_module("caller_module", caller_module, None).unwrap(); diff --git a/examples/interpret.rs b/examples/interpret.rs index 56c1db0..31ca5c8 100644 --- a/examples/interpret.rs +++ b/examples/interpret.rs @@ -15,9 +15,9 @@ fn main() { } // Intrepreter initialization. - // It also initializes a default "env" module. - let program = parity_wasm::ProgramInstance::with_env_params( - interpreter::EnvParams { + // It also initializes a default "env" module. + let program = parity_wasm::ProgramInstance::with_emscripten_env( + interpreter::EmscriptenParams { total_stack: 128*1024, ..Default::default() } diff --git a/examples/invoke.rs b/examples/invoke.rs index 8704cbf..57784f6 100644 --- a/examples/invoke.rs +++ b/examples/invoke.rs @@ -17,8 +17,8 @@ fn main() { // Intrepreter initialization. // It also initializes a default "env" module. - let program = parity_wasm::ProgramInstance::with_env_params( - interpreter::EnvParams { + let program = parity_wasm::ProgramInstance::with_emscripten_env( + interpreter::EmscriptenParams { total_stack: 128*1024, ..Default::default() } diff --git a/spec/src/run.rs b/spec/src/run.rs index 3e4053e..bb6111e 100644 --- a/spec/src/run.rs +++ b/spec/src/run.rs @@ -59,7 +59,7 @@ fn try_deserialize(base_dir: &str, module_path: &str) -> Result Result<(), InterpreterError> { let module = try_deserialize(base_dir, module_path).map_err(|e| parity_wasm::interpreter::Error::Program(format!("{:?}", e)))?; - let program = ProgramInstance::new().expect("Failed creating program"); + let program = ProgramInstance::new(); program.add_module("try_load", module, None).map(|_| ()) } @@ -172,7 +172,7 @@ pub fn spec(name: &str) { .expect(&format!("Failed to load json file {}", &fixture.json)); let spec: test::Spec = serde_json::from_reader(&mut f).expect("Failed to deserialize JSON file"); - let program = ProgramInstance::new().expect("Failed creating program"); + let program = ProgramInstance::new(); let mut last_module = None; for command in &spec.commands { println!("command {:?}", command); diff --git a/src/interpreter/env.rs b/src/interpreter/emscripten.rs similarity index 93% rename from src/interpreter/env.rs rename to src/interpreter/emscripten.rs index fd0bba2..8fd094c 100644 --- a/src/interpreter/env.rs +++ b/src/interpreter/emscripten.rs @@ -1,10 +1,13 @@ +//! This module provides some of the simplest exports +//! from the Emscripten runtime, such as `STACKTOP` or `abort`. + use std::sync::{Arc, Weak}; use std::collections::HashMap; use builder::module; use elements::{Module, ExportEntry, Internal, GlobalEntry, GlobalType, ValueType, InitExpr, Opcode, Opcodes}; use interpreter::Error; -use interpreter::env_native::NATIVE_INDEX_FUNC_MIN; +use interpreter::native::NATIVE_INDEX_FUNC_MIN; use interpreter::module::{ModuleInstanceInterface, ModuleInstance, ExecutionParams, ItemIndex, CallerContext, ExportEntryType, InternalFunctionReference, InternalFunction, FunctionSignature}; use interpreter::memory::{MemoryInstance, LINEAR_MEMORY_PAGE_SIZE}; @@ -27,7 +30,7 @@ const DEFAULT_TABLE_BASE: u32 = 0; /// Default tableBase variable value. const DEFAULT_MEMORY_BASE: u32 = 0; -/// Defaul table size. +/// Default table size. const DEFAULT_TABLE_SIZE: u32 = 64; /// Index of default memory. @@ -70,8 +73,8 @@ const INDEX_FUNC_MIN_NONUSED: u32 = 4; /// Max index of reserved function. const INDEX_FUNC_MAX: u32 = NATIVE_INDEX_FUNC_MIN - 1; -/// Environment parameters. -pub struct EnvParams { +/// Emscripten environment parameters. +pub struct EmscriptenParams { /// Stack size in bytes. pub total_stack: u32, /// Total memory size in bytes. @@ -84,24 +87,24 @@ pub struct EnvParams { pub static_size: Option, } -pub struct EnvModuleInstance { - _params: EnvParams, +pub struct EmscriptenModuleInstance { + _params: EmscriptenParams, instance: ModuleInstance, } -impl EnvModuleInstance { - pub fn new(params: EnvParams, module: Module) -> Result { +impl EmscriptenModuleInstance { + pub fn new(params: EmscriptenParams, module: Module) -> Result { let mut instance = ModuleInstance::new(Weak::default(), "env".into(), module)?; instance.instantiate(None)?; - Ok(EnvModuleInstance { + Ok(EmscriptenModuleInstance { _params: params, instance: instance, }) } } -impl ModuleInstanceInterface for EnvModuleInstance { +impl ModuleInstanceInterface for EmscriptenModuleInstance { fn execute_index(&self, index: u32, params: ExecutionParams) -> Result, Error> { self.instance.execute_index(index, params) } @@ -173,7 +176,7 @@ impl ModuleInstanceInterface for EnvModuleInstance { } } -pub fn env_module(params: EnvParams) -> Result { +pub fn env_module(params: EmscriptenParams) -> Result { debug_assert!(params.total_stack < params.total_memory); debug_assert!((params.total_stack % LINEAR_MEMORY_PAGE_SIZE) == 0); debug_assert!((params.total_memory % LINEAR_MEMORY_PAGE_SIZE) == 0); @@ -241,12 +244,12 @@ pub fn env_module(params: EnvParams) -> Result { .build() .with_export(ExportEntry::new("getTotalMemory".into(), Internal::Function(INDEX_FUNC_GET_TOTAL_MEMORY))); - EnvModuleInstance::new(params, builder.build()) + EmscriptenModuleInstance::new(params, builder.build()) } -impl Default for EnvParams { +impl Default for EmscriptenParams { fn default() -> Self { - EnvParams { + EmscriptenParams { total_stack: DEFAULT_TOTAL_STACK, total_memory: DEFAULT_TOTAL_MEMORY, allow_memory_growth: DEFAULT_ALLOW_MEMORY_GROWTH, @@ -256,7 +259,7 @@ impl Default for EnvParams { } } -impl EnvParams { +impl EmscriptenParams { fn max_memory(&self) -> Option { if self.allow_memory_growth { None } else { Some(self.total_memory) } } diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs index af9dccf..c056d7e 100644 --- a/src/interpreter/mod.rs +++ b/src/interpreter/mod.rs @@ -58,8 +58,6 @@ pub enum Error { Value(String), /// Interpreter (code) error. Interpreter(String), - /// Env module error. - Env(String), /// Native module error. Native(String), /// Trap. @@ -83,7 +81,6 @@ impl Into for Error { Error::Stack(s) => s, Error::Interpreter(s) => s, Error::Value(s) => s, - Error::Env(s) => s, Error::Native(s) => s, Error::Trap(s) => format!("trap: {}", s), Error::User(e) => format!("user: {}", e), @@ -106,7 +103,6 @@ impl ::std::fmt::Display for Error { Error::Stack(ref s) => write!(f, "Stack: {}", s), Error::Interpreter(ref s) => write!(f, "Interpreter: {}", s), Error::Value(ref s) => write!(f, "Value: {}", s), - Error::Env(ref s) => write!(f, "Env: {}", s), Error::Native(ref s) => write!(f, "Native: {}", s), Error::Trap(ref s) => write!(f, "Trap: {}", s), Error::User(ref e) => write!(f, "User: {}", e), @@ -120,8 +116,8 @@ impl From for Error where U: UserError + Sized { } } -mod env; -mod env_native; +mod emscripten; +mod native; mod imports; mod memory; mod module; @@ -143,5 +139,5 @@ pub use self::table::TableInstance; pub use self::program::ProgramInstance; pub use self::value::RuntimeValue; pub use self::variable::{VariableInstance, VariableType, ExternalVariableValue}; -pub use self::env_native::{env_native_module, UserDefinedElements, UserFunctionExecutor, UserFunctionDescriptor}; -pub use self::env::EnvParams; +pub use self::native::{native_module, UserDefinedElements, UserFunctionExecutor, UserFunctionDescriptor}; +pub use self::emscripten::EmscriptenParams; diff --git a/src/interpreter/module.rs b/src/interpreter/module.rs index 33b0af6..876d566 100644 --- a/src/interpreter/module.rs +++ b/src/interpreter/module.rs @@ -4,7 +4,7 @@ use std::sync::{Arc, Weak}; use std::fmt; use elements::{Module, InitExpr, Opcode, Type, FunctionType, Internal, External, BlockType, ResizableLimits, Local, ValueType}; use interpreter::Error; -use interpreter::env_native::UserFunctionDescriptor; +use interpreter::native::UserFunctionDescriptor; use interpreter::imports::ModuleImports; use interpreter::memory::MemoryInstance; use interpreter::program::ProgramInstanceEssence; diff --git a/src/interpreter/env_native.rs b/src/interpreter/native.rs similarity index 76% rename from src/interpreter/env_native.rs rename to src/interpreter/native.rs index edb75b4..3bc7127 100644 --- a/src/interpreter/env_native.rs +++ b/src/interpreter/native.rs @@ -1,3 +1,4 @@ + use std::sync::Arc; use std::collections::HashMap; use std::borrow::Cow; @@ -79,8 +80,8 @@ pub struct UserDefinedElements<'a> { /// Native module instance. pub struct NativeModuleInstance<'a> { - /// Underllying module reference. - env: Arc, + /// Underlying module reference. + base: Arc, /// User function executor. executor: RwLock>, /// By-name functions index. @@ -95,13 +96,13 @@ pub struct NativeModuleInstance<'a> { impl<'a> NativeModuleInstance<'a> { /// Create new native module - pub fn new(env: Arc, elements: UserDefinedElements<'a>) -> Result { + pub fn new(base: Arc, elements: UserDefinedElements<'a>) -> Result { if !elements.functions.is_empty() && elements.executor.is_none() { - return Err(Error::Function("trying to construct native env module with functions, but without executor".into())); + return Err(Error::Function("trying to construct native module with functions, but without executor".into())); } Ok(NativeModuleInstance { - env: env, + base: base, executor: RwLock::new(elements.executor), functions_by_name: elements.functions.iter().enumerate().map(|(i, f)| (f.name().to_owned(), i as u32)).collect(), functions: elements.functions, @@ -113,11 +114,11 @@ impl<'a> NativeModuleInstance<'a> { impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> { fn execute_index(&self, index: u32, params: ExecutionParams) -> Result, Error> { - self.env.execute_index(index, params) + self.base.execute_index(index, params) } fn execute_export(&self, name: &str, params: ExecutionParams) -> Result, Error> { - self.env.execute_export(name, params) + self.base.execute_export(name, params) } fn export_entry<'b>(&self, name: &str, required_type: &ExportEntryType) -> Result { @@ -174,25 +175,25 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> { } } - self.env.export_entry(name, required_type) + self.base.export_entry(name, required_type) } fn table(&self, index: ItemIndex) -> Result, Error> { - self.env.table(index) + self.base.table(index) } fn memory(&self, index: ItemIndex) -> Result, Error> { - self.env.memory(index) + self.base.memory(index) } fn global<'b>(&self, global_index: ItemIndex, variable_type: Option, externals: Option<&'b HashMap>>) -> Result, Error> { let index = match global_index { ItemIndex::IndexSpace(index) | ItemIndex::Internal(index) => index, - ItemIndex::External(_) => unreachable!("trying to get global, exported by native env module"), + ItemIndex::External(_) => unreachable!("trying to get global, exported by native module"), }; if index < NATIVE_INDEX_GLOBAL_MIN { - return self.env.global(global_index, variable_type, externals); + return self.base.global(global_index, variable_type, externals); } self.globals @@ -204,16 +205,16 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> { fn function_type(&self, function_index: ItemIndex) -> Result { let index = match function_index { ItemIndex::IndexSpace(index) | ItemIndex::Internal(index) => index, - ItemIndex::External(_) => unreachable!("trying to call function, exported by native env module"), + ItemIndex::External(_) => unreachable!("trying to call function, exported by native module"), }; if index < NATIVE_INDEX_FUNC_MIN || index >= NATIVE_INDEX_GLOBAL_MIN { - return self.env.function_type(function_index); + return self.base.function_type(function_index); } Ok(FunctionSignature::User(self.functions .get((index - NATIVE_INDEX_FUNC_MIN) as usize) - .ok_or(Error::Native(format!("missing native env function with index {}", index)))?)) + .ok_or(Error::Native(format!("missing native function with index {}", index)))?)) } fn function_type_by_index(&self, type_index: u32) -> Result { @@ -221,11 +222,11 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> { } fn function_reference<'b>(&self, index: ItemIndex, externals: Option<&'b HashMap>>) -> Result, Error> { - self.env.function_reference(index, externals) + self.base.function_reference(index, externals) } fn function_reference_indirect<'b>(&self, table_idx: u32, type_idx: u32, func_idx: u32, externals: Option<&'b HashMap>>) -> Result, Error> { - self.env.function_reference_indirect(table_idx, type_idx, func_idx, externals) + self.base.function_reference_indirect(table_idx, type_idx, func_idx, externals) } fn function_body<'b>(&'b self, _internal_index: u32) -> Result>, Error> { @@ -234,7 +235,7 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> { fn call_internal_function(&self, outer: CallerContext, index: u32) -> Result, Error> { if index < NATIVE_INDEX_FUNC_MIN || index >= NATIVE_INDEX_GLOBAL_MIN { - return self.env.call_internal_function(outer, index); + return self.base.call_internal_function(outer, index); } self.functions @@ -242,14 +243,45 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> { .ok_or(Error::Native(format!("trying to call native function with index {}", index)).into()) .and_then(|f| self.executor.write() .as_mut() - .expect("function existss; if function exists, executor must also exists [checked in constructor]; qed") + .expect("function exists; if function exists, executor must also exists [checked in constructor]; qed") .execute(&f.name(), outer)) } } -/// Create wrapper for env module with given native user functions. -pub fn env_native_module<'a>(env: Arc, user_elements: UserDefinedElements<'a>) -> Result { - NativeModuleInstance::new(env, user_elements) +/// Create wrapper for a module with given native user functions. +/// +/// # Examples +/// +/// ```rust +/// use parity_wasm::interpreter::{CallerContext, Error, ExecutionParams, ExportEntryType, +/// FunctionSignature, ItemIndex, ModuleInstance, +/// ModuleInstanceInterface, ProgramInstance, RuntimeValue, +/// UserDefinedElements, UserError, UserFunctionDescriptor, +/// UserFunctionExecutor}; +/// +/// struct MyExecutor; +/// +/// impl UserFunctionExecutor for MyExecutor { +/// fn execute( +/// &mut self, +/// name: &str, +/// context: CallerContext, +/// ) -> Result, Error> { +/// match name { +/// "add" => { +/// // fn add(a: u32, b: u32) -> u32 +/// let b = context.value_stack.pop_as::()? as u32; +/// let a = context.value_stack.pop_as::()? as u32; +/// let sum = a + b; +/// Ok(Some(RuntimeValue::I32(sum as i32))) +/// } +/// _ => Err(Error::Trap("not implemented".into()).into()), +/// } +/// } +/// } +/// ``` +pub fn native_module<'a>(base: Arc, user_elements: UserDefinedElements<'a>) -> Result { + NativeModuleInstance::new(base, user_elements) } impl<'a> PartialEq for UserFunctionDescriptor { diff --git a/src/interpreter/program.rs b/src/interpreter/program.rs index 706f8dc..ec9da80 100644 --- a/src/interpreter/program.rs +++ b/src/interpreter/program.rs @@ -3,7 +3,7 @@ use std::collections::HashMap; use parking_lot::RwLock; use elements::Module; use interpreter::Error; -use interpreter::env::{self, env_module}; +use interpreter::emscripten::{EmscriptenParams, env_module}; use interpreter::module::{ModuleInstance, ModuleInstanceInterface}; /// Program instance. Program is a set of instantiated modules. @@ -20,24 +20,21 @@ pub struct ProgramInstanceEssence { impl ProgramInstance { /// Create new program instance. - pub fn new() -> Result { - ProgramInstance::with_env_params(env::EnvParams::default()) + pub fn new() -> Self { + ProgramInstance { + essence: Arc::new(ProgramInstanceEssence::new()), + } } - /// Create new program instance with custom env module params (mostly memory) - pub fn with_env_params(params: env::EnvParams) -> Result { + /// Create new program instance with added Emscripten's `env` module. + /// + /// You can specify desired environment params. Or you can just pass `Default::default()`. + pub fn with_emscripten_env(params: EmscriptenParams) -> Result { Ok(ProgramInstance { essence: Arc::new(ProgramInstanceEssence::with_env_params(params)?), }) } - /// Create a new program instance with a custom env module - pub fn with_env_module(env_module: Arc) -> Self { - ProgramInstance { - essence: Arc::new(ProgramInstanceEssence::with_env_module(env_module)), - } - } - /// Instantiate module with validation. pub fn add_module<'a>(&self, name: &str, module: Module, externals: Option<&'a HashMap>>) -> Result, Error> { let mut module_instance = ModuleInstance::new(Arc::downgrade(&self.essence), name.into(), module)?; @@ -64,11 +61,13 @@ impl ProgramInstance { impl ProgramInstanceEssence { /// Create new program essence. - pub fn new() -> Result { - ProgramInstanceEssence::with_env_params(env::EnvParams::default()) + pub fn new() -> Self { + ProgramInstanceEssence { + modules: RwLock::new(HashMap::new()), + } } - pub fn with_env_params(env_params: env::EnvParams) -> Result { + pub fn with_env_params(env_params: EmscriptenParams) -> Result { let env_mod = env_module(env_params)?; Ok(ProgramInstanceEssence::with_env_module(Arc::new(env_mod))) } @@ -81,7 +80,6 @@ impl ProgramInstanceEssence { } } - /// Get module reference. pub fn module(&self, name: &str) -> Option> { self.modules.read().get(name).cloned() diff --git a/src/interpreter/tests/basics.rs b/src/interpreter/tests/basics.rs index d9879cd..e9e9d6b 100644 --- a/src/interpreter/tests/basics.rs +++ b/src/interpreter/tests/basics.rs @@ -7,7 +7,7 @@ use builder::module; use elements::{ExportEntry, Internal, ImportEntry, External, GlobalEntry, GlobalType, InitExpr, ValueType, BlockType, Opcodes, Opcode, FunctionType, TableType, MemoryType}; use interpreter::{Error, UserError, ProgramInstance}; -use interpreter::env_native::{env_native_module, UserDefinedElements, UserFunctionExecutor, UserFunctionDescriptor}; +use interpreter::native::{native_module, UserDefinedElements, UserFunctionExecutor, UserFunctionDescriptor}; use interpreter::memory::MemoryInstance; use interpreter::module::{ModuleInstance, ModuleInstanceInterface, CallerContext, ItemIndex, ExecutionParams, ExportEntryType, FunctionSignature}; use interpreter::validator::{FunctionValidationContext, Validator}; @@ -40,7 +40,7 @@ fn import_function() { .build() .build(); - let program = ProgramInstance::new().unwrap(); + let program = ProgramInstance::new(); let external_module = program.add_module("external_module", module1, None).unwrap(); let main_module = program.add_module("main", module2, None).unwrap(); @@ -74,7 +74,7 @@ fn wrong_import() { .build() .build(); - let program = ProgramInstance::new().unwrap(); + let program = ProgramInstance::new(); let _side_module_instance = program.add_module("side_module", side_module, None).unwrap(); assert!(program.add_module("main", module, None).is_err()); } @@ -96,7 +96,7 @@ fn global_get_set() { .build() .build(); - let program = ProgramInstance::new().unwrap(); + let program = ProgramInstance::new(); let module = program.add_module("main", module, None).unwrap(); assert_eq!(module.execute_index(0, vec![].into()).unwrap().unwrap(), RuntimeValue::I32(50)); assert_eq!(module.execute_index(0, vec![].into()).unwrap().unwrap(), RuntimeValue::I32(58)); @@ -196,7 +196,7 @@ impl UserFunctionExecutor for FunctionExecutor { #[test] fn native_env_function() { // create new program - let program = ProgramInstance::new().unwrap(); + let program = ProgramInstance::with_emscripten_env(Default::default()).unwrap(); // => env module is created let env_instance = program.module("env").unwrap(); // => linear memory is created @@ -213,7 +213,7 @@ fn native_env_function() { globals: HashMap::new(), functions: ::std::borrow::Cow::from(SIGNATURES), }; - let native_env_instance = Arc::new(env_native_module(env_instance, functions).unwrap()); + let native_env_instance = Arc::new(native_module(env_instance, functions).unwrap()); let params = ExecutionParams::with_external("env".into(), native_env_instance); let module = module() @@ -256,7 +256,7 @@ fn native_env_function() { #[test] fn native_env_function_own_memory() { // create program + env module is auto instantiated + env module memory is instantiated (we do not need this) - let program = ProgramInstance::new().unwrap(); + let program = ProgramInstance::with_emscripten_env(Default::default()).unwrap(); struct OwnMemoryReference { pub memory: RefCell>>, @@ -287,7 +287,7 @@ fn native_env_function_own_memory() { let env_instance = program.module("env").unwrap(); let memory_ref = Arc::new(OwnMemoryReference { memory: RefCell::new(None) }); let mut executor = OwnMemoryExecutor { memory_ref: memory_ref.clone() }; - let native_env_instance = Arc::new(env_native_module(env_instance, UserDefinedElements { + let native_env_instance = Arc::new(native_module(env_instance, UserDefinedElements { executor: Some(&mut executor), globals: HashMap::new(), functions: ::std::borrow::Cow::from(SIGNATURES), @@ -326,9 +326,9 @@ fn native_env_function_own_memory() { fn native_env_global() { // module constructor let module_constructor = |elements| { - let program = ProgramInstance::new().unwrap(); + let program = ProgramInstance::with_emscripten_env(Default::default()).unwrap(); let env_instance = program.module("env").unwrap(); - let native_env_instance = Arc::new(env_native_module(env_instance.clone(), elements).unwrap()); + let native_env_instance = Arc::new(native_module(env_instance.clone(), elements).unwrap()); let params = ExecutionParams::with_external("env".into(), native_env_instance); let module = module() @@ -375,7 +375,7 @@ fn native_env_global() { #[test] fn native_custom_error() { - let program = ProgramInstance::new().unwrap(); + let program = ProgramInstance::with_emscripten_env(Default::default()).unwrap(); let env_instance = program.module("env").unwrap(); let env_memory = env_instance.memory(ItemIndex::Internal(0)).unwrap(); let mut executor = FunctionExecutor { memory: env_memory.clone(), values: Vec::new() }; @@ -384,7 +384,7 @@ fn native_custom_error() { globals: HashMap::new(), functions: ::std::borrow::Cow::from(SIGNATURES), }; - let native_env_instance = Arc::new(env_native_module(env_instance, functions).unwrap()); + let native_env_instance = Arc::new(native_module(env_instance, functions).unwrap()); let params = ExecutionParams::with_external("env".into(), native_env_instance); let module = module() @@ -428,7 +428,7 @@ fn native_custom_error() { #[test] fn import_env_mutable_global() { - let program = ProgramInstance::new().unwrap(); + let program = ProgramInstance::with_emscripten_env(Default::default()).unwrap(); let module = module() .with_import(ImportEntry::new("env".into(), "STACKTOP".into(), External::Global(GlobalType::new(ValueType::I32, false)))) @@ -439,12 +439,12 @@ fn import_env_mutable_global() { #[test] fn env_native_export_entry_type_check() { - let program = ProgramInstance::new().unwrap(); + let program = ProgramInstance::with_emscripten_env(Default::default()).unwrap(); let mut function_executor = FunctionExecutor { memory: program.module("env").unwrap().memory(ItemIndex::Internal(0)).unwrap(), values: Vec::new(), }; - let native_env_instance = Arc::new(env_native_module(program.module("env").unwrap(), UserDefinedElements { + let native_env_instance = Arc::new(native_module(program.module("env").unwrap(), UserDefinedElements { executor: Some(&mut function_executor), globals: vec![("ext_global".into(), Arc::new(VariableInstance::new(false, VariableType::I32, RuntimeValue::I32(1312)).unwrap()))].into_iter().collect(), functions: ::std::borrow::Cow::from(SIGNATURES), @@ -498,7 +498,7 @@ fn memory_import_limits_initial() { .with_export(ExportEntry::new("memory".into(), Internal::Memory(0))) .build(); - let program = ProgramInstance::new().unwrap(); + let program = ProgramInstance::new(); program.add_module("core", core_module, None).unwrap(); let test_cases = vec![ @@ -535,7 +535,7 @@ fn memory_import_limits_maximum() { (None, None, MaximumError::Ok), ]; - let program = ProgramInstance::new().unwrap(); + let program = ProgramInstance::new(); for test_case in test_cases { let (core_maximum, client_maximum, expected_err) = test_case; let core_module = module() @@ -566,7 +566,7 @@ fn table_import_limits_initial() { .with_export(ExportEntry::new("table".into(), Internal::Table(0))) .build(); - let program = ProgramInstance::new().unwrap(); + let program = ProgramInstance::new(); program.add_module("core", core_module, None).unwrap(); let test_cases = vec![ @@ -603,7 +603,7 @@ fn table_import_limits_maximum() { (None, None, MaximumError::Ok), ]; - let program = ProgramInstance::new().unwrap(); + let program = ProgramInstance::new(); for test_case in test_cases { let (core_maximum, client_maximum, expected_err) = test_case; let core_module = module() diff --git a/src/interpreter/tests/wabt.rs b/src/interpreter/tests/wabt.rs index e397314..e32c507 100644 --- a/src/interpreter/tests/wabt.rs +++ b/src/interpreter/tests/wabt.rs @@ -17,7 +17,7 @@ fn make_function_i32(body: Opcodes) -> (ProgramInstance, Arc