From f91dc921196f45bd7f02ab4779dabd702e31e338 Mon Sep 17 00:00:00 2001 From: Wei Tang Date: Fri, 29 Jun 2018 19:10:04 +0800 Subject: [PATCH] Update parity-wasm dependency to 0.31 (#105) * Update parity-wasm dependency to 0.31 * Fix tests --- Cargo.toml | 2 +- src/func.rs | 4 +- src/module.rs | 14 +- src/runner.rs | 354 ++++++++++++++++++++-------------------- src/validation/func.rs | 10 +- src/validation/mod.rs | 20 +-- src/validation/tests.rs | 58 +++---- 7 files changed, 231 insertions(+), 231 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index b74d752..5df7d97 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -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" diff --git a/src/func.rs b/src/func.rs index b72107d..6a84ac1 100644 --- a/src/func.rs +++ b/src/func.rs @@ -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, - pub opcodes: Opcodes, + pub instructions: Instructions, pub labels: HashMap, } diff --git a/src/module.rs b/src/module.rs index 820e66a..faaf95e 100644 --- a/src/module.rs +++ b/src/module.rs @@ -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", ); diff --git a/src/runner.rs b/src/runner.rs index 51c9661..ea94d11 100644 --- a/src/runner.rs +++ b/src/runner.rs @@ -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) -> Result { + fn do_run_function(&mut self, function_context: &mut FunctionContext, function_body: &[Instruction], function_labels: &HashMap) -> Result { 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, opcode: &Opcode) -> Result { - 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, instruction: &Instruction) -> Result { + 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::(context, align, offset), - &Opcode::I64Load(align, offset) => self.run_load::(context, align, offset), - &Opcode::F32Load(align, offset) => self.run_load::(context, align, offset), - &Opcode::F64Load(align, offset) => self.run_load::(context, align, offset), - &Opcode::I32Load8S(align, offset) => self.run_load_extend::(context, align, offset), - &Opcode::I32Load8U(align, offset) => self.run_load_extend::(context, align, offset), - &Opcode::I32Load16S(align, offset) => self.run_load_extend::(context, align, offset), - &Opcode::I32Load16U(align, offset) => self.run_load_extend::(context, align, offset), - &Opcode::I64Load8S(align, offset) => self.run_load_extend::(context, align, offset), - &Opcode::I64Load8U(align, offset) => self.run_load_extend::(context, align, offset), - &Opcode::I64Load16S(align, offset) => self.run_load_extend::(context, align, offset), - &Opcode::I64Load16U(align, offset) => self.run_load_extend::(context, align, offset), - &Opcode::I64Load32S(align, offset) => self.run_load_extend::(context, align, offset), - &Opcode::I64Load32U(align, offset) => self.run_load_extend::(context, align, offset), + &Instruction::I32Load(align, offset) => self.run_load::(context, align, offset), + &Instruction::I64Load(align, offset) => self.run_load::(context, align, offset), + &Instruction::F32Load(align, offset) => self.run_load::(context, align, offset), + &Instruction::F64Load(align, offset) => self.run_load::(context, align, offset), + &Instruction::I32Load8S(align, offset) => self.run_load_extend::(context, align, offset), + &Instruction::I32Load8U(align, offset) => self.run_load_extend::(context, align, offset), + &Instruction::I32Load16S(align, offset) => self.run_load_extend::(context, align, offset), + &Instruction::I32Load16U(align, offset) => self.run_load_extend::(context, align, offset), + &Instruction::I64Load8S(align, offset) => self.run_load_extend::(context, align, offset), + &Instruction::I64Load8U(align, offset) => self.run_load_extend::(context, align, offset), + &Instruction::I64Load16S(align, offset) => self.run_load_extend::(context, align, offset), + &Instruction::I64Load16U(align, offset) => self.run_load_extend::(context, align, offset), + &Instruction::I64Load32S(align, offset) => self.run_load_extend::(context, align, offset), + &Instruction::I64Load32U(align, offset) => self.run_load_extend::(context, align, offset), - &Opcode::I32Store(align, offset) => self.run_store::(context, align, offset), - &Opcode::I64Store(align, offset) => self.run_store::(context, align, offset), - &Opcode::F32Store(align, offset) => self.run_store::(context, align, offset), - &Opcode::F64Store(align, offset) => self.run_store::(context, align, offset), - &Opcode::I32Store8(align, offset) => self.run_store_wrap::(context, align, offset), - &Opcode::I32Store16(align, offset) => self.run_store_wrap::(context, align, offset), - &Opcode::I64Store8(align, offset) => self.run_store_wrap::(context, align, offset), - &Opcode::I64Store16(align, offset) => self.run_store_wrap::(context, align, offset), - &Opcode::I64Store32(align, offset) => self.run_store_wrap::(context, align, offset), + &Instruction::I32Store(align, offset) => self.run_store::(context, align, offset), + &Instruction::I64Store(align, offset) => self.run_store::(context, align, offset), + &Instruction::F32Store(align, offset) => self.run_store::(context, align, offset), + &Instruction::F64Store(align, offset) => self.run_store::(context, align, offset), + &Instruction::I32Store8(align, offset) => self.run_store_wrap::(context, align, offset), + &Instruction::I32Store16(align, offset) => self.run_store_wrap::(context, align, offset), + &Instruction::I64Store8(align, offset) => self.run_store_wrap::(context, align, offset), + &Instruction::I64Store16(align, offset) => self.run_store_wrap::(context, align, offset), + &Instruction::I64Store32(align, offset) => self.run_store_wrap::(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::(context), - &Opcode::I32Eq => self.run_eq::(context), - &Opcode::I32Ne => self.run_ne::(context), - &Opcode::I32LtS => self.run_lt::(context), - &Opcode::I32LtU => self.run_lt::(context), - &Opcode::I32GtS => self.run_gt::(context), - &Opcode::I32GtU => self.run_gt::(context), - &Opcode::I32LeS => self.run_lte::(context), - &Opcode::I32LeU => self.run_lte::(context), - &Opcode::I32GeS => self.run_gte::(context), - &Opcode::I32GeU => self.run_gte::(context), + &Instruction::I32Eqz => self.run_eqz::(context), + &Instruction::I32Eq => self.run_eq::(context), + &Instruction::I32Ne => self.run_ne::(context), + &Instruction::I32LtS => self.run_lt::(context), + &Instruction::I32LtU => self.run_lt::(context), + &Instruction::I32GtS => self.run_gt::(context), + &Instruction::I32GtU => self.run_gt::(context), + &Instruction::I32LeS => self.run_lte::(context), + &Instruction::I32LeU => self.run_lte::(context), + &Instruction::I32GeS => self.run_gte::(context), + &Instruction::I32GeU => self.run_gte::(context), - &Opcode::I64Eqz => self.run_eqz::(context), - &Opcode::I64Eq => self.run_eq::(context), - &Opcode::I64Ne => self.run_ne::(context), - &Opcode::I64LtS => self.run_lt::(context), - &Opcode::I64LtU => self.run_lt::(context), - &Opcode::I64GtS => self.run_gt::(context), - &Opcode::I64GtU => self.run_gt::(context), - &Opcode::I64LeS => self.run_lte::(context), - &Opcode::I64LeU => self.run_lte::(context), - &Opcode::I64GeS => self.run_gte::(context), - &Opcode::I64GeU => self.run_gte::(context), + &Instruction::I64Eqz => self.run_eqz::(context), + &Instruction::I64Eq => self.run_eq::(context), + &Instruction::I64Ne => self.run_ne::(context), + &Instruction::I64LtS => self.run_lt::(context), + &Instruction::I64LtU => self.run_lt::(context), + &Instruction::I64GtS => self.run_gt::(context), + &Instruction::I64GtU => self.run_gt::(context), + &Instruction::I64LeS => self.run_lte::(context), + &Instruction::I64LeU => self.run_lte::(context), + &Instruction::I64GeS => self.run_gte::(context), + &Instruction::I64GeU => self.run_gte::(context), - &Opcode::F32Eq => self.run_eq::(context), - &Opcode::F32Ne => self.run_ne::(context), - &Opcode::F32Lt => self.run_lt::(context), - &Opcode::F32Gt => self.run_gt::(context), - &Opcode::F32Le => self.run_lte::(context), - &Opcode::F32Ge => self.run_gte::(context), + &Instruction::F32Eq => self.run_eq::(context), + &Instruction::F32Ne => self.run_ne::(context), + &Instruction::F32Lt => self.run_lt::(context), + &Instruction::F32Gt => self.run_gt::(context), + &Instruction::F32Le => self.run_lte::(context), + &Instruction::F32Ge => self.run_gte::(context), - &Opcode::F64Eq => self.run_eq::(context), - &Opcode::F64Ne => self.run_ne::(context), - &Opcode::F64Lt => self.run_lt::(context), - &Opcode::F64Gt => self.run_gt::(context), - &Opcode::F64Le => self.run_lte::(context), - &Opcode::F64Ge => self.run_gte::(context), + &Instruction::F64Eq => self.run_eq::(context), + &Instruction::F64Ne => self.run_ne::(context), + &Instruction::F64Lt => self.run_lt::(context), + &Instruction::F64Gt => self.run_gt::(context), + &Instruction::F64Le => self.run_lte::(context), + &Instruction::F64Ge => self.run_gte::(context), - &Opcode::I32Clz => self.run_clz::(context), - &Opcode::I32Ctz => self.run_ctz::(context), - &Opcode::I32Popcnt => self.run_popcnt::(context), - &Opcode::I32Add => self.run_add::(context), - &Opcode::I32Sub => self.run_sub::(context), - &Opcode::I32Mul => self.run_mul::(context), - &Opcode::I32DivS => self.run_div::(context), - &Opcode::I32DivU => self.run_div::(context), - &Opcode::I32RemS => self.run_rem::(context), - &Opcode::I32RemU => self.run_rem::(context), - &Opcode::I32And => self.run_and::(context), - &Opcode::I32Or => self.run_or::(context), - &Opcode::I32Xor => self.run_xor::(context), - &Opcode::I32Shl => self.run_shl::(context, 0x1F), - &Opcode::I32ShrS => self.run_shr::(context, 0x1F), - &Opcode::I32ShrU => self.run_shr::(context, 0x1F), - &Opcode::I32Rotl => self.run_rotl::(context), - &Opcode::I32Rotr => self.run_rotr::(context), + &Instruction::I32Clz => self.run_clz::(context), + &Instruction::I32Ctz => self.run_ctz::(context), + &Instruction::I32Popcnt => self.run_popcnt::(context), + &Instruction::I32Add => self.run_add::(context), + &Instruction::I32Sub => self.run_sub::(context), + &Instruction::I32Mul => self.run_mul::(context), + &Instruction::I32DivS => self.run_div::(context), + &Instruction::I32DivU => self.run_div::(context), + &Instruction::I32RemS => self.run_rem::(context), + &Instruction::I32RemU => self.run_rem::(context), + &Instruction::I32And => self.run_and::(context), + &Instruction::I32Or => self.run_or::(context), + &Instruction::I32Xor => self.run_xor::(context), + &Instruction::I32Shl => self.run_shl::(context, 0x1F), + &Instruction::I32ShrS => self.run_shr::(context, 0x1F), + &Instruction::I32ShrU => self.run_shr::(context, 0x1F), + &Instruction::I32Rotl => self.run_rotl::(context), + &Instruction::I32Rotr => self.run_rotr::(context), - &Opcode::I64Clz => self.run_clz::(context), - &Opcode::I64Ctz => self.run_ctz::(context), - &Opcode::I64Popcnt => self.run_popcnt::(context), - &Opcode::I64Add => self.run_add::(context), - &Opcode::I64Sub => self.run_sub::(context), - &Opcode::I64Mul => self.run_mul::(context), - &Opcode::I64DivS => self.run_div::(context), - &Opcode::I64DivU => self.run_div::(context), - &Opcode::I64RemS => self.run_rem::(context), - &Opcode::I64RemU => self.run_rem::(context), - &Opcode::I64And => self.run_and::(context), - &Opcode::I64Or => self.run_or::(context), - &Opcode::I64Xor => self.run_xor::(context), - &Opcode::I64Shl => self.run_shl::(context, 0x3F), - &Opcode::I64ShrS => self.run_shr::(context, 0x3F), - &Opcode::I64ShrU => self.run_shr::(context, 0x3F), - &Opcode::I64Rotl => self.run_rotl::(context), - &Opcode::I64Rotr => self.run_rotr::(context), + &Instruction::I64Clz => self.run_clz::(context), + &Instruction::I64Ctz => self.run_ctz::(context), + &Instruction::I64Popcnt => self.run_popcnt::(context), + &Instruction::I64Add => self.run_add::(context), + &Instruction::I64Sub => self.run_sub::(context), + &Instruction::I64Mul => self.run_mul::(context), + &Instruction::I64DivS => self.run_div::(context), + &Instruction::I64DivU => self.run_div::(context), + &Instruction::I64RemS => self.run_rem::(context), + &Instruction::I64RemU => self.run_rem::(context), + &Instruction::I64And => self.run_and::(context), + &Instruction::I64Or => self.run_or::(context), + &Instruction::I64Xor => self.run_xor::(context), + &Instruction::I64Shl => self.run_shl::(context, 0x3F), + &Instruction::I64ShrS => self.run_shr::(context, 0x3F), + &Instruction::I64ShrU => self.run_shr::(context, 0x3F), + &Instruction::I64Rotl => self.run_rotl::(context), + &Instruction::I64Rotr => self.run_rotr::(context), - &Opcode::F32Abs => self.run_abs::(context), - &Opcode::F32Neg => self.run_neg::(context), - &Opcode::F32Ceil => self.run_ceil::(context), - &Opcode::F32Floor => self.run_floor::(context), - &Opcode::F32Trunc => self.run_trunc::(context), - &Opcode::F32Nearest => self.run_nearest::(context), - &Opcode::F32Sqrt => self.run_sqrt::(context), - &Opcode::F32Add => self.run_add::(context), - &Opcode::F32Sub => self.run_sub::(context), - &Opcode::F32Mul => self.run_mul::(context), - &Opcode::F32Div => self.run_div::(context), - &Opcode::F32Min => self.run_min::(context), - &Opcode::F32Max => self.run_max::(context), - &Opcode::F32Copysign => self.run_copysign::(context), + &Instruction::F32Abs => self.run_abs::(context), + &Instruction::F32Neg => self.run_neg::(context), + &Instruction::F32Ceil => self.run_ceil::(context), + &Instruction::F32Floor => self.run_floor::(context), + &Instruction::F32Trunc => self.run_trunc::(context), + &Instruction::F32Nearest => self.run_nearest::(context), + &Instruction::F32Sqrt => self.run_sqrt::(context), + &Instruction::F32Add => self.run_add::(context), + &Instruction::F32Sub => self.run_sub::(context), + &Instruction::F32Mul => self.run_mul::(context), + &Instruction::F32Div => self.run_div::(context), + &Instruction::F32Min => self.run_min::(context), + &Instruction::F32Max => self.run_max::(context), + &Instruction::F32Copysign => self.run_copysign::(context), - &Opcode::F64Abs => self.run_abs::(context), - &Opcode::F64Neg => self.run_neg::(context), - &Opcode::F64Ceil => self.run_ceil::(context), - &Opcode::F64Floor => self.run_floor::(context), - &Opcode::F64Trunc => self.run_trunc::(context), - &Opcode::F64Nearest => self.run_nearest::(context), - &Opcode::F64Sqrt => self.run_sqrt::(context), - &Opcode::F64Add => self.run_add::(context), - &Opcode::F64Sub => self.run_sub::(context), - &Opcode::F64Mul => self.run_mul::(context), - &Opcode::F64Div => self.run_div::(context), - &Opcode::F64Min => self.run_min::(context), - &Opcode::F64Max => self.run_max::(context), - &Opcode::F64Copysign => self.run_copysign::(context), + &Instruction::F64Abs => self.run_abs::(context), + &Instruction::F64Neg => self.run_neg::(context), + &Instruction::F64Ceil => self.run_ceil::(context), + &Instruction::F64Floor => self.run_floor::(context), + &Instruction::F64Trunc => self.run_trunc::(context), + &Instruction::F64Nearest => self.run_nearest::(context), + &Instruction::F64Sqrt => self.run_sqrt::(context), + &Instruction::F64Add => self.run_add::(context), + &Instruction::F64Sub => self.run_sub::(context), + &Instruction::F64Mul => self.run_mul::(context), + &Instruction::F64Div => self.run_div::(context), + &Instruction::F64Min => self.run_min::(context), + &Instruction::F64Max => self.run_max::(context), + &Instruction::F64Copysign => self.run_copysign::(context), - &Opcode::I32WrapI64 => self.run_wrap::(context), - &Opcode::I32TruncSF32 => self.run_trunc_to_int::(context), - &Opcode::I32TruncUF32 => self.run_trunc_to_int::(context), - &Opcode::I32TruncSF64 => self.run_trunc_to_int::(context), - &Opcode::I32TruncUF64 => self.run_trunc_to_int::(context), - &Opcode::I64ExtendSI32 => self.run_extend::(context), - &Opcode::I64ExtendUI32 => self.run_extend::(context), - &Opcode::I64TruncSF32 => self.run_trunc_to_int::(context), - &Opcode::I64TruncUF32 => self.run_trunc_to_int::(context), - &Opcode::I64TruncSF64 => self.run_trunc_to_int::(context), - &Opcode::I64TruncUF64 => self.run_trunc_to_int::(context), - &Opcode::F32ConvertSI32 => self.run_extend::(context), - &Opcode::F32ConvertUI32 => self.run_extend::(context), - &Opcode::F32ConvertSI64 => self.run_wrap::(context), - &Opcode::F32ConvertUI64 => self.run_wrap::(context), - &Opcode::F32DemoteF64 => self.run_wrap::(context), - &Opcode::F64ConvertSI32 => self.run_extend::(context), - &Opcode::F64ConvertUI32 => self.run_extend::(context), - &Opcode::F64ConvertSI64 => self.run_extend::(context), - &Opcode::F64ConvertUI64 => self.run_extend::(context), - &Opcode::F64PromoteF32 => self.run_extend::(context), + &Instruction::I32WrapI64 => self.run_wrap::(context), + &Instruction::I32TruncSF32 => self.run_trunc_to_int::(context), + &Instruction::I32TruncUF32 => self.run_trunc_to_int::(context), + &Instruction::I32TruncSF64 => self.run_trunc_to_int::(context), + &Instruction::I32TruncUF64 => self.run_trunc_to_int::(context), + &Instruction::I64ExtendSI32 => self.run_extend::(context), + &Instruction::I64ExtendUI32 => self.run_extend::(context), + &Instruction::I64TruncSF32 => self.run_trunc_to_int::(context), + &Instruction::I64TruncUF32 => self.run_trunc_to_int::(context), + &Instruction::I64TruncSF64 => self.run_trunc_to_int::(context), + &Instruction::I64TruncUF64 => self.run_trunc_to_int::(context), + &Instruction::F32ConvertSI32 => self.run_extend::(context), + &Instruction::F32ConvertUI32 => self.run_extend::(context), + &Instruction::F32ConvertSI64 => self.run_wrap::(context), + &Instruction::F32ConvertUI64 => self.run_wrap::(context), + &Instruction::F32DemoteF64 => self.run_wrap::(context), + &Instruction::F64ConvertSI32 => self.run_extend::(context), + &Instruction::F64ConvertUI32 => self.run_extend::(context), + &Instruction::F64ConvertSI64 => self.run_extend::(context), + &Instruction::F64ConvertUI64 => self.run_extend::(context), + &Instruction::F64PromoteF32 => self.run_extend::(context), - &Opcode::I32ReinterpretF32 => self.run_reinterpret::(context), - &Opcode::I64ReinterpretF64 => self.run_reinterpret::(context), - &Opcode::F32ReinterpretI32 => self.run_reinterpret::(context), - &Opcode::F64ReinterpretI64 => self.run_reinterpret::(context), + &Instruction::I32ReinterpretF32 => self.run_reinterpret::(context), + &Instruction::I64ReinterpretF64 => self.run_reinterpret::(context), + &Instruction::F32ReinterpretI32 => self.run_reinterpret::(context), + &Instruction::F64ReinterpretI64 => self.run_reinterpret::(context), } } diff --git a/src/validation/func.rs b/src/validation/func.rs index b15acc1..e004bb0 100644 --- a/src/validation/func.rs +++ b/src/validation/func.rs @@ -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 { - use self::Opcode::*; - match *opcode { + fn validate_instruction(context: &mut FunctionValidationContext, instruction: &Instruction) -> Result { + use self::Instruction::*; + match *instruction { Unreachable => Ok(InstructionOutcome::Unreachable), Nop => Ok(InstructionOutcome::ValidateNextInstruction), Block(block_type) => Validator::validate_block(context, block_type), diff --git a/src/validation/mod.rs b/src/validation/mod.rs index 3244173..78f8355 100644 --- a/src/validation/mod.rs +++ b/src/validation/mod.rs @@ -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 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 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) diff --git a/src/validation/tests.rs b/src/validation/tests.rs index 38ad0cc..591c30a 100644 --- a/src/validation/tests.rs +++ b/src/validation/tests.rs @@ -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();