xeos
/
wasmi
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Update parity-wasm dependency to 0.31 (#105) 

* Update parity-wasm dependency to 0.31
* Fix tests
This commit is contained in:
Wei Tang 2018-06-29 19:10:04 +08:00 committed by Sergey Pepyakin
parent 2fb793c8b8
commit f91dc92119
7 changed files with 231 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@ -11,7 +11,7 @@ keywords = ["wasm", "webassembly", "bytecode", "interpreter"]
exclude = [ "/res/*", "/tests/*", "/fuzz/*", "/benches/*" ]
[dependencies]
parity-wasm = "0.27"
parity-wasm = "0.31"
byteorder = "1.0"
memory_units = "0.3.0"
nan-preserving-float = "0.1.0"

4
src/func.rs
View File

@ -1,7 +1,7 @@
use std::rc::{Rc, Weak};
use std::fmt;
use std::collections::HashMap;
use parity_wasm::elements::{Local, Opcodes};
use parity_wasm::elements::{Local, Instructions};
use {Trap, TrapKind, Signature};
use host::Externals;
use runner::{check_function_args, Interpreter};
@ -158,6 +158,6 @@ impl FuncInstance {
#[derive(Clone, Debug)]
pub struct FuncBody {
pub locals: Vec<Local>,
pub opcodes: Opcodes,
pub instructions: Instructions,
pub labels: HashMap<usize, usize>,
}

14
src/module.rs
View File

@ -4,7 +4,7 @@ use std::rc::Rc;
use std::cell::RefCell;
use std::fmt;
use std::collections::HashMap;
use parity_wasm::elements::{External, InitExpr, Internal, Opcode, ResizableLimits, Type};
use parity_wasm::elements::{External, InitExpr, Internal, Instruction, ResizableLimits, Type};
use {Module, Error, Signature, MemoryInstance, RuntimeValue, TableInstance};
use imports::ImportResolver;
use global::{GlobalInstance, GlobalRef};
@ -313,7 +313,7 @@ impl ModuleInstance {
).clone();
let func_body = FuncBody {
locals: body.locals().to_vec(),
opcodes: body.code().clone(),
instructions: body.code().clone(),
labels: labels,
};
let func_instance =
@ -709,11 +709,11 @@ fn eval_init_expr(init_expr: &InitExpr, module: &ModuleInstance) -> RuntimeValue
"Due to validation `code`.len() should be 2"
);
match code[0] {
Opcode::I32Const(v) => v.into(),
Opcode::I64Const(v) => v.into(),
Opcode::F32Const(v) => RuntimeValue::decode_f32(v),
Opcode::F64Const(v) => RuntimeValue::decode_f64(v),
Opcode::GetGlobal(idx) => {
Instruction::I32Const(v) => v.into(),
Instruction::I64Const(v) => v.into(),
Instruction::F32Const(v) => RuntimeValue::decode_f32(v),
Instruction::F64Const(v) => RuntimeValue::decode_f64(v),
Instruction::GetGlobal(idx) => {
let global = module.global_by_index(idx).expect(
"Due to validation global should exists in module",
);

354
src/runner.rs
View File

@ -4,7 +4,7 @@ use std::{u32, usize};
use std::fmt;
use std::iter::repeat;
use std::collections::{HashMap, VecDeque};
use parity_wasm::elements::{Opcode, BlockType, Local};
use parity_wasm::elements::{Instruction, BlockType, Local};
use {Error, Trap, TrapKind, Signature};
use module::ModuleRef;
use func::{FuncRef, FuncInstance, FuncInstanceInternal};
@ -87,7 +87,7 @@ impl<'a, E: Externals> Interpreter<'a, E> {
function_context.push_frame(&function_body.labels, BlockFrameType::Function, return_type).map_err(Trap::new)?;
}
let function_return = self.do_run_function(&mut function_context, function_body.opcodes.elements(), &function_body.labels).map_err(Trap::new)?;
let function_return = self.do_run_function(&mut function_context, function_body.instructions.elements(), &function_body.labels).map_err(Trap::new)?;
match function_return {
RunResult::Return(return_value) => {
@ -127,7 +127,7 @@ impl<'a, E: Externals> Interpreter<'a, E> {
}
}
fn do_run_function(&mut self, function_context: &mut FunctionContext, function_body: &[Opcode], function_labels: &HashMap<usize, usize>) -> Result<RunResult, TrapKind> {
fn do_run_function(&mut self, function_context: &mut FunctionContext, function_body: &[Instruction], function_labels: &HashMap<usize, usize>) -> Result<RunResult, TrapKind> {
loop {
let instruction = &function_body[function_context.position];
@ -169,197 +169,197 @@ impl<'a, E: Externals> Interpreter<'a, E> {
}))
}
fn run_instruction(&mut self, context: &mut FunctionContext, labels: &HashMap<usize, usize>, opcode: &Opcode) -> Result<InstructionOutcome, TrapKind> {
match opcode {
&Opcode::Unreachable => self.run_unreachable(context),
&Opcode::Nop => self.run_nop(context),
&Opcode::Block(block_type) => self.run_block(context, labels, block_type),
&Opcode::Loop(block_type) => self.run_loop(context, labels, block_type),
&Opcode::If(block_type) => self.run_if(context, labels, block_type),
&Opcode::Else => self.run_else(context, labels),
&Opcode::End => self.run_end(context),
&Opcode::Br(idx) => self.run_br(context, idx),
&Opcode::BrIf(idx) => self.run_br_if(context, idx),
&Opcode::BrTable(ref table, default) => self.run_br_table(context, table, default),
&Opcode::Return => self.run_return(context),
fn run_instruction(&mut self, context: &mut FunctionContext, labels: &HashMap<usize, usize>, instruction: &Instruction) -> Result<InstructionOutcome, TrapKind> {
match instruction {
&Instruction::Unreachable => self.run_unreachable(context),
&Instruction::Nop => self.run_nop(context),
&Instruction::Block(block_type) => self.run_block(context, labels, block_type),
&Instruction::Loop(block_type) => self.run_loop(context, labels, block_type),
&Instruction::If(block_type) => self.run_if(context, labels, block_type),
&Instruction::Else => self.run_else(context, labels),
&Instruction::End => self.run_end(context),
&Instruction::Br(idx) => self.run_br(context, idx),
&Instruction::BrIf(idx) => self.run_br_if(context, idx),
&Instruction::BrTable(ref table, default) => self.run_br_table(context, table, default),
&Instruction::Return => self.run_return(context),
&Opcode::Call(index) => self.run_call(context, index),
&Opcode::CallIndirect(index, _reserved) => self.run_call_indirect(context, index),
&Instruction::Call(index) => self.run_call(context, index),
&Instruction::CallIndirect(index, _reserved) => self.run_call_indirect(context, index),
&Opcode::Drop => self.run_drop(context),
&Opcode::Select => self.run_select(context),
&Instruction::Drop => self.run_drop(context),
&Instruction::Select => self.run_select(context),
&Opcode::GetLocal(index) => self.run_get_local(context, index),
&Opcode::SetLocal(index) => self.run_set_local(context, index),
&Opcode::TeeLocal(index) => self.run_tee_local(context, index),
&Opcode::GetGlobal(index) => self.run_get_global(context, index),
&Opcode::SetGlobal(index) => self.run_set_global(context, index),
&Instruction::GetLocal(index) => self.run_get_local(context, index),
&Instruction::SetLocal(index) => self.run_set_local(context, index),
&Instruction::TeeLocal(index) => self.run_tee_local(context, index),
&Instruction::GetGlobal(index) => self.run_get_global(context, index),
&Instruction::SetGlobal(index) => self.run_set_global(context, index),
&Opcode::I32Load(align, offset) => self.run_load::<i32>(context, align, offset),
&Opcode::I64Load(align, offset) => self.run_load::<i64>(context, align, offset),
&Opcode::F32Load(align, offset) => self.run_load::<F32>(context, align, offset),
&Opcode::F64Load(align, offset) => self.run_load::<F64>(context, align, offset),
&Opcode::I32Load8S(align, offset) => self.run_load_extend::<i8, i32>(context, align, offset),
&Opcode::I32Load8U(align, offset) => self.run_load_extend::<u8, i32>(context, align, offset),
&Opcode::I32Load16S(align, offset) => self.run_load_extend::<i16, i32>(context, align, offset),
&Opcode::I32Load16U(align, offset) => self.run_load_extend::<u16, i32>(context, align, offset),
&Opcode::I64Load8S(align, offset) => self.run_load_extend::<i8, i64>(context, align, offset),
&Opcode::I64Load8U(align, offset) => self.run_load_extend::<u8, i64>(context, align, offset),
&Opcode::I64Load16S(align, offset) => self.run_load_extend::<i16, i64>(context, align, offset),
&Opcode::I64Load16U(align, offset) => self.run_load_extend::<u16, i64>(context, align, offset),
&Opcode::I64Load32S(align, offset) => self.run_load_extend::<i32, i64>(context, align, offset),
&Opcode::I64Load32U(align, offset) => self.run_load_extend::<u32, i64>(context, align, offset),
&Instruction::I32Load(align, offset) => self.run_load::<i32>(context, align, offset),
&Instruction::I64Load(align, offset) => self.run_load::<i64>(context, align, offset),
&Instruction::F32Load(align, offset) => self.run_load::<F32>(context, align, offset),
&Instruction::F64Load(align, offset) => self.run_load::<F64>(context, align, offset),
&Instruction::I32Load8S(align, offset) => self.run_load_extend::<i8, i32>(context, align, offset),
&Instruction::I32Load8U(align, offset) => self.run_load_extend::<u8, i32>(context, align, offset),
&Instruction::I32Load16S(align, offset) => self.run_load_extend::<i16, i32>(context, align, offset),
&Instruction::I32Load16U(align, offset) => self.run_load_extend::<u16, i32>(context, align, offset),
&Instruction::I64Load8S(align, offset) => self.run_load_extend::<i8, i64>(context, align, offset),
&Instruction::I64Load8U(align, offset) => self.run_load_extend::<u8, i64>(context, align, offset),
&Instruction::I64Load16S(align, offset) => self.run_load_extend::<i16, i64>(context, align, offset),
&Instruction::I64Load16U(align, offset) => self.run_load_extend::<u16, i64>(context, align, offset),
&Instruction::I64Load32S(align, offset) => self.run_load_extend::<i32, i64>(context, align, offset),
&Instruction::I64Load32U(align, offset) => self.run_load_extend::<u32, i64>(context, align, offset),
&Opcode::I32Store(align, offset) => self.run_store::<i32>(context, align, offset),
&Opcode::I64Store(align, offset) => self.run_store::<i64>(context, align, offset),
&Opcode::F32Store(align, offset) => self.run_store::<F32>(context, align, offset),
&Opcode::F64Store(align, offset) => self.run_store::<F64>(context, align, offset),
&Opcode::I32Store8(align, offset) => self.run_store_wrap::<i32, i8>(context, align, offset),
&Opcode::I32Store16(align, offset) => self.run_store_wrap::<i32, i16>(context, align, offset),
&Opcode::I64Store8(align, offset) => self.run_store_wrap::<i64, i8>(context, align, offset),
&Opcode::I64Store16(align, offset) => self.run_store_wrap::<i64, i16>(context, align, offset),
&Opcode::I64Store32(align, offset) => self.run_store_wrap::<i64, i32>(context, align, offset),
&Instruction::I32Store(align, offset) => self.run_store::<i32>(context, align, offset),
&Instruction::I64Store(align, offset) => self.run_store::<i64>(context, align, offset),
&Instruction::F32Store(align, offset) => self.run_store::<F32>(context, align, offset),
&Instruction::F64Store(align, offset) => self.run_store::<F64>(context, align, offset),
&Instruction::I32Store8(align, offset) => self.run_store_wrap::<i32, i8>(context, align, offset),
&Instruction::I32Store16(align, offset) => self.run_store_wrap::<i32, i16>(context, align, offset),
&Instruction::I64Store8(align, offset) => self.run_store_wrap::<i64, i8>(context, align, offset),
&Instruction::I64Store16(align, offset) => self.run_store_wrap::<i64, i16>(context, align, offset),
&Instruction::I64Store32(align, offset) => self.run_store_wrap::<i64, i32>(context, align, offset),
&Opcode::CurrentMemory(_) => self.run_current_memory(context),
&Opcode::GrowMemory(_) => self.run_grow_memory(context),
&Instruction::CurrentMemory(_) => self.run_current_memory(context),
&Instruction::GrowMemory(_) => self.run_grow_memory(context),
&Opcode::I32Const(val) => self.run_const(context, val.into()),
&Opcode::I64Const(val) => self.run_const(context, val.into()),
&Opcode::F32Const(val) => self.run_const(context, RuntimeValue::decode_f32(val)),
&Opcode::F64Const(val) => self.run_const(context, RuntimeValue::decode_f64(val)),
&Instruction::I32Const(val) => self.run_const(context, val.into()),
&Instruction::I64Const(val) => self.run_const(context, val.into()),
&Instruction::F32Const(val) => self.run_const(context, RuntimeValue::decode_f32(val)),
&Instruction::F64Const(val) => self.run_const(context, RuntimeValue::decode_f64(val)),
&Opcode::I32Eqz => self.run_eqz::<i32>(context),
&Opcode::I32Eq => self.run_eq::<i32>(context),
&Opcode::I32Ne => self.run_ne::<i32>(context),
&Opcode::I32LtS => self.run_lt::<i32>(context),
&Opcode::I32LtU => self.run_lt::<u32>(context),
&Opcode::I32GtS => self.run_gt::<i32>(context),
&Opcode::I32GtU => self.run_gt::<u32>(context),
&Opcode::I32LeS => self.run_lte::<i32>(context),
&Opcode::I32LeU => self.run_lte::<u32>(context),
&Opcode::I32GeS => self.run_gte::<i32>(context),
&Opcode::I32GeU => self.run_gte::<u32>(context),
&Instruction::I32Eqz => self.run_eqz::<i32>(context),
&Instruction::I32Eq => self.run_eq::<i32>(context),
&Instruction::I32Ne => self.run_ne::<i32>(context),
&Instruction::I32LtS => self.run_lt::<i32>(context),
&Instruction::I32LtU => self.run_lt::<u32>(context),
&Instruction::I32GtS => self.run_gt::<i32>(context),
&Instruction::I32GtU => self.run_gt::<u32>(context),
&Instruction::I32LeS => self.run_lte::<i32>(context),
&Instruction::I32LeU => self.run_lte::<u32>(context),
&Instruction::I32GeS => self.run_gte::<i32>(context),
&Instruction::I32GeU => self.run_gte::<u32>(context),
&Opcode::I64Eqz => self.run_eqz::<i64>(context),
&Opcode::I64Eq => self.run_eq::<i64>(context),
&Opcode::I64Ne => self.run_ne::<i64>(context),
&Opcode::I64LtS => self.run_lt::<i64>(context),
&Opcode::I64LtU => self.run_lt::<u64>(context),
&Opcode::I64GtS => self.run_gt::<i64>(context),
&Opcode::I64GtU => self.run_gt::<u64>(context),
&Opcode::I64LeS => self.run_lte::<i64>(context),
&Opcode::I64LeU => self.run_lte::<u64>(context),
&Opcode::I64GeS => self.run_gte::<i64>(context),
&Opcode::I64GeU => self.run_gte::<u64>(context),
&Instruction::I64Eqz => self.run_eqz::<i64>(context),
&Instruction::I64Eq => self.run_eq::<i64>(context),
&Instruction::I64Ne => self.run_ne::<i64>(context),
&Instruction::I64LtS => self.run_lt::<i64>(context),
&Instruction::I64LtU => self.run_lt::<u64>(context),
&Instruction::I64GtS => self.run_gt::<i64>(context),
&Instruction::I64GtU => self.run_gt::<u64>(context),
&Instruction::I64LeS => self.run_lte::<i64>(context),
&Instruction::I64LeU => self.run_lte::<u64>(context),
&Instruction::I64GeS => self.run_gte::<i64>(context),
&Instruction::I64GeU => self.run_gte::<u64>(context),
&Opcode::F32Eq => self.run_eq::<F32>(context),
&Opcode::F32Ne => self.run_ne::<F32>(context),
&Opcode::F32Lt => self.run_lt::<F32>(context),
&Opcode::F32Gt => self.run_gt::<F32>(context),
&Opcode::F32Le => self.run_lte::<F32>(context),
&Opcode::F32Ge => self.run_gte::<F32>(context),
&Instruction::F32Eq => self.run_eq::<F32>(context),
&Instruction::F32Ne => self.run_ne::<F32>(context),
&Instruction::F32Lt => self.run_lt::<F32>(context),
&Instruction::F32Gt => self.run_gt::<F32>(context),
&Instruction::F32Le => self.run_lte::<F32>(context),
&Instruction::F32Ge => self.run_gte::<F32>(context),
&Opcode::F64Eq => self.run_eq::<F64>(context),
&Opcode::F64Ne => self.run_ne::<F64>(context),
&Opcode::F64Lt => self.run_lt::<F64>(context),
&Opcode::F64Gt => self.run_gt::<F64>(context),
&Opcode::F64Le => self.run_lte::<F64>(context),
&Opcode::F64Ge => self.run_gte::<F64>(context),
&Instruction::F64Eq => self.run_eq::<F64>(context),
&Instruction::F64Ne => self.run_ne::<F64>(context),
&Instruction::F64Lt => self.run_lt::<F64>(context),
&Instruction::F64Gt => self.run_gt::<F64>(context),
&Instruction::F64Le => self.run_lte::<F64>(context),
&Instruction::F64Ge => self.run_gte::<F64>(context),
&Opcode::I32Clz => self.run_clz::<i32>(context),
&Opcode::I32Ctz => self.run_ctz::<i32>(context),
&Opcode::I32Popcnt => self.run_popcnt::<i32>(context),
&Opcode::I32Add => self.run_add::<i32>(context),
&Opcode::I32Sub => self.run_sub::<i32>(context),
&Opcode::I32Mul => self.run_mul::<i32>(context),
&Opcode::I32DivS => self.run_div::<i32, i32>(context),
&Opcode::I32DivU => self.run_div::<i32, u32>(context),
&Opcode::I32RemS => self.run_rem::<i32, i32>(context),
&Opcode::I32RemU => self.run_rem::<i32, u32>(context),
&Opcode::I32And => self.run_and::<i32>(context),
&Opcode::I32Or => self.run_or::<i32>(context),
&Opcode::I32Xor => self.run_xor::<i32>(context),
&Opcode::I32Shl => self.run_shl::<i32>(context, 0x1F),
&Opcode::I32ShrS => self.run_shr::<i32, i32>(context, 0x1F),
&Opcode::I32ShrU => self.run_shr::<i32, u32>(context, 0x1F),
&Opcode::I32Rotl => self.run_rotl::<i32>(context),
&Opcode::I32Rotr => self.run_rotr::<i32>(context),
&Instruction::I32Clz => self.run_clz::<i32>(context),
&Instruction::I32Ctz => self.run_ctz::<i32>(context),
&Instruction::I32Popcnt => self.run_popcnt::<i32>(context),
&Instruction::I32Add => self.run_add::<i32>(context),
&Instruction::I32Sub => self.run_sub::<i32>(context),
&Instruction::I32Mul => self.run_mul::<i32>(context),
&Instruction::I32DivS => self.run_div::<i32, i32>(context),
&Instruction::I32DivU => self.run_div::<i32, u32>(context),
&Instruction::I32RemS => self.run_rem::<i32, i32>(context),
&Instruction::I32RemU => self.run_rem::<i32, u32>(context),
&Instruction::I32And => self.run_and::<i32>(context),
&Instruction::I32Or => self.run_or::<i32>(context),
&Instruction::I32Xor => self.run_xor::<i32>(context),
&Instruction::I32Shl => self.run_shl::<i32>(context, 0x1F),
&Instruction::I32ShrS => self.run_shr::<i32, i32>(context, 0x1F),
&Instruction::I32ShrU => self.run_shr::<i32, u32>(context, 0x1F),
&Instruction::I32Rotl => self.run_rotl::<i32>(context),
&Instruction::I32Rotr => self.run_rotr::<i32>(context),
&Opcode::I64Clz => self.run_clz::<i64>(context),
&Opcode::I64Ctz => self.run_ctz::<i64>(context),
&Opcode::I64Popcnt => self.run_popcnt::<i64>(context),
&Opcode::I64Add => self.run_add::<i64>(context),
&Opcode::I64Sub => self.run_sub::<i64>(context),
&Opcode::I64Mul => self.run_mul::<i64>(context),
&Opcode::I64DivS => self.run_div::<i64, i64>(context),
&Opcode::I64DivU => self.run_div::<i64, u64>(context),
&Opcode::I64RemS => self.run_rem::<i64, i64>(context),
&Opcode::I64RemU => self.run_rem::<i64, u64>(context),
&Opcode::I64And => self.run_and::<i64>(context),
&Opcode::I64Or => self.run_or::<i64>(context),
&Opcode::I64Xor => self.run_xor::<i64>(context),
&Opcode::I64Shl => self.run_shl::<i64>(context, 0x3F),
&Opcode::I64ShrS => self.run_shr::<i64, i64>(context, 0x3F),
&Opcode::I64ShrU => self.run_shr::<i64, u64>(context, 0x3F),
&Opcode::I64Rotl => self.run_rotl::<i64>(context),
&Opcode::I64Rotr => self.run_rotr::<i64>(context),
&Instruction::I64Clz => self.run_clz::<i64>(context),
&Instruction::I64Ctz => self.run_ctz::<i64>(context),
&Instruction::I64Popcnt => self.run_popcnt::<i64>(context),
&Instruction::I64Add => self.run_add::<i64>(context),
&Instruction::I64Sub => self.run_sub::<i64>(context),
&Instruction::I64Mul => self.run_mul::<i64>(context),
&Instruction::I64DivS => self.run_div::<i64, i64>(context),
&Instruction::I64DivU => self.run_div::<i64, u64>(context),
&Instruction::I64RemS => self.run_rem::<i64, i64>(context),
&Instruction::I64RemU => self.run_rem::<i64, u64>(context),
&Instruction::I64And => self.run_and::<i64>(context),
&Instruction::I64Or => self.run_or::<i64>(context),
&Instruction::I64Xor => self.run_xor::<i64>(context),
&Instruction::I64Shl => self.run_shl::<i64>(context, 0x3F),
&Instruction::I64ShrS => self.run_shr::<i64, i64>(context, 0x3F),
&Instruction::I64ShrU => self.run_shr::<i64, u64>(context, 0x3F),
&Instruction::I64Rotl => self.run_rotl::<i64>(context),
&Instruction::I64Rotr => self.run_rotr::<i64>(context),
&Opcode::F32Abs => self.run_abs::<F32>(context),
&Opcode::F32Neg => self.run_neg::<F32>(context),
&Opcode::F32Ceil => self.run_ceil::<F32>(context),
&Opcode::F32Floor => self.run_floor::<F32>(context),
&Opcode::F32Trunc => self.run_trunc::<F32>(context),
&Opcode::F32Nearest => self.run_nearest::<F32>(context),
&Opcode::F32Sqrt => self.run_sqrt::<F32>(context),
&Opcode::F32Add => self.run_add::<F32>(context),
&Opcode::F32Sub => self.run_sub::<F32>(context),
&Opcode::F32Mul => self.run_mul::<F32>(context),
&Opcode::F32Div => self.run_div::<F32, F32>(context),
&Opcode::F32Min => self.run_min::<F32>(context),
&Opcode::F32Max => self.run_max::<F32>(context),
&Opcode::F32Copysign => self.run_copysign::<F32>(context),
&Instruction::F32Abs => self.run_abs::<F32>(context),
&Instruction::F32Neg => self.run_neg::<F32>(context),
&Instruction::F32Ceil => self.run_ceil::<F32>(context),
&Instruction::F32Floor => self.run_floor::<F32>(context),
&Instruction::F32Trunc => self.run_trunc::<F32>(context),
&Instruction::F32Nearest => self.run_nearest::<F32>(context),
&Instruction::F32Sqrt => self.run_sqrt::<F32>(context),
&Instruction::F32Add => self.run_add::<F32>(context),
&Instruction::F32Sub => self.run_sub::<F32>(context),
&Instruction::F32Mul => self.run_mul::<F32>(context),
&Instruction::F32Div => self.run_div::<F32, F32>(context),
&Instruction::F32Min => self.run_min::<F32>(context),
&Instruction::F32Max => self.run_max::<F32>(context),
&Instruction::F32Copysign => self.run_copysign::<F32>(context),
&Opcode::F64Abs => self.run_abs::<F64>(context),
&Opcode::F64Neg => self.run_neg::<F64>(context),
&Opcode::F64Ceil => self.run_ceil::<F64>(context),
&Opcode::F64Floor => self.run_floor::<F64>(context),
&Opcode::F64Trunc => self.run_trunc::<F64>(context),
&Opcode::F64Nearest => self.run_nearest::<F64>(context),
&Opcode::F64Sqrt => self.run_sqrt::<F64>(context),
&Opcode::F64Add => self.run_add::<F64>(context),
&Opcode::F64Sub => self.run_sub::<F64>(context),
&Opcode::F64Mul => self.run_mul::<F64>(context),
&Opcode::F64Div => self.run_div::<F64, F64>(context),
&Opcode::F64Min => self.run_min::<F64>(context),
&Opcode::F64Max => self.run_max::<F64>(context),
&Opcode::F64Copysign => self.run_copysign::<F64>(context),
&Instruction::F64Abs => self.run_abs::<F64>(context),
&Instruction::F64Neg => self.run_neg::<F64>(context),
&Instruction::F64Ceil => self.run_ceil::<F64>(context),
&Instruction::F64Floor => self.run_floor::<F64>(context),
&Instruction::F64Trunc => self.run_trunc::<F64>(context),
&Instruction::F64Nearest => self.run_nearest::<F64>(context),
&Instruction::F64Sqrt => self.run_sqrt::<F64>(context),
&Instruction::F64Add => self.run_add::<F64>(context),
&Instruction::F64Sub => self.run_sub::<F64>(context),
&Instruction::F64Mul => self.run_mul::<F64>(context),
&Instruction::F64Div => self.run_div::<F64, F64>(context),
&Instruction::F64Min => self.run_min::<F64>(context),
&Instruction::F64Max => self.run_max::<F64>(context),
&Instruction::F64Copysign => self.run_copysign::<F64>(context),
&Opcode::I32WrapI64 => self.run_wrap::<i64, i32>(context),
&Opcode::I32TruncSF32 => self.run_trunc_to_int::<F32, i32, i32>(context),
&Opcode::I32TruncUF32 => self.run_trunc_to_int::<F32, u32, i32>(context),
&Opcode::I32TruncSF64 => self.run_trunc_to_int::<F64, i32, i32>(context),
&Opcode::I32TruncUF64 => self.run_trunc_to_int::<F64, u32, i32>(context),
&Opcode::I64ExtendSI32 => self.run_extend::<i32, i64, i64>(context),
&Opcode::I64ExtendUI32 => self.run_extend::<u32, u64, i64>(context),
&Opcode::I64TruncSF32 => self.run_trunc_to_int::<F32, i64, i64>(context),
&Opcode::I64TruncUF32 => self.run_trunc_to_int::<F32, u64, i64>(context),
&Opcode::I64TruncSF64 => self.run_trunc_to_int::<F64, i64, i64>(context),
&Opcode::I64TruncUF64 => self.run_trunc_to_int::<F64, u64, i64>(context),
&Opcode::F32ConvertSI32 => self.run_extend::<i32, F32, F32>(context),
&Opcode::F32ConvertUI32 => self.run_extend::<u32, F32, F32>(context),
&Opcode::F32ConvertSI64 => self.run_wrap::<i64, F32>(context),
&Opcode::F32ConvertUI64 => self.run_wrap::<u64, F32>(context),
&Opcode::F32DemoteF64 => self.run_wrap::<F64, F32>(context),
&Opcode::F64ConvertSI32 => self.run_extend::<i32, F64, F64>(context),
&Opcode::F64ConvertUI32 => self.run_extend::<u32, F64, F64>(context),
&Opcode::F64ConvertSI64 => self.run_extend::<i64, F64, F64>(context),
&Opcode::F64ConvertUI64 => self.run_extend::<u64, F64, F64>(context),
&Opcode::F64PromoteF32 => self.run_extend::<F32, F64, F64>(context),
&Instruction::I32WrapI64 => self.run_wrap::<i64, i32>(context),
&Instruction::I32TruncSF32 => self.run_trunc_to_int::<F32, i32, i32>(context),
&Instruction::I32TruncUF32 => self.run_trunc_to_int::<F32, u32, i32>(context),
&Instruction::I32TruncSF64 => self.run_trunc_to_int::<F64, i32, i32>(context),
&Instruction::I32TruncUF64 => self.run_trunc_to_int::<F64, u32, i32>(context),
&Instruction::I64ExtendSI32 => self.run_extend::<i32, i64, i64>(context),
&Instruction::I64ExtendUI32 => self.run_extend::<u32, u64, i64>(context),
&Instruction::I64TruncSF32 => self.run_trunc_to_int::<F32, i64, i64>(context),
&Instruction::I64TruncUF32 => self.run_trunc_to_int::<F32, u64, i64>(context),
&Instruction::I64TruncSF64 => self.run_trunc_to_int::<F64, i64, i64>(context),
&Instruction::I64TruncUF64 => self.run_trunc_to_int::<F64, u64, i64>(context),
&Instruction::F32ConvertSI32 => self.run_extend::<i32, F32, F32>(context),
&Instruction::F32ConvertUI32 => self.run_extend::<u32, F32, F32>(context),
&Instruction::F32ConvertSI64 => self.run_wrap::<i64, F32>(context),
&Instruction::F32ConvertUI64 => self.run_wrap::<u64, F32>(context),
&Instruction::F32DemoteF64 => self.run_wrap::<F64, F32>(context),
&Instruction::F64ConvertSI32 => self.run_extend::<i32, F64, F64>(context),
&Instruction::F64ConvertUI32 => self.run_extend::<u32, F64, F64>(context),
&Instruction::F64ConvertSI64 => self.run_extend::<i64, F64, F64>(context),
&Instruction::F64ConvertUI64 => self.run_extend::<u64, F64, F64>(context),
&Instruction::F64PromoteF32 => self.run_extend::<F32, F64, F64>(context),
&Opcode::I32ReinterpretF32 => self.run_reinterpret::<F32, i32>(context),
&Opcode::I64ReinterpretF64 => self.run_reinterpret::<F64, i64>(context),
&Opcode::F32ReinterpretI32 => self.run_reinterpret::<i32, F32>(context),
&Opcode::F64ReinterpretI64 => self.run_reinterpret::<i64, F64>(context),
&Instruction::I32ReinterpretF32 => self.run_reinterpret::<F32, i32>(context),
&Instruction::I64ReinterpretF64 => self.run_reinterpret::<F64, i64>(context),
&Instruction::F32ReinterpretI32 => self.run_reinterpret::<i32, F32>(context),
&Instruction::F64ReinterpretI64 => self.run_reinterpret::<i64, F64>(context),
}
}

10
src/validation/func.rs
View File

@ -1,6 +1,6 @@
use std::u32;
use std::collections::HashMap;
use parity_wasm::elements::{Opcode, BlockType, ValueType, TableElementType, Func, FuncBody};
use parity_wasm::elements::{Instruction, BlockType, ValueType, TableElementType, Func, FuncBody};
use common::{DEFAULT_MEMORY_INDEX, DEFAULT_TABLE_INDEX};
use validation::context::ModuleContext;
@ -79,7 +79,7 @@ impl Validator {
Ok(context.into_labels())
}
fn validate_function_block(context: &mut FunctionValidationContext, body: &[Opcode]) -> Result<(), Error> {
fn validate_function_block(context: &mut FunctionValidationContext, body: &[Instruction]) -> Result<(), Error> {
let body_len = body.len();
if body_len == 0 {
return Err(Error("Non-empty function body expected".into()));
@ -99,9 +99,9 @@ impl Validator {
}
}
fn validate_instruction(context: &mut FunctionValidationContext, opcode: &Opcode) -> Result<InstructionOutcome, Error> {
use self::Opcode::*;
match *opcode {
fn validate_instruction(context: &mut FunctionValidationContext, instruction: &Instruction) -> Result<InstructionOutcome, Error> {
use self::Instruction::*;
match *instruction {
Unreachable => Ok(InstructionOutcome::Unreachable),
Nop => Ok(InstructionOutcome::ValidateNextInstruction),
Block(block_type) => Validator::validate_block(context, block_type),

20
src/validation/mod.rs
View File

@ -2,8 +2,8 @@ use std::error;
use std::fmt;
use std::collections::{HashMap, HashSet};
use parity_wasm::elements::{
BlockType, External, GlobalEntry, GlobalType, Internal, MemoryType, Module, Opcode,
ResizableLimits, TableType, ValueType, InitExpr, Type
BlockType, External, GlobalEntry, GlobalType, Internal, MemoryType, Module, Instruction,
ResizableLimits, TableType, ValueType, InitExpr, Type,
};
use common::stack;
use self::context::ModuleContextBuilder;
@ -54,7 +54,7 @@ impl ::std::ops::Deref for ValidatedModule {
pub fn deny_floating_point(module: &Module) -> Result<(), Error> {
if let Some(code) = module.code_section() {
for op in code.bodies().iter().flat_map(|body| body.code().elements()) {
use parity_wasm::elements::Opcode::*;
use parity_wasm::elements::Instruction::*;
macro_rules! match_eq {
($pattern:pat) => {
@ -62,7 +62,7 @@ pub fn deny_floating_point(module: &Module) -> Result<(), Error> {
};
}
const DENIED: &[fn(&Opcode) -> bool] = &[
const DENIED: &[fn(&Instruction) -> bool] = &[
match_eq!(F32Load(_, _)),
match_eq!(F64Load(_, _)),
match_eq!(F32Store(_, _)),
@ -423,11 +423,11 @@ fn expr_const_type(init_expr: &InitExpr, globals: &[GlobalType]) -> Result<Value
));
}
let expr_ty: ValueType = match code[0] {
Opcode::I32Const(_) => ValueType::I32,
Opcode::I64Const(_) => ValueType::I64,
Opcode::F32Const(_) => ValueType::F32,
Opcode::F64Const(_) => ValueType::F64,
Opcode::GetGlobal(idx) => {
Instruction::I32Const(_) => ValueType::I32,
Instruction::I64Const(_) => ValueType::I64,
Instruction::F32Const(_) => ValueType::F32,
Instruction::F64Const(_) => ValueType::F64,
Instruction::GetGlobal(idx) => {
match globals.get(idx as usize) {
Some(target_global) => {
if target_global.is_mutable() {
@ -444,7 +444,7 @@ fn expr_const_type(init_expr: &InitExpr, globals: &[GlobalType]) -> Result<Value
}
_ => return Err(Error("Non constant opcode in init expr".into())),
};
if code[1] != Opcode::End {
if code[1] != Instruction::End {
return Err(Error("Expression doesn't ends with `end` opcode".into()));
}
Ok(expr_ty)

58
src/validation/tests.rs
View File

@ -2,7 +2,7 @@ use super::validate_module;
use parity_wasm::builder::module;
use parity_wasm::elements::{
External, GlobalEntry, GlobalType, ImportEntry, InitExpr, MemoryType,
Opcode, Opcodes, TableType, ValueType, BlockType
Instruction, Instructions, TableType, ValueType, BlockType
};
#[test]
@ -74,7 +74,7 @@ fn global_init_const() {
GlobalEntry::new(
GlobalType::new(ValueType::I32, true),
InitExpr::new(
vec![Opcode::I32Const(42), Opcode::End]
vec![Instruction::I32Const(42), Instruction::End]
)
)
)
@ -86,7 +86,7 @@ fn global_init_const() {
.with_global(
GlobalEntry::new(
GlobalType::new(ValueType::I64, true),
InitExpr::new(vec![Opcode::I32Const(42), Opcode::End])
InitExpr::new(vec![Instruction::I32Const(42), Instruction::End])
)
)
.build();
@ -106,7 +106,7 @@ fn global_init_global() {
.with_global(
GlobalEntry::new(
GlobalType::new(ValueType::I32, true),
InitExpr::new(vec![Opcode::GetGlobal(0), Opcode::End])
InitExpr::new(vec![Instruction::GetGlobal(0), Instruction::End])
)
)
.build();
@ -117,7 +117,7 @@ fn global_init_global() {
.with_global(
GlobalEntry::new(
GlobalType::new(ValueType::I32, true),
InitExpr::new(vec![Opcode::GetGlobal(0), Opcode::End])
InitExpr::new(vec![Instruction::GetGlobal(0), Instruction::End])
)
)
.build();
@ -135,7 +135,7 @@ fn global_init_global() {
.with_global(
GlobalEntry::new(
GlobalType::new(ValueType::I32, true),
InitExpr::new(vec![Opcode::GetGlobal(0), Opcode::End])
InitExpr::new(vec![Instruction::GetGlobal(0), Instruction::End])
)
)
.build();
@ -146,13 +146,13 @@ fn global_init_global() {
.with_global(
GlobalEntry::new(
GlobalType::new(ValueType::I32, false),
InitExpr::new(vec![Opcode::I32Const(0), Opcode::End])
InitExpr::new(vec![Instruction::I32Const(0), Instruction::End])
)
)
.with_global(
GlobalEntry::new(
GlobalType::new(ValueType::I32, true),
InitExpr::new(vec![Opcode::GetGlobal(0), Opcode::End])
InitExpr::new(vec![Instruction::GetGlobal(0), Instruction::End])
)
)
.build();
@ -166,7 +166,7 @@ fn global_init_misc() {
.with_global(
GlobalEntry::new(
GlobalType::new(ValueType::I32, true),
InitExpr::new(vec![Opcode::I32Const(42)])
InitExpr::new(vec![Instruction::I32Const(42)])
)
)
.build();
@ -177,7 +177,7 @@ fn global_init_misc() {
.with_global(
GlobalEntry::new(
GlobalType::new(ValueType::I32, true),
InitExpr::new(vec![Opcode::End])
InitExpr::new(vec![Instruction::End])
)
)
.build();
@ -188,7 +188,7 @@ fn global_init_misc() {
.with_global(
GlobalEntry::new(
GlobalType::new(ValueType::I32, true),
InitExpr::new(vec![Opcode::Unreachable, Opcode::End])
InitExpr::new(vec![Instruction::Unreachable, Instruction::End])
)
)
.build();
@ -234,16 +234,16 @@ fn funcs() {
let m = module()
.function()
.signature().return_type().i32().build()
.body().with_opcodes(Opcodes::new(vec![
Opcode::Call(1),
Opcode::End,
.body().with_instructions(Instructions::new(vec![
Instruction::Call(1),
Instruction::End,
])).build()
.build()
.function()
.signature().return_type().i32().build()
.body().with_opcodes(Opcodes::new(vec![
Opcode::Call(0),
Opcode::End,
.body().with_instructions(Instructions::new(vec![
Instruction::Call(0),
Instruction::End,
])).build()
.build()
.build();
@ -282,18 +282,18 @@ fn if_else_with_return_type_validation() {
let m = module()
.function()
.signature().build()
.body().with_opcodes(Opcodes::new(vec![
Opcode::I32Const(1),
Opcode::If(BlockType::NoResult),
Opcode::I32Const(1),
Opcode::If(BlockType::Value(ValueType::I32)),
Opcode::I32Const(1),
Opcode::Else,
Opcode::I32Const(2),
Opcode::End,
Opcode::Drop,
Opcode::End,
Opcode::End,
.body().with_instructions(Instructions::new(vec![
Instruction::I32Const(1),
Instruction::If(BlockType::NoResult),
Instruction::I32Const(1),
Instruction::If(BlockType::Value(ValueType::I32)),
Instruction::I32Const(1),
Instruction::Else,
Instruction::I32Const(2),
Instruction::End,
Instruction::Drop,
Instruction::End,
Instruction::End,
])).build()
.build()
.build();