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

function_type returns type reference

Browse Source
This commit is contained in:
Svyatoslav Nikolsky
2017-06-26 11:54:17 +03:00
parent 0398726cd7
commit 4b3f67e3cc
8 changed files with 155 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/interpreter/env.rs
View File

@ -1,13 +1,12 @@
use std::sync::{Arc, Weak};
use std::collections::HashMap;
use builder::module;
use elements::{Module, FunctionType, ExportEntry, Internal, GlobalEntry, GlobalType,
use elements::{Module, ExportEntry, Internal, GlobalEntry, GlobalType,
ValueType, InitExpr, Opcode, Opcodes};
use interpreter::Error;
use interpreter::env_native::NATIVE_INDEX_FUNC_MIN;
use interpreter::module::{ModuleInstanceInterface, ModuleInstance, ExecutionParams,
ItemIndex, CallerContext, ExportEntryType, InternalFunctionReference, InternalFunction};
ItemIndex, CallerContext, ExportEntryType, InternalFunctionReference, InternalFunction, FunctionSignature};
use interpreter::memory::{MemoryInstance, LINEAR_MEMORY_PAGE_SIZE};
use interpreter::table::TableInstance;
use interpreter::value::RuntimeValue;
@ -116,11 +115,11 @@ impl ModuleInstanceInterface for EnvModuleInstance {
self.instance.global(index, variable_type)
}
fn function_type(&self, function_index: ItemIndex) -> Result<FunctionType, Error> {
fn function_type(&self, function_index: ItemIndex) -> Result<FunctionSignature, Error> {
self.instance.function_type(function_index)
}
fn function_type_by_index(&self, type_index: u32) -> Result<FunctionType, Error> {
fn function_type_by_index(&self, type_index: u32) -> Result<FunctionSignature, Error> {
self.instance.function_type_by_index(type_index)
}

74
src/interpreter/env_native.rs
View File

@ -2,10 +2,10 @@ use std::sync::Arc;
use std::collections::HashMap;
use std::borrow::Cow;
use parking_lot::RwLock;
use elements::{FunctionType, Internal, ValueType};
use elements::{Internal, ValueType};
use interpreter::Error;
use interpreter::module::{ModuleInstanceInterface, ExecutionParams, ItemIndex,
CallerContext, ExportEntryType, InternalFunctionReference, InternalFunction};
CallerContext, ExportEntryType, InternalFunctionReference, InternalFunction, FunctionSignature};
use interpreter::memory::MemoryInstance;
use interpreter::table::TableInstance;
use interpreter::value::RuntimeValue;
@ -21,66 +21,54 @@ pub trait UserFunctionExecutor {
}
/// User function descriptor
#[derive(Clone)]
#[derive(Debug, Clone)]
pub enum UserFunctionDescriptor {
/// Static function definition
Static(&'static str, &'static [ValueType]),
Static(&'static str, &'static [ValueType], Option<ValueType>),
/// Dynamic heap function definition
Heap(String, Vec<ValueType>),
Heap(String, Vec<ValueType>, Option<ValueType>),
}
/// User function type.
#[derive(Clone)]
pub struct UserFunction {
/// Descriptor with variable-length definitions
pub desc: UserFunctionDescriptor,
/// Return type of the signature
pub result: Option<ValueType>,
}
impl UserFunction {
impl UserFunctionDescriptor {
/// New function with statically known params
pub fn statik(name: &'static str, params: &'static [ValueType], result: Option<ValueType>) -> Self {
UserFunction {
desc: UserFunctionDescriptor::Static(name, params),
result: result,
}
UserFunctionDescriptor::Static(name, params, result)
}
/// New function with statically unknown params
pub fn heap(name: String, params: Vec<ValueType>, result: Option<ValueType>) -> Self {
UserFunction {
desc: UserFunctionDescriptor::Heap(name, params),
result: result,
}
UserFunctionDescriptor::Heap(name, params, result)
}
/// Name of the function
pub fn name(&self) -> &str {
match self.desc {
UserFunctionDescriptor::Static(name, _) => name,
UserFunctionDescriptor::Heap(ref name, _) => name,
match self {
&UserFunctionDescriptor::Static(name, _, _) => name,
&UserFunctionDescriptor::Heap(ref name, _, _) => name,
}
}
/// Arguments of the function
pub fn params(&self) -> &[ValueType] {
match self.desc {
UserFunctionDescriptor::Static(_, params) => params,
UserFunctionDescriptor::Heap(_, ref params) => params,
match self {
&UserFunctionDescriptor::Static(_, params, _) => params,
&UserFunctionDescriptor::Heap(_, ref params, _) => params,
}
}
/// Return type of the function
pub fn result(&self) -> Option<ValueType> {
self.result
pub fn return_type(&self) -> Option<ValueType> {
match self {
&UserFunctionDescriptor::Static(_, _, result) => result,
&UserFunctionDescriptor::Heap(_, _, result) => result,
}
}
}
/// Set of user-defined functions
pub struct UserFunctions<'a> {
/// Functions list.
pub functions: Cow<'static, [UserFunction]>,
pub functions: Cow<'static, [UserFunctionDescriptor]>,
/// Functions executor.
pub executor: &'a mut UserFunctionExecutor,
}
@ -94,7 +82,7 @@ pub struct NativeModuleInstance<'a> {
/// By-name functions index.
by_name: HashMap<String, u32>,
/// User functions list.
functions: Cow<'static, [UserFunction]>,
functions: Cow<'static, [UserFunctionDescriptor]>,
}
impl<'a> NativeModuleInstance<'a> {
@ -123,8 +111,8 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> {
let composite_index = NATIVE_INDEX_FUNC_MIN + *index;
match required_type {
&ExportEntryType::Function(ref required_type)
if required_type == &self.function_type(ItemIndex::Internal(composite_index))
.expect("by_name contains index; function_type succeeds for all functions from by_name; qed")
if self.function_type(ItemIndex::Internal(composite_index))
.expect("by_name contains index; function_type succeeds for all functions from by_name; qed") == *required_type
=> return Ok(Internal::Function(composite_index)),
_ => (),
}
@ -145,7 +133,7 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> {
self.env.global(index, variable_type)
}
fn function_type(&self, function_index: ItemIndex) -> Result<FunctionType, Error> {
fn function_type(&self, function_index: ItemIndex) -> Result<FunctionSignature, Error> {
let index = match function_index {
ItemIndex::IndexSpace(index) | ItemIndex::Internal(index) => index,
ItemIndex::External(_) => unreachable!("trying to call function, exported by native env module"),
@ -155,13 +143,12 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> {
return self.env.function_type(function_index);
}
self.functions
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)))
.map(|f| FunctionType::new(f.params().to_vec(), f.result().clone()))
.ok_or(Error::Native(format!("missing native env function with index {}", index)))?))
}
fn function_type_by_index(&self, type_index: u32) -> Result<FunctionType, Error> {
fn function_type_by_index(&self, type_index: u32) -> Result<FunctionSignature, Error> {
self.function_type(ItemIndex::Internal(type_index))
}
@ -193,3 +180,10 @@ impl<'a> ModuleInstanceInterface for NativeModuleInstance<'a> {
pub fn env_native_module<'a>(env: Arc<ModuleInstanceInterface>, user_functions: UserFunctions<'a>) -> Result<NativeModuleInstance, Error> {
NativeModuleInstance::new(env, user_functions)
}
impl<'a> PartialEq for UserFunctionDescriptor {
fn eq(&self, other: &Self) -> bool {
self.params() == other.params()
&& self.return_type() == other.return_type()
}
}

8
src/interpreter/imports.rs
View File

@ -1,9 +1,9 @@
use std::sync::{Arc, Weak};
use std::collections::HashMap;
use elements::{ImportSection, ImportEntry, External, Internal, FunctionType};
use elements::{ImportSection, ImportEntry, External, Internal};
use interpreter::Error;
use interpreter::memory::MemoryInstance;
use interpreter::module::{ModuleInstanceInterface, ItemIndex, ExportEntryType};
use interpreter::module::{ModuleInstanceInterface, ItemIndex, ExportEntryType, FunctionSignature};
use interpreter::program::ProgramInstanceEssence;
use interpreter::table::TableInstance;
use interpreter::variable::{VariableInstance, VariableType};
@ -119,8 +119,8 @@ impl ModuleImports {
}
/// Get function index.
pub fn function<'a>(&self, externals: Option<&'a HashMap<String, Arc<ModuleInstanceInterface + 'a>>>, import: &ImportEntry, required_type: Option<&FunctionType>) -> Result<u32, Error> {
let (_, export) = self.external_export(externals, import, &required_type.map(|ft| ExportEntryType::Function(ft.clone())).unwrap_or(ExportEntryType::Any))?;
pub fn function<'a>(&self, externals: Option<&'a HashMap<String, Arc<ModuleInstanceInterface + 'a>>>, import: &ImportEntry, required_type: Option<FunctionSignature>) -> Result<u32, Error> {
let (_, export) = self.external_export(externals, import, &required_type.map(|ft| ExportEntryType::Function(ft)).unwrap_or(ExportEntryType::Any))?;
if let Internal::Function(external_index) = export {
return Ok(external_index);
}

2
src/interpreter/mod.rs
View File

@ -79,5 +79,5 @@ pub use self::table::TableInstance;
pub use self::program::ProgramInstance;
pub use self::value::RuntimeValue;
pub use self::variable::VariableInstance;
pub use self::env_native::{env_native_module, UserFunctions, UserFunction, UserFunctionExecutor, UserFunctionDescriptor};
pub use self::env_native::{env_native_module, UserFunctions, UserFunctionExecutor, UserFunctionDescriptor};
pub use self::env::EnvParams;

74
src/interpreter/module.rs
View File

@ -2,8 +2,9 @@ use std::collections::HashMap;
use std::iter::repeat;
use std::sync::{Arc, Weak};
use std::fmt;
use elements::{Module, InitExpr, Opcode, Type, FunctionType, Internal, External, BlockType, ResizableLimits, Local};
use elements::{Module, InitExpr, Opcode, Type, FunctionType, Internal, External, BlockType, ResizableLimits, Local, ValueType};
use interpreter::Error;
use interpreter::env_native::UserFunctionDescriptor;
use interpreter::imports::ModuleImports;
use interpreter::memory::MemoryInstance;
use interpreter::program::ProgramInstanceEssence;
@ -30,15 +31,24 @@ pub struct ExecutionParams<'a> {
/// Export type.
#[derive(Debug, Clone)]
pub enum ExportEntryType {
pub enum ExportEntryType<'a> {
/// Any type.
Any,
/// Type of function.
Function(FunctionType),
Function(FunctionSignature<'a>),
/// Type of global.
Global(VariableType),
}
/// Function signature.
#[derive(Debug, Clone)]
pub enum FunctionSignature<'a> {
/// Module function reference.
Module(&'a FunctionType),
/// Native user function refrence.
User(&'a UserFunctionDescriptor),
}
/// Module instance API.
pub trait ModuleInstanceInterface {
/// Execute function with the given index.
@ -54,9 +64,9 @@ pub trait ModuleInstanceInterface {
/// Get global reference.
fn global(&self, index: ItemIndex, variable_type: Option<VariableType>) -> Result<Arc<VariableInstance>, Error>;
/// Get function type for given function index.
fn function_type(&self, function_index: ItemIndex) -> Result<FunctionType, Error>;
fn function_type(&self, function_index: ItemIndex) -> Result<FunctionSignature, Error>;
/// Get function type for given function index.
fn function_type_by_index(&self, type_index: u32) -> Result<FunctionType, Error>;
fn function_type_by_index(&self, type_index: u32) -> Result<FunctionSignature, Error>;
/// Get function reference.
fn function_reference<'a>(&self, index: ItemIndex, externals: Option<&'a HashMap<String, Arc<ModuleInstanceInterface + 'a>>>) -> Result<InternalFunctionReference<'a>, Error>;
/// Get function indirect reference.
@ -259,16 +269,18 @@ impl ModuleInstance {
// export entry points to function in function index space
// and Internal::Function points to type in type section
{
let export_function_type = match export_entry {
Internal::Function(function_index) => external_module.function_type(ItemIndex::IndexSpace(function_index))?,
_ => return Err(Error::Validation(format!("Export with name {} from module {} is not a function", import.field(), import.module()))),
};
if import_function_type != export_function_type {
if export_function_type != import_function_type {
return Err(Error::Validation(format!("Export function type {} mismatch. Expected function with signature ({:?}) -> {:?} when got with ({:?}) -> {:?}",
function_type_index, import_function_type.params(), import_function_type.return_type(),
export_function_type.params(), export_function_type.return_type())));
}
}
},
&External::Global(ref global_type) => if global_type.is_mutable() {
return Err(Error::Validation(format!("trying to import mutable global {}", import.field())));
@ -310,18 +322,18 @@ impl ModuleInstance {
let code_section = self.module.code_section().expect("function_section_len != 0; function_section_len == code_section_len; qed");
// check every function body
for (index, function) in function_section.entries().iter().enumerate() {
let function_labels = {
let function_type = self.function_type_by_index(function.type_ref())?;
let function_body = code_section.bodies().get(index as usize).ok_or(Error::Validation(format!("Missing body for function {}", index)))?;
let mut locals = function_type.params().to_vec();
locals.extend(function_body.locals().iter().flat_map(|l| repeat(l.value_type()).take(l.count() as usize)));
let function_labels = {
let mut context = FunctionValidationContext::new(
self,
&locals,
DEFAULT_VALUE_STACK_LIMIT,
DEFAULT_FRAME_STACK_LIMIT,
&function_type);
function_type.clone());
let block_type = function_type.return_type().map(BlockType::Value).unwrap_or(BlockType::NoResult);
Validator::validate_function(&mut context, block_type, function_body.code().elements())
@ -439,7 +451,7 @@ impl ModuleInstanceInterface for ModuleInstance {
&ExportEntryType::Function(ref required_type) => match e.internal() {
&Internal::Function(function_index) =>
self.function_type(ItemIndex::IndexSpace(function_index))
.map(|ft| &ft == required_type)
.map(|ft| ft == *required_type)
.unwrap_or(false),
_ => false,
},
@ -487,7 +499,7 @@ impl ModuleInstanceInterface for ModuleInstance {
}
}
fn function_type(&self, function_index: ItemIndex) -> Result<FunctionType, Error> {
fn function_type(&self, function_index: ItemIndex) -> Result<FunctionSignature, Error> {
match self.imports.parse_function_index(function_index) {
ItemIndex::IndexSpace(_) => unreachable!("parse_function_index resolves IndexSpace option"),
ItemIndex::Internal(index) => self.require_function(ItemIndex::Internal(index))
@ -503,14 +515,14 @@ impl ModuleInstanceInterface for ModuleInstance {
}
}
fn function_type_by_index(&self, type_index: u32) -> Result<FunctionType, Error> {
fn function_type_by_index(&self, type_index: u32) -> Result<FunctionSignature, Error> {
self.module.type_section()
.ok_or(Error::Validation(format!("type reference {} exists in module without type section", type_index)))
.and_then(|s| match s.types().get(type_index as usize) {
Some(&Type::Function(ref function_type)) => Ok(function_type),
_ => Err(Error::Validation(format!("missing function type with index {}", type_index))),
})
.map(Clone::clone)
.map(FunctionSignature::Module)
}
fn function_reference<'a>(&self, index: ItemIndex, externals: Option<&'a HashMap<String, Arc<ModuleInstanceInterface + 'a>>>) -> Result<InternalFunctionReference<'a>, Error> {
@ -526,7 +538,7 @@ impl ModuleInstanceInterface for ModuleInstance {
.entries().get(index as usize)
.expect("parse_function_index has returned External(index); it is only returned when entry with index exists in import section exists; qed");
let required_function_type = self.function_type(ItemIndex::External(index))?;
let internal_function_index = self.imports.function(externals, import_entry, Some(&required_function_type))?;
let internal_function_index = self.imports.function(externals, import_entry, Some(required_function_type))?;
Ok(InternalFunctionReference {
module: self.imports.module(externals, import_entry.module())?,
internal_index: internal_function_index,
@ -640,3 +652,39 @@ fn get_initializer(expr: &InitExpr, module: &Module, imports: &ModuleImports, ex
_ => Err(Error::Initialization(format!("not-supported {:?} instruction in instantiation-time initializer", first_opcode))),
}
}
impl<'a> FunctionSignature<'a> {
pub fn return_type(&self) -> Option<ValueType> {
match self {
&FunctionSignature::Module(ft) => ft.return_type(),
&FunctionSignature::User(fd) => fd.return_type(),
}
}
pub fn params(&self) -> &[ValueType] {
match self {
&FunctionSignature::Module(ft) => ft.params(),
&FunctionSignature::User(fd) => fd.params(),
}
}
}
impl<'a> PartialEq for FunctionSignature<'a> {
fn eq<'b>(&self, other: &FunctionSignature<'b>) -> bool {
match self {
&FunctionSignature::Module(ft1) => match other {
&FunctionSignature::Module(ft2) => ft1 == ft2,
&FunctionSignature::User(ft2) => ft1.params() == ft2.params() && ft1.return_type() == ft2.return_type(),
},
&FunctionSignature::User(ft1) => match other {
&FunctionSignature::User(ft2) => ft1 == ft2,
&FunctionSignature::Module(ft2) => ft1.params() == ft2.params() && ft1.return_type() == ft2.return_type(),
},
}
}
}
impl<'a> From<&'a FunctionType> for FunctionSignature<'a> {
fn from(other: &'a FunctionType) -> Self {
FunctionSignature::Module(other)
}
}

13
src/interpreter/runner.rs
View File

@ -5,9 +5,9 @@ use std::sync::Arc;
use std::fmt::{self, Display};
use std::iter::repeat;
use std::collections::{HashMap, VecDeque};
use elements::{Opcode, BlockType, FunctionType, Local};
use elements::{Opcode, BlockType, Local};
use interpreter::Error;
use interpreter::module::{ModuleInstanceInterface, CallerContext, ItemIndex, InternalFunctionReference};
use interpreter::module::{ModuleInstanceInterface, CallerContext, ItemIndex, InternalFunctionReference, FunctionSignature};
use interpreter::stack::StackWithLimit;
use interpreter::value::{
RuntimeValue, TryInto, WrapInto, TryTruncateInto, ExtendInto,
@ -423,6 +423,7 @@ impl Interpreter {
fn run_call_indirect<'a>(context: &mut FunctionContext<'a>, type_idx: u32) -> Result<InstructionOutcome<'a>, Error> {
let table_func_idx: u32 = context.value_stack_mut().pop_as()?;
let function_reference = context.module().function_reference_indirect(DEFAULT_TABLE_INDEX, type_idx, table_func_idx, Some(context.externals))?;
{
let required_function_type = context.module().function_type_by_index(type_idx)?;
let actual_function_type = function_reference.module.function_type(ItemIndex::Internal(function_reference.internal_index))?;
if required_function_type != actual_function_type {
@ -430,6 +431,7 @@ impl Interpreter {
required_function_type.params(), required_function_type.return_type(),
actual_function_type.params(), actual_function_type.return_type())));
}
}
Ok(InstructionOutcome::ExecuteCall(function_reference))
}
@ -931,7 +933,7 @@ impl Interpreter {
}
impl<'a> FunctionContext<'a> {
pub fn new(function: InternalFunctionReference<'a>, externals: &'a HashMap<String, Arc<ModuleInstanceInterface + 'a>>, function_labels: HashMap<usize, usize>, value_stack_limit: usize, frame_stack_limit: usize, function_type: &FunctionType, args: Vec<VariableInstance>) -> Self {
pub fn new(function: InternalFunctionReference<'a>, externals: &'a HashMap<String, Arc<ModuleInstanceInterface + 'a>>, function_labels: HashMap<usize, usize>, value_stack_limit: usize, frame_stack_limit: usize, function_type: &FunctionSignature, args: Vec<VariableInstance>) -> Self {
FunctionContext {
is_initialized: false,
function: function,
@ -946,9 +948,12 @@ impl<'a> FunctionContext<'a> {
}
pub fn nested(&mut self, function: InternalFunctionReference<'a>) -> Result<Self, Error> {
let (function_locals, function_return_type) = {
let function_type = function.module.function_type(ItemIndex::Internal(function.internal_index))?;
let function_return_type = function_type.return_type().map(|vt| BlockType::Value(vt)).unwrap_or(BlockType::NoResult);
let function_locals = prepare_function_args(&function_type, &mut self.value_stack)?;
(function_locals, function_return_type)
};
Ok(FunctionContext {
is_initialized: false,
@ -1083,7 +1088,7 @@ fn effective_address(address: u32, offset: u32) -> Result<u32, Error> {
}
}
pub fn prepare_function_args(function_type: &FunctionType, caller_stack: &mut StackWithLimit<RuntimeValue>) -> Result<Vec<VariableInstance>, Error> {
pub fn prepare_function_args(function_type: &FunctionSignature, caller_stack: &mut StackWithLimit<RuntimeValue>) -> Result<Vec<VariableInstance>, Error> {
let mut args = function_type.params().iter().rev().map(|param_type| {
let param_value = caller_stack.pop()?;
let actual_type = param_value.variable_type();

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

@ -5,9 +5,9 @@ use builder::module;
use elements::{ExportEntry, Internal, ImportEntry, External, GlobalEntry, GlobalType,
InitExpr, ValueType, BlockType, Opcodes, Opcode, FunctionType};
use interpreter::Error;
use interpreter::env_native::{env_native_module, UserFunction, UserFunctions, UserFunctionExecutor, UserFunctionDescriptor};
use interpreter::env_native::{env_native_module, UserFunctions, UserFunctionExecutor, UserFunctionDescriptor};
use interpreter::memory::MemoryInstance;
use interpreter::module::{ModuleInstance, ModuleInstanceInterface, CallerContext, ItemIndex, ExecutionParams, ExportEntryType};
use interpreter::module::{ModuleInstance, ModuleInstanceInterface, CallerContext, ItemIndex, ExecutionParams, ExportEntryType, FunctionSignature};
use interpreter::program::ProgramInstance;
use interpreter::validator::{FunctionValidationContext, Validator};
use interpreter::value::RuntimeValue;
@ -101,21 +101,17 @@ fn global_get_set() {
const SIGNATURE_I32: &'static [ValueType] = &[ValueType::I32];
const SIGNATURES: &'static [UserFunction] = &[
UserFunction {
desc: UserFunctionDescriptor::Static(
const SIGNATURES: &'static [UserFunctionDescriptor] = &[
UserFunctionDescriptor::Static(
"add",
SIGNATURE_I32,
Some(ValueType::I32),
),
result: Some(ValueType::I32),
},
UserFunction {
desc: UserFunctionDescriptor::Static(
UserFunctionDescriptor::Static(
"sub",
SIGNATURE_I32,
Some(ValueType::I32),
),
result: Some(ValueType::I32),
},
];
// user function executor
@ -217,16 +213,16 @@ fn env_native_export_entry_type_check() {
functions: ::std::borrow::Cow::from(SIGNATURES),
}).unwrap());
assert!(native_env_instance.export_entry("add", &ExportEntryType::Function(FunctionType::new(vec![ValueType::I32], Some(ValueType::I32)))).is_ok());
assert!(native_env_instance.export_entry("add", &ExportEntryType::Function(FunctionType::new(vec![], Some(ValueType::I32)))).is_err());
assert!(native_env_instance.export_entry("add", &ExportEntryType::Function(FunctionType::new(vec![ValueType::I32], None))).is_err());
assert!(native_env_instance.export_entry("add", &ExportEntryType::Function(FunctionType::new(vec![ValueType::I32], Some(ValueType::I64)))).is_err());
assert!(native_env_instance.export_entry("add", &ExportEntryType::Function(FunctionSignature::Module(&FunctionType::new(vec![ValueType::I32], Some(ValueType::I32))))).is_ok());
assert!(native_env_instance.export_entry("add", &ExportEntryType::Function(FunctionSignature::Module(&FunctionType::new(vec![], Some(ValueType::I32))))).is_err());
assert!(native_env_instance.export_entry("add", &ExportEntryType::Function(FunctionSignature::Module(&FunctionType::new(vec![ValueType::I32], None)))).is_err());
assert!(native_env_instance.export_entry("add", &ExportEntryType::Function(FunctionSignature::Module(&FunctionType::new(vec![ValueType::I32], Some(ValueType::I64))))).is_err());
}
#[test]
fn if_else_with_return_type_validation() {
let module_instance = ModuleInstance::new(Weak::default(), "test".into(), module().build()).unwrap();
let mut context = FunctionValidationContext::new(&module_instance, &[], 1024, 1024, &FunctionType::default());
let mut context = FunctionValidationContext::new(&module_instance, &[], 1024, 1024, FunctionSignature::Module(&FunctionType::default()));
Validator::validate_function(&mut context, BlockType::NoResult, &[
Opcode::I32Const(1),

6
src/interpreter/validator.rs
View File

@ -1,9 +1,9 @@
use std::u32;
use std::collections::HashMap;
use elements::{Opcode, BlockType, FunctionType, ValueType};
use elements::{Opcode, BlockType, ValueType};
use interpreter::Error;
use interpreter::runner::{DEFAULT_MEMORY_INDEX, DEFAULT_TABLE_INDEX};
use interpreter::module::{ModuleInstance, ModuleInstanceInterface, ItemIndex};
use interpreter::module::{ModuleInstance, ModuleInstanceInterface, ItemIndex, FunctionSignature};
use interpreter::stack::StackWithLimit;
use interpreter::variable::VariableType;
@ -572,7 +572,7 @@ impl<'a> FunctionValidationContext<'a> {
locals: &'a [ValueType],
value_stack_limit: usize,
frame_stack_limit: usize,
function: &FunctionType,
function: FunctionSignature,
) -> Self {
FunctionValidationContext {
module_instance: module_instance,