fluencelabs/parity-wasm
1
0
Fork 0
mirror of https://github.com/fluencelabs/parity-wasm synced 2025-06-03 10:01:39 +00:00
Code Issues Projects Releases Wiki Activity

Add St everywhere

Browse Source
This commit is contained in:
Sergey Pepyakin 2017-12-15 18:23:54 +03:00
parent e5bac395fd
commit 11afa2dc2f
11 changed files with 290 additions and 379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
src/interpreter/func.rs
View File

@ -5,25 +5,25 @@ use std::any::Any;
use elements::{FunctionType, Opcodes, Local};
use interpreter::{Error, ModuleInstance};
use interpreter::runner::{prepare_function_args, FunctionContext, Interpreter};
use interpreter::host::AnyFunc;
use interpreter::host::HostFunc;
use interpreter::value::RuntimeValue;
use common::stack::StackWithLimit;
use common::{DEFAULT_FRAME_STACK_LIMIT, DEFAULT_VALUE_STACK_LIMIT};
#[derive(Clone)]
pub enum FuncInstance {
pub enum FuncInstance<St> {
Internal {
func_type: Rc<FunctionType>,
module: Rc<ModuleInstance>,
module: Rc<ModuleInstance<St>>,
body: Rc<FuncBody>,
},
Host {
func_type: Rc<FunctionType>,
host_func: Rc<AnyFunc>,
host_func: Rc<HostFunc<St>>,
},
}
impl fmt::Debug for FuncInstance {
impl<St: fmt::Debug> fmt::Debug for FuncInstance<St> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
&FuncInstance::Internal {
@ -43,9 +43,9 @@ impl fmt::Debug for FuncInstance {
}
}
impl FuncInstance {
impl<St> FuncInstance<St> {
pub fn alloc_internal(
module: Rc<ModuleInstance>,
module: Rc<ModuleInstance<St>>,
func_type: Rc<FunctionType>,
body: FuncBody,
) -> Rc<Self> {
@ -59,7 +59,7 @@ impl FuncInstance {
pub fn alloc_host(
func_type: Rc<FunctionType>,
host_func: Rc<AnyFunc>,
host_func: Rc<HostFunc<St>>,
) -> Rc<Self> {
let func = FuncInstance::Host {
func_type,
@ -82,14 +82,14 @@ impl FuncInstance {
}
}
pub fn invoke<St: 'static>(
func: Rc<FuncInstance>,
pub fn invoke(
func: Rc<FuncInstance<St>>,
args: Vec<RuntimeValue>,
state: &mut St,
) -> Result<Option<RuntimeValue>, Error> {
enum InvokeKind {
Internal(FunctionContext),
Host(Rc<AnyFunc>, Vec<RuntimeValue>),
enum InvokeKind<St> {
Internal(FunctionContext<St>),
Host(Rc<HostFunc<St>>, Vec<RuntimeValue>),
}
let result = match *func {
@ -115,7 +115,7 @@ impl FuncInstance {
let mut interpreter = Interpreter::new(state);
interpreter.run_function(ctx)
}
InvokeKind::Host(host_func, args) => host_func.call_as_any(state as &mut Any, &args),
InvokeKind::Host(host_func, args) => host_func(state, &args),
}
}
}

218
src/interpreter/host.rs
View File

@ -1,6 +1,4 @@
use std::any::Any;
use std::rc::Rc;
use std::marker::PhantomData;
use std::collections::HashMap;
use std::collections::hash_map::Entry;
use elements::{FunctionType, ValueType, GlobalType, MemoryType, TableType};
@ -13,71 +11,59 @@ use interpreter::value::RuntimeValue;
use interpreter::Error;
use interpreter::ImportResolver;
pub type HostFunc<St> = Fn(&mut St, &[RuntimeValue]) -> Result<Option<RuntimeValue>, Error>;
pub struct HostModuleBuilder<St> {
exports: HashMap<String, ExternVal>,
_marker: PhantomData<St>,
exports: HashMap<String, ExternVal<St>>,
}
impl<St: 'static> HostModuleBuilder<St> {
impl<St> HostModuleBuilder<St> {
pub fn new() -> Self {
HostModuleBuilder {
exports: HashMap::new(),
_marker: PhantomData,
}
}
pub fn insert_func0<
Cl: Fn(&mut St) -> Result<Option<Ret>, Error> + 'static,
Ret: AsReturnVal + 'static,
F: Into<Func0<Cl, St, Ret>>,
N: Into<String>,
>(
&mut self,
name: N,
f: F,
) {
let func_type = Func0::<Cl, St, Ret>::derive_func_type();
let host_func = Rc::new(f.into()) as Rc<AnyFunc>;
let func = FuncInstance::alloc_host(Rc::new(func_type), host_func);
self.insert_func(name, func);
}
pub fn with_func1<
Cl: Fn(&mut St, P1) -> Result<Option<Ret>, Error> + 'static,
Ret: AsReturnVal + 'static,
P1: FromArg + 'static,
F: Into<Func1<Cl, St, Ret, P1>>,
N: Into<String>,
>(
&mut self,
name: N,
f: F,
) {
let func_type = Func1::<Cl, St, Ret, P1>::derive_func_type();
let host_func = Rc::new(f.into()) as Rc<AnyFunc>;
let func = FuncInstance::alloc_host(Rc::new(func_type), host_func);
self.insert_func(name, func);
}
// pub fn insert_func0<
// Cl: Fn(&mut St) -> Result<Option<Ret>, Error> + AnyFunc<St> + 'static,
// Ret: AsReturnVal + 'static,
// F: Into<Cl>,
// N: Into<String>,
// >(
// &mut self,
// name: N,
// f: Box<F>,
// ) {
// let func_type = FunctionType::new(vec![], Ret::value_type());
// let host_func = Rc::new(f) as Rc<AnyFunc<St>>;
// let func = FuncInstance::alloc_host(Rc::new(func_type), host_func);
// self.insert_func(name, func);
// }
pub fn with_func2<
Cl: Fn(&mut St, P1, P2) -> Result<Option<Ret>, Error> + 'static,
Ret: AsReturnVal + 'static,
P1: FromArg + 'static,
P2: FromArg + 'static,
F: Into<Func2<Cl, St, Ret, P1, P2>>,
N: Into<String>,
>(
&mut self,
name: N,
f: F,
f: Cl,
) {
let func_type = Func2::<Cl, St, Ret, P1, P2>::derive_func_type();
let host_func = Rc::new(f.into()) as Rc<AnyFunc>;
let func_type = FunctionType::new(vec![P1::value_type(), P2::value_type()], Ret::value_type());
let host_func = Rc::new(move |state: &mut St, args: &[RuntimeValue]| -> Result<Option<RuntimeValue>, Error> {
let p1 = P1::from_arg(&args[0]);
let p2 = P2::from_arg(&args[1]);
let result = f(state, p1, p2);
result.map(|r| r.and_then(|r| r.as_return_val()))
});
let func = FuncInstance::alloc_host(Rc::new(func_type), host_func);
self.insert_func(name, func);
}
pub fn insert_func<N: Into<String>>(&mut self, name: N, func: Rc<FuncInstance>) {
pub fn insert_func<N: Into<String>>(&mut self, name: N, func: Rc<FuncInstance<St>>) {
self.insert(name, ExternVal::Func(func));
}
@ -89,7 +75,7 @@ impl<St: 'static> HostModuleBuilder<St> {
self.insert(name, ExternVal::Memory(memory));
}
pub fn insert_table<N: Into<String>>(&mut self, name: N, table: Rc<TableInstance>) {
pub fn insert_table<N: Into<String>>(&mut self, name: N, table: Rc<TableInstance<St>>) {
self.insert(name, ExternVal::Table(table));
}
@ -103,19 +89,19 @@ impl<St: 'static> HostModuleBuilder<St> {
self
}
pub fn with_table<N: Into<String>>(mut self, name: N, table: Rc<TableInstance>) -> Self {
pub fn with_table<N: Into<String>>(mut self, name: N, table: Rc<TableInstance<St>>) -> Self {
self.insert_table(name, table);
self
}
fn insert<N: Into<String>>(&mut self, name: N, extern_val: ExternVal) {
fn insert<N: Into<String>>(&mut self, name: N, extern_val: ExternVal<St>) {
match self.exports.entry(name.into()) {
Entry::Vacant(v) => v.insert(extern_val),
Entry::Occupied(o) => panic!("Duplicate export name {}", o.key()),
};
}
pub fn build(self) -> HostModule {
pub fn build(self) -> HostModule<St> {
let internal_instance = Rc::new(ModuleInstance::with_exports(self.exports));
HostModule {
internal_instance
@ -123,22 +109,22 @@ impl<St: 'static> HostModuleBuilder<St> {
}
}
pub struct HostModule {
internal_instance: Rc<ModuleInstance>,
pub struct HostModule<St> {
internal_instance: Rc<ModuleInstance<St>>,
}
impl HostModule {
pub fn export_by_name(&self, name: &str) -> Option<ExternVal> {
impl<St> HostModule<St> {
pub fn export_by_name(&self, name: &str) -> Option<ExternVal<St>> {
self.internal_instance.export_by_name(name)
}
}
impl ImportResolver for HostModule {
impl<St> ImportResolver<St> for HostModule<St> {
fn resolve_func(
&self,
field_name: &str,
func_type: &FunctionType,
) -> Result<Rc<FuncInstance>, Error> {
) -> Result<Rc<FuncInstance<St>>, Error> {
self.internal_instance.resolve_func(field_name, func_type)
}
@ -162,15 +148,15 @@ impl ImportResolver for HostModule {
&self,
field_name: &str,
table_type: &TableType,
) -> Result<Rc<TableInstance>, Error> {
) -> Result<Rc<TableInstance<St>>, Error> {
self.internal_instance.resolve_table(field_name, table_type)
}
}
pub trait AnyFunc {
pub trait AnyFunc<St> {
fn call_as_any(
&self,
state: &mut Any,
state: &mut St,
args: &[RuntimeValue],
) -> Result<Option<RuntimeValue>, Error>;
}
@ -218,134 +204,26 @@ impl AsReturnVal for () {
}
}
pub struct Func0<Cl: Fn(&mut St) -> Result<Option<Ret>, Error>, St, Ret: AsReturnVal> {
closure: Cl,
_marker: PhantomData<(St, Ret)>,
}
impl<
St: 'static,
Ret: AsReturnVal,
Cl: Fn(&mut St) -> Result<Option<Ret>, Error>,
> AnyFunc for Func0<Cl, St, Ret> {
impl<St, Ret: AsReturnVal> AnyFunc<St> for Fn(&mut St) -> Result<Option<Ret>, Error> {
fn call_as_any(
&self,
state: &mut Any,
state: &mut St,
_args: &[RuntimeValue],
) -> Result<Option<RuntimeValue>, Error> {
let state = state.downcast_mut::<St>().unwrap();
let result = (self.closure)(state);
let result = self(state);
result.map(|r| r.and_then(|r| r.as_return_val()))
}
}
impl<St: 'static, Ret: AsReturnVal, Cl: Fn(&mut St) -> Result<Option<Ret>, Error>> From<Cl>
for Func0<Cl, St, Ret> {
fn from(cl: Cl) -> Self {
Func0 {
closure: cl,
_marker: PhantomData,
}
}
}
impl<
St: 'static,
Ret: AsReturnVal,
Cl: Fn(&mut St) -> Result<Option<Ret>, Error>,
> Func0<Cl, St, Ret> {
fn derive_func_type() -> FunctionType {
FunctionType::new(vec![], Ret::value_type())
}
}
pub struct Func1<Cl: Fn(&mut St, P1) -> Result<Option<Ret>, Error>, St, Ret: AsReturnVal, P1: FromArg> {
closure: Cl,
_marker: PhantomData<(St, Ret, P1)>,
}
impl<
St: 'static,
Ret: AsReturnVal,
P1: FromArg,
Cl: Fn(&mut St, P1) -> Result<Option<Ret>, Error>,
> AnyFunc for Func1<Cl, St, Ret, P1> {
impl<St, Ret: AsReturnVal, P1: FromArg, P2: FromArg> AnyFunc<St> for Fn(&mut St, P1, P2) -> Result<Option<Ret>, Error> {
fn call_as_any(
&self,
state: &mut Any,
state: &mut St,
args: &[RuntimeValue],
) -> Result<Option<RuntimeValue>, Error> {
let state = state.downcast_mut::<St>().unwrap();
let p1 = P1::from_arg(&args[0]);
let result = (self.closure)(state, p1);
result.map(|r| r.and_then(|r| r.as_return_val()))
}
}
impl<St: 'static, Ret: AsReturnVal, P1: FromArg, Cl: Fn(&mut St, P1) -> Result<Option<Ret>, Error>> From<Cl>
for Func1<Cl, St, Ret, P1> {
fn from(cl: Cl) -> Self {
Func1 {
closure: cl,
_marker: PhantomData,
}
}
}
impl<
St: 'static,
Ret: AsReturnVal,
P1: FromArg,
Cl: Fn(&mut St, P1) -> Result<Option<Ret>, Error>,
> Func1<Cl, St, Ret, P1> {
fn derive_func_type() -> FunctionType {
FunctionType::new(vec![P1::value_type()], Ret::value_type())
}
}
pub struct Func2<Cl: Fn(&mut St, P1, P2) -> Result<Option<Ret>, Error>, St, Ret: AsReturnVal, P1: FromArg, P2: FromArg> {
closure: Cl,
_marker: PhantomData<(St, Ret, P1, P2)>,
}
impl<
St: 'static,
Ret: AsReturnVal,
P1: FromArg,
P2: FromArg,
Cl: Fn(&mut St, P1, P2) -> Result<Option<Ret>, Error>,
> AnyFunc for Func2<Cl, St, Ret, P1, P2> {
fn call_as_any(
&self,
state: &mut Any,
args: &[RuntimeValue],
) -> Result<Option<RuntimeValue>, Error> {
let state = state.downcast_mut::<St>().unwrap();
let p1 = P1::from_arg(&args[0]);
let p2 = P2::from_arg(&args[1]);
let result = (self.closure)(state, p1, p2);
let result = self(state, p1, p2);
result.map(|r| r.and_then(|r| r.as_return_val()))
}
}
impl<St: 'static, Ret: AsReturnVal, P1: FromArg, P2: FromArg, Cl: Fn(&mut St, P1, P2) -> Result<Option<Ret>, Error>> From<Cl>
for Func2<Cl, St, Ret, P1, P2> {
fn from(cl: Cl) -> Self {
Func2 {
closure: cl,
_marker: PhantomData,
}
}
}
impl<
St: 'static,
Ret: AsReturnVal,
P1: FromArg,
P2: FromArg,
Cl: Fn(&mut St, P1, P2) -> Result<Option<Ret>, Error>,
> Func2<Cl, St, Ret, P1, P2> {
fn derive_func_type() -> FunctionType {
FunctionType::new(vec![P1::value_type(), P2::value_type()], Ret::value_type())
}
}

27
src/interpreter/imports.rs
View File

@ -7,38 +7,43 @@ use interpreter::memory::MemoryInstance;
use interpreter::table::TableInstance;
use interpreter::Error;
#[derive(Default)]
pub struct Imports<'a> {
modules: HashMap<String, &'a ImportResolver>,
pub struct Imports<'a, St: 'a> {
modules: HashMap<String, &'a ImportResolver<St>>,
}
impl<'a> Imports<'a> {
pub fn new() -> Imports<'a> {
impl<'a, St: 'a> Default for Imports<'a, St> {
fn default() -> Self {
Self::new()
}
}
impl<'a, St: 'a> Imports<'a, St> {
pub fn new() -> Imports<'a, St> {
Imports {
modules: HashMap::new(),
}
}
pub fn with_resolver<N: Into<String>>(mut self, name: N, resolver: &'a ImportResolver) -> Imports<'a> {
pub fn with_resolver<N: Into<String>>(mut self, name: N, resolver: &'a ImportResolver<St>) -> Self {
self.modules.insert(name.into(), resolver);
self
}
pub fn push_resolver<N: Into<String>>(&mut self, name: N, resolver: &'a ImportResolver) {
pub fn push_resolver<N: Into<String>>(&mut self, name: N, resolver: &'a ImportResolver<St>) {
self.modules.insert(name.into(), resolver);
}
pub fn resolver(&self, name: &str) -> Option<&ImportResolver> {
pub fn resolver(&self, name: &str) -> Option<&ImportResolver<St>> {
self.modules.get(name).cloned()
}
}
pub trait ImportResolver {
pub trait ImportResolver<St> {
fn resolve_func(
&self,
field_name: &str,
func_type: &FunctionType,
) -> Result<Rc<FuncInstance>, Error>;
) -> Result<Rc<FuncInstance<St>>, Error>;
fn resolve_global(
&self,
@ -56,5 +61,5 @@ pub trait ImportResolver {
&self,
field_name: &str,
table_type: &TableType,
) -> Result<Rc<TableInstance>, Error>;
) -> Result<Rc<TableInstance<St>>, Error>;
}

2
src/interpreter/mod.rs
View File

@ -149,7 +149,7 @@ pub use self::memory::MemoryInstance;
pub use self::table::TableInstance;
pub use self::program::ProgramInstance;
pub use self::value::RuntimeValue;
pub use self::host::{HostModule, HostModuleBuilder, Func1, AnyFunc, AsReturnVal, FromArg};
pub use self::host::{HostModule, HostModuleBuilder, AnyFunc, AsReturnVal, FromArg};
pub use self::imports::{ImportResolver, Imports};
pub use self::module::ModuleInstance;
pub use self::global::GlobalInstance;

122
src/interpreter/module.rs
View File

@ -1,5 +1,6 @@
use std::rc::Rc;
use std::cell::RefCell;
use std::fmt;
use std::collections::HashMap;
use elements::{External, FunctionType, GlobalType, InitExpr, Internal, MemoryType, Module,
Opcode, ResizableLimits, TableType, Type};
@ -10,23 +11,44 @@ use interpreter::func::{FuncInstance, FuncBody};
use validation::validate_module;
use common::{DEFAULT_MEMORY_INDEX, DEFAULT_TABLE_INDEX};
#[derive(Clone, Debug)]
pub enum ExternVal {
Func(Rc<FuncInstance>),
Table(Rc<TableInstance>),
pub enum ExternVal<St> {
Func(Rc<FuncInstance<St>>),
Table(Rc<TableInstance<St>>),
Memory(Rc<MemoryInstance>),
Global(Rc<GlobalInstance>),
}
impl ExternVal {
pub fn as_func(&self) -> Option<Rc<FuncInstance>> {
impl<St> Clone for ExternVal<St> {
fn clone(&self) -> Self {
match *self {
ExternVal::Func(ref func) => ExternVal::Func(Rc::clone(func)),
ExternVal::Table(ref table) => ExternVal::Table(Rc::clone(table)),
ExternVal::Memory(ref memory) => ExternVal::Memory(Rc::clone(memory)),
ExternVal::Global(ref global) => ExternVal::Global(Rc::clone(global)),
}
}
}
impl<St> fmt::Debug for ExternVal<St> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "ExternVal {{ {} }}", match *self {
ExternVal::Func(_) => "Func",
ExternVal::Table(_) => "Table",
ExternVal::Memory(_) => "Memory",
ExternVal::Global(_) => "Global",
})
}
}
impl<St> ExternVal<St> {
pub fn as_func(&self) -> Option<Rc<FuncInstance<St>>> {
match *self {
ExternVal::Func(ref func) => Some(Rc::clone(func)),
_ => None,
}
}
pub fn as_table(&self) -> Option<Rc<TableInstance>> {
pub fn as_table(&self) -> Option<Rc<TableInstance<St>>> {
match *self {
ExternVal::Table(ref table) => Some(Rc::clone(table)),
_ => None,
@ -49,32 +71,38 @@ impl ExternVal {
}
#[derive(Default, Debug)]
pub struct ModuleInstance {
pub struct ModuleInstance<St> {
types: RefCell<Vec<Rc<FunctionType>>>,
tables: RefCell<Vec<Rc<TableInstance>>>,
funcs: RefCell<Vec<Rc<FuncInstance>>>,
tables: RefCell<Vec<Rc<TableInstance<St>>>>,
funcs: RefCell<Vec<Rc<FuncInstance<St>>>>,
memories: RefCell<Vec<Rc<MemoryInstance>>>,
globals: RefCell<Vec<Rc<GlobalInstance>>>,
exports: RefCell<HashMap<String, ExternVal>>,
exports: RefCell<HashMap<String, ExternVal<St>>>,
}
impl ModuleInstance {
fn new() -> ModuleInstance {
ModuleInstance::default()
impl<St> ModuleInstance<St> {
fn new() -> ModuleInstance<St> {
ModuleInstance {
types: RefCell::new(Vec::new()),
tables: RefCell::new(Vec::new()),
funcs: RefCell::new(Vec::new()),
memories: RefCell::new(Vec::new()),
globals: RefCell::new(Vec::new()),
exports: RefCell::new(HashMap::new()),
}
}
pub fn with_exports(exports: HashMap<String, ExternVal>) -> ModuleInstance {
ModuleInstance {
exports: RefCell::new(exports),
..Default::default()
}
pub fn with_exports(exports: HashMap<String, ExternVal<St>>) -> ModuleInstance<St> {
let mut instance = Self::new();
instance.exports = RefCell::new(exports);
instance
}
pub fn memory_by_index(&self, idx: u32) -> Option<Rc<MemoryInstance>> {
self.memories.borrow().get(idx as usize).cloned()
}
pub fn table_by_index(&self, idx: u32) -> Option<Rc<TableInstance>> {
pub fn table_by_index(&self, idx: u32) -> Option<Rc<TableInstance<St>>> {
self.tables.borrow().get(idx as usize).cloned()
}
@ -82,7 +110,7 @@ impl ModuleInstance {
self.globals.borrow().get(idx as usize).cloned()
}
pub fn func_by_index(&self, idx: u32) -> Option<Rc<FuncInstance>> {
pub fn func_by_index(&self, idx: u32) -> Option<Rc<FuncInstance<St>>> {
self.funcs.borrow().get(idx as usize).cloned()
}
@ -90,11 +118,11 @@ impl ModuleInstance {
self.types.borrow().get(idx as usize).cloned()
}
pub fn export_by_name(&self, name: &str) -> Option<ExternVal> {
pub fn export_by_name(&self, name: &str) -> Option<ExternVal<St>> {
self.exports.borrow().get(name).cloned()
}
fn push_func(&self, func: Rc<FuncInstance>) {
fn push_func(&self, func: Rc<FuncInstance<St>>) {
self.funcs.borrow_mut().push(func);
}
@ -106,7 +134,7 @@ impl ModuleInstance {
self.memories.borrow_mut().push(memory)
}
fn push_table(&self, table: Rc<TableInstance>) {
fn push_table(&self, table: Rc<TableInstance<St>>) {
self.tables.borrow_mut().push(table)
}
@ -114,14 +142,14 @@ impl ModuleInstance {
self.globals.borrow_mut().push(global)
}
fn insert_export<N: Into<String>>(&self, name: N, extern_val: ExternVal) {
fn insert_export<N: Into<String>>(&self, name: N, extern_val: ExternVal<St>) {
self.exports.borrow_mut().insert(name.into(), extern_val);
}
fn alloc_module(
module: &Module,
extern_vals: &[ExternVal],
instance: &Rc<ModuleInstance>,
extern_vals: &[ExternVal<St>],
instance: &Rc<ModuleInstance<St>>,
) -> Result<(), Error> {
let mut aux_data = validate_module(module)?;
@ -246,7 +274,7 @@ impl ModuleInstance {
.unwrap_or(&[])
{
let field = export.field();
let extern_val: ExternVal = match *export.internal() {
let extern_val: ExternVal<St> = match *export.internal() {
Internal::Function(idx) => {
let func = instance
.func_by_index(idx)
@ -280,8 +308,8 @@ impl ModuleInstance {
fn instantiate_with_externvals(
module: &Module,
extern_vals: &[ExternVal],
) -> Result<Rc<ModuleInstance>, Error> {
extern_vals: &[ExternVal<St>],
) -> Result<Rc<ModuleInstance<St>>, Error> {
let instance = Rc::new(ModuleInstance::new());
ModuleInstance::alloc_module(module, extern_vals, &instance)?;
@ -325,8 +353,8 @@ impl ModuleInstance {
fn instantiate_with_imports(
module: &Module,
imports: &Imports,
) -> Result<Rc<ModuleInstance>, Error> {
imports: &Imports<St>,
) -> Result<Rc<ModuleInstance<St>>, Error> {
let mut extern_vals = Vec::new();
for import_entry in module.import_section().map(|s| s.entries()).unwrap_or(&[]) {
let module_name = import_entry.module();
@ -365,11 +393,11 @@ impl ModuleInstance {
Self::instantiate_with_externvals(module, &extern_vals)
}
pub fn instantiate<'a>(module: &'a Module) -> InstantiationWizard<'a> {
pub fn instantiate<'a>(module: &'a Module) -> InstantiationWizard<'a, St> {
InstantiationWizard::new(module)
}
pub fn invoke_index<St: 'static>(
pub fn invoke_index(
&self,
func_idx: u32,
args: Vec<RuntimeValue>,
@ -384,7 +412,7 @@ impl ModuleInstance {
FuncInstance::invoke(func_instance, args, state)
}
pub fn invoke_export<St: 'static>(
pub fn invoke_export(
&self,
func_name: &str,
args: Vec<RuntimeValue>,
@ -409,12 +437,12 @@ impl ModuleInstance {
}
}
pub struct InstantiationWizard<'a> {
pub struct InstantiationWizard<'a, St: 'a> {
module: &'a Module,
imports: Option<Imports<'a>>,
imports: Option<Imports<'a, St>>,
}
impl<'a> InstantiationWizard<'a> {
impl<'a, St: 'a> InstantiationWizard<'a, St> {
fn new(module: &'a Module) -> Self {
InstantiationWizard {
module,
@ -422,7 +450,7 @@ impl<'a> InstantiationWizard<'a> {
}
}
pub fn with_imports(mut self, imports: Imports<'a>) -> Self {
pub fn with_imports(mut self, imports: Imports<'a, St>) -> Self {
self.imports = Some(imports);
self
}
@ -430,7 +458,7 @@ impl<'a> InstantiationWizard<'a> {
pub fn with_import<N: Into<String>>(
mut self,
name: N,
import_resolver: &'a ImportResolver,
import_resolver: &'a ImportResolver<St>,
) -> Self {
self.imports
.get_or_insert_with(|| Imports::default())
@ -438,7 +466,7 @@ impl<'a> InstantiationWizard<'a> {
self
}
pub fn run_start<St: 'static>(mut self, state: &mut St) -> Result<Rc<ModuleInstance>, Error> {
pub fn run_start(mut self, state: &mut St) -> Result<Rc<ModuleInstance<St>>, Error> {
let imports = self.imports.get_or_insert_with(|| Imports::default());
let instance = ModuleInstance::instantiate_with_imports(self.module, imports)?;
@ -451,7 +479,7 @@ impl<'a> InstantiationWizard<'a> {
Ok(instance)
}
pub fn assert_no_start(mut self) -> Result<Rc<ModuleInstance>, Error> {
pub fn assert_no_start(mut self) -> Result<Rc<ModuleInstance<St>>, Error> {
assert!(self.module.start_section().is_none());
let imports = self.imports.get_or_insert_with(|| Imports::default());
let instance = ModuleInstance::instantiate_with_imports(self.module, imports)?;
@ -459,12 +487,12 @@ impl<'a> InstantiationWizard<'a> {
}
}
impl ImportResolver for ModuleInstance {
impl<St> ImportResolver<St> for ModuleInstance<St> {
fn resolve_func(
&self,
field_name: &str,
_func_type: &FunctionType,
) -> Result<Rc<FuncInstance>, Error> {
) -> Result<Rc<FuncInstance<St>>, Error> {
Ok(self.export_by_name(field_name)
.ok_or_else(|| {
Error::Validation(format!("Export {} not found", field_name))
@ -509,7 +537,7 @@ impl ImportResolver for ModuleInstance {
&self,
field_name: &str,
_table_type: &TableType,
) -> Result<Rc<TableInstance>, Error> {
) -> Result<Rc<TableInstance<St>>, Error> {
Ok(self.export_by_name(field_name)
.ok_or_else(|| {
Error::Validation(format!("Export {} not found", field_name))
@ -525,7 +553,7 @@ fn alloc_func_type(func_type: FunctionType) -> Rc<FunctionType> {
Rc::new(func_type)
}
fn alloc_table(table_type: &TableType) -> Result<Rc<TableInstance>, Error> {
fn alloc_table<St>(table_type: &TableType) -> Result<Rc<TableInstance<St>>, Error> {
let table = TableInstance::new(table_type)?;
Ok(Rc::new(table))
}
@ -540,7 +568,7 @@ fn alloc_global(global_type: GlobalType, val: RuntimeValue) -> Rc<GlobalInstance
Rc::new(global)
}
fn eval_init_expr(init_expr: &InitExpr, module: &ModuleInstance) -> RuntimeValue {
fn eval_init_expr<T>(init_expr: &InitExpr, module: &ModuleInstance<T>) -> RuntimeValue {
let code = init_expr.code();
debug_assert!(
code.len() == 2,

39
src/interpreter/program.rs
View File

@ -9,14 +9,14 @@ use interpreter::value::RuntimeValue;
use interpreter::imports::{Imports, ImportResolver};
/// Program instance. Program is a set of instantiated modules.
pub struct ProgramInstance {
modules: HashMap<String, Rc<ModuleInstance>>,
resolvers: HashMap<String, Box<ImportResolver>>,
pub struct ProgramInstance<St=()> {
modules: HashMap<String, Rc<ModuleInstance<St>>>,
resolvers: HashMap<String, Box<ImportResolver<St>>>,
}
impl ProgramInstance {
impl<St> ProgramInstance<St> {
/// Create new program instance.
pub fn new() -> Self {
pub fn new() -> ProgramInstance<St> {
ProgramInstance {
modules: HashMap::new(),
resolvers: HashMap::new(),
@ -24,12 +24,12 @@ impl ProgramInstance {
}
/// Instantiate module with validation.
pub fn add_module<'a, St: 'static>(
pub fn add_module(
&mut self,
name: &str,
module: Module,
state: &mut St,
) -> Result<Rc<ModuleInstance>, Error> {
) -> Result<Rc<ModuleInstance<St>>, Error> {
let module_instance = {
let mut imports = Imports::new();
for (module_name, module_instance) in self.modules.iter() {
@ -50,7 +50,7 @@ impl ProgramInstance {
pub fn add_import_resolver(
&mut self,
name: &str,
import_resolver: Box<ImportResolver>,
import_resolver: Box<ImportResolver<St>>,
) {
self.resolvers.insert(name.to_owned(), import_resolver);
}
@ -58,16 +58,16 @@ impl ProgramInstance {
pub fn add_host_module(
&mut self,
name: &str,
host_module: HostModule,
) {
self.resolvers.insert(name.to_owned(), Box::new(host_module) as Box<ImportResolver>);
host_module: HostModule<St>,
) where St: 'static {
self.resolvers.insert(name.to_owned(), Box::new(host_module) as Box<ImportResolver<St>>);
}
pub fn insert_loaded_module(&mut self, name: &str, module: Rc<ModuleInstance>) {
pub fn insert_loaded_module(&mut self, name: &str, module: Rc<ModuleInstance<St>>) {
self.modules.insert(name.to_owned(), module);
}
pub fn invoke_export<St: 'static>(
pub fn invoke_export(
&mut self,
module_name: &str,
func_name: &str,
@ -80,7 +80,7 @@ impl ProgramInstance {
module_instance.invoke_export(func_name, args, state)
}
pub fn invoke_index<St: 'static>(
pub fn invoke_index(
&mut self,
module_name: &str,
func_idx: u32,
@ -93,16 +93,19 @@ impl ProgramInstance {
module_instance.invoke_index(func_idx, args, state)
}
pub fn invoke_func<St: 'static>(
pub fn invoke_func(
&mut self,
func_instance: Rc<FuncInstance>,
func_instance: Rc<FuncInstance<St>>,
args: Vec<RuntimeValue>,
state: &mut St,
) -> Result<Option<RuntimeValue>, Error> {
FuncInstance::invoke(Rc::clone(&func_instance), args, state)
}
pub fn module(&self, name: &str) -> Option<Rc<ModuleInstance>> {
self.modules.get(name).cloned()
pub fn module(&self, name: &str) -> Option<&ImportResolver<St>> {
self.modules
.get(name)
.map(|x| &**x as &ImportResolver<St>)
.or_else(|| self.resolvers.get(name).map(|x| &**x))
}
}

172
src/interpreter/runner.rs
View File

@ -17,17 +17,17 @@ use common::{DEFAULT_MEMORY_INDEX, DEFAULT_TABLE_INDEX, BlockFrame, BlockFrameTy
use common::stack::StackWithLimit;
/// Function interpreter.
pub struct Interpreter<'a, St: 'static> {
pub struct Interpreter<'a, St: 'a> {
state: &'a mut St,
}
/// Function execution context.
pub struct FunctionContext {
pub struct FunctionContext<St> {
/// Is context initialized.
pub is_initialized: bool,
/// Internal function reference.
pub function: Rc<FuncInstance>,
pub module: Rc<ModuleInstance>,
pub function: Rc<FuncInstance<St>>,
pub module: Rc<ModuleInstance<St>>,
/// Function return type.
pub return_type: BlockType,
/// Local variables.
@ -42,13 +42,13 @@ pub struct FunctionContext {
/// Interpreter action to execute after executing instruction.
#[derive(Debug)]
pub enum InstructionOutcome {
pub enum InstructionOutcome<St> {
/// Continue with next instruction.
RunNextInstruction,
/// Branch to given frame.
Branch(usize),
/// Execute function call.
ExecuteCall(Rc<FuncInstance>),
ExecuteCall(Rc<FuncInstance<St>>),
/// End current frame.
End,
/// Return from current function block.
@ -56,21 +56,21 @@ pub enum InstructionOutcome {
}
/// Function run result.
enum RunResult {
enum RunResult<St> {
/// Function has returned (optional) value.
Return(Option<RuntimeValue>),
/// Function is calling other function.
NestedCall(Rc<FuncInstance>),
NestedCall(Rc<FuncInstance<St>>),
}
impl<'a, St: 'static> Interpreter<'a, St> {
impl<'a, St: 'a> Interpreter<'a, St> {
pub fn new(state: &'a mut St) -> Interpreter<'a, St> {
Interpreter {
state
}
}
pub fn run_function(&mut self, function_context: FunctionContext) -> Result<Option<RuntimeValue>, Error> {
pub fn run_function(&mut self, function_context: FunctionContext<St>) -> Result<Option<RuntimeValue>, Error> {
let mut function_stack = VecDeque::new();
function_stack.push_back(function_context);
@ -117,7 +117,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
}
}
fn do_run_function(&mut self, function_context: &mut FunctionContext, function_body: &[Opcode], function_labels: &HashMap<usize, usize>) -> Result<RunResult, Error> {
fn do_run_function(&mut self, function_context: &mut FunctionContext<St>, function_body: &[Opcode], function_labels: &HashMap<usize, usize>) -> Result<RunResult<St>, Error> {
loop {
let instruction = &function_body[function_context.position];
@ -155,7 +155,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
}))
}
fn run_instruction(&mut self, context: &mut FunctionContext, labels: &HashMap<usize, usize>, opcode: &Opcode) -> Result<InstructionOutcome, Error> {
fn run_instruction(&mut self, context: &mut FunctionContext<St>, labels: &HashMap<usize, usize>, opcode: &Opcode) -> Result<InstructionOutcome<St>, Error> {
match opcode {
&Opcode::Unreachable => self.run_unreachable(context),
&Opcode::Nop => self.run_nop(context),
@ -349,25 +349,25 @@ impl<'a, St: 'static> Interpreter<'a, St> {
}
}
fn run_unreachable(&mut self, _context: &mut FunctionContext) -> Result<InstructionOutcome, Error> {
fn run_unreachable(&mut self, _context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error> {
Err(Error::Trap("programmatic".into()))
}
fn run_nop(&mut self, _context: &mut FunctionContext) -> Result<InstructionOutcome, Error> {
fn run_nop(&mut self, _context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error> {
Ok(InstructionOutcome::RunNextInstruction)
}
fn run_block(&mut self, context: &mut FunctionContext, labels: &HashMap<usize, usize>, block_type: BlockType) -> Result<InstructionOutcome, Error> {
fn run_block(&mut self, context: &mut FunctionContext<St>, labels: &HashMap<usize, usize>, block_type: BlockType) -> Result<InstructionOutcome<St>, Error> {
context.push_frame(labels, BlockFrameType::Block, block_type)?;
Ok(InstructionOutcome::RunNextInstruction)
}
fn run_loop(&mut self, context: &mut FunctionContext, labels: &HashMap<usize, usize>, block_type: BlockType) -> Result<InstructionOutcome, Error> {
fn run_loop(&mut self, context: &mut FunctionContext<St>, labels: &HashMap<usize, usize>, block_type: BlockType) -> Result<InstructionOutcome<St>, Error> {
context.push_frame(labels, BlockFrameType::Loop, block_type)?;
Ok(InstructionOutcome::RunNextInstruction)
}
fn run_if(&mut self, context: &mut FunctionContext, labels: &HashMap<usize, usize>, block_type: BlockType) -> Result<InstructionOutcome, Error> {
fn run_if(&mut self, context: &mut FunctionContext<St>, labels: &HashMap<usize, usize>, block_type: BlockType) -> Result<InstructionOutcome<St>, Error> {
let branch = context.value_stack_mut().pop_as()?;
let block_frame_type = if branch { BlockFrameType::IfTrue } else {
let else_pos = labels[&context.position];
@ -382,23 +382,23 @@ impl<'a, St: 'static> Interpreter<'a, St> {
context.push_frame(labels, block_frame_type, block_type).map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_else(&mut self, context: &mut FunctionContext, labels: &HashMap<usize, usize>) -> Result<InstructionOutcome, Error> {
fn run_else(&mut self, context: &mut FunctionContext<St>, labels: &HashMap<usize, usize>) -> Result<InstructionOutcome<St>, Error> {
let end_pos = labels[&context.position];
context.pop_frame(false)?;
context.position = end_pos;
Ok(InstructionOutcome::RunNextInstruction)
}
fn run_end(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error> {
fn run_end(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error> {
context.pop_frame(false)?;
Ok(InstructionOutcome::End)
}
fn run_br(&mut self, _context: &mut FunctionContext, label_idx: u32) -> Result<InstructionOutcome, Error> {
fn run_br(&mut self, _context: &mut FunctionContext<St>, label_idx: u32) -> Result<InstructionOutcome<St>, Error> {
Ok(InstructionOutcome::Branch(label_idx as usize))
}
fn run_br_if(&mut self, context: &mut FunctionContext, label_idx: u32) -> Result<InstructionOutcome, Error> {
fn run_br_if(&mut self, context: &mut FunctionContext<St>, label_idx: u32) -> Result<InstructionOutcome<St>, Error> {
if context.value_stack_mut().pop_as()? {
Ok(InstructionOutcome::Branch(label_idx as usize))
} else {
@ -406,20 +406,20 @@ impl<'a, St: 'static> Interpreter<'a, St> {
}
}
fn run_br_table(&mut self, context: &mut FunctionContext, table: &Vec<u32>, default: u32) -> Result<InstructionOutcome, Error> {
fn run_br_table(&mut self, context: &mut FunctionContext<St>, table: &Vec<u32>, default: u32) -> Result<InstructionOutcome<St>, Error> {
let index: u32 = context.value_stack_mut().pop_as()?;
Ok(InstructionOutcome::Branch(table.get(index as usize).cloned().unwrap_or(default) as usize))
}
fn run_return(&mut self, _context: &mut FunctionContext) -> Result<InstructionOutcome, Error> {
fn run_return(&mut self, _context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error> {
Ok(InstructionOutcome::Return)
}
fn run_call(
&mut self,
context: &mut FunctionContext,
context: &mut FunctionContext<St>,
func_idx: u32,
) -> Result<InstructionOutcome, Error> {
) -> Result<InstructionOutcome<St>, Error> {
let func = context
.module()
.func_by_index(func_idx)
@ -429,9 +429,9 @@ impl<'a, St: 'static> Interpreter<'a, St> {
fn run_call_indirect(
&mut self,
context: &mut FunctionContext,
context: &mut FunctionContext<St>,
type_idx: u32,
) -> Result<InstructionOutcome, Error> {
) -> Result<InstructionOutcome<St>, Error> {
let table_func_idx: u32 = context.value_stack_mut().pop_as()?;
let table = context
.module()
@ -458,7 +458,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
Ok(InstructionOutcome::ExecuteCall(func_ref))
}
fn run_drop(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error> {
fn run_drop(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error> {
context
.value_stack_mut()
.pop()
@ -466,7 +466,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_select(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error> {
fn run_select(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error> {
context
.value_stack_mut()
.pop_triple()
@ -482,19 +482,19 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_get_local(&mut self, context: &mut FunctionContext, index: u32) -> Result<InstructionOutcome, Error> {
fn run_get_local(&mut self, context: &mut FunctionContext<St>, index: u32) -> Result<InstructionOutcome<St>, Error> {
context.get_local(index as usize)
.map(|value| context.value_stack_mut().push(value))
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_set_local(&mut self, context: &mut FunctionContext, index: u32) -> Result<InstructionOutcome, Error> {
fn run_set_local(&mut self, context: &mut FunctionContext<St>, index: u32) -> Result<InstructionOutcome<St>, Error> {
let arg = context.value_stack_mut().pop()?;
context.set_local(index as usize, arg)
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_tee_local(&mut self, context: &mut FunctionContext, index: u32) -> Result<InstructionOutcome, Error> {
fn run_tee_local(&mut self, context: &mut FunctionContext<St>, index: u32) -> Result<InstructionOutcome<St>, Error> {
let arg = context.value_stack().top()?.clone();
context.set_local(index as usize, arg)
.map(|_| InstructionOutcome::RunNextInstruction)
@ -502,9 +502,9 @@ impl<'a, St: 'static> Interpreter<'a, St> {
fn run_get_global(
&mut self,
context: &mut FunctionContext,
context: &mut FunctionContext<St>,
index: u32,
) -> Result<InstructionOutcome, Error> {
) -> Result<InstructionOutcome<St>, Error> {
let global = context
.module()
.global_by_index(index)
@ -516,9 +516,9 @@ impl<'a, St: 'static> Interpreter<'a, St> {
fn run_set_global(
&mut self,
context: &mut FunctionContext,
context: &mut FunctionContext<St>,
index: u32,
) -> Result<InstructionOutcome, Error> {
) -> Result<InstructionOutcome<St>, Error> {
let val = context.value_stack_mut().pop()?;
let global = context
@ -529,7 +529,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
Ok(InstructionOutcome::RunNextInstruction)
}
fn run_load<T>(&mut self, context: &mut FunctionContext, _align: u32, offset: u32) -> Result<InstructionOutcome, Error>
fn run_load<T>(&mut self, context: &mut FunctionContext<St>, _align: u32, offset: u32) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T>, T: LittleEndianConvert {
let address = effective_address(offset, context.value_stack_mut().pop_as()?)?;
let m = context.module()
@ -541,7 +541,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
Ok(InstructionOutcome::RunNextInstruction)
}
fn run_load_extend<T, U>(&mut self, context: &mut FunctionContext, _align: u32, offset: u32) -> Result<InstructionOutcome, Error>
fn run_load_extend<T, U>(&mut self, context: &mut FunctionContext<St>, _align: u32, offset: u32) -> Result<InstructionOutcome<St>, Error>
where T: ExtendInto<U>, RuntimeValue: From<U>, T: LittleEndianConvert {
let address = effective_address(offset, context.value_stack_mut().pop_as()?)?;
let m = context.module()
@ -557,7 +557,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_store<T>(&mut self, context: &mut FunctionContext, _align: u32, offset: u32) -> Result<InstructionOutcome, Error>
fn run_store<T>(&mut self, context: &mut FunctionContext<St>, _align: u32, offset: u32) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: TryInto<T, Error>, T: LittleEndianConvert {
let stack_value = context
.value_stack_mut()
@ -574,10 +574,10 @@ impl<'a, St: 'static> Interpreter<'a, St> {
fn run_store_wrap<T, U>(
&mut self,
context: &mut FunctionContext,
context: &mut FunctionContext<St>,
_align: u32,
offset: u32,
) -> Result<InstructionOutcome, Error>
) -> Result<InstructionOutcome<St>, Error>
where
RuntimeValue: TryInto<T, Error>,
T: WrapInto<U>,
@ -597,7 +597,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
Ok(InstructionOutcome::RunNextInstruction)
}
fn run_current_memory(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error> {
fn run_current_memory(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error> {
let m = context.module()
.memory_by_index(DEFAULT_MEMORY_INDEX)
.expect("Due to validation memory should exists");
@ -608,7 +608,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
Ok(InstructionOutcome::RunNextInstruction)
}
fn run_grow_memory(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error> {
fn run_grow_memory(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error> {
let pages: u32 = context.value_stack_mut().pop_as()?;
let m = context.module()
.memory_by_index(DEFAULT_MEMORY_INDEX)
@ -620,7 +620,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
Ok(InstructionOutcome::RunNextInstruction)
}
fn run_const(&mut self, context: &mut FunctionContext, val: RuntimeValue) -> Result<InstructionOutcome, Error> {
fn run_const(&mut self, context: &mut FunctionContext<St>, val: RuntimeValue) -> Result<InstructionOutcome<St>, Error> {
context
.value_stack_mut()
.push(val)
@ -628,7 +628,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_eqz<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_eqz<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: TryInto<T, Error>, T: PartialEq<T> + Default {
context
.value_stack_mut()
@ -638,7 +638,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_eq<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_eq<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: TryInto<T, Error>, T: PartialEq<T> {
context
.value_stack_mut()
@ -648,7 +648,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_ne<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_ne<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: TryInto<T, Error>, T: PartialEq<T> {
context
.value_stack_mut()
@ -658,7 +658,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_lt<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_lt<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: TryInto<T, Error>, T: PartialOrd<T> + Display {
context
.value_stack_mut()
@ -668,7 +668,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_gt<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_gt<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: TryInto<T, Error>, T: PartialOrd<T> {
context
.value_stack_mut()
@ -678,7 +678,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_lte<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_lte<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: TryInto<T, Error>, T: PartialOrd<T> {
context
.value_stack_mut()
@ -688,7 +688,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_gte<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_gte<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: TryInto<T, Error>, T: PartialOrd<T> {
context
.value_stack_mut()
@ -698,7 +698,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_clz<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_clz<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: Integer<T> {
context
.value_stack_mut()
@ -708,7 +708,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_ctz<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_ctz<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: Integer<T> {
context
.value_stack_mut()
@ -718,7 +718,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_popcnt<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_popcnt<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: Integer<T> {
context
.value_stack_mut()
@ -728,7 +728,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_add<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_add<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: ArithmeticOps<T> {
context
.value_stack_mut()
@ -738,7 +738,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_sub<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_sub<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: ArithmeticOps<T> {
context
.value_stack_mut()
@ -748,7 +748,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_mul<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_mul<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: ArithmeticOps<T> {
context
.value_stack_mut()
@ -758,7 +758,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_div<T, U>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_div<T, U>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: TransmuteInto<U> + Display, U: ArithmeticOps<U> + TransmuteInto<T> {
context
.value_stack_mut()
@ -770,7 +770,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_rem<T, U>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_rem<T, U>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: TransmuteInto<U>, U: Integer<U> + TransmuteInto<T> {
context
.value_stack_mut()
@ -782,7 +782,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_and<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_and<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<<T as ops::BitAnd>::Output> + TryInto<T, Error>, T: ops::BitAnd<T> {
context
.value_stack_mut()
@ -792,7 +792,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_or<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_or<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<<T as ops::BitOr>::Output> + TryInto<T, Error>, T: ops::BitOr<T> {
context
.value_stack_mut()
@ -802,7 +802,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_xor<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_xor<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<<T as ops::BitXor>::Output> + TryInto<T, Error>, T: ops::BitXor<T> {
context
.value_stack_mut()
@ -812,7 +812,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_shl<T>(&mut self, context: &mut FunctionContext, mask: T) -> Result<InstructionOutcome, Error>
fn run_shl<T>(&mut self, context: &mut FunctionContext<St>, mask: T) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<<T as ops::Shl<T>>::Output> + TryInto<T, Error>, T: ops::Shl<T> + ops::BitAnd<T, Output=T> {
context
.value_stack_mut()
@ -822,7 +822,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_shr<T, U>(&mut self, context: &mut FunctionContext, mask: U) -> Result<InstructionOutcome, Error>
fn run_shr<T, U>(&mut self, context: &mut FunctionContext<St>, mask: U) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: TransmuteInto<U>, U: ops::Shr<U> + ops::BitAnd<U, Output=U>, <U as ops::Shr<U>>::Output: TransmuteInto<T> {
context
.value_stack_mut()
@ -834,7 +834,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_rotl<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_rotl<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: Integer<T> {
context
.value_stack_mut()
@ -844,7 +844,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_rotr<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_rotr<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: Integer<T> {
context
.value_stack_mut()
@ -854,7 +854,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_abs<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_abs<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: Float<T> {
context
.value_stack_mut()
@ -864,7 +864,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_neg<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_neg<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<<T as ops::Neg>::Output> + TryInto<T, Error>, T: ops::Neg {
context
.value_stack_mut()
@ -874,7 +874,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_ceil<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_ceil<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: Float<T> {
context
.value_stack_mut()
@ -884,7 +884,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_floor<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_floor<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: Float<T> {
context
.value_stack_mut()
@ -894,7 +894,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_trunc<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_trunc<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: Float<T> {
context
.value_stack_mut()
@ -904,7 +904,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_nearest<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_nearest<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: Float<T> {
context
.value_stack_mut()
@ -914,7 +914,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_sqrt<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_sqrt<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: Float<T> {
context
.value_stack_mut()
@ -924,7 +924,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_min<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_min<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: Float<T> {
context
.value_stack_mut()
@ -934,7 +934,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_max<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_max<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: Float<T> {
context
.value_stack_mut()
@ -944,7 +944,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_copysign<T>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_copysign<T>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<T> + TryInto<T, Error>, T: Float<T> {
context
.value_stack_mut()
@ -954,7 +954,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_wrap<T, U>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_wrap<T, U>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<U> + TryInto<T, Error>, T: WrapInto<U> {
context
.value_stack_mut()
@ -964,7 +964,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_trunc_to_int<T, U, V>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_trunc_to_int<T, U, V>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<V> + TryInto<T, Error>, T: TryTruncateInto<U, Error>, U: TransmuteInto<V>, {
context
.value_stack_mut()
@ -975,7 +975,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_extend<T, U, V>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_extend<T, U, V>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<V> + TryInto<T, Error>, T: ExtendInto<U>, U: TransmuteInto<V> {
context
.value_stack_mut()
@ -987,7 +987,7 @@ impl<'a, St: 'static> Interpreter<'a, St> {
.map(|_| InstructionOutcome::RunNextInstruction)
}
fn run_reinterpret<T, U>(&mut self, context: &mut FunctionContext) -> Result<InstructionOutcome, Error>
fn run_reinterpret<T, U>(&mut self, context: &mut FunctionContext<St>) -> Result<InstructionOutcome<St>, Error>
where RuntimeValue: From<U>, RuntimeValue: TryInto<T, Error>, T: TransmuteInto<U> {
context
.value_stack_mut()
@ -998,8 +998,8 @@ impl<'a, St: 'static> Interpreter<'a, St> {
}
}
impl FunctionContext {
pub fn new<'store>(function: Rc<FuncInstance>, value_stack_limit: usize, frame_stack_limit: usize, function_type: &FunctionType, args: Vec<RuntimeValue>) -> Self {
impl<St> FunctionContext<St> {
pub fn new<'store>(function: Rc<FuncInstance<St>>, value_stack_limit: usize, frame_stack_limit: usize, function_type: &FunctionType, args: Vec<RuntimeValue>) -> Self {
let module = match *function {
FuncInstance::Internal { ref module, .. } => Rc::clone(module),
FuncInstance::Host { .. } => panic!("Host functions can't be called as internally defined functions; Thus FunctionContext can be created only with internally defined functions; qed"),
@ -1016,7 +1016,7 @@ impl FunctionContext {
}
}
pub fn nested(&mut self, function: Rc<FuncInstance>) -> Result<Self, Error> {
pub fn nested(&mut self, function: Rc<FuncInstance<St>>) -> Result<Self, Error> {
let (function_locals, module, function_return_type) = {
let module = match *function {
FuncInstance::Internal { ref module, .. } => Rc::clone(module),
@ -1055,11 +1055,11 @@ impl FunctionContext {
self.locals.extend(locals);
}
pub fn module(&self) -> Rc<ModuleInstance> {
pub fn module(&self) -> Rc<ModuleInstance<St>> {
Rc::clone(&self.module)
}
pub fn set_local(&mut self, index: usize, value: RuntimeValue) -> Result<InstructionOutcome, Error> {
pub fn set_local(&mut self, index: usize, value: RuntimeValue) -> Result<InstructionOutcome<St>, Error> {
let l = self.locals.get_mut(index)
.ok_or(Error::Local(format!("expected to have local with index {}", index)))?;
@ -1137,7 +1137,7 @@ impl FunctionContext {
}
}
impl fmt::Debug for FunctionContext {
impl<St> fmt::Debug for FunctionContext<St> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "FunctionContext")
}

12
src/interpreter/table.rs
View File

@ -8,15 +8,15 @@ use interpreter::module::check_limits;
use interpreter::func::FuncInstance;
/// Table instance.
pub struct TableInstance {
pub struct TableInstance<St> {
/// Table limits.
limits: ResizableLimits,
/// Table memory buffer.
buffer: RwLock<Vec<Option<Rc<FuncInstance>>>>,
buffer: RwLock<Vec<Option<Rc<FuncInstance<St>>>>>,
}
impl fmt::Debug for TableInstance {
impl<St> fmt::Debug for TableInstance<St> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("TableInstance")
.field("limits", &self.limits)
@ -25,7 +25,7 @@ impl fmt::Debug for TableInstance {
}
}
impl TableInstance {
impl<St> TableInstance<St> {
/// New instance of the table
pub fn new(table_type: &TableType) -> Result<Self, Error> {
check_limits(table_type.limits())?;
@ -43,7 +43,7 @@ impl TableInstance {
}
/// Get the specific value in the table
pub fn get(&self, offset: u32) -> Result<Rc<FuncInstance>, Error> {
pub fn get(&self, offset: u32) -> Result<Rc<FuncInstance<St>>, Error> {
let buffer = self.buffer.read();
let buffer_len = buffer.len();
let table_elem = buffer.get(offset as usize).cloned().ok_or(Error::Table(format!(
@ -58,7 +58,7 @@ impl TableInstance {
}
/// Set the table element to the specified function.
pub fn set(&self, offset: u32, value: Rc<FuncInstance>) -> Result<(), Error> {
pub fn set(&self, offset: u32, value: Rc<FuncInstance<St>>) -> Result<(), Error> {
let mut buffer = self.buffer.write();
let buffer_len = buffer.len();
let table_elem = buffer.get_mut(offset as usize).ok_or(Error::Table(format!(

4
src/interpreter/tests/basics.rs
View File

@ -121,7 +121,7 @@ struct TestState {
pub values: Vec<i32>,
}
fn build_env_module() -> HostModule {
fn build_env_module() -> HostModule<TestState> {
let mut builder = HostModuleBuilder::<TestState>::new();
builder.with_func2("add", |state: &mut TestState, arg: i32, unused: i32| {
let memory_value = state.memory.get(0, 1).unwrap()[0];
@ -219,7 +219,7 @@ fn native_env_function() {
fn native_env_global() {
struct State;
let module_constructor = |host_module: HostModule| {
let module_constructor = |host_module: HostModule<State>| {
let mut program = ProgramInstance::new();
program.add_host_module("env", host_module);

35
src/interpreter/tests/mod.rs
View File

@ -3,27 +3,22 @@ mod wabt;
mod wasm;
mod utils {
use elements::{Internal, ExportEntry, InitExpr, Opcode, ValueType, GlobalType, GlobalEntry};
use interpreter::ProgramInstance;
use builder::module;
use elements::{ExportEntry, InitExpr, Opcode, ValueType, GlobalType, GlobalEntry, MemoryType, TableType};
use interpreter::{ProgramInstance, HostModuleBuilder, MemoryInstance, TableInstance, GlobalInstance, RuntimeValue};
use std::rc::Rc;
pub fn program_with_default_env() -> ProgramInstance {
let mut program = ProgramInstance::new();
let env_module = module()
.memory()
.with_min(256) // 256 pages. 256 * 64K = 16MB
.build()
.with_export(ExportEntry::new("memory".into(), Internal::Memory(0)))
.table()
.with_min(64)
.build()
.with_export(ExportEntry::new("table".into(), Internal::Table(0)))
.with_global(GlobalEntry::new(GlobalType::new(ValueType::I32, false), InitExpr::new(vec![Opcode::I32Const(0), Opcode::End])))
.with_export(ExportEntry::new("tableBase".into(), Internal::Global(0)))
.with_global(GlobalEntry::new(GlobalType::new(ValueType::I32, false), InitExpr::new(vec![Opcode::I32Const(0), Opcode::End])))
.with_export(ExportEntry::new("memoryBase".into(), Internal::Global(1)))
.build();
program.add_module("env", env_module, &mut ()).unwrap();
pub fn program_with_default_env<St: 'static>() -> ProgramInstance<St> {
let mut program = ProgramInstance::<St>::new();
let mut builder = HostModuleBuilder::<St>::new();
// TODO: Alloc
builder.insert_memory("memory", Rc::new(MemoryInstance::new(&MemoryType::new(256, None)).unwrap()));
builder.insert_table("table", Rc::new(TableInstance::new(&TableType::new(64, None)).unwrap()));
builder.insert_global("tableBase", Rc::new(GlobalInstance::new(RuntimeValue::I32(0), false)));
builder.insert_global("memoryBase", Rc::new(GlobalInstance::new(RuntimeValue::I32(0), false)));
let env_host_module = builder.build();
program.add_host_module("env", env_host_module);
program
}
}

10
src/interpreter/tests/wasm.rs
View File

@ -1,6 +1,6 @@
use elements::deserialize_file;
use elements::Module;
use interpreter::value::RuntimeValue;
use elements::{Module, MemoryType};
use interpreter::RuntimeValue;
use super::utils::program_with_default_env;
#[test]
@ -46,8 +46,10 @@ fn interpreter_accumulate_u8() {
.add_module("main", module, &mut ())
.expect("Failed to initialize module");
let env_module = program.module("env").unwrap();
let env_memory = env_module.memory_by_index(0).unwrap();
let env_memory = {
let env_module = program.module("env").unwrap();
env_module.resolve_memory("memory", &MemoryType::new(1, None)).unwrap()
};
// Place the octet-sequence at index 0 in linear memory
let offset: u32 = 0;