From 0fa1bca956229fa49509524aa7edd087439ea39a Mon Sep 17 00:00:00 2001 From: Henry Gressmann Date: Mon, 26 Feb 2024 15:30:42 +0100 Subject: [PATCH 1/9] chore: preperations for simd support Signed-off-by: Henry Gressmann --- .../src/runtime/interpreter/macros.rs | 4 +- crates/tinywasm/src/runtime/value.rs | 69 +++++++++++-------- crates/tinywasm/tests/generated/2.0.csv | 2 +- crates/types/src/value.rs | 7 ++ 4 files changed, 51 insertions(+), 31 deletions(-) diff --git a/crates/tinywasm/src/runtime/interpreter/macros.rs b/crates/tinywasm/src/runtime/interpreter/macros.rs index 824666d..18330a4 100644 --- a/crates/tinywasm/src/runtime/interpreter/macros.rs +++ b/crates/tinywasm/src/runtime/interpreter/macros.rs @@ -32,7 +32,7 @@ macro_rules! mem_load { let mem = $store.get_mem(mem_idx as usize)?; let mem_ref = mem.borrow_mut(); - let addr = $stack.values.pop()?.raw_value(); + let addr: u64 = $stack.values.pop()?.into(); let addr = $arg.offset.checked_add(addr).ok_or_else(|| { cold(); Error::Trap(crate::Trap::MemoryOutOfBounds { @@ -71,7 +71,7 @@ macro_rules! mem_store { let mem = $store.get_mem(mem_idx as usize)?; let val = $stack.values.pop_t::<$store_type>()?; - let addr = $stack.values.pop()?.raw_value(); + let addr: u64 = $stack.values.pop()?.into(); let val = val as $store_type; let val = val.to_le_bytes(); diff --git a/crates/tinywasm/src/runtime/value.rs b/crates/tinywasm/src/runtime/value.rs index bc78adb..4e1b746 100644 --- a/crates/tinywasm/src/runtime/value.rs +++ b/crates/tinywasm/src/runtime/value.rs @@ -8,39 +8,42 @@ use tinywasm_types::{ValType, WasmValue}; /// See [`WasmValue`] for the public representation. #[derive(Clone, Copy, Default, PartialEq, Eq)] #[repr(transparent)] -pub struct RawWasmValue(u64); +pub struct RawWasmValue([u8; 16]); impl Debug for RawWasmValue { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(f, "RawWasmValue({})", self.0 as i64) // cast to i64 so at least negative numbers for i32 and i64 are printed correctly + write!(f, "RawWasmValue({})", 0) } } impl RawWasmValue { #[inline(always)] - pub fn raw_value(&self) -> u64 { + pub fn raw_value(&self) -> [u8; 16] { self.0 } #[inline] pub fn attach_type(self, ty: ValType) -> WasmValue { match ty { - ValType::I32 => WasmValue::I32(self.0 as i32), - ValType::I64 => WasmValue::I64(self.0 as i64), - ValType::F32 => WasmValue::F32(f32::from_bits(self.0 as u32)), - ValType::F64 => WasmValue::F64(f64::from_bits(self.0)), + ValType::I32 => WasmValue::I32(self.into()), + ValType::I64 => WasmValue::I64(self.into()), + ValType::F32 => WasmValue::F32(f32::from_bits(self.into())), + ValType::F64 => WasmValue::F64(f64::from_bits(self.into())), + ValType::V128 => WasmValue::V128(self.into()), ValType::RefExtern => { - if self.0 == -1i64 as u64 { + let val: i64 = self.into(); + if val < 0 { WasmValue::RefNull(ValType::RefExtern) } else { - WasmValue::RefExtern(self.0 as u32) + WasmValue::RefExtern(val as u32) } } ValType::RefFunc => { - if self.0 == -1i64 as u64 { + let val: i64 = self.into(); + if val < 0 { WasmValue::RefNull(ValType::RefFunc) } else { - WasmValue::RefFunc(self.0 as u32) + WasmValue::RefFunc(val as u32) } } } @@ -51,13 +54,14 @@ impl From for RawWasmValue { #[inline] fn from(v: WasmValue) -> Self { match v { - WasmValue::I32(i) => Self(i as u64), - WasmValue::I64(i) => Self(i as u64), - WasmValue::F32(i) => Self(i.to_bits() as u64), - WasmValue::F64(i) => Self(i.to_bits()), - WasmValue::RefExtern(v) => Self(v as i64 as u64), - WasmValue::RefFunc(v) => Self(v as i64 as u64), - WasmValue::RefNull(_) => Self(-1i64 as u64), + WasmValue::I32(i) => Self::from(i), + WasmValue::I64(i) => Self::from(i), + WasmValue::F32(i) => Self::from(i), + WasmValue::F64(i) => Self::from(i), + WasmValue::V128(i) => Self::from(i), + WasmValue::RefExtern(v) => Self::from(v as i64), + WasmValue::RefFunc(v) => Self::from(v as i64), + WasmValue::RefNull(_) => Self::from(-1i64), } } } @@ -69,7 +73,7 @@ macro_rules! impl_from_raw_wasm_value { #[inline] fn from(value: $type) -> Self { #[allow(clippy::redundant_closure_call)] // the comiler will figure it out :) - Self($to_raw(value)) + Self(u128::to_ne_bytes($to_raw(value))) } } @@ -84,13 +88,22 @@ macro_rules! impl_from_raw_wasm_value { }; } -impl_from_raw_wasm_value!(i32, |x| x as u64, |x| x as i32); -impl_from_raw_wasm_value!(i64, |x| x as u64, |x| x as i64); -impl_from_raw_wasm_value!(f32, |x| f32::to_bits(x) as u64, |x| f32::from_bits(x as u32)); -impl_from_raw_wasm_value!(f64, f64::to_bits, f64::from_bits); +// This all looks like a lot of extra steps, but the compiler will optimize it all away. +// The u128 just makes it a bit easier to write. +impl_from_raw_wasm_value!(i32, |x| x as u128, |x: [u8; 16]| i32::from_ne_bytes(x[0..4].try_into().unwrap())); +impl_from_raw_wasm_value!(i64, |x| x as u128, |x: [u8; 16]| i64::from_ne_bytes(x[0..8].try_into().unwrap())); +impl_from_raw_wasm_value!(f32, |x| f32::to_bits(x) as u128, |x: [u8; 16]| f32::from_bits(u32::from_ne_bytes( + x[0..4].try_into().unwrap() +))); +impl_from_raw_wasm_value!(f64, |x| f64::to_bits(x) as u128, |x: [u8; 16]| f64::from_bits(u64::from_ne_bytes( + x[0..8].try_into().unwrap() +))); -// used for memory load/store -impl_from_raw_wasm_value!(i8, |x| x as u64, |x| x as i8); -impl_from_raw_wasm_value!(i16, |x| x as u64, |x| x as i16); -impl_from_raw_wasm_value!(u32, |x| x as u64, |x| x as u32); -impl_from_raw_wasm_value!(u64, |x| x, |x| x); +impl_from_raw_wasm_value!(u8, |x| x as u128, |x: [u8; 16]| u8::from_ne_bytes(x[0..1].try_into().unwrap())); +impl_from_raw_wasm_value!(u16, |x| x as u128, |x: [u8; 16]| u16::from_ne_bytes(x[0..2].try_into().unwrap())); +impl_from_raw_wasm_value!(u32, |x| x as u128, |x: [u8; 16]| u32::from_ne_bytes(x[0..4].try_into().unwrap())); +impl_from_raw_wasm_value!(u64, |x| x as u128, |x: [u8; 16]| u64::from_ne_bytes(x[0..8].try_into().unwrap())); +impl_from_raw_wasm_value!(u128, |x| x, |x: [u8; 16]| u128::from_ne_bytes(x.try_into().unwrap())); + +impl_from_raw_wasm_value!(i8, |x| x as u128, |x: [u8; 16]| i8::from_ne_bytes(x[0..1].try_into().unwrap())); +impl_from_raw_wasm_value!(i16, |x| x as u128, |x: [u8; 16]| i16::from_ne_bytes(x[0..2].try_into().unwrap())); diff --git a/crates/tinywasm/tests/generated/2.0.csv b/crates/tinywasm/tests/generated/2.0.csv index 495ea38..40ef2ae 100644 --- a/crates/tinywasm/tests/generated/2.0.csv +++ b/crates/tinywasm/tests/generated/2.0.csv @@ -1,3 +1,3 @@ 0.3.0,26722,1161,[{"name":"address.wast","passed":260,"failed":0},{"name":"align.wast","passed":156,"failed":0},{"name":"binary-leb128.wast","passed":91,"failed":0},{"name":"binary.wast","passed":112,"failed":0},{"name":"block.wast","passed":223,"failed":0},{"name":"br.wast","passed":97,"failed":0},{"name":"br_if.wast","passed":118,"failed":0},{"name":"br_table.wast","passed":174,"failed":0},{"name":"bulk.wast","passed":8,"failed":109},{"name":"call.wast","passed":91,"failed":0},{"name":"call_indirect.wast","passed":170,"failed":0},{"name":"comments.wast","passed":8,"failed":0},{"name":"const.wast","passed":778,"failed":0},{"name":"conversions.wast","passed":619,"failed":0},{"name":"custom.wast","passed":11,"failed":0},{"name":"data.wast","passed":61,"failed":0},{"name":"elem.wast","passed":98,"failed":1},{"name":"endianness.wast","passed":69,"failed":0},{"name":"exports.wast","passed":96,"failed":0},{"name":"f32.wast","passed":2514,"failed":0},{"name":"f32_bitwise.wast","passed":364,"failed":0},{"name":"f32_cmp.wast","passed":2407,"failed":0},{"name":"f64.wast","passed":2514,"failed":0},{"name":"f64_bitwise.wast","passed":364,"failed":0},{"name":"f64_cmp.wast","passed":2407,"failed":0},{"name":"fac.wast","passed":8,"failed":0},{"name":"float_exprs.wast","passed":900,"failed":0},{"name":"float_literals.wast","passed":163,"failed":0},{"name":"float_memory.wast","passed":90,"failed":0},{"name":"float_misc.wast","passed":441,"failed":0},{"name":"forward.wast","passed":5,"failed":0},{"name":"func.wast","passed":172,"failed":0},{"name":"func_ptrs.wast","passed":36,"failed":0},{"name":"global.wast","passed":110,"failed":0},{"name":"i32.wast","passed":460,"failed":0},{"name":"i64.wast","passed":416,"failed":0},{"name":"if.wast","passed":241,"failed":0},{"name":"imports.wast","passed":171,"failed":12},{"name":"inline-module.wast","passed":1,"failed":0},{"name":"int_exprs.wast","passed":108,"failed":0},{"name":"int_literals.wast","passed":51,"failed":0},{"name":"labels.wast","passed":29,"failed":0},{"name":"left-to-right.wast","passed":96,"failed":0},{"name":"linking.wast","passed":132,"failed":0},{"name":"load.wast","passed":97,"failed":0},{"name":"local_get.wast","passed":36,"failed":0},{"name":"local_set.wast","passed":53,"failed":0},{"name":"local_tee.wast","passed":97,"failed":0},{"name":"loop.wast","passed":120,"failed":0},{"name":"memory.wast","passed":79,"failed":0},{"name":"memory_copy.wast","passed":3928,"failed":522},{"name":"memory_fill.wast","passed":64,"failed":36},{"name":"memory_grow.wast","passed":96,"failed":0},{"name":"memory_init.wast","passed":177,"failed":63},{"name":"memory_redundancy.wast","passed":8,"failed":0},{"name":"memory_size.wast","passed":42,"failed":0},{"name":"memory_trap.wast","passed":182,"failed":0},{"name":"names.wast","passed":486,"failed":0},{"name":"nop.wast","passed":88,"failed":0},{"name":"ref_func.wast","passed":9,"failed":8},{"name":"ref_is_null.wast","passed":4,"failed":12},{"name":"ref_null.wast","passed":1,"failed":2},{"name":"return.wast","passed":84,"failed":0},{"name":"select.wast","passed":148,"failed":0},{"name":"skip-stack-guard-page.wast","passed":11,"failed":0},{"name":"stack.wast","passed":7,"failed":0},{"name":"start.wast","passed":20,"failed":0},{"name":"store.wast","passed":68,"failed":0},{"name":"switch.wast","passed":28,"failed":0},{"name":"table-sub.wast","passed":2,"failed":0},{"name":"table.wast","passed":19,"failed":0},{"name":"table_copy.wast","passed":1613,"failed":115},{"name":"table_fill.wast","passed":23,"failed":22},{"name":"table_get.wast","passed":10,"failed":6},{"name":"table_grow.wast","passed":21,"failed":29},{"name":"table_init.wast","passed":594,"failed":186},{"name":"table_set.wast","passed":19,"failed":7},{"name":"table_size.wast","passed":8,"failed":31},{"name":"token.wast","passed":58,"failed":0},{"name":"traps.wast","passed":36,"failed":0},{"name":"type.wast","passed":3,"failed":0},{"name":"unreachable.wast","passed":64,"failed":0},{"name":"unreached-invalid.wast","passed":118,"failed":0},{"name":"unreached-valid.wast","passed":7,"failed":0},{"name":"unwind.wast","passed":50,"failed":0},{"name":"utf8-custom-section-id.wast","passed":176,"failed":0},{"name":"utf8-import-field.wast","passed":176,"failed":0},{"name":"utf8-import-module.wast","passed":176,"failed":0},{"name":"utf8-invalid-encoding.wast","passed":176,"failed":0}] 0.4.0,27549,334,[{"name":"address.wast","passed":260,"failed":0},{"name":"align.wast","passed":156,"failed":0},{"name":"binary-leb128.wast","passed":91,"failed":0},{"name":"binary.wast","passed":112,"failed":0},{"name":"block.wast","passed":223,"failed":0},{"name":"br.wast","passed":97,"failed":0},{"name":"br_if.wast","passed":118,"failed":0},{"name":"br_table.wast","passed":174,"failed":0},{"name":"bulk.wast","passed":75,"failed":42},{"name":"call.wast","passed":91,"failed":0},{"name":"call_indirect.wast","passed":170,"failed":0},{"name":"comments.wast","passed":8,"failed":0},{"name":"const.wast","passed":778,"failed":0},{"name":"conversions.wast","passed":619,"failed":0},{"name":"custom.wast","passed":11,"failed":0},{"name":"data.wast","passed":61,"failed":0},{"name":"elem.wast","passed":99,"failed":0},{"name":"endianness.wast","passed":69,"failed":0},{"name":"exports.wast","passed":96,"failed":0},{"name":"f32.wast","passed":2514,"failed":0},{"name":"f32_bitwise.wast","passed":364,"failed":0},{"name":"f32_cmp.wast","passed":2407,"failed":0},{"name":"f64.wast","passed":2514,"failed":0},{"name":"f64_bitwise.wast","passed":364,"failed":0},{"name":"f64_cmp.wast","passed":2407,"failed":0},{"name":"fac.wast","passed":8,"failed":0},{"name":"float_exprs.wast","passed":900,"failed":0},{"name":"float_literals.wast","passed":163,"failed":0},{"name":"float_memory.wast","passed":90,"failed":0},{"name":"float_misc.wast","passed":441,"failed":0},{"name":"forward.wast","passed":5,"failed":0},{"name":"func.wast","passed":172,"failed":0},{"name":"func_ptrs.wast","passed":36,"failed":0},{"name":"global.wast","passed":110,"failed":0},{"name":"i32.wast","passed":460,"failed":0},{"name":"i64.wast","passed":416,"failed":0},{"name":"if.wast","passed":241,"failed":0},{"name":"imports.wast","passed":183,"failed":0},{"name":"inline-module.wast","passed":1,"failed":0},{"name":"int_exprs.wast","passed":108,"failed":0},{"name":"int_literals.wast","passed":51,"failed":0},{"name":"labels.wast","passed":29,"failed":0},{"name":"left-to-right.wast","passed":96,"failed":0},{"name":"linking.wast","passed":132,"failed":0},{"name":"load.wast","passed":97,"failed":0},{"name":"local_get.wast","passed":36,"failed":0},{"name":"local_set.wast","passed":53,"failed":0},{"name":"local_tee.wast","passed":97,"failed":0},{"name":"loop.wast","passed":120,"failed":0},{"name":"memory.wast","passed":79,"failed":0},{"name":"memory_copy.wast","passed":4450,"failed":0},{"name":"memory_fill.wast","passed":100,"failed":0},{"name":"memory_grow.wast","passed":96,"failed":0},{"name":"memory_init.wast","passed":240,"failed":0},{"name":"memory_redundancy.wast","passed":8,"failed":0},{"name":"memory_size.wast","passed":42,"failed":0},{"name":"memory_trap.wast","passed":182,"failed":0},{"name":"names.wast","passed":486,"failed":0},{"name":"nop.wast","passed":88,"failed":0},{"name":"ref_func.wast","passed":9,"failed":8},{"name":"ref_is_null.wast","passed":4,"failed":12},{"name":"ref_null.wast","passed":1,"failed":2},{"name":"return.wast","passed":84,"failed":0},{"name":"select.wast","passed":148,"failed":0},{"name":"skip-stack-guard-page.wast","passed":11,"failed":0},{"name":"stack.wast","passed":7,"failed":0},{"name":"start.wast","passed":20,"failed":0},{"name":"store.wast","passed":68,"failed":0},{"name":"switch.wast","passed":28,"failed":0},{"name":"table-sub.wast","passed":2,"failed":0},{"name":"table.wast","passed":19,"failed":0},{"name":"table_copy.wast","passed":1613,"failed":115},{"name":"table_fill.wast","passed":23,"failed":22},{"name":"table_get.wast","passed":10,"failed":6},{"name":"table_grow.wast","passed":21,"failed":29},{"name":"table_init.wast","passed":720,"failed":60},{"name":"table_set.wast","passed":19,"failed":7},{"name":"table_size.wast","passed":8,"failed":31},{"name":"token.wast","passed":58,"failed":0},{"name":"traps.wast","passed":36,"failed":0},{"name":"type.wast","passed":3,"failed":0},{"name":"unreachable.wast","passed":64,"failed":0},{"name":"unreached-invalid.wast","passed":118,"failed":0},{"name":"unreached-valid.wast","passed":7,"failed":0},{"name":"unwind.wast","passed":50,"failed":0},{"name":"utf8-custom-section-id.wast","passed":176,"failed":0},{"name":"utf8-import-field.wast","passed":176,"failed":0},{"name":"utf8-import-module.wast","passed":176,"failed":0},{"name":"utf8-invalid-encoding.wast","passed":176,"failed":0}] -0.4.1,27552,334,[{"name":"address.wast","passed":260,"failed":0},{"name":"align.wast","passed":156,"failed":0},{"name":"binary-leb128.wast","passed":91,"failed":0},{"name":"binary.wast","passed":112,"failed":0},{"name":"block.wast","passed":223,"failed":0},{"name":"br.wast","passed":97,"failed":0},{"name":"br_if.wast","passed":118,"failed":0},{"name":"br_table.wast","passed":174,"failed":0},{"name":"bulk.wast","passed":75,"failed":42},{"name":"call.wast","passed":91,"failed":0},{"name":"call_indirect.wast","passed":170,"failed":0},{"name":"comments.wast","passed":8,"failed":0},{"name":"const.wast","passed":778,"failed":0},{"name":"conversions.wast","passed":619,"failed":0},{"name":"custom.wast","passed":11,"failed":0},{"name":"data.wast","passed":61,"failed":0},{"name":"elem.wast","passed":99,"failed":0},{"name":"endianness.wast","passed":69,"failed":0},{"name":"exports.wast","passed":96,"failed":0},{"name":"f32.wast","passed":2514,"failed":0},{"name":"f32_bitwise.wast","passed":364,"failed":0},{"name":"f32_cmp.wast","passed":2407,"failed":0},{"name":"f64.wast","passed":2514,"failed":0},{"name":"f64_bitwise.wast","passed":364,"failed":0},{"name":"f64_cmp.wast","passed":2407,"failed":0},{"name":"fac.wast","passed":8,"failed":0},{"name":"float_exprs.wast","passed":900,"failed":0},{"name":"float_literals.wast","passed":163,"failed":0},{"name":"float_memory.wast","passed":90,"failed":0},{"name":"float_misc.wast","passed":441,"failed":0},{"name":"forward.wast","passed":5,"failed":0},{"name":"func.wast","passed":172,"failed":0},{"name":"func_ptrs.wast","passed":36,"failed":0},{"name":"global.wast","passed":110,"failed":0},{"name":"i32.wast","passed":460,"failed":0},{"name":"i64.wast","passed":416,"failed":0},{"name":"if.wast","passed":241,"failed":0},{"name":"imports.wast","passed":186,"failed":0},{"name":"inline-module.wast","passed":1,"failed":0},{"name":"int_exprs.wast","passed":108,"failed":0},{"name":"int_literals.wast","passed":51,"failed":0},{"name":"labels.wast","passed":29,"failed":0},{"name":"left-to-right.wast","passed":96,"failed":0},{"name":"linking.wast","passed":132,"failed":0},{"name":"load.wast","passed":97,"failed":0},{"name":"local_get.wast","passed":36,"failed":0},{"name":"local_set.wast","passed":53,"failed":0},{"name":"local_tee.wast","passed":97,"failed":0},{"name":"loop.wast","passed":120,"failed":0},{"name":"memory.wast","passed":79,"failed":0},{"name":"memory_copy.wast","passed":4450,"failed":0},{"name":"memory_fill.wast","passed":100,"failed":0},{"name":"memory_grow.wast","passed":96,"failed":0},{"name":"memory_init.wast","passed":240,"failed":0},{"name":"memory_redundancy.wast","passed":8,"failed":0},{"name":"memory_size.wast","passed":42,"failed":0},{"name":"memory_trap.wast","passed":182,"failed":0},{"name":"names.wast","passed":486,"failed":0},{"name":"nop.wast","passed":88,"failed":0},{"name":"ref_func.wast","passed":9,"failed":8},{"name":"ref_is_null.wast","passed":4,"failed":12},{"name":"ref_null.wast","passed":1,"failed":2},{"name":"return.wast","passed":84,"failed":0},{"name":"select.wast","passed":148,"failed":0},{"name":"skip-stack-guard-page.wast","passed":11,"failed":0},{"name":"stack.wast","passed":7,"failed":0},{"name":"start.wast","passed":20,"failed":0},{"name":"store.wast","passed":68,"failed":0},{"name":"switch.wast","passed":28,"failed":0},{"name":"table-sub.wast","passed":2,"failed":0},{"name":"table.wast","passed":19,"failed":0},{"name":"table_copy.wast","passed":1613,"failed":115},{"name":"table_fill.wast","passed":23,"failed":22},{"name":"table_get.wast","passed":10,"failed":6},{"name":"table_grow.wast","passed":21,"failed":29},{"name":"table_init.wast","passed":720,"failed":60},{"name":"table_set.wast","passed":19,"failed":7},{"name":"table_size.wast","passed":8,"failed":31},{"name":"token.wast","passed":58,"failed":0},{"name":"traps.wast","passed":36,"failed":0},{"name":"type.wast","passed":3,"failed":0},{"name":"unreachable.wast","passed":64,"failed":0},{"name":"unreached-invalid.wast","passed":118,"failed":0},{"name":"unreached-valid.wast","passed":7,"failed":0},{"name":"unwind.wast","passed":50,"failed":0},{"name":"utf8-custom-section-id.wast","passed":176,"failed":0},{"name":"utf8-import-field.wast","passed":176,"failed":0},{"name":"utf8-import-module.wast","passed":176,"failed":0},{"name":"utf8-invalid-encoding.wast","passed":176,"failed":0}] +0.4.1,27551,335,[{"name":"address.wast","passed":260,"failed":0},{"name":"align.wast","passed":156,"failed":0},{"name":"binary-leb128.wast","passed":91,"failed":0},{"name":"binary.wast","passed":112,"failed":0},{"name":"block.wast","passed":223,"failed":0},{"name":"br.wast","passed":97,"failed":0},{"name":"br_if.wast","passed":118,"failed":0},{"name":"br_table.wast","passed":174,"failed":0},{"name":"bulk.wast","passed":75,"failed":42},{"name":"call.wast","passed":91,"failed":0},{"name":"call_indirect.wast","passed":170,"failed":0},{"name":"comments.wast","passed":8,"failed":0},{"name":"const.wast","passed":778,"failed":0},{"name":"conversions.wast","passed":619,"failed":0},{"name":"custom.wast","passed":11,"failed":0},{"name":"data.wast","passed":61,"failed":0},{"name":"elem.wast","passed":99,"failed":0},{"name":"endianness.wast","passed":69,"failed":0},{"name":"exports.wast","passed":96,"failed":0},{"name":"f32.wast","passed":2514,"failed":0},{"name":"f32_bitwise.wast","passed":364,"failed":0},{"name":"f32_cmp.wast","passed":2407,"failed":0},{"name":"f64.wast","passed":2514,"failed":0},{"name":"f64_bitwise.wast","passed":364,"failed":0},{"name":"f64_cmp.wast","passed":2407,"failed":0},{"name":"fac.wast","passed":8,"failed":0},{"name":"float_exprs.wast","passed":900,"failed":0},{"name":"float_literals.wast","passed":163,"failed":0},{"name":"float_memory.wast","passed":90,"failed":0},{"name":"float_misc.wast","passed":441,"failed":0},{"name":"forward.wast","passed":5,"failed":0},{"name":"func.wast","passed":172,"failed":0},{"name":"func_ptrs.wast","passed":36,"failed":0},{"name":"global.wast","passed":110,"failed":0},{"name":"i32.wast","passed":460,"failed":0},{"name":"i64.wast","passed":416,"failed":0},{"name":"if.wast","passed":241,"failed":0},{"name":"imports.wast","passed":186,"failed":0},{"name":"inline-module.wast","passed":1,"failed":0},{"name":"int_exprs.wast","passed":108,"failed":0},{"name":"int_literals.wast","passed":51,"failed":0},{"name":"labels.wast","passed":29,"failed":0},{"name":"left-to-right.wast","passed":96,"failed":0},{"name":"linking.wast","passed":132,"failed":0},{"name":"load.wast","passed":97,"failed":0},{"name":"local_get.wast","passed":36,"failed":0},{"name":"local_set.wast","passed":53,"failed":0},{"name":"local_tee.wast","passed":97,"failed":0},{"name":"loop.wast","passed":120,"failed":0},{"name":"memory.wast","passed":79,"failed":0},{"name":"memory_copy.wast","passed":4450,"failed":0},{"name":"memory_fill.wast","passed":100,"failed":0},{"name":"memory_grow.wast","passed":96,"failed":0},{"name":"memory_init.wast","passed":240,"failed":0},{"name":"memory_redundancy.wast","passed":8,"failed":0},{"name":"memory_size.wast","passed":42,"failed":0},{"name":"memory_trap.wast","passed":182,"failed":0},{"name":"names.wast","passed":486,"failed":0},{"name":"nop.wast","passed":88,"failed":0},{"name":"ref_func.wast","passed":9,"failed":8},{"name":"ref_is_null.wast","passed":4,"failed":12},{"name":"ref_null.wast","passed":1,"failed":2},{"name":"return.wast","passed":84,"failed":0},{"name":"select.wast","passed":148,"failed":0},{"name":"skip-stack-guard-page.wast","passed":11,"failed":0},{"name":"stack.wast","passed":7,"failed":0},{"name":"start.wast","passed":20,"failed":0},{"name":"store.wast","passed":68,"failed":0},{"name":"switch.wast","passed":28,"failed":0},{"name":"table-sub.wast","passed":2,"failed":0},{"name":"table.wast","passed":19,"failed":0},{"name":"table_copy.wast","passed":1613,"failed":115},{"name":"table_fill.wast","passed":23,"failed":22},{"name":"table_get.wast","passed":10,"failed":6},{"name":"table_grow.wast","passed":21,"failed":29},{"name":"table_init.wast","passed":719,"failed":61},{"name":"table_set.wast","passed":19,"failed":7},{"name":"table_size.wast","passed":8,"failed":31},{"name":"token.wast","passed":58,"failed":0},{"name":"traps.wast","passed":36,"failed":0},{"name":"type.wast","passed":3,"failed":0},{"name":"unreachable.wast","passed":64,"failed":0},{"name":"unreached-invalid.wast","passed":118,"failed":0},{"name":"unreached-valid.wast","passed":7,"failed":0},{"name":"unwind.wast","passed":50,"failed":0},{"name":"utf8-custom-section-id.wast","passed":176,"failed":0},{"name":"utf8-import-field.wast","passed":176,"failed":0},{"name":"utf8-import-module.wast","passed":176,"failed":0},{"name":"utf8-invalid-encoding.wast","passed":176,"failed":0}] diff --git a/crates/types/src/value.rs b/crates/types/src/value.rs index 24fed3b..3c02e55 100644 --- a/crates/types/src/value.rs +++ b/crates/types/src/value.rs @@ -16,6 +16,8 @@ pub enum WasmValue { F32(f32), /// A 64-bit float. F64(f64), + /// A half of a 128-bit vector. Allways used in pairs. + V128(u128), RefExtern(ExternAddr), RefFunc(FuncAddr), @@ -47,6 +49,7 @@ impl WasmValue { ValType::I64 => Self::I64(0), ValType::F32 => Self::F32(0.0), ValType::F64 => Self::F64(0.0), + ValType::V128 => Self::V128(0), ValType::RefFunc => Self::RefNull(ValType::RefFunc), ValType::RefExtern => Self::RefNull(ValType::RefExtern), } @@ -89,6 +92,7 @@ impl Debug for WasmValue { WasmValue::I64(i) => write!(f, "i64({})", i), WasmValue::F32(i) => write!(f, "f32({})", i), WasmValue::F64(i) => write!(f, "f64({})", i), + WasmValue::V128(i) => write!(f, "v128.half({:?})", i), WasmValue::RefExtern(addr) => write!(f, "ref.extern({:?})", addr), WasmValue::RefFunc(addr) => write!(f, "ref.func({:?})", addr), WasmValue::RefNull(ty) => write!(f, "ref.null({:?})", ty), @@ -105,6 +109,7 @@ impl WasmValue { Self::I64(_) => ValType::I64, Self::F32(_) => ValType::F32, Self::F64(_) => ValType::F64, + Self::V128(_) => ValType::V128, Self::RefExtern(_) => ValType::RefExtern, Self::RefFunc(_) => ValType::RefFunc, Self::RefNull(ty) => *ty, @@ -124,6 +129,8 @@ pub enum ValType { F32, /// A 64-bit float. F64, + /// A half of a 128-bit vector. Allways used in pairs. + V128, /// A reference to a function. RefFunc, /// A reference to an external value. From 5e573f0765570e0aaf6c9415b652b25d5bddebd9 Mon Sep 17 00:00:00 2001 From: Henry Gressmann Date: Tue, 27 Feb 2024 00:17:09 +0100 Subject: [PATCH 2/9] no more simd Signed-off-by: Henry Gressmann --- crates/benchmarks/benches/fibonacci.rs | 6 +- crates/parser/src/visit.rs | 69 +++++++++- .../src/runtime/interpreter/macros.rs | 2 +- .../tinywasm/src/runtime/interpreter/mod.rs | 129 +++++++++++------- .../tinywasm/src/runtime/stack/call_stack.rs | 12 +- .../tinywasm/src/runtime/stack/value_stack.rs | 10 +- crates/tinywasm/src/runtime/value.rs | 42 +++--- crates/types/src/instructions.rs | 26 ++++ crates/types/src/value.rs | 15 +- examples/rust/analyze.py | 36 +++++ 10 files changed, 250 insertions(+), 97 deletions(-) create mode 100644 examples/rust/analyze.py diff --git a/crates/benchmarks/benches/fibonacci.rs b/crates/benchmarks/benches/fibonacci.rs index 38bbde9..8a4dab2 100644 --- a/crates/benchmarks/benches/fibonacci.rs +++ b/crates/benchmarks/benches/fibonacci.rs @@ -17,10 +17,10 @@ fn run_wasmi(wasm: &[u8], iterations: i32, name: &str) { fn run_wasmer(wasm: &[u8], iterations: i32, name: &str) { use wasmer::*; - let engine: Engine = wasmer::Singlepass::default().into(); - let mut store = Store::default(); + let compiler = wasmer::Singlepass::default(); + let mut store = Store::new(compiler); let import_object = imports! {}; - let module = wasmer::Module::from_binary(&engine, wasm).expect("wasmer::Module::from_binary"); + let module = wasmer::Module::from_binary(&store, wasm).expect("wasmer::Module::from_binary"); let instance = Instance::new(&mut store, &module, &import_object).expect("Instance::new"); let fib = instance.exports.get_typed_function::(&store, name).expect("get_function"); fib.call(&mut store, iterations).expect("call"); diff --git a/crates/parser/src/visit.rs b/crates/parser/src/visit.rs index 15024f1..9038567 100644 --- a/crates/parser/src/visit.rs +++ b/crates/parser/src/visit.rs @@ -142,9 +142,6 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { define_primitive_operands! { visit_br, Instruction::Br, u32, visit_br_if, Instruction::BrIf, u32, - visit_local_get, Instruction::LocalGet, u32, - visit_local_set, Instruction::LocalSet, u32, - visit_local_tee, Instruction::LocalTee, u32, visit_global_get, Instruction::GlobalGet, u32, visit_global_set, Instruction::GlobalSet, u32, visit_i32_const, Instruction::I32Const, i32, @@ -220,7 +217,7 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { visit_i32_clz, Instruction::I32Clz, visit_i32_ctz, Instruction::I32Ctz, visit_i32_popcnt, Instruction::I32Popcnt, - visit_i32_add, Instruction::I32Add, + // visit_i32_add, Instruction::I32Add, custom implementation visit_i32_sub, Instruction::I32Sub, visit_i32_mul, Instruction::I32Mul, visit_i32_div_s, Instruction::I32DivS, @@ -251,7 +248,7 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { visit_i64_shl, Instruction::I64Shl, visit_i64_shr_s, Instruction::I64ShrS, visit_i64_shr_u, Instruction::I64ShrU, - visit_i64_rotl, Instruction::I64Rotl, + // visit_i64_rotl, Instruction::I64Rotl, custom implementation visit_i64_rotr, Instruction::I64Rotr, visit_f32_abs, Instruction::F32Abs, visit_f32_neg, Instruction::F32Neg, @@ -325,6 +322,68 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { visit_i64_trunc_sat_f64_u, Instruction::I64TruncSatF64U } + fn visit_local_get(&mut self, idx: u32) -> Self::Output { + if let Some(instruction) = self.instructions.last_mut() { + match instruction { + // Instruction::LocalGet(a) => *instruction = Instruction::LocalGet2(*a, idx), + // Instruction::LocalGet2(a, b) => *instruction = Instruction::LocalGet3(*a, *b, idx), + // Instruction::LocalGet3(a, b, c) => *instruction = Instruction::LocalGet4(*a, *b, *c, idx), + // Instruction::LocalTee(a) => *instruction = Instruction::LocalTeeGet(*a, idx), + _ => return self.visit(Instruction::LocalGet(idx)), + }; + Ok(()) + } else { + self.visit(Instruction::LocalGet(idx)) + } + } + + fn visit_local_set(&mut self, idx: u32) -> Self::Output { + // LocalGetSet + if let Some(instruction) = self.instructions.last_mut() { + match instruction { + // Instruction::LocalGet(a) => *instruction = Instruction::LocalGetSet(*a, idx), + _ => return self.visit(Instruction::LocalSet(idx)), + }; + Ok(()) + } else { + self.visit(Instruction::LocalSet(idx)) + } + } + + fn visit_local_tee(&mut self, idx: u32) -> Self::Output { + self.visit(Instruction::LocalTee(idx)) + } + + fn visit_i64_rotl(&mut self) -> Self::Output { + if self.instructions.len() < 2 { + return self.visit(Instruction::I64Rotl); + } + + match self.instructions[self.instructions.len() - 2..] { + // [Instruction::I64Xor, Instruction::I64Const(a)] => { + // self.instructions.pop(); + // self.instructions.pop(); + // self.visit(Instruction::I64XorConstRotl(a)) + // } + _ => self.visit(Instruction::I64Rotl), + } + } + + fn visit_i32_add(&mut self) -> Self::Output { + if self.instructions.len() < 2 { + return self.visit(Instruction::I32Add); + } + + match self.instructions[self.instructions.len() - 2..] { + // [Instruction::LocalGet(a), Instruction::I32Const(b)] => { + // self.instructions.pop(); + // self.instructions.pop(); + // self.visit(Instruction::I32LocalGetConstAdd(a, b)) + // } + _ => self.visit(Instruction::I32Add), + } + } + fn visit_block(&mut self, blockty: wasmparser::BlockType) -> Self::Output { self.label_ptrs.push(self.instructions.len()); self.visit(Instruction::Block(convert_blocktype(blockty), 0)) diff --git a/crates/tinywasm/src/runtime/interpreter/macros.rs b/crates/tinywasm/src/runtime/interpreter/macros.rs index 18330a4..1da8758 100644 --- a/crates/tinywasm/src/runtime/interpreter/macros.rs +++ b/crates/tinywasm/src/runtime/interpreter/macros.rs @@ -11,7 +11,7 @@ // from a function, so we need to check if the label stack is empty macro_rules! break_to { ($cf:ident, $stack:ident, $break_to_relative:ident) => {{ - if $cf.break_to(*$break_to_relative, &mut $stack.values, &mut $stack.blocks).is_none() { + if $cf.break_to($break_to_relative, &mut $stack.values, &mut $stack.blocks).is_none() { if $stack.call_stack.is_empty() { return Ok(ExecResult::Return); } else { diff --git a/crates/tinywasm/src/runtime/interpreter/mod.rs b/crates/tinywasm/src/runtime/interpreter/mod.rs index b06152d..57e5f34 100644 --- a/crates/tinywasm/src/runtime/interpreter/mod.rs +++ b/crates/tinywasm/src/runtime/interpreter/mod.rs @@ -89,7 +89,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M // unreasonable complexity // See https://pliniker.github.io/post/dispatchers/ use tinywasm_types::Instruction::*; - match &instrs[cf.instr_ptr] { + match cf.current_instruction() { Nop => { /* do nothing */ } Unreachable => { cold(); @@ -113,7 +113,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M Call(v) => { // prepare the call frame - let func_idx = module.resolve_func_addr(*v); + let func_idx = module.resolve_func_addr(v); let func_inst = store.get_func(func_idx as usize)?.clone(); let wasm_func = match &func_inst.func { @@ -140,7 +140,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } CallIndirect(type_addr, table_addr) => { - let table = store.get_table(module.resolve_table_addr(*table_addr) as usize)?; + let table = store.get_table(module.resolve_table_addr(table_addr) as usize)?; let table_idx = stack.values.pop_t::()?; // verify that the table is of the right type, this should be validated by the parser already @@ -155,7 +155,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M }; let func_inst = store.get_func(func_ref as usize)?.clone(); - let call_ty = module.func_ty(*type_addr); + let call_ty = module.func_ty(type_addr); let wasm_func = match func_inst.func { crate::Function::Wasm(ref f) => f.clone(), @@ -202,10 +202,10 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M cf.enter_block( BlockFrame::new( cf.instr_ptr, - cf.instr_ptr + *end_offset, + cf.instr_ptr + end_offset, stack.values.len(), BlockType::If, - args, + &args, module, ), &mut stack.values, @@ -217,17 +217,17 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M // falsy value is on the top of the stack if let Some(else_offset) = else_offset { let label = BlockFrame::new( - cf.instr_ptr + *else_offset, - cf.instr_ptr + *end_offset, + cf.instr_ptr + else_offset, + cf.instr_ptr + end_offset, stack.values.len(), BlockType::Else, - args, + &args, module, ); - cf.instr_ptr += *else_offset; + cf.instr_ptr += else_offset; cf.enter_block(label, &mut stack.values, &mut stack.blocks); } else { - cf.instr_ptr += *end_offset; + cf.instr_ptr += end_offset; } } @@ -235,10 +235,10 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M cf.enter_block( BlockFrame::new( cf.instr_ptr, - cf.instr_ptr + *end_offset, + cf.instr_ptr + end_offset, stack.values.len(), BlockType::Loop, - args, + &args, module, ), &mut stack.values, @@ -250,10 +250,10 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M cf.enter_block( BlockFrame::new( cf.instr_ptr, - cf.instr_ptr + *end_offset, + cf.instr_ptr + end_offset, stack.values.len(), // - params, BlockType::Block, - args, + &args, module, ), &mut stack.values, @@ -262,7 +262,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } BrTable(default, len) => { - let instr = instrs[cf.instr_ptr + 1..cf.instr_ptr + 1 + *len] + let instr = cf.instructions()[cf.instr_ptr + 1..cf.instr_ptr + 1 + len] .iter() .map(|i| match i { BrLabel(l) => Ok(*l), @@ -273,7 +273,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M }) .collect::>>()?; - if unlikely(instr.len() != *len) { + if unlikely(instr.len() != len) { panic!( "Expected {} BrLabel instructions, got {}, this should have been validated by the parser", len, @@ -282,7 +282,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } let idx = stack.values.pop_t::()? as usize; - let to = instr.get(idx).unwrap_or(default); + let to = *instr.get(idx).unwrap_or(&default); break_to!(cf, stack, to); } @@ -319,7 +319,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M let res_count = block.results; stack.values.truncate_keep(block.stack_ptr, res_count); - cf.instr_ptr += *end_offset; + cf.instr_ptr += end_offset; } EndBlockFrame => { @@ -332,55 +332,53 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M stack.values.truncate_keep(block.stack_ptr, block.results); } - LocalGet(local_index) => stack.values.push(cf.get_local(*local_index as usize)), - LocalSet(local_index) => cf.set_local(*local_index as usize, stack.values.pop()?), + LocalGet(local_index) => stack.values.push(cf.get_local(local_index as usize)), + LocalSet(local_index) => cf.set_local(local_index as usize, stack.values.pop()?), LocalTee(local_index) => { - let last_val = match stack.values.last() { - Ok(val) => val, - Err(_) => { - log::error!("index: {}", local_index); - log::error!("stack: {:?}", stack.values); - - panic!(); - } - }; - cf.set_local(*local_index as usize, *last_val) + cf.set_local( + local_index as usize, + stack + .values + .last() + .expect("localtee: stack is empty. this should have been validated by the parser") + .clone(), + ); } GlobalGet(global_index) => { - let idx = module.resolve_global_addr(*global_index); + let idx = module.resolve_global_addr(global_index); let global = store.get_global_val(idx as usize)?; stack.values.push(global); } GlobalSet(global_index) => { - let idx = module.resolve_global_addr(*global_index); + let idx = module.resolve_global_addr(global_index); store.set_global_val(idx as usize, stack.values.pop()?)?; } - I32Const(val) => stack.values.push((*val).into()), - I64Const(val) => stack.values.push((*val).into()), - F32Const(val) => stack.values.push((*val).into()), - F64Const(val) => stack.values.push((*val).into()), + I32Const(val) => stack.values.push((val).into()), + I64Const(val) => stack.values.push((val).into()), + F32Const(val) => stack.values.push((val).into()), + F64Const(val) => stack.values.push((val).into()), MemorySize(addr, byte) => { - if *byte != 0 { + if byte != 0 { cold(); return Err(Error::UnsupportedFeature("memory.size with byte != 0".to_string())); } - let mem_idx = module.resolve_mem_addr(*addr); + let mem_idx = module.resolve_mem_addr(addr); let mem = store.get_mem(mem_idx as usize)?; stack.values.push((mem.borrow().page_count() as i32).into()); } MemoryGrow(addr, byte) => { - if *byte != 0 { + if byte != 0 { cold(); return Err(Error::UnsupportedFeature("memory.grow with byte != 0".to_string())); } - let mem_idx = module.resolve_mem_addr(*addr); + let mem_idx = module.resolve_mem_addr(addr); let mem = store.get_mem(mem_idx as usize)?; let (res, prev_size) = { @@ -401,7 +399,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M let src = stack.values.pop_t::()?; let dst = stack.values.pop_t::()?; - let mem = store.get_mem(module.resolve_mem_addr(*from) as usize)?; + let mem = store.get_mem(module.resolve_mem_addr(from) as usize)?; let mut mem = mem.borrow_mut(); if from == to { @@ -409,7 +407,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M mem.copy_within(dst as usize, src as usize, size as usize)?; } else { // copy between two memories - let mem2 = store.get_mem(module.resolve_mem_addr(*to) as usize)?; + let mem2 = store.get_mem(module.resolve_mem_addr(to) as usize)?; let mut mem2 = mem2.borrow_mut(); mem2.copy_from_slice(dst as usize, mem.load(src as usize, 0, size as usize)?)?; } @@ -420,7 +418,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M let val = stack.values.pop_t::()?; let dst = stack.values.pop_t::()?; - let mem = store.get_mem(module.resolve_mem_addr(*addr) as usize)?; + let mem = store.get_mem(module.resolve_mem_addr(addr) as usize)?; let mut mem = mem.borrow_mut(); mem.fill(dst as usize, size as usize, val as u8)?; } @@ -430,13 +428,13 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M let offset = stack.values.pop_t::()? as usize; let dst = stack.values.pop_t::()? as usize; - let data_idx = module.resolve_data_addr(*data_index); + let data_idx = module.resolve_data_addr(data_index); let Some(ref data) = store.get_data(data_idx as usize)?.data else { cold(); return Err(Trap::MemoryOutOfBounds { offset: 0, len: 0, max: 0 }.into()); }; - let mem_idx = module.resolve_mem_addr(*mem_index); + let mem_idx = module.resolve_mem_addr(mem_index); let mem = store.get_mem(mem_idx as usize)?; let data_len = data.len(); @@ -453,7 +451,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } DataDrop(data_index) => { - let data_idx = module.resolve_data_addr(*data_index); + let data_idx = module.resolve_data_addr(data_index); let data = store.get_data_mut(data_idx as usize)?; data.drop(); } @@ -632,7 +630,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M I64TruncF64U => checked_conv_float!(f64, u64, i64, stack), TableGet(table_index) => { - let table_idx = module.resolve_table_addr(*table_index); + let table_idx = module.resolve_table_addr(table_index); let table = store.get_table(table_idx as usize)?; let idx = stack.values.pop_t::()? as usize; let v = table.borrow().get_wasm_val(idx)?; @@ -640,7 +638,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } TableSet(table_index) => { - let table_idx = module.resolve_table_addr(*table_index); + let table_idx = module.resolve_table_addr(table_index); let table = store.get_table(table_idx as usize)?; let val = stack.values.pop_t::()?; let idx = stack.values.pop_t::()? as usize; @@ -648,16 +646,16 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } TableSize(table_index) => { - let table_idx = module.resolve_table_addr(*table_index); + let table_idx = module.resolve_table_addr(table_index); let table = store.get_table(table_idx as usize)?; stack.values.push(table.borrow().size().into()); } TableInit(table_index, elem_index) => { - let table_idx = module.resolve_table_addr(*table_index); + let table_idx = module.resolve_table_addr(table_index); let table = store.get_table(table_idx as usize)?; - let elem_idx = module.resolve_elem_addr(*elem_index); + let elem_idx = module.resolve_elem_addr(elem_index); let elem = store.get_elem(elem_idx as usize)?; if let ElementKind::Passive = elem.kind { @@ -680,6 +678,33 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M I64TruncSatF64S => arithmetic_single!(trunc, f64, i64, stack), I64TruncSatF64U => arithmetic_single!(trunc, f64, u64, stack), + // custom instructions + LocalGet2(a, b) => { + stack.values.push(cf.get_local(a as usize)); + stack.values.push(cf.get_local(b as usize)); + } + LocalGet3(a, b, c) => { + stack.values.push(cf.get_local(a as usize)); + stack.values.push(cf.get_local(b as usize)); + stack.values.push(cf.get_local(c as usize)); + } + LocalGet4(a, b, c, d) => { + stack.values.push(cf.get_local(a as usize)); + stack.values.push(cf.get_local(b as usize)); + stack.values.push(cf.get_local(c as usize)); + stack.values.push(cf.get_local(d as usize)); + } + LocalTeeGet(a, b) => { + let last = + *stack.values.last().expect("localtee: stack is empty. this should have been validated by the parser"); + cf.set_local(a as usize, last); + stack.values.push(cf.get_local(b as usize)); + } + + // LocalTeeGet + // LocalGetSet + // I64XorConstRotl + // I32LocalGetConstAdd i => { cold(); log::error!("unimplemented instruction: {:?}", i); diff --git a/crates/tinywasm/src/runtime/stack/call_stack.rs b/crates/tinywasm/src/runtime/stack/call_stack.rs index 1c441a8..dd80bb7 100644 --- a/crates/tinywasm/src/runtime/stack/call_stack.rs +++ b/crates/tinywasm/src/runtime/stack/call_stack.rs @@ -1,5 +1,5 @@ use alloc::{boxed::Box, rc::Rc, vec::Vec}; -use tinywasm_types::{ModuleInstanceAddr, WasmFunction}; +use tinywasm_types::{Instruction, ModuleInstanceAddr, WasmFunction}; use crate::runtime::{BlockType, RawWasmValue}; use crate::unlikely; @@ -142,4 +142,14 @@ impl CallFrame { pub(crate) fn get_local(&self, local_index: usize) -> RawWasmValue { self.locals[local_index] } + + #[inline] + pub(crate) fn instructions(&self) -> &[Instruction] { + &self.func_instance.0.instructions + } + + #[inline(always)] + pub(crate) fn current_instruction(&self) -> Instruction { + self.func_instance.0.instructions[self.instr_ptr] + } } diff --git a/crates/tinywasm/src/runtime/stack/value_stack.rs b/crates/tinywasm/src/runtime/stack/value_stack.rs index 9649177..be5b53b 100644 --- a/crates/tinywasm/src/runtime/stack/value_stack.rs +++ b/crates/tinywasm/src/runtime/stack/value_stack.rs @@ -58,14 +58,8 @@ impl ValueStack { } #[inline] - pub(crate) fn last(&self) -> Result<&RawWasmValue> { - match self.stack.last() { - Some(v) => Ok(v), - None => { - cold(); - Err(Error::ValueStackUnderflow) - } - } + pub(crate) fn last(&self) -> Option<&RawWasmValue> { + self.stack.last() } #[inline] diff --git a/crates/tinywasm/src/runtime/value.rs b/crates/tinywasm/src/runtime/value.rs index 4e1b746..56fdf60 100644 --- a/crates/tinywasm/src/runtime/value.rs +++ b/crates/tinywasm/src/runtime/value.rs @@ -8,7 +8,8 @@ use tinywasm_types::{ValType, WasmValue}; /// See [`WasmValue`] for the public representation. #[derive(Clone, Copy, Default, PartialEq, Eq)] #[repr(transparent)] -pub struct RawWasmValue([u8; 16]); +// pub struct RawWasmValue([u8; 16]); +pub struct RawWasmValue([u8; 8]); impl Debug for RawWasmValue { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { @@ -18,7 +19,7 @@ impl Debug for RawWasmValue { impl RawWasmValue { #[inline(always)] - pub fn raw_value(&self) -> [u8; 16] { + pub fn raw_value(&self) -> [u8; 8] { self.0 } @@ -29,7 +30,7 @@ impl RawWasmValue { ValType::I64 => WasmValue::I64(self.into()), ValType::F32 => WasmValue::F32(f32::from_bits(self.into())), ValType::F64 => WasmValue::F64(f64::from_bits(self.into())), - ValType::V128 => WasmValue::V128(self.into()), + // ValType::V128 => WasmValue::V128(self.into()), ValType::RefExtern => { let val: i64 = self.into(); if val < 0 { @@ -58,7 +59,7 @@ impl From for RawWasmValue { WasmValue::I64(i) => Self::from(i), WasmValue::F32(i) => Self::from(i), WasmValue::F64(i) => Self::from(i), - WasmValue::V128(i) => Self::from(i), + // WasmValue::V128(i) => Self::from(i), WasmValue::RefExtern(v) => Self::from(v as i64), WasmValue::RefFunc(v) => Self::from(v as i64), WasmValue::RefNull(_) => Self::from(-1i64), @@ -72,8 +73,8 @@ macro_rules! impl_from_raw_wasm_value { impl From<$type> for RawWasmValue { #[inline] fn from(value: $type) -> Self { - #[allow(clippy::redundant_closure_call)] // the comiler will figure it out :) - Self(u128::to_ne_bytes($to_raw(value))) + #[allow(clippy::redundant_closure_call)] + Self(u64::to_ne_bytes($to_raw(value))) } } @@ -81,29 +82,32 @@ macro_rules! impl_from_raw_wasm_value { impl From for $type { #[inline] fn from(value: RawWasmValue) -> Self { - #[allow(clippy::redundant_closure_call)] // the comiler will figure it out :) + #[allow(clippy::redundant_closure_call)] $from_raw(value.0) } } }; } +type RawValue = u64; +type RawValueRep = [u8; 8]; + // This all looks like a lot of extra steps, but the compiler will optimize it all away. -// The u128 just makes it a bit easier to write. -impl_from_raw_wasm_value!(i32, |x| x as u128, |x: [u8; 16]| i32::from_ne_bytes(x[0..4].try_into().unwrap())); -impl_from_raw_wasm_value!(i64, |x| x as u128, |x: [u8; 16]| i64::from_ne_bytes(x[0..8].try_into().unwrap())); -impl_from_raw_wasm_value!(f32, |x| f32::to_bits(x) as u128, |x: [u8; 16]| f32::from_bits(u32::from_ne_bytes( +// The `u128` is used to make the conversion easier to write. +impl_from_raw_wasm_value!(i32, |x| x as RawValue, |x: RawValueRep| i32::from_ne_bytes(x[0..4].try_into().unwrap())); +impl_from_raw_wasm_value!(i64, |x| x as RawValue, |x: RawValueRep| i64::from_ne_bytes(x[0..8].try_into().unwrap())); +impl_from_raw_wasm_value!(f32, |x| f32::to_bits(x) as RawValue, |x: RawValueRep| f32::from_bits(u32::from_ne_bytes( x[0..4].try_into().unwrap() ))); -impl_from_raw_wasm_value!(f64, |x| f64::to_bits(x) as u128, |x: [u8; 16]| f64::from_bits(u64::from_ne_bytes( +impl_from_raw_wasm_value!(f64, |x| f64::to_bits(x) as RawValue, |x: RawValueRep| f64::from_bits(u64::from_ne_bytes( x[0..8].try_into().unwrap() ))); -impl_from_raw_wasm_value!(u8, |x| x as u128, |x: [u8; 16]| u8::from_ne_bytes(x[0..1].try_into().unwrap())); -impl_from_raw_wasm_value!(u16, |x| x as u128, |x: [u8; 16]| u16::from_ne_bytes(x[0..2].try_into().unwrap())); -impl_from_raw_wasm_value!(u32, |x| x as u128, |x: [u8; 16]| u32::from_ne_bytes(x[0..4].try_into().unwrap())); -impl_from_raw_wasm_value!(u64, |x| x as u128, |x: [u8; 16]| u64::from_ne_bytes(x[0..8].try_into().unwrap())); -impl_from_raw_wasm_value!(u128, |x| x, |x: [u8; 16]| u128::from_ne_bytes(x.try_into().unwrap())); +impl_from_raw_wasm_value!(u8, |x| x as RawValue, |x: RawValueRep| u8::from_ne_bytes(x[0..1].try_into().unwrap())); +impl_from_raw_wasm_value!(u16, |x| x as RawValue, |x: RawValueRep| u16::from_ne_bytes(x[0..2].try_into().unwrap())); +impl_from_raw_wasm_value!(u32, |x| x as RawValue, |x: RawValueRep| u32::from_ne_bytes(x[0..4].try_into().unwrap())); +impl_from_raw_wasm_value!(u64, |x| x as RawValue, |x: RawValueRep| u64::from_ne_bytes(x[0..8].try_into().unwrap())); +// impl_from_raw_wasm_value!(u128, |x| x, |x: RawValueRep| RawValue::from_ne_bytes(x)); -impl_from_raw_wasm_value!(i8, |x| x as u128, |x: [u8; 16]| i8::from_ne_bytes(x[0..1].try_into().unwrap())); -impl_from_raw_wasm_value!(i16, |x| x as u128, |x: [u8; 16]| i16::from_ne_bytes(x[0..2].try_into().unwrap())); +impl_from_raw_wasm_value!(i8, |x| x as RawValue, |x: RawValueRep| i8::from_ne_bytes(x[0..1].try_into().unwrap())); +impl_from_raw_wasm_value!(i16, |x| x as RawValue, |x: RawValueRep| i16::from_ne_bytes(x[0..2].try_into().unwrap())); diff --git a/crates/types/src/instructions.rs b/crates/types/src/instructions.rs index fc12b54..dd941b3 100644 --- a/crates/types/src/instructions.rs +++ b/crates/types/src/instructions.rs @@ -54,6 +54,32 @@ pub enum Instruction { // Custom Instructions BrLabel(LabelAddr), + //== Not implemented yet, to be determined + + // LocalGet + I32Const + I32Add + // One of the most common patterns in the Rust compiler output + I32LocalGetConstAdd(LocalAddr, i32), + + // LocalGet + I32Const + I32Store + // Also common, helps us skip the stack entirely + I32LocalGetConstStore(LocalAddr, i32, MemoryArg), // I32Store + LocalGet + I32Const + + // I64Xor + I64Const + I64RotL + // Commonly used by a few crypto libraries + I64XorConstRotl(i64), + + // LocalTee + LocalGet + LocalTeeGet(LocalAddr, LocalAddr), + LocalGet2(LocalAddr, LocalAddr), + LocalGet3(LocalAddr, LocalAddr, LocalAddr), + LocalGet4(LocalAddr, LocalAddr, LocalAddr, LocalAddr), + LocalGetSet(LocalAddr, LocalAddr), + + I32AddConst(i32), + I32SubConst(i32), + I64AddConst(i64), + I64SubConst(i64), + // Control Instructions // See Unreachable, diff --git a/crates/types/src/value.rs b/crates/types/src/value.rs index 3c02e55..8fd72fb 100644 --- a/crates/types/src/value.rs +++ b/crates/types/src/value.rs @@ -16,9 +16,8 @@ pub enum WasmValue { F32(f32), /// A 64-bit float. F64(f64), - /// A half of a 128-bit vector. Allways used in pairs. - V128(u128), - + // /// A 128-bit vector + // V128(u128), RefExtern(ExternAddr), RefFunc(FuncAddr), RefNull(ValType), @@ -49,7 +48,7 @@ impl WasmValue { ValType::I64 => Self::I64(0), ValType::F32 => Self::F32(0.0), ValType::F64 => Self::F64(0.0), - ValType::V128 => Self::V128(0), + // ValType::V128 => Self::V128(0), ValType::RefFunc => Self::RefNull(ValType::RefFunc), ValType::RefExtern => Self::RefNull(ValType::RefExtern), } @@ -92,7 +91,7 @@ impl Debug for WasmValue { WasmValue::I64(i) => write!(f, "i64({})", i), WasmValue::F32(i) => write!(f, "f32({})", i), WasmValue::F64(i) => write!(f, "f64({})", i), - WasmValue::V128(i) => write!(f, "v128.half({:?})", i), + // WasmValue::V128(i) => write!(f, "v128.half({:?})", i), WasmValue::RefExtern(addr) => write!(f, "ref.extern({:?})", addr), WasmValue::RefFunc(addr) => write!(f, "ref.func({:?})", addr), WasmValue::RefNull(ty) => write!(f, "ref.null({:?})", ty), @@ -109,7 +108,7 @@ impl WasmValue { Self::I64(_) => ValType::I64, Self::F32(_) => ValType::F32, Self::F64(_) => ValType::F64, - Self::V128(_) => ValType::V128, + // Self::V128(_) => ValType::V128, Self::RefExtern(_) => ValType::RefExtern, Self::RefFunc(_) => ValType::RefFunc, Self::RefNull(ty) => *ty, @@ -129,8 +128,8 @@ pub enum ValType { F32, /// A 64-bit float. F64, - /// A half of a 128-bit vector. Allways used in pairs. - V128, + /// A 128-bit vector + // V128, /// A reference to a function. RefFunc, /// A reference to an external value. diff --git a/examples/rust/analyze.py b/examples/rust/analyze.py new file mode 100644 index 0000000..a450a1a --- /dev/null +++ b/examples/rust/analyze.py @@ -0,0 +1,36 @@ +import re +import sys +from collections import Counter + +seq_len = 5 + +# Check if a file path was provided +if len(sys.argv) < 2: + print("Usage: python script.py path/to/yourfile.wat") + sys.exit(1) + +# The first command line argument is the file path +file_path = sys.argv[1] + +# Regex to match WASM operators, adjust as necessary +operator_pattern = re.compile(r'\b[a-z0-9_]+\.[a-z0-9_]+\b') + +# Read the file +with open(file_path, 'r') as file: + content = file.read() + +# Find all operators +operators = operator_pattern.findall(content) + +# Generate sequences of three consecutive operators +sequences = [' '.join(operators[i:i+seq_len]) for i in range(len(operators) - 2)] + +# Count occurrences of each sequence +sequence_counts = Counter(sequences) + +# Sort sequences by their count, this time in ascending order for reverse display +sorted_sequences = sorted(sequence_counts.items(), key=lambda x: x[1]) + +# Print the sequences, now from least common to most common +for sequence, count in sorted_sequences: + print(f"{sequence}: {count}") From e883003b7436708e91d0971b1a8e5f74c8166261 Mon Sep 17 00:00:00 2001 From: Henry Gressmann Date: Tue, 27 Feb 2024 01:04:34 +0100 Subject: [PATCH 3/9] some new instructuons Signed-off-by: Henry Gressmann --- crates/benchmarks/benches/selfhosted.rs | 6 ++-- crates/parser/src/visit.rs | 35 +++++++++---------- .../tinywasm/src/runtime/interpreter/mod.rs | 33 ++++++++++------- .../tinywasm/src/runtime/stack/value_stack.rs | 9 ++--- 4 files changed, 45 insertions(+), 38 deletions(-) diff --git a/crates/benchmarks/benches/selfhosted.rs b/crates/benchmarks/benches/selfhosted.rs index 94dfdce..1396fd1 100644 --- a/crates/benchmarks/benches/selfhosted.rs +++ b/crates/benchmarks/benches/selfhosted.rs @@ -61,10 +61,10 @@ fn criterion_benchmark(c: &mut Criterion) { { let twasm = util::wasm_to_twasm(TINYWASM); let mut group = c.benchmark_group("selfhosted"); - group.bench_function("native", |b| b.iter(run_native)); + // group.bench_function("native", |b| b.iter(run_native)); group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(&twasm))); - group.bench_function("wasmi", |b| b.iter(|| run_wasmi(TINYWASM))); - group.bench_function("wasmer", |b| b.iter(|| run_wasmer(TINYWASM))); + // group.bench_function("wasmi", |b| b.iter(|| run_wasmi(TINYWASM))); + // group.bench_function("wasmer", |b| b.iter(|| run_wasmer(TINYWASM))); } } diff --git a/crates/parser/src/visit.rs b/crates/parser/src/visit.rs index 9038567..f994e7e 100644 --- a/crates/parser/src/visit.rs +++ b/crates/parser/src/visit.rs @@ -325,10 +325,10 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { fn visit_local_get(&mut self, idx: u32) -> Self::Output { if let Some(instruction) = self.instructions.last_mut() { match instruction { - // Instruction::LocalGet(a) => *instruction = Instruction::LocalGet2(*a, idx), - // Instruction::LocalGet2(a, b) => *instruction = Instruction::LocalGet3(*a, *b, idx), - // Instruction::LocalGet3(a, b, c) => *instruction = Instruction::LocalGet4(*a, *b, *c, idx), - // Instruction::LocalTee(a) => *instruction = Instruction::LocalTeeGet(*a, idx), + Instruction::LocalGet(a) => *instruction = Instruction::LocalGet2(*a, idx), + Instruction::LocalGet2(a, b) => *instruction = Instruction::LocalGet3(*a, *b, idx), + Instruction::LocalGet3(a, b, c) => *instruction = Instruction::LocalGet4(*a, *b, *c, idx), + Instruction::LocalTee(a) => *instruction = Instruction::LocalTeeGet(*a, idx), _ => return self.visit(Instruction::LocalGet(idx)), }; Ok(()) @@ -338,16 +338,15 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { } fn visit_local_set(&mut self, idx: u32) -> Self::Output { - // LocalGetSet - if let Some(instruction) = self.instructions.last_mut() { - match instruction { - // Instruction::LocalGet(a) => *instruction = Instruction::LocalGetSet(*a, idx), - _ => return self.visit(Instruction::LocalSet(idx)), - }; - Ok(()) - } else { - self.visit(Instruction::LocalSet(idx)) + if self.instructions.len() < 1 { + return self.visit(Instruction::I64Rotl); } + + // LocalGetSet + match self.instructions[self.instructions.len() - 1..] { + // Instruction::LocalGet(a) => *instruction = Instruction::LocalGetSet(*a, idx), + _ => return self.visit(Instruction::LocalSet(idx)), + }; } fn visit_local_tee(&mut self, idx: u32) -> Self::Output { @@ -360,11 +359,11 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { } match self.instructions[self.instructions.len() - 2..] { - // [Instruction::I64Xor, Instruction::I64Const(a)] => { - // self.instructions.pop(); - // self.instructions.pop(); - // self.visit(Instruction::I64XorConstRotl(a)) - // } + [Instruction::I64Xor, Instruction::I64Const(a)] => { + self.instructions.pop(); + self.instructions.pop(); + self.visit(Instruction::I64XorConstRotl(a)) + } _ => self.visit(Instruction::I64Rotl), } } diff --git a/crates/tinywasm/src/runtime/interpreter/mod.rs b/crates/tinywasm/src/runtime/interpreter/mod.rs index 57e5f34..91d1859 100644 --- a/crates/tinywasm/src/runtime/interpreter/mod.rs +++ b/crates/tinywasm/src/runtime/interpreter/mod.rs @@ -680,19 +680,22 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M // custom instructions LocalGet2(a, b) => { - stack.values.push(cf.get_local(a as usize)); - stack.values.push(cf.get_local(b as usize)); + stack.values.extend_from_slice(&[cf.get_local(a as usize), cf.get_local(b as usize)]); } LocalGet3(a, b, c) => { - stack.values.push(cf.get_local(a as usize)); - stack.values.push(cf.get_local(b as usize)); - stack.values.push(cf.get_local(c as usize)); + stack.values.extend_from_slice(&[ + cf.get_local(a as usize), + cf.get_local(b as usize), + cf.get_local(c as usize), + ]); } LocalGet4(a, b, c, d) => { - stack.values.push(cf.get_local(a as usize)); - stack.values.push(cf.get_local(b as usize)); - stack.values.push(cf.get_local(c as usize)); - stack.values.push(cf.get_local(d as usize)); + stack.values.extend_from_slice(&[ + cf.get_local(a as usize), + cf.get_local(b as usize), + cf.get_local(c as usize), + cf.get_local(d as usize), + ]); } LocalTeeGet(a, b) => { let last = @@ -701,10 +704,14 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M stack.values.push(cf.get_local(b as usize)); } - // LocalTeeGet - // LocalGetSet - // I64XorConstRotl - // I32LocalGetConstAdd + // I64Xor + I64Const + I64RotL + I64XorConstRotl(rotate_by) => { + let val = stack.values.pop_t::()?; + let mask = stack.values.pop_t::()?; + let res = val ^ mask; + stack.values.push(res.rotate_left(rotate_by as u32).into()); + } + i => { cold(); log::error!("unimplemented instruction: {:?}", i); diff --git a/crates/tinywasm/src/runtime/stack/value_stack.rs b/crates/tinywasm/src/runtime/stack/value_stack.rs index be5b53b..c6d7918 100644 --- a/crates/tinywasm/src/runtime/stack/value_stack.rs +++ b/crates/tinywasm/src/runtime/stack/value_stack.rs @@ -25,13 +25,14 @@ impl ValueStack { #[inline] pub(crate) fn extend_from_typed(&mut self, values: &[WasmValue]) { - if values.is_empty() { - return; - } - self.stack.extend(values.iter().map(|v| RawWasmValue::from(*v))); } + #[inline] + pub(crate) fn extend_from_slice(&mut self, values: &[RawWasmValue]) { + self.stack.extend_from_slice(values); + } + #[inline] pub(crate) fn len(&self) -> usize { self.stack.len() From 83a768d77ac57f5d8e8884173765e0efc80831f4 Mon Sep 17 00:00:00 2001 From: Henry Gressmann Date: Tue, 27 Feb 2024 01:50:54 +0100 Subject: [PATCH 4/9] reduce instruction enum size Signed-off-by: Henry Gressmann --- crates/parser/src/conversion.rs | 2 +- crates/parser/src/visit.rs | 29 ++++++------ crates/tinywasm/src/reference.rs | 10 ++-- .../src/runtime/interpreter/macros.rs | 4 +- .../tinywasm/src/runtime/interpreter/mod.rs | 29 +++++++----- crates/tinywasm/src/runtime/value.rs | 1 - crates/tinywasm/src/store/memory.rs | 12 ++--- crates/tinywasm/src/store/mod.rs | 46 +++++++++---------- crates/types/src/instructions.rs | 12 ++--- 9 files changed, 76 insertions(+), 69 deletions(-) diff --git a/crates/parser/src/conversion.rs b/crates/parser/src/conversion.rs index 53cceb6..c13d08f 100644 --- a/crates/parser/src/conversion.rs +++ b/crates/parser/src/conversion.rs @@ -226,7 +226,7 @@ pub(crate) fn convert_valtype(valtype: &wasmparser::ValType) -> ValType { } pub(crate) fn convert_memarg(memarg: wasmparser::MemArg) -> MemoryArg { - MemoryArg { offset: memarg.offset, align: memarg.align, align_max: memarg.max_align, mem_addr: memarg.memory } + MemoryArg { offset: memarg.offset, mem_addr: memarg.memory } } pub(crate) fn process_const_operators(ops: OperatorsReader<'_>) -> Result { diff --git a/crates/parser/src/visit.rs b/crates/parser/src/visit.rs index f994e7e..3a10a93 100644 --- a/crates/parser/src/visit.rs +++ b/crates/parser/src/visit.rs @@ -338,15 +338,16 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { } fn visit_local_set(&mut self, idx: u32) -> Self::Output { - if self.instructions.len() < 1 { - return self.visit(Instruction::I64Rotl); + if let Some(instruction) = self.instructions.last_mut() { + match instruction { + // Needs more testing, seems to make performance worse + // Instruction::LocalGet(a) => *instruction = Instruction::LocalGetSet(*a, idx), + _ => return self.visit(Instruction::LocalSet(idx)), + }; + // Ok(()) + } else { + self.visit(Instruction::LocalSet(idx)) } - - // LocalGetSet - match self.instructions[self.instructions.len() - 1..] { - // Instruction::LocalGet(a) => *instruction = Instruction::LocalGetSet(*a, idx), - _ => return self.visit(Instruction::LocalSet(idx)), - }; } fn visit_local_tee(&mut self, idx: u32) -> Self::Output { @@ -413,7 +414,7 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { match self.instructions[label_pointer] { Instruction::Else(ref mut else_instr_end_offset) => { - *else_instr_end_offset = current_instr_ptr - label_pointer; + *else_instr_end_offset = (current_instr_ptr - label_pointer as usize) as u32; #[cold] fn error() -> crate::ParseError { @@ -430,13 +431,13 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { return Err(error()); }; - *else_offset = Some(label_pointer - if_label_pointer); - *end_offset = current_instr_ptr - if_label_pointer; + *else_offset = Some((label_pointer - if_label_pointer) as u32); + *end_offset = (current_instr_ptr - if_label_pointer) as u32; } Instruction::Block(_, ref mut end_offset) | Instruction::Loop(_, ref mut end_offset) | Instruction::If(_, _, ref mut end_offset) => { - *end_offset = current_instr_ptr - label_pointer; + *end_offset = (current_instr_ptr - label_pointer) as u32; } _ => { return Err(crate::ParseError::UnsupportedOperator( @@ -456,7 +457,9 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { .collect::, wasmparser::BinaryReaderError>>() .expect("BrTable targets are invalid, this should have been caught by the validator"); - self.instructions.extend(IntoIterator::into_iter([Instruction::BrTable(def, instrs.len())]).chain(instrs)); + self.instructions + .extend(IntoIterator::into_iter([Instruction::BrTable(def, instrs.len() as u32)]).chain(instrs)); + Ok(()) } diff --git a/crates/tinywasm/src/reference.rs b/crates/tinywasm/src/reference.rs index 4c6d703..6713a42 100644 --- a/crates/tinywasm/src/reference.rs +++ b/crates/tinywasm/src/reference.rs @@ -26,21 +26,21 @@ pub struct MemoryRefMut<'a> { impl<'a> MemoryRefLoad for MemoryRef<'a> { /// Load a slice of memory fn load(&self, offset: usize, len: usize) -> Result<&[u8]> { - self.instance.load(offset, 0, len) + self.instance.load(offset, len) } } impl<'a> MemoryRefLoad for MemoryRefMut<'a> { /// Load a slice of memory fn load(&self, offset: usize, len: usize) -> Result<&[u8]> { - self.instance.load(offset, 0, len) + self.instance.load(offset, len) } } impl MemoryRef<'_> { /// Load a slice of memory pub fn load(&self, offset: usize, len: usize) -> Result<&[u8]> { - self.instance.load(offset, 0, len) + self.instance.load(offset, len) } /// Load a slice of memory as a vector @@ -52,7 +52,7 @@ impl MemoryRef<'_> { impl MemoryRefMut<'_> { /// Load a slice of memory pub fn load(&self, offset: usize, len: usize) -> Result<&[u8]> { - self.instance.load(offset, 0, len) + self.instance.load(offset, len) } /// Load a slice of memory as a vector @@ -82,7 +82,7 @@ impl MemoryRefMut<'_> { /// Store a slice of memory pub fn store(&mut self, offset: usize, len: usize, data: &[u8]) -> Result<()> { - self.instance.store(offset, 0, data, len) + self.instance.store(offset, len, data) } } diff --git a/crates/tinywasm/src/runtime/interpreter/macros.rs b/crates/tinywasm/src/runtime/interpreter/macros.rs index 1da8758..a13531b 100644 --- a/crates/tinywasm/src/runtime/interpreter/macros.rs +++ b/crates/tinywasm/src/runtime/interpreter/macros.rs @@ -52,7 +52,7 @@ macro_rules! mem_load { })?; const LEN: usize = core::mem::size_of::<$load_type>(); - let val = mem_ref.load_as::(addr, $arg.align as usize)?; + let val = mem_ref.load_as::(addr)?; $stack.values.push((val as $target_type).into()); }}; } @@ -76,7 +76,7 @@ macro_rules! mem_store { let val = val as $store_type; let val = val.to_le_bytes(); - mem.borrow_mut().store(($arg.offset + addr) as usize, $arg.align as usize, &val, val.len())?; + mem.borrow_mut().store(($arg.offset + addr) as usize, val.len(), &val)?; }}; } diff --git a/crates/tinywasm/src/runtime/interpreter/mod.rs b/crates/tinywasm/src/runtime/interpreter/mod.rs index 91d1859..45e10b7 100644 --- a/crates/tinywasm/src/runtime/interpreter/mod.rs +++ b/crates/tinywasm/src/runtime/interpreter/mod.rs @@ -202,7 +202,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M cf.enter_block( BlockFrame::new( cf.instr_ptr, - cf.instr_ptr + end_offset, + cf.instr_ptr + end_offset as usize, stack.values.len(), BlockType::If, &args, @@ -217,17 +217,17 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M // falsy value is on the top of the stack if let Some(else_offset) = else_offset { let label = BlockFrame::new( - cf.instr_ptr + else_offset, - cf.instr_ptr + end_offset, + cf.instr_ptr + else_offset as usize, + cf.instr_ptr + end_offset as usize, stack.values.len(), BlockType::Else, &args, module, ); - cf.instr_ptr += else_offset; + cf.instr_ptr += else_offset as usize; cf.enter_block(label, &mut stack.values, &mut stack.blocks); } else { - cf.instr_ptr += end_offset; + cf.instr_ptr += end_offset as usize; } } @@ -235,7 +235,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M cf.enter_block( BlockFrame::new( cf.instr_ptr, - cf.instr_ptr + end_offset, + cf.instr_ptr + end_offset as usize, stack.values.len(), BlockType::Loop, &args, @@ -250,7 +250,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M cf.enter_block( BlockFrame::new( cf.instr_ptr, - cf.instr_ptr + end_offset, + cf.instr_ptr + end_offset as usize, stack.values.len(), // - params, BlockType::Block, &args, @@ -262,7 +262,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } BrTable(default, len) => { - let instr = cf.instructions()[cf.instr_ptr + 1..cf.instr_ptr + 1 + len] + let instr = cf.instructions()[cf.instr_ptr + 1..cf.instr_ptr + 1 + len as usize] .iter() .map(|i| match i { BrLabel(l) => Ok(*l), @@ -273,7 +273,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M }) .collect::>>()?; - if unlikely(instr.len() != len) { + if unlikely(instr.len() != len as usize) { panic!( "Expected {} BrLabel instructions, got {}, this should have been validated by the parser", len, @@ -319,7 +319,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M let res_count = block.results; stack.values.truncate_keep(block.stack_ptr, res_count); - cf.instr_ptr += end_offset; + cf.instr_ptr += end_offset as usize; } EndBlockFrame => { @@ -409,7 +409,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M // copy between two memories let mem2 = store.get_mem(module.resolve_mem_addr(to) as usize)?; let mut mem2 = mem2.borrow_mut(); - mem2.copy_from_slice(dst as usize, mem.load(src as usize, 0, size as usize)?)?; + mem2.copy_from_slice(dst as usize, mem.load(src as usize, size as usize)?)?; } } @@ -447,7 +447,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M let data = &data[offset..(offset + size)]; // mem.store checks bounds - mem.store(dst, 0, data, size)?; + mem.store(dst, size, data)?; } DataDrop(data_index) => { @@ -704,6 +704,11 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M stack.values.push(cf.get_local(b as usize)); } + LocalGetSet(a, b) => { + let a = cf.get_local(a as usize); + cf.set_local(b as usize, a); + } + // I64Xor + I64Const + I64RotL I64XorConstRotl(rotate_by) => { let val = stack.values.pop_t::()?; diff --git a/crates/tinywasm/src/runtime/value.rs b/crates/tinywasm/src/runtime/value.rs index 56fdf60..4835eab 100644 --- a/crates/tinywasm/src/runtime/value.rs +++ b/crates/tinywasm/src/runtime/value.rs @@ -7,7 +7,6 @@ use tinywasm_types::{ValType, WasmValue}; /// /// See [`WasmValue`] for the public representation. #[derive(Clone, Copy, Default, PartialEq, Eq)] -#[repr(transparent)] // pub struct RawWasmValue([u8; 16]); pub struct RawWasmValue([u8; 8]); diff --git a/crates/tinywasm/src/store/memory.rs b/crates/tinywasm/src/store/memory.rs index cbaed8d..1c8acce 100644 --- a/crates/tinywasm/src/store/memory.rs +++ b/crates/tinywasm/src/store/memory.rs @@ -37,7 +37,7 @@ impl MemoryInstance { Error::Trap(crate::Trap::MemoryOutOfBounds { offset: addr, len, max: self.data.len() }) } - pub(crate) fn store(&mut self, addr: usize, _align: usize, data: &[u8], len: usize) -> Result<()> { + pub(crate) fn store(&mut self, addr: usize, len: usize, data: &[u8]) -> Result<()> { let Some(end) = addr.checked_add(len) else { return Err(self.trap_oob(addr, data.len())); }; @@ -67,7 +67,7 @@ impl MemoryInstance { self.kind.page_count_max.unwrap_or(MAX_PAGES as u64) as usize } - pub(crate) fn load(&self, addr: usize, _align: usize, len: usize) -> Result<&[u8]> { + pub(crate) fn load(&self, addr: usize, len: usize) -> Result<&[u8]> { let Some(end) = addr.checked_add(len) else { return Err(self.trap_oob(addr, len)); }; @@ -80,7 +80,7 @@ impl MemoryInstance { } // this is a workaround since we can't use generic const expressions yet (https://github.com/rust-lang/rust/issues/76560) - pub(crate) fn load_as>(&self, addr: usize, _align: usize) -> Result { + pub(crate) fn load_as>(&self, addr: usize) -> Result { let Some(end) = addr.checked_add(SIZE) else { return Err(self.trap_oob(addr, SIZE)); }; @@ -223,8 +223,8 @@ mod memory_instance_tests { fn test_memory_store_and_load() { let mut memory = create_test_memory(); let data_to_store = [1, 2, 3, 4]; - assert!(memory.store(0, 0, &data_to_store, data_to_store.len()).is_ok()); - let loaded_data = memory.load(0, 0, data_to_store.len()).unwrap(); + assert!(memory.store(0, data_to_store.len(), &data_to_store).is_ok()); + let loaded_data = memory.load(0, data_to_store.len()).unwrap(); assert_eq!(loaded_data, &data_to_store); } @@ -232,7 +232,7 @@ mod memory_instance_tests { fn test_memory_store_out_of_bounds() { let mut memory = create_test_memory(); let data_to_store = [1, 2, 3, 4]; - assert!(memory.store(memory.data.len(), 0, &data_to_store, data_to_store.len()).is_err()); + assert!(memory.store(memory.data.len(), data_to_store.len(), &data_to_store).is_err()); } #[test] diff --git a/crates/tinywasm/src/store/mod.rs b/crates/tinywasm/src/store/mod.rs index ce02dd7..a3d99fe 100644 --- a/crates/tinywasm/src/store/mod.rs +++ b/crates/tinywasm/src/store/mod.rs @@ -349,36 +349,36 @@ impl Store { let data_count = self.data.datas.len(); let mut data_addrs = Vec::with_capacity(data_count); for (i, data) in datas.into_iter().enumerate() { - let data_val = - match data.kind { - tinywasm_types::DataKind::Active { mem: mem_addr, offset } => { - // a. Assert: memidx == 0 - if mem_addr != 0 { - return Err(Error::UnsupportedFeature("data segments for non-zero memories".to_string())); - } + let data_val = match data.kind { + tinywasm_types::DataKind::Active { mem: mem_addr, offset } => { + // a. Assert: memidx == 0 + if mem_addr != 0 { + return Err(Error::UnsupportedFeature("data segments for non-zero memories".to_string())); + } - let mem_addr = mem_addrs.get(mem_addr as usize).copied().ok_or_else(|| { - Error::Other(format!("memory {} not found for data segment {}", mem_addr, i)) - })?; + let mem_addr = mem_addrs + .get(mem_addr as usize) + .copied() + .ok_or_else(|| Error::Other(format!("memory {} not found for data segment {}", mem_addr, i)))?; - let offset = self.eval_i32_const(&offset)?; + let offset = self.eval_i32_const(&offset)?; - let mem = self.data.memories.get_mut(mem_addr as usize).ok_or_else(|| { + let mem = + self.data.memories.get_mut(mem_addr as usize).ok_or_else(|| { Error::Other(format!("memory {} not found for data segment {}", mem_addr, i)) })?; - // See comment for active element sections in the function above why we need to do this here - if let Err(Error::Trap(trap)) = - mem.borrow_mut().store(offset as usize, 0, &data.data, data.data.len()) - { - return Ok((data_addrs.into_boxed_slice(), Some(trap))); - } - - // drop the data - None + // See comment for active element sections in the function above why we need to do this here + if let Err(Error::Trap(trap)) = mem.borrow_mut().store(offset as usize, data.data.len(), &data.data) + { + return Ok((data_addrs.into_boxed_slice(), Some(trap))); } - tinywasm_types::DataKind::Passive => Some(data.data.to_vec()), - }; + + // drop the data + None + } + tinywasm_types::DataKind::Passive => Some(data.data.to_vec()), + }; self.data.datas.push(DataInstance::new(data_val, idx)); data_addrs.push((i + data_count) as Addr); diff --git a/crates/types/src/instructions.rs b/crates/types/src/instructions.rs index dd941b3..a19b4d2 100644 --- a/crates/types/src/instructions.rs +++ b/crates/types/src/instructions.rs @@ -15,14 +15,14 @@ pub enum BlockArgs { pub struct MemoryArg { pub offset: u64, pub mem_addr: MemAddr, - pub align: u8, - pub align_max: u8, + // pub align: u8, + // pub align_max: u8, } type BrTableDefault = u32; -type BrTableLen = usize; -type EndOffset = usize; -type ElseOffset = usize; +type BrTableLen = u32; +type EndOffset = u32; +type ElseOffset = u32; #[derive(Debug, Clone, Copy, PartialEq)] #[cfg_attr(feature = "archive", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize), archive(check_bytes))] @@ -62,7 +62,7 @@ pub enum Instruction { // LocalGet + I32Const + I32Store // Also common, helps us skip the stack entirely - I32LocalGetConstStore(LocalAddr, i32, MemoryArg), // I32Store + LocalGet + I32Const + // I32LocalGetConstStore(LocalAddr, i32, MemoryArg), // I32Store + LocalGet + I32Const // I64Xor + I64Const + I64RotL // Commonly used by a few crypto libraries From 4faaf5bb222947a95b854d733a3cbe3bf588b597 Mon Sep 17 00:00:00 2001 From: Henry Gressmann Date: Tue, 27 Feb 2024 14:35:40 +0100 Subject: [PATCH 5/9] reduce instruction enum size even more Signed-off-by: Henry Gressmann --- crates/benchmarks/benches/selfhosted.rs | 6 +- crates/parser/src/visit.rs | 79 ++++---- .../src/runtime/interpreter/macros.rs | 27 +-- .../tinywasm/src/runtime/interpreter/mod.rs | 179 +++++++++--------- .../tinywasm/src/runtime/stack/call_stack.rs | 4 +- crates/types/src/archive.rs | 2 - crates/types/src/instructions.rs | 156 +++++++++++---- crates/types/src/value.rs | 23 +++ 8 files changed, 296 insertions(+), 180 deletions(-) diff --git a/crates/benchmarks/benches/selfhosted.rs b/crates/benchmarks/benches/selfhosted.rs index 1396fd1..94dfdce 100644 --- a/crates/benchmarks/benches/selfhosted.rs +++ b/crates/benchmarks/benches/selfhosted.rs @@ -61,10 +61,10 @@ fn criterion_benchmark(c: &mut Criterion) { { let twasm = util::wasm_to_twasm(TINYWASM); let mut group = c.benchmark_group("selfhosted"); - // group.bench_function("native", |b| b.iter(run_native)); + group.bench_function("native", |b| b.iter(run_native)); group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(&twasm))); - // group.bench_function("wasmi", |b| b.iter(|| run_wasmi(TINYWASM))); - // group.bench_function("wasmer", |b| b.iter(|| run_wasmer(TINYWASM))); + group.bench_function("wasmi", |b| b.iter(|| run_wasmi(TINYWASM))); + group.bench_function("wasmer", |b| b.iter(|| run_wasmer(TINYWASM))); } } diff --git a/crates/parser/src/visit.rs b/crates/parser/src/visit.rs index 3a10a93..edebc97 100644 --- a/crates/parser/src/visit.rs +++ b/crates/parser/src/visit.rs @@ -3,7 +3,7 @@ use crate::{conversion::convert_blocktype, Result}; use crate::conversion::{convert_heaptype, convert_memarg, convert_valtype}; use alloc::string::ToString; use alloc::{boxed::Box, format, vec::Vec}; -use tinywasm_types::Instruction; +use tinywasm_types::{BlockArgsPacked, Instruction}; use wasmparser::{FuncValidator, FunctionBody, VisitOperator, WasmModuleResources}; struct ValidateThenVisit<'a, T, U>(T, &'a mut U); @@ -74,12 +74,14 @@ macro_rules! define_primitive_operands { } macro_rules! define_mem_operands { - ($($name:ident, $instr:expr),*) => { + ($($name:ident, $instr:ident),*) => { $( fn $name(&mut self, mem_arg: wasmparser::MemArg) -> Self::Output { - self.instructions.push($instr( - convert_memarg(mem_arg) - )); + let arg = convert_memarg(mem_arg); + self.instructions.push(Instruction::$instr { + offset: arg.offset, + mem_addr: arg.mem_addr, + }); Ok(()) } )* @@ -149,29 +151,29 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { } define_mem_operands! { - visit_i32_load, Instruction::I32Load, - visit_i64_load, Instruction::I64Load, - visit_f32_load, Instruction::F32Load, - visit_f64_load, Instruction::F64Load, - visit_i32_load8_s, Instruction::I32Load8S, - visit_i32_load8_u, Instruction::I32Load8U, - visit_i32_load16_s, Instruction::I32Load16S, - visit_i32_load16_u, Instruction::I32Load16U, - visit_i64_load8_s, Instruction::I64Load8S, - visit_i64_load8_u, Instruction::I64Load8U, - visit_i64_load16_s, Instruction::I64Load16S, - visit_i64_load16_u, Instruction::I64Load16U, - visit_i64_load32_s, Instruction::I64Load32S, - visit_i64_load32_u, Instruction::I64Load32U, - visit_i32_store, Instruction::I32Store, - visit_i64_store, Instruction::I64Store, - visit_f32_store, Instruction::F32Store, - visit_f64_store, Instruction::F64Store, - visit_i32_store8, Instruction::I32Store8, - visit_i32_store16, Instruction::I32Store16, - visit_i64_store8, Instruction::I64Store8, - visit_i64_store16, Instruction::I64Store16, - visit_i64_store32, Instruction::I64Store32 + visit_i32_load, I32Load, + visit_i64_load, I64Load, + visit_f32_load, F32Load, + visit_f64_load, F64Load, + visit_i32_load8_s, I32Load8S, + visit_i32_load8_u, I32Load8U, + visit_i32_load16_s, I32Load16S, + visit_i32_load16_u, I32Load16U, + visit_i64_load8_s, I64Load8S, + visit_i64_load8_u, I64Load8U, + visit_i64_load16_s, I64Load16S, + visit_i64_load16_u, I64Load16U, + visit_i64_load32_s, I64Load32S, + visit_i64_load32_u, I64Load32U, + visit_i32_store, I32Store, + visit_i64_store, I64Store, + visit_f32_store, F32Store, + visit_f64_store, F64Store, + visit_i32_store8, I32Store8, + visit_i32_store16, I32Store16, + visit_i64_store8, I64Store8, + visit_i64_store16, I64Store16, + visit_i64_store32, I64Store32 } define_operands! { @@ -327,7 +329,7 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { match instruction { Instruction::LocalGet(a) => *instruction = Instruction::LocalGet2(*a, idx), Instruction::LocalGet2(a, b) => *instruction = Instruction::LocalGet3(*a, *b, idx), - Instruction::LocalGet3(a, b, c) => *instruction = Instruction::LocalGet4(*a, *b, *c, idx), + // Instruction::LocalGet3(a, b, c) => *instruction = Instruction::LocalGet4(*a, *b, *c, idx), Instruction::LocalTee(a) => *instruction = Instruction::LocalTeeGet(*a, idx), _ => return self.visit(Instruction::LocalGet(idx)), }; @@ -396,7 +398,7 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { fn visit_if(&mut self, ty: wasmparser::BlockType) -> Self::Output { self.label_ptrs.push(self.instructions.len()); - self.visit(Instruction::If(convert_blocktype(ty), None, 0)) + self.visit(Instruction::If(BlockArgsPacked::new(convert_blocktype(ty)), 0, 0)) } fn visit_else(&mut self) -> Self::Output { @@ -414,7 +416,9 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { match self.instructions[label_pointer] { Instruction::Else(ref mut else_instr_end_offset) => { - *else_instr_end_offset = (current_instr_ptr - label_pointer as usize) as u32; + *else_instr_end_offset = (current_instr_ptr - label_pointer as usize) + .try_into() + .expect("else_instr_end_offset is too large, tinywasm does not support if blocks that large"); #[cold] fn error() -> crate::ParseError { @@ -431,13 +435,20 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { return Err(error()); }; - *else_offset = Some((label_pointer - if_label_pointer) as u32); - *end_offset = (current_instr_ptr - if_label_pointer) as u32; + *else_offset = (label_pointer - if_label_pointer) + .try_into() + .expect("else_instr_end_offset is too large, tinywasm does not support blocks that large"); + + *end_offset = (current_instr_ptr - if_label_pointer) + .try_into() + .expect("else_instr_end_offset is too large, tinywasm does not support blocks that large"); } Instruction::Block(_, ref mut end_offset) | Instruction::Loop(_, ref mut end_offset) | Instruction::If(_, _, ref mut end_offset) => { - *end_offset = (current_instr_ptr - label_pointer) as u32; + *end_offset = (current_instr_ptr - label_pointer) + .try_into() + .expect("else_instr_end_offset is too large, tinywasm does not support blocks that large"); } _ => { return Err(crate::ParseError::UnsupportedOperator( diff --git a/crates/tinywasm/src/runtime/interpreter/macros.rs b/crates/tinywasm/src/runtime/interpreter/macros.rs index a13531b..9227ceb 100644 --- a/crates/tinywasm/src/runtime/interpreter/macros.rs +++ b/crates/tinywasm/src/runtime/interpreter/macros.rs @@ -11,7 +11,7 @@ // from a function, so we need to check if the label stack is empty macro_rules! break_to { ($cf:ident, $stack:ident, $break_to_relative:ident) => {{ - if $cf.break_to($break_to_relative, &mut $stack.values, &mut $stack.blocks).is_none() { + if $cf.break_to(*$break_to_relative, &mut $stack.values, &mut $stack.blocks).is_none() { if $stack.call_stack.is_empty() { return Ok(ExecResult::Return); } else { @@ -23,20 +23,22 @@ macro_rules! break_to { /// Load a value from memory macro_rules! mem_load { - ($type:ty, $arg:ident, $stack:ident, $store:ident, $module:ident) => {{ + ($type:ty, $arg:expr, $stack:ident, $store:ident, $module:ident) => {{ mem_load!($type, $type, $arg, $stack, $store, $module) }}; - ($load_type:ty, $target_type:ty, $arg:ident, $stack:ident, $store:ident, $module:ident) => {{ - let mem_idx = $module.resolve_mem_addr($arg.mem_addr); + ($load_type:ty, $target_type:ty, $arg:expr, $stack:ident, $store:ident, $module:ident) => {{ + let (mem_addr, offset) = $arg; + + let mem_idx = $module.resolve_mem_addr(*mem_addr); let mem = $store.get_mem(mem_idx as usize)?; let mem_ref = mem.borrow_mut(); let addr: u64 = $stack.values.pop()?.into(); - let addr = $arg.offset.checked_add(addr).ok_or_else(|| { + let addr = offset.checked_add(addr).ok_or_else(|| { cold(); Error::Trap(crate::Trap::MemoryOutOfBounds { - offset: $arg.offset as usize, + offset: *offset as usize, len: core::mem::size_of::<$load_type>(), max: mem_ref.max_pages(), }) @@ -45,7 +47,7 @@ macro_rules! mem_load { let addr: usize = addr.try_into().ok().ok_or_else(|| { cold(); Error::Trap(crate::Trap::MemoryOutOfBounds { - offset: $arg.offset as usize, + offset: *offset as usize, len: core::mem::size_of::<$load_type>(), max: mem_ref.max_pages(), }) @@ -59,15 +61,14 @@ macro_rules! mem_load { /// Store a value to memory macro_rules! mem_store { - ($type:ty, $arg:ident, $stack:ident, $store:ident, $module:ident) => {{ + ($type:ty, $arg:expr, $stack:ident, $store:ident, $module:ident) => {{ log::debug!("mem_store!({}, {:?})", stringify!($type), $arg); - mem_store!($type, $type, $arg, $stack, $store, $module) }}; - ($store_type:ty, $target_type:ty, $arg:ident, $stack:ident, $store:ident, $module:ident) => {{ - // likewise, there could be a lot of performance improvements here - let mem_idx = $module.resolve_mem_addr($arg.mem_addr); + ($store_type:ty, $target_type:ty, $arg:expr, $stack:ident, $store:ident, $module:ident) => {{ + let (mem_addr, offset) = $arg; + let mem_idx = $module.resolve_mem_addr(*mem_addr); let mem = $store.get_mem(mem_idx as usize)?; let val = $stack.values.pop_t::<$store_type>()?; @@ -76,7 +77,7 @@ macro_rules! mem_store { let val = val as $store_type; let val = val.to_le_bytes(); - mem.borrow_mut().store(($arg.offset + addr) as usize, val.len(), &val)?; + mem.borrow_mut().store((*offset + addr) as usize, val.len(), &val)?; }}; } diff --git a/crates/tinywasm/src/runtime/interpreter/mod.rs b/crates/tinywasm/src/runtime/interpreter/mod.rs index 45e10b7..bd07051 100644 --- a/crates/tinywasm/src/runtime/interpreter/mod.rs +++ b/crates/tinywasm/src/runtime/interpreter/mod.rs @@ -113,7 +113,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M Call(v) => { // prepare the call frame - let func_idx = module.resolve_func_addr(v); + let func_idx = module.resolve_func_addr(*v); let func_inst = store.get_func(func_idx as usize)?.clone(); let wasm_func = match &func_inst.func { @@ -140,7 +140,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } CallIndirect(type_addr, table_addr) => { - let table = store.get_table(module.resolve_table_addr(table_addr) as usize)?; + let table = store.get_table(module.resolve_table_addr(*table_addr) as usize)?; let table_idx = stack.values.pop_t::()?; // verify that the table is of the right type, this should be validated by the parser already @@ -155,7 +155,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M }; let func_inst = store.get_func(func_ref as usize)?.clone(); - let call_ty = module.func_ty(type_addr); + let call_ty = module.func_ty(*type_addr); let wasm_func = match func_inst.func { crate::Function::Wasm(ref f) => f.clone(), @@ -202,10 +202,10 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M cf.enter_block( BlockFrame::new( cf.instr_ptr, - cf.instr_ptr + end_offset as usize, + cf.instr_ptr + *end_offset as usize, stack.values.len(), BlockType::If, - &args, + &args.unpack(), module, ), &mut stack.values, @@ -215,19 +215,19 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } // falsy value is on the top of the stack - if let Some(else_offset) = else_offset { + if *else_offset != 0 { let label = BlockFrame::new( - cf.instr_ptr + else_offset as usize, - cf.instr_ptr + end_offset as usize, + cf.instr_ptr + *else_offset as usize, + cf.instr_ptr + *end_offset as usize, stack.values.len(), BlockType::Else, - &args, + &args.unpack(), module, ); - cf.instr_ptr += else_offset as usize; + cf.instr_ptr += *else_offset as usize; cf.enter_block(label, &mut stack.values, &mut stack.blocks); } else { - cf.instr_ptr += end_offset as usize; + cf.instr_ptr += *end_offset as usize; } } @@ -235,7 +235,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M cf.enter_block( BlockFrame::new( cf.instr_ptr, - cf.instr_ptr + end_offset as usize, + cf.instr_ptr + *end_offset as usize, stack.values.len(), BlockType::Loop, &args, @@ -250,7 +250,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M cf.enter_block( BlockFrame::new( cf.instr_ptr, - cf.instr_ptr + end_offset as usize, + cf.instr_ptr + *end_offset as usize, stack.values.len(), // - params, BlockType::Block, &args, @@ -262,7 +262,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } BrTable(default, len) => { - let instr = cf.instructions()[cf.instr_ptr + 1..cf.instr_ptr + 1 + len as usize] + let instr = cf.instructions()[cf.instr_ptr + 1..cf.instr_ptr + 1 + *len as usize] .iter() .map(|i| match i { BrLabel(l) => Ok(*l), @@ -273,7 +273,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M }) .collect::>>()?; - if unlikely(instr.len() != len as usize) { + if unlikely(instr.len() != *len as usize) { panic!( "Expected {} BrLabel instructions, got {}, this should have been validated by the parser", len, @@ -282,7 +282,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } let idx = stack.values.pop_t::()? as usize; - let to = *instr.get(idx).unwrap_or(&default); + let to = instr.get(idx).unwrap_or(&default); break_to!(cf, stack, to); } @@ -319,7 +319,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M let res_count = block.results; stack.values.truncate_keep(block.stack_ptr, res_count); - cf.instr_ptr += end_offset as usize; + cf.instr_ptr += *end_offset as usize; } EndBlockFrame => { @@ -332,11 +332,11 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M stack.values.truncate_keep(block.stack_ptr, block.results); } - LocalGet(local_index) => stack.values.push(cf.get_local(local_index as usize)), - LocalSet(local_index) => cf.set_local(local_index as usize, stack.values.pop()?), + LocalGet(local_index) => stack.values.push(cf.get_local(*local_index as usize)), + LocalSet(local_index) => cf.set_local(*local_index as usize, stack.values.pop()?), LocalTee(local_index) => { cf.set_local( - local_index as usize, + *local_index as usize, stack .values .last() @@ -346,39 +346,39 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } GlobalGet(global_index) => { - let idx = module.resolve_global_addr(global_index); + let idx = module.resolve_global_addr(*global_index); let global = store.get_global_val(idx as usize)?; stack.values.push(global); } GlobalSet(global_index) => { - let idx = module.resolve_global_addr(global_index); + let idx = module.resolve_global_addr(*global_index); store.set_global_val(idx as usize, stack.values.pop()?)?; } - I32Const(val) => stack.values.push((val).into()), - I64Const(val) => stack.values.push((val).into()), - F32Const(val) => stack.values.push((val).into()), - F64Const(val) => stack.values.push((val).into()), + I32Const(val) => stack.values.push((*val).into()), + I64Const(val) => stack.values.push((*val).into()), + F32Const(val) => stack.values.push((*val).into()), + F64Const(val) => stack.values.push((*val).into()), MemorySize(addr, byte) => { - if byte != 0 { + if *byte != 0 { cold(); return Err(Error::UnsupportedFeature("memory.size with byte != 0".to_string())); } - let mem_idx = module.resolve_mem_addr(addr); + let mem_idx = module.resolve_mem_addr(*addr); let mem = store.get_mem(mem_idx as usize)?; stack.values.push((mem.borrow().page_count() as i32).into()); } MemoryGrow(addr, byte) => { - if byte != 0 { + if *byte != 0 { cold(); return Err(Error::UnsupportedFeature("memory.grow with byte != 0".to_string())); } - let mem_idx = module.resolve_mem_addr(addr); + let mem_idx = module.resolve_mem_addr(*addr); let mem = store.get_mem(mem_idx as usize)?; let (res, prev_size) = { @@ -399,7 +399,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M let src = stack.values.pop_t::()?; let dst = stack.values.pop_t::()?; - let mem = store.get_mem(module.resolve_mem_addr(from) as usize)?; + let mem = store.get_mem(module.resolve_mem_addr(*from) as usize)?; let mut mem = mem.borrow_mut(); if from == to { @@ -407,7 +407,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M mem.copy_within(dst as usize, src as usize, size as usize)?; } else { // copy between two memories - let mem2 = store.get_mem(module.resolve_mem_addr(to) as usize)?; + let mem2 = store.get_mem(module.resolve_mem_addr(*to) as usize)?; let mut mem2 = mem2.borrow_mut(); mem2.copy_from_slice(dst as usize, mem.load(src as usize, size as usize)?)?; } @@ -418,7 +418,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M let val = stack.values.pop_t::()?; let dst = stack.values.pop_t::()?; - let mem = store.get_mem(module.resolve_mem_addr(addr) as usize)?; + let mem = store.get_mem(module.resolve_mem_addr(*addr) as usize)?; let mut mem = mem.borrow_mut(); mem.fill(dst as usize, size as usize, val as u8)?; } @@ -428,13 +428,13 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M let offset = stack.values.pop_t::()? as usize; let dst = stack.values.pop_t::()? as usize; - let data_idx = module.resolve_data_addr(data_index); + let data_idx = module.resolve_data_addr(*data_index); let Some(ref data) = store.get_data(data_idx as usize)?.data else { cold(); return Err(Trap::MemoryOutOfBounds { offset: 0, len: 0, max: 0 }.into()); }; - let mem_idx = module.resolve_mem_addr(mem_index); + let mem_idx = module.resolve_mem_addr(*mem_index); let mem = store.get_mem(mem_idx as usize)?; let data_len = data.len(); @@ -451,35 +451,35 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } DataDrop(data_index) => { - let data_idx = module.resolve_data_addr(data_index); + let data_idx = module.resolve_data_addr(*data_index); let data = store.get_data_mut(data_idx as usize)?; data.drop(); } - I32Store(arg) => mem_store!(i32, arg, stack, store, module), - I64Store(arg) => mem_store!(i64, arg, stack, store, module), - F32Store(arg) => mem_store!(f32, arg, stack, store, module), - F64Store(arg) => mem_store!(f64, arg, stack, store, module), - I32Store8(arg) => mem_store!(i8, i32, arg, stack, store, module), - I32Store16(arg) => mem_store!(i16, i32, arg, stack, store, module), - I64Store8(arg) => mem_store!(i8, i64, arg, stack, store, module), - I64Store16(arg) => mem_store!(i16, i64, arg, stack, store, module), - I64Store32(arg) => mem_store!(i32, i64, arg, stack, store, module), - - I32Load(arg) => mem_load!(i32, arg, stack, store, module), - I64Load(arg) => mem_load!(i64, arg, stack, store, module), - F32Load(arg) => mem_load!(f32, arg, stack, store, module), - F64Load(arg) => mem_load!(f64, arg, stack, store, module), - I32Load8S(arg) => mem_load!(i8, i32, arg, stack, store, module), - I32Load8U(arg) => mem_load!(u8, i32, arg, stack, store, module), - I32Load16S(arg) => mem_load!(i16, i32, arg, stack, store, module), - I32Load16U(arg) => mem_load!(u16, i32, arg, stack, store, module), - I64Load8S(arg) => mem_load!(i8, i64, arg, stack, store, module), - I64Load8U(arg) => mem_load!(u8, i64, arg, stack, store, module), - I64Load16S(arg) => mem_load!(i16, i64, arg, stack, store, module), - I64Load16U(arg) => mem_load!(u16, i64, arg, stack, store, module), - I64Load32S(arg) => mem_load!(i32, i64, arg, stack, store, module), - I64Load32U(arg) => mem_load!(u32, i64, arg, stack, store, module), + I32Store { mem_addr, offset } => mem_store!(i32, (mem_addr, offset), stack, store, module), + I64Store { mem_addr, offset } => mem_store!(i64, (mem_addr, offset), stack, store, module), + F32Store { mem_addr, offset } => mem_store!(f32, (mem_addr, offset), stack, store, module), + F64Store { mem_addr, offset } => mem_store!(f64, (mem_addr, offset), stack, store, module), + I32Store8 { mem_addr, offset } => mem_store!(i8, i32, (mem_addr, offset), stack, store, module), + I32Store16 { mem_addr, offset } => mem_store!(i16, i32, (mem_addr, offset), stack, store, module), + I64Store8 { mem_addr, offset } => mem_store!(i8, i64, (mem_addr, offset), stack, store, module), + I64Store16 { mem_addr, offset } => mem_store!(i16, i64, (mem_addr, offset), stack, store, module), + I64Store32 { mem_addr, offset } => mem_store!(i32, i64, (mem_addr, offset), stack, store, module), + + I32Load { mem_addr, offset } => mem_load!(i32, (mem_addr, offset), stack, store, module), + I64Load { mem_addr, offset } => mem_load!(i64, (mem_addr, offset), stack, store, module), + F32Load { mem_addr, offset } => mem_load!(f32, (mem_addr, offset), stack, store, module), + F64Load { mem_addr, offset } => mem_load!(f64, (mem_addr, offset), stack, store, module), + I32Load8S { mem_addr, offset } => mem_load!(i8, i32, (mem_addr, offset), stack, store, module), + I32Load8U { mem_addr, offset } => mem_load!(u8, i32, (mem_addr, offset), stack, store, module), + I32Load16S { mem_addr, offset } => mem_load!(i16, i32, (mem_addr, offset), stack, store, module), + I32Load16U { mem_addr, offset } => mem_load!(u16, i32, (mem_addr, offset), stack, store, module), + I64Load8S { mem_addr, offset } => mem_load!(i8, i64, (mem_addr, offset), stack, store, module), + I64Load8U { mem_addr, offset } => mem_load!(u8, i64, (mem_addr, offset), stack, store, module), + I64Load16S { mem_addr, offset } => mem_load!(i16, i64, (mem_addr, offset), stack, store, module), + I64Load16U { mem_addr, offset } => mem_load!(u16, i64, (mem_addr, offset), stack, store, module), + I64Load32S { mem_addr, offset } => mem_load!(i32, i64, (mem_addr, offset), stack, store, module), + I64Load32U { mem_addr, offset } => mem_load!(u32, i64, (mem_addr, offset), stack, store, module), I64Eqz => comp_zero!(==, i64, stack), I32Eqz => comp_zero!(==, i32, stack), @@ -630,7 +630,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M I64TruncF64U => checked_conv_float!(f64, u64, i64, stack), TableGet(table_index) => { - let table_idx = module.resolve_table_addr(table_index); + let table_idx = module.resolve_table_addr(*table_index); let table = store.get_table(table_idx as usize)?; let idx = stack.values.pop_t::()? as usize; let v = table.borrow().get_wasm_val(idx)?; @@ -638,7 +638,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } TableSet(table_index) => { - let table_idx = module.resolve_table_addr(table_index); + let table_idx = module.resolve_table_addr(*table_index); let table = store.get_table(table_idx as usize)?; let val = stack.values.pop_t::()?; let idx = stack.values.pop_t::()? as usize; @@ -646,16 +646,16 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } TableSize(table_index) => { - let table_idx = module.resolve_table_addr(table_index); + let table_idx = module.resolve_table_addr(*table_index); let table = store.get_table(table_idx as usize)?; stack.values.push(table.borrow().size().into()); } TableInit(table_index, elem_index) => { - let table_idx = module.resolve_table_addr(table_index); + let table_idx = module.resolve_table_addr(*table_index); let table = store.get_table(table_idx as usize)?; - let elem_idx = module.resolve_elem_addr(elem_index); + let elem_idx = module.resolve_elem_addr(*elem_index); let elem = store.get_elem(elem_idx as usize)?; if let ElementKind::Passive = elem.kind { @@ -680,43 +680,46 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M // custom instructions LocalGet2(a, b) => { - stack.values.extend_from_slice(&[cf.get_local(a as usize), cf.get_local(b as usize)]); + stack.values.extend_from_slice(&[cf.get_local(*a as usize), cf.get_local(*b as usize)]); } LocalGet3(a, b, c) => { stack.values.extend_from_slice(&[ - cf.get_local(a as usize), - cf.get_local(b as usize), - cf.get_local(c as usize), - ]); - } - LocalGet4(a, b, c, d) => { - stack.values.extend_from_slice(&[ - cf.get_local(a as usize), - cf.get_local(b as usize), - cf.get_local(c as usize), - cf.get_local(d as usize), + cf.get_local(*a as usize), + cf.get_local(*b as usize), + cf.get_local(*c as usize), ]); } + // LocalGet4(a, b, c, d) => { + // stack.values.extend_from_slice(&[ + // cf.get_local(*a as usize), + // cf.get_local(*b as usize), + // cf.get_local(*c as usize), + // cf.get_local(*d as usize), + // ]); + // } LocalTeeGet(a, b) => { - let last = - *stack.values.last().expect("localtee: stack is empty. this should have been validated by the parser"); - cf.set_local(a as usize, last); - stack.values.push(cf.get_local(b as usize)); + #[inline] + fn local_tee_get(cf: &mut CallFrame, stack: &mut Stack, a: u32, b: u32) -> Result<()> { + let last = *stack + .values + .last() + .expect("localtee: stack is empty. this should have been validated by the parser"); + cf.set_local(a as usize, last); + stack.values.push(cf.get_local(b as usize)); + Ok(()) + } + local_tee_get(cf, stack, *a, *b)?; } - LocalGetSet(a, b) => { - let a = cf.get_local(a as usize); - cf.set_local(b as usize, a); + let a = cf.get_local(*a as usize); + cf.set_local(*b as usize, a); } - - // I64Xor + I64Const + I64RotL I64XorConstRotl(rotate_by) => { let val = stack.values.pop_t::()?; let mask = stack.values.pop_t::()?; let res = val ^ mask; - stack.values.push(res.rotate_left(rotate_by as u32).into()); + stack.values.push(res.rotate_left(*rotate_by as u32).into()); } - i => { cold(); log::error!("unimplemented instruction: {:?}", i); diff --git a/crates/tinywasm/src/runtime/stack/call_stack.rs b/crates/tinywasm/src/runtime/stack/call_stack.rs index dd80bb7..14ad050 100644 --- a/crates/tinywasm/src/runtime/stack/call_stack.rs +++ b/crates/tinywasm/src/runtime/stack/call_stack.rs @@ -149,7 +149,7 @@ impl CallFrame { } #[inline(always)] - pub(crate) fn current_instruction(&self) -> Instruction { - self.func_instance.0.instructions[self.instr_ptr] + pub(crate) fn current_instruction(&self) -> &Instruction { + &self.func_instance.0.instructions[self.instr_ptr] } } diff --git a/crates/types/src/archive.rs b/crates/types/src/archive.rs index bbd2206..273d6ed 100644 --- a/crates/types/src/archive.rs +++ b/crates/types/src/archive.rs @@ -7,10 +7,8 @@ use rkyv::{ Deserialize, }; -// 16 bytes const TWASM_MAGIC_PREFIX: &[u8; 4] = b"TWAS"; const TWASM_VERSION: &[u8; 2] = b"01"; - #[rustfmt::skip] const TWASM_MAGIC: [u8; 16] = [ TWASM_MAGIC_PREFIX[0], TWASM_MAGIC_PREFIX[1], TWASM_MAGIC_PREFIX[2], TWASM_MAGIC_PREFIX[3], TWASM_VERSION[0], TWASM_VERSION[1], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; diff --git a/crates/types/src/instructions.rs b/crates/types/src/instructions.rs index a19b4d2..537b8d7 100644 --- a/crates/types/src/instructions.rs +++ b/crates/types/src/instructions.rs @@ -9,14 +9,44 @@ pub enum BlockArgs { FuncType(u32), } +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +#[cfg_attr(feature = "archive", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize), archive(check_bytes))] +/// A packed representation of BlockArgs +/// This is needed to keep the size of the Instruction enum small. +/// Sadly, using #[repr(u8)] on BlockArgs itself is not possible because of the FuncType variant. +pub struct BlockArgsPacked([u8; 5]); // Modifying this directly can cause runtime errors, but no UB +impl BlockArgsPacked { + pub fn new(args: BlockArgs) -> Self { + let mut packed = [0; 5]; + match args { + BlockArgs::Empty => packed[0] = 0, + BlockArgs::Type(t) => { + packed[0] = 1; + packed[1] = t.to_byte(); + } + BlockArgs::FuncType(t) => { + packed[0] = 2; + packed[1..].copy_from_slice(&t.to_le_bytes()); + } + } + Self(packed) + } + pub fn unpack(&self) -> BlockArgs { + match self.0[0] { + 0 => BlockArgs::Empty, + 1 => BlockArgs::Type(ValType::from_byte(self.0[1]).unwrap()), + 2 => BlockArgs::FuncType(u32::from_le_bytes(self.0[1..].try_into().unwrap())), + _ => unreachable!(), + } + } +} + /// Represents a memory immediate in a WebAssembly memory instruction. #[derive(Debug, Copy, Clone, PartialEq)] #[cfg_attr(feature = "archive", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize), archive(check_bytes))] pub struct MemoryArg { pub offset: u64, pub mem_addr: MemAddr, - // pub align: u8, - // pub align_max: u8, } type BrTableDefault = u32; @@ -48,21 +78,23 @@ pub enum ConstInstruction { /// This makes it easier to implement the label stack iteratively. /// /// See -#[derive(Debug, Clone, Copy, PartialEq)] +#[derive(Debug, Clone, PartialEq)] #[cfg_attr(feature = "archive", derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize), archive(check_bytes))] +// should be kept as small as possible (16 bytes max) pub enum Instruction { // Custom Instructions BrLabel(LabelAddr), - //== Not implemented yet, to be determined - + // Not implemented yet // LocalGet + I32Const + I32Add // One of the most common patterns in the Rust compiler output - I32LocalGetConstAdd(LocalAddr, i32), + // I32LocalGetConstAdd(LocalAddr, i32), - // LocalGet + I32Const + I32Store - // Also common, helps us skip the stack entirely - // I32LocalGetConstStore(LocalAddr, i32, MemoryArg), // I32Store + LocalGet + I32Const + // Not implemented yet + // LocalGet + I32Const + I32Store => I32LocalGetConstStore + I32Const + // Also common, helps us skip the stack entirely. + // Has to be followed by an I32Const instruction + // I32LocalGetConstStore { local: LocalAddr, offset: i32, mem_addr: MemAddr }, // I32Store + LocalGet + I32Const // I64Xor + I64Const + I64RotL // Commonly used by a few crypto libraries @@ -72,13 +104,13 @@ pub enum Instruction { LocalTeeGet(LocalAddr, LocalAddr), LocalGet2(LocalAddr, LocalAddr), LocalGet3(LocalAddr, LocalAddr, LocalAddr), - LocalGet4(LocalAddr, LocalAddr, LocalAddr, LocalAddr), LocalGetSet(LocalAddr, LocalAddr), - I32AddConst(i32), - I32SubConst(i32), - I64AddConst(i64), - I64SubConst(i64), + // Not implemented yet + // I32AddConst(i32), + // I32SubConst(i32), + // I64AddConst(i64), + // I64SubConst(i64), // Control Instructions // See @@ -86,7 +118,7 @@ pub enum Instruction { Nop, Block(BlockArgs, EndOffset), Loop(BlockArgs, EndOffset), - If(BlockArgs, Option, EndOffset), + If(BlockArgsPacked, ElseOffset, EndOffset), // If else offset is 0 if there is no else block Else(EndOffset), EndBlockFrame, EndFunc, @@ -111,29 +143,29 @@ pub enum Instruction { GlobalSet(GlobalAddr), // Memory Instructions - I32Load(MemoryArg), - I64Load(MemoryArg), - F32Load(MemoryArg), - F64Load(MemoryArg), - I32Load8S(MemoryArg), - I32Load8U(MemoryArg), - I32Load16S(MemoryArg), - I32Load16U(MemoryArg), - I64Load8S(MemoryArg), - I64Load8U(MemoryArg), - I64Load16S(MemoryArg), - I64Load16U(MemoryArg), - I64Load32S(MemoryArg), - I64Load32U(MemoryArg), - I32Store(MemoryArg), - I64Store(MemoryArg), - F32Store(MemoryArg), - F64Store(MemoryArg), - I32Store8(MemoryArg), - I32Store16(MemoryArg), - I64Store8(MemoryArg), - I64Store16(MemoryArg), - I64Store32(MemoryArg), + I32Load { offset: u64, mem_addr: MemAddr }, + I64Load { offset: u64, mem_addr: MemAddr }, + F32Load { offset: u64, mem_addr: MemAddr }, + F64Load { offset: u64, mem_addr: MemAddr }, + I32Load8S { offset: u64, mem_addr: MemAddr }, + I32Load8U { offset: u64, mem_addr: MemAddr }, + I32Load16S { offset: u64, mem_addr: MemAddr }, + I32Load16U { offset: u64, mem_addr: MemAddr }, + I64Load8S { offset: u64, mem_addr: MemAddr }, + I64Load8U { offset: u64, mem_addr: MemAddr }, + I64Load16S { offset: u64, mem_addr: MemAddr }, + I64Load16U { offset: u64, mem_addr: MemAddr }, + I64Load32S { offset: u64, mem_addr: MemAddr }, + I64Load32U { offset: u64, mem_addr: MemAddr }, + I32Store { offset: u64, mem_addr: MemAddr }, + I64Store { offset: u64, mem_addr: MemAddr }, + F32Store { offset: u64, mem_addr: MemAddr }, + F64Store { offset: u64, mem_addr: MemAddr }, + I32Store8 { offset: u64, mem_addr: MemAddr }, + I32Store16 { offset: u64, mem_addr: MemAddr }, + I64Store8 { offset: u64, mem_addr: MemAddr }, + I64Store16 { offset: u64, mem_addr: MemAddr }, + I64Store32 { offset: u64, mem_addr: MemAddr }, MemorySize(MemAddr, u8), MemoryGrow(MemAddr, u8), @@ -302,3 +334,51 @@ pub enum Instruction { MemoryFill(MemAddr), DataDrop(DataAddr), } + +#[cfg(test)] +mod test_blockargs_packed { + use super::*; + + #[test] + fn test_empty() { + let args = BlockArgs::Empty; + let packed = BlockArgsPacked::new(args); + assert_eq!(packed.unpack(), BlockArgs::Empty); + } + + #[test] + fn test_val_type_i32() { + let args = BlockArgs::Type(ValType::I32); + let packed = BlockArgsPacked::new(args); + assert_eq!(packed.unpack(), BlockArgs::Type(ValType::I32)); + } + + #[test] + fn test_val_type_i64() { + let args = BlockArgs::Type(ValType::I64); + let packed = BlockArgsPacked::new(args); + assert_eq!(packed.unpack(), BlockArgs::Type(ValType::I64)); + } + + #[test] + fn test_val_type_f32() { + let args = BlockArgs::Type(ValType::F32); + let packed = BlockArgsPacked::new(args); + assert_eq!(packed.unpack(), BlockArgs::Type(ValType::F32)); + } + + #[test] + fn test_val_type_f64() { + let args = BlockArgs::Type(ValType::F64); + let packed = BlockArgsPacked::new(args); + assert_eq!(packed.unpack(), BlockArgs::Type(ValType::F64)); + } + + #[test] + fn test_func_type() { + let func_type = 123; // Use an arbitrary u32 value + let args = BlockArgs::FuncType(func_type); + let packed = BlockArgsPacked::new(args); + assert_eq!(packed.unpack(), BlockArgs::FuncType(func_type)); + } +} diff --git a/crates/types/src/value.rs b/crates/types/src/value.rs index 8fd72fb..df062ce 100644 --- a/crates/types/src/value.rs +++ b/crates/types/src/value.rs @@ -141,6 +141,29 @@ impl ValType { pub fn default_value(&self) -> WasmValue { WasmValue::default_for(*self) } + + pub(crate) fn to_byte(&self) -> u8 { + match self { + ValType::I32 => 0x7F, + ValType::I64 => 0x7E, + ValType::F32 => 0x7D, + ValType::F64 => 0x7C, + ValType::RefFunc => 0x70, + ValType::RefExtern => 0x6F, + } + } + + pub(crate) fn from_byte(byte: u8) -> Option { + match byte { + 0x7F => Some(ValType::I32), + 0x7E => Some(ValType::I64), + 0x7D => Some(ValType::F32), + 0x7C => Some(ValType::F64), + 0x70 => Some(ValType::RefFunc), + 0x6F => Some(ValType::RefExtern), + _ => None, + } + } } macro_rules! impl_conversion_for_wasmvalue { From d2db1f7b3803c42619d91b85a66c12ace296bb21 Mon Sep 17 00:00:00 2001 From: Henry Gressmann Date: Tue, 27 Feb 2024 16:08:14 +0100 Subject: [PATCH 6/9] chore: overall code cleanup Signed-off-by: Henry Gressmann --- crates/benchmarks/benches/argon2id.rs | 6 +- crates/parser/src/visit.rs | 46 +++---- crates/tinywasm/src/func.rs | 73 ++++++----- crates/tinywasm/src/imports.rs | 1 - .../src/runtime/interpreter/macros.rs | 79 +++++------- .../tinywasm/src/runtime/interpreter/mod.rs | 115 ++++++++---------- .../src/runtime/interpreter/no_std_floats.rs | 97 +++------------ .../src/runtime/interpreter/traits.rs | 44 +++---- .../tinywasm/src/runtime/stack/call_stack.rs | 2 +- .../tinywasm/src/runtime/stack/value_stack.rs | 12 +- crates/tinywasm/src/store/mod.rs | 81 +++++------- crates/tinywasm/src/store/table.rs | 4 +- crates/types/src/instructions.rs | 2 +- crates/types/src/value.rs | 2 +- 14 files changed, 221 insertions(+), 343 deletions(-) diff --git a/crates/benchmarks/benches/argon2id.rs b/crates/benchmarks/benches/argon2id.rs index 7c1ffc5..a503687 100644 --- a/crates/benchmarks/benches/argon2id.rs +++ b/crates/benchmarks/benches/argon2id.rs @@ -45,10 +45,10 @@ fn criterion_benchmark(c: &mut Criterion) { group.measurement_time(std::time::Duration::from_secs(7)); group.sample_size(10); - group.bench_function("native", |b| b.iter(|| run_native(black_box(params)))); + // group.bench_function("native", |b| b.iter(|| run_native(black_box(params)))); group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(&twasm, black_box(params), "argon2id"))); - group.bench_function("wasmi", |b| b.iter(|| run_wasmi(ARGON2ID, black_box(params), "argon2id"))); - group.bench_function("wasmer", |b| b.iter(|| run_wasmer(ARGON2ID, black_box(params), "argon2id"))); + // group.bench_function("wasmi", |b| b.iter(|| run_wasmi(ARGON2ID, black_box(params), "argon2id"))); + // group.bench_function("wasmer", |b| b.iter(|| run_wasmer(ARGON2ID, black_box(params), "argon2id"))); } criterion_group!( diff --git a/crates/parser/src/visit.rs b/crates/parser/src/visit.rs index edebc97..88b6ba5 100644 --- a/crates/parser/src/visit.rs +++ b/crates/parser/src/visit.rs @@ -340,16 +340,17 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { } fn visit_local_set(&mut self, idx: u32) -> Self::Output { - if let Some(instruction) = self.instructions.last_mut() { - match instruction { - // Needs more testing, seems to make performance worse - // Instruction::LocalGet(a) => *instruction = Instruction::LocalGetSet(*a, idx), - _ => return self.visit(Instruction::LocalSet(idx)), - }; - // Ok(()) - } else { - self.visit(Instruction::LocalSet(idx)) - } + self.visit(Instruction::LocalSet(idx)) + // if let Some(instruction) = self.instructions.last_mut() { + // match instruction { + // // Needs more testing, seems to make performance worse + // // Instruction::LocalGet(a) => *instruction = Instruction::LocalGetSet(*a, idx), + // _ => return self.visit(Instruction::LocalSet(idx)), + // }; + // // Ok(()) + // } else { + // self.visit(Instruction::LocalSet(idx)) + // } } fn visit_local_tee(&mut self, idx: u32) -> Self::Output { @@ -372,18 +373,19 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { } fn visit_i32_add(&mut self) -> Self::Output { - if self.instructions.len() < 2 { - return self.visit(Instruction::I32Add); - } + self.visit(Instruction::I32Add) + // if self.instructions.len() < 2 { + // return self.visit(Instruction::I32Add); + // } - match self.instructions[self.instructions.len() - 2..] { - // [Instruction::LocalGet(a), Instruction::I32Const(b)] => { - // self.instructions.pop(); - // self.instructions.pop(); - // self.visit(Instruction::I32LocalGetConstAdd(a, b)) - // } - _ => self.visit(Instruction::I32Add), - } + // match self.instructions[self.instructions.len() - 2..] { + // // [Instruction::LocalGet(a), Instruction::I32Const(b)] => { + // // self.instructions.pop(); + // // self.instructions.pop(); + // // self.visit(Instruction::I32LocalGetConstAdd(a, b)) + // // } + // _ => self.visit(Instruction::I32Add), + // } } fn visit_block(&mut self, blockty: wasmparser::BlockType) -> Self::Output { @@ -416,7 +418,7 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { match self.instructions[label_pointer] { Instruction::Else(ref mut else_instr_end_offset) => { - *else_instr_end_offset = (current_instr_ptr - label_pointer as usize) + *else_instr_end_offset = (current_instr_ptr - label_pointer) .try_into() .expect("else_instr_end_offset is too large, tinywasm does not support if blocks that large"); diff --git a/crates/tinywasm/src/func.rs b/crates/tinywasm/src/func.rs index 757cb85..d7f7ca1 100644 --- a/crates/tinywasm/src/func.rs +++ b/crates/tinywasm/src/func.rs @@ -22,6 +22,9 @@ impl FuncHandle { /// See #[inline] pub fn call(&self, store: &mut Store, params: &[WasmValue]) -> Result> { + // Comments are ordered by the steps in the spec + // In this implementation, some steps are combined and ordered differently for performance reasons + // 3. Let func_ty be the function type let func_ty = &self.ty; @@ -35,7 +38,7 @@ impl FuncHandle { } // 5. For each value type and the corresponding value, check if types match - if !unlikely(func_ty.params.iter().zip(params).enumerate().all(|(i, (ty, param))| { + if !(func_ty.params.iter().zip(params).enumerate().all(|(i, (ty, param))| { if ty != ¶m.val_type() { log::error!("param type mismatch at index {}: expected {:?}, got {:?}", i, ty, param); false @@ -57,8 +60,8 @@ impl FuncHandle { }; // 6. Let f be the dummy frame - let call_frame = - CallFrame::new(wasm_func.clone(), func_inst.owner, params.iter().map(|v| RawWasmValue::from(*v)), 0); + let call_frame_params = params.iter().map(|v| RawWasmValue::from(*v)); + let call_frame = CallFrame::new(wasm_func.clone(), func_inst.owner, call_frame_params, 0); // 7. Push the frame f to the call stack // & 8. Push the values to the stack (Not needed since the call frame owns the values) @@ -113,6 +116,7 @@ impl FuncHandleTyped { R::from_wasm_value_tuple(&result) } } + macro_rules! impl_into_wasm_value_tuple { ($($T:ident),*) => { impl<$($T),*> IntoWasmValueTuple for ($($T,)*) @@ -140,21 +144,6 @@ macro_rules! impl_into_wasm_value_tuple_single { }; } -impl_into_wasm_value_tuple_single!(i32); -impl_into_wasm_value_tuple_single!(i64); -impl_into_wasm_value_tuple_single!(f32); -impl_into_wasm_value_tuple_single!(f64); - -impl_into_wasm_value_tuple!(); -impl_into_wasm_value_tuple!(T1); -impl_into_wasm_value_tuple!(T1, T2); -impl_into_wasm_value_tuple!(T1, T2, T3); -impl_into_wasm_value_tuple!(T1, T2, T3, T4); -impl_into_wasm_value_tuple!(T1, T2, T3, T4, T5); -impl_into_wasm_value_tuple!(T1, T2, T3, T4, T5, T6); -impl_into_wasm_value_tuple!(T1, T2, T3, T4, T5, T6, T7); -impl_into_wasm_value_tuple!(T1, T2, T3, T4, T5, T6, T7, T8); - macro_rules! impl_from_wasm_value_tuple { ($($T:ident),*) => { impl<$($T),*> FromWasmValueTuple for ($($T,)*) @@ -200,21 +189,6 @@ macro_rules! impl_from_wasm_value_tuple_single { }; } -impl_from_wasm_value_tuple_single!(i32); -impl_from_wasm_value_tuple_single!(i64); -impl_from_wasm_value_tuple_single!(f32); -impl_from_wasm_value_tuple_single!(f64); - -impl_from_wasm_value_tuple!(); -impl_from_wasm_value_tuple!(T1); -impl_from_wasm_value_tuple!(T1, T2); -impl_from_wasm_value_tuple!(T1, T2, T3); -impl_from_wasm_value_tuple!(T1, T2, T3, T4); -impl_from_wasm_value_tuple!(T1, T2, T3, T4, T5); -impl_from_wasm_value_tuple!(T1, T2, T3, T4, T5, T6); -impl_from_wasm_value_tuple!(T1, T2, T3, T4, T5, T6, T7); -impl_from_wasm_value_tuple!(T1, T2, T3, T4, T5, T6, T7, T8); - pub trait ValTypesFromTuple { fn val_types() -> Box<[ValType]>; } @@ -268,19 +242,42 @@ impl ValTypesFromTuple for () { } } -impl ValTypesFromTuple for T1 -where - T1: ToValType, -{ +impl ValTypesFromTuple for T { #[inline] fn val_types() -> Box<[ValType]> { - Box::new([T1::to_val_type()]) + Box::new([T::to_val_type()]) } } +impl_from_wasm_value_tuple_single!(i32); +impl_from_wasm_value_tuple_single!(i64); +impl_from_wasm_value_tuple_single!(f32); +impl_from_wasm_value_tuple_single!(f64); + +impl_into_wasm_value_tuple_single!(i32); +impl_into_wasm_value_tuple_single!(i64); +impl_into_wasm_value_tuple_single!(f32); +impl_into_wasm_value_tuple_single!(f64); + impl_val_types_from_tuple!(T1); impl_val_types_from_tuple!(T1, T2); impl_val_types_from_tuple!(T1, T2, T3); impl_val_types_from_tuple!(T1, T2, T3, T4); impl_val_types_from_tuple!(T1, T2, T3, T4, T5); impl_val_types_from_tuple!(T1, T2, T3, T4, T5, T6); + +impl_from_wasm_value_tuple!(); +impl_from_wasm_value_tuple!(T1); +impl_from_wasm_value_tuple!(T1, T2); +impl_from_wasm_value_tuple!(T1, T2, T3); +impl_from_wasm_value_tuple!(T1, T2, T3, T4); +impl_from_wasm_value_tuple!(T1, T2, T3, T4, T5); +impl_from_wasm_value_tuple!(T1, T2, T3, T4, T5, T6); + +impl_into_wasm_value_tuple!(); +impl_into_wasm_value_tuple!(T1); +impl_into_wasm_value_tuple!(T1, T2); +impl_into_wasm_value_tuple!(T1, T2, T3); +impl_into_wasm_value_tuple!(T1, T2, T3, T4); +impl_into_wasm_value_tuple!(T1, T2, T3, T4, T5); +impl_into_wasm_value_tuple!(T1, T2, T3, T4, T5, T6); diff --git a/crates/tinywasm/src/imports.rs b/crates/tinywasm/src/imports.rs index 522a82d..1c5ca98 100644 --- a/crates/tinywasm/src/imports.rs +++ b/crates/tinywasm/src/imports.rs @@ -157,7 +157,6 @@ impl Extern { }; let ty = tinywasm_types::FuncType { params: P::val_types(), results: R::val_types() }; - Self::Function(Function::Host(Rc::new(HostFunction { func: Box::new(inner_func), ty }))) } diff --git a/crates/tinywasm/src/runtime/interpreter/macros.rs b/crates/tinywasm/src/runtime/interpreter/macros.rs index 9227ceb..30f34fc 100644 --- a/crates/tinywasm/src/runtime/interpreter/macros.rs +++ b/crates/tinywasm/src/runtime/interpreter/macros.rs @@ -12,10 +12,9 @@ macro_rules! break_to { ($cf:ident, $stack:ident, $break_to_relative:ident) => {{ if $cf.break_to(*$break_to_relative, &mut $stack.values, &mut $stack.blocks).is_none() { - if $stack.call_stack.is_empty() { - return Ok(ExecResult::Return); - } else { - return Ok(ExecResult::Call); + match $stack.call_stack.is_empty() { + true => return Ok(ExecResult::Return), + false => return Ok(ExecResult::Call), } } }}; @@ -62,21 +61,15 @@ macro_rules! mem_load { /// Store a value to memory macro_rules! mem_store { ($type:ty, $arg:expr, $stack:ident, $store:ident, $module:ident) => {{ - log::debug!("mem_store!({}, {:?})", stringify!($type), $arg); mem_store!($type, $type, $arg, $stack, $store, $module) }}; ($store_type:ty, $target_type:ty, $arg:expr, $stack:ident, $store:ident, $module:ident) => {{ let (mem_addr, offset) = $arg; - let mem_idx = $module.resolve_mem_addr(*mem_addr); - let mem = $store.get_mem(mem_idx as usize)?; - - let val = $stack.values.pop_t::<$store_type>()?; - let addr: u64 = $stack.values.pop()?.into(); - - let val = val as $store_type; + let mem = $store.get_mem($module.resolve_mem_addr(*mem_addr) as usize)?; + let val: $store_type = $stack.values.pop()?.into(); let val = val.to_le_bytes(); - + let addr: u64 = $stack.values.pop()?.into(); mem.borrow_mut().store((*offset + addr) as usize, val.len(), &val)?; }}; } @@ -103,13 +96,11 @@ macro_rules! float_min_max { /// Convert a value on the stack macro_rules! conv { - ($from:ty, $intermediate:ty, $to:ty, $stack:ident) => {{ - let a = $stack.values.pop_t::<$from>()? as $intermediate; - $stack.values.push((a as $to).into()); - }}; ($from:ty, $to:ty, $stack:ident) => {{ - let a = $stack.values.pop_t::<$from>()?; - $stack.values.push((a as $to).into()); + $stack.values.replace_top(|v| { + let a: $from = v.into(); + (a as $to).into() + }); }}; } @@ -138,13 +129,9 @@ macro_rules! checked_conv_float { /// Compare two values on the stack macro_rules! comp { - ($op:tt, $ty:ty, $stack:ident) => {{ - comp!($op, $ty, $ty, $stack) - }}; - - ($op:tt, $intermediate:ty, $to:ty, $stack:ident) => {{ - let b = $stack.values.pop_t::<$intermediate>()? as $to; - let a = $stack.values.pop_t::<$intermediate>()? as $to; + ($op:tt, $to:ty, $stack:ident) => {{ + let b: $to = $stack.values.pop()?.into(); + let a: $to = $stack.values.pop()?.into(); $stack.values.push(((a $op b) as i32).into()); }}; } @@ -152,62 +139,52 @@ macro_rules! comp { /// Compare a value on the stack to zero macro_rules! comp_zero { ($op:tt, $ty:ty, $stack:ident) => {{ - let a = $stack.values.pop_t::<$ty>()?; + let a: $ty = $stack.values.pop()?.into(); $stack.values.push(((a $op 0) as i32).into()); }}; } /// Apply an arithmetic method to two values on the stack macro_rules! arithmetic { - ($op:ident, $ty:ty, $stack:ident) => { - arithmetic!($op, $ty, $ty, $stack) - }; + ($op:ident, $to:ty, $stack:ident) => {{ + let b: $to = $stack.values.pop()?.into(); + let a: $to = $stack.values.pop()?.into(); + $stack.values.push((a.$op(b) as $to).into()); + }}; // also allow operators such as +, - ($op:tt, $ty:ty, $stack:ident) => {{ - let b: $ty = $stack.values.pop_t()?; - let a: $ty = $stack.values.pop_t()?; + let b: $ty = $stack.values.pop()?.into(); + let a: $ty = $stack.values.pop()?.into(); $stack.values.push((a $op b).into()); }}; - - ($op:ident, $intermediate:ty, $to:ty, $stack:ident) => {{ - let b = $stack.values.pop_t::<$to>()? as $intermediate; - let a = $stack.values.pop_t::<$to>()? as $intermediate; - $stack.values.push((a.$op(b) as $to).into()); - }}; } /// Apply an arithmetic method to a single value on the stack macro_rules! arithmetic_single { ($op:ident, $ty:ty, $stack:ident) => {{ - let a = $stack.values.pop_t::<$ty>()?; + let a: $ty = $stack.values.pop()?.into(); $stack.values.push((a.$op() as $ty).into()); }}; ($op:ident, $from:ty, $to:ty, $stack:ident) => {{ - let a = $stack.values.pop_t::<$from>()?; + let a: $from = $stack.values.pop()?.into(); $stack.values.push((a.$op() as $to).into()); }}; } /// Apply an arithmetic operation to two values on the stack with error checking macro_rules! checked_int_arithmetic { - // Direct conversion with error checking (two types) - ($from:tt, $to:tt, $stack:ident) => {{ - checked_int_arithmetic!($from, $to, $to, $stack) - }}; - - ($op:ident, $from:ty, $to:ty, $stack:ident) => {{ - let b = $stack.values.pop_t::<$from>()? as $to; - let a = $stack.values.pop_t::<$from>()? as $to; + ($op:ident, $to:ty, $stack:ident) => {{ + let b: $to = $stack.values.pop()?.into(); + let a: $to = $stack.values.pop()?.into(); - if b == 0 { + if unlikely(b == 0) { return Err(Error::Trap(crate::Trap::DivisionByZero)); } let result = a.$op(b).ok_or_else(|| Error::Trap(crate::Trap::IntegerOverflow))?; - // Cast back to original type if different - $stack.values.push((result as $from).into()); + $stack.values.push((result).into()); }}; } diff --git a/crates/tinywasm/src/runtime/interpreter/mod.rs b/crates/tinywasm/src/runtime/interpreter/mod.rs index bd07051..007acaa 100644 --- a/crates/tinywasm/src/runtime/interpreter/mod.rs +++ b/crates/tinywasm/src/runtime/interpreter/mod.rs @@ -79,14 +79,14 @@ enum ExecResult { #[inline(always)] fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &ModuleInstance) -> Result { let instrs = &cf.func_instance.0.instructions; + if unlikely(cf.instr_ptr >= instrs.len() || instrs.is_empty()) { - cold(); log::error!("instr_ptr out of bounds: {} >= {}", cf.instr_ptr, instrs.len()); return Err(Error::Other(format!("instr_ptr out of bounds: {} >= {}", cf.instr_ptr, instrs.len()))); } // A match statement is probably the fastest way to do this without - // unreasonable complexity + // unreasonable complexity. This *should* be optimized to a jump table. // See https://pliniker.github.io/post/dispatchers/ use tinywasm_types::Instruction::*; match cf.current_instruction() { @@ -144,14 +144,10 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M let table_idx = stack.values.pop_t::()?; // verify that the table is of the right type, this should be validated by the parser already - assert!(table.borrow().kind.element_type == ValType::RefFunc, "table is not of type funcref"); - let func_ref = { - table - .borrow() - .get(table_idx as usize)? - .addr() - .ok_or(Trap::UninitializedElement { index: table_idx as usize })? + let table = table.borrow(); + assert!(table.kind.element_type == ValType::RefFunc, "table is not of type funcref"); + table.get(table_idx as usize)?.addr().ok_or(Trap::UninitializedElement { index: table_idx as usize })? }; let func_inst = store.get_func(func_ref as usize)?.clone(); @@ -238,7 +234,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M cf.instr_ptr + *end_offset as usize, stack.values.len(), BlockType::Loop, - &args, + args, module, ), &mut stack.values, @@ -251,9 +247,9 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M BlockFrame::new( cf.instr_ptr, cf.instr_ptr + *end_offset as usize, - stack.values.len(), // - params, + stack.values.len(), BlockType::Block, - &args, + args, module, ), &mut stack.values, @@ -282,7 +278,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } let idx = stack.values.pop_t::()? as usize; - let to = instr.get(idx).unwrap_or(&default); + let to = instr.get(idx).unwrap_or(default); break_to!(cf, stack, to); } @@ -335,13 +331,10 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M LocalGet(local_index) => stack.values.push(cf.get_local(*local_index as usize)), LocalSet(local_index) => cf.set_local(*local_index as usize, stack.values.pop()?), LocalTee(local_index) => { + let local = stack.values.last(); cf.set_local( *local_index as usize, - stack - .values - .last() - .expect("localtee: stack is empty. this should have been validated by the parser") - .clone(), + *local.expect("localtee: stack is empty. this should have been validated by the parser"), ); } @@ -362,8 +355,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M F64Const(val) => stack.values.push((*val).into()), MemorySize(addr, byte) => { - if *byte != 0 { - cold(); + if unlikely(*byte != 0) { return Err(Error::UnsupportedFeature("memory.size with byte != 0".to_string())); } @@ -373,8 +365,7 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } MemoryGrow(addr, byte) => { - if *byte != 0 { - cold(); + if unlikely(*byte != 0) { return Err(Error::UnsupportedFeature("memory.grow with byte != 0".to_string())); } @@ -395,9 +386,9 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M // Bulk memory operations MemoryCopy(from, to) => { - let size = stack.values.pop_t::()?; - let src = stack.values.pop_t::()?; - let dst = stack.values.pop_t::()?; + let size: i32 = stack.values.pop()?.into(); + let src: i32 = stack.values.pop()?.into(); + let dst: i32 = stack.values.pop()?.into(); let mem = store.get_mem(module.resolve_mem_addr(*from) as usize)?; let mut mem = mem.borrow_mut(); @@ -414,9 +405,9 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M } MemoryFill(addr) => { - let size = stack.values.pop_t::()?; - let val = stack.values.pop_t::()?; - let dst = stack.values.pop_t::()?; + let size: i32 = stack.values.pop()?.into(); + let val: i32 = stack.values.pop()?.into(); + let dst: i32 = stack.values.pop()?.into(); let mem = store.get_mem(module.resolve_mem_addr(*addr) as usize)?; let mut mem = mem.borrow_mut(); @@ -428,26 +419,20 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M let offset = stack.values.pop_t::()? as usize; let dst = stack.values.pop_t::()? as usize; - let data_idx = module.resolve_data_addr(*data_index); - let Some(ref data) = store.get_data(data_idx as usize)?.data else { - cold(); - return Err(Trap::MemoryOutOfBounds { offset: 0, len: 0, max: 0 }.into()); + let data = match &store.get_data(module.resolve_data_addr(*data_index) as usize)?.data { + Some(data) => data, + None => return Err(Trap::MemoryOutOfBounds { offset: 0, len: 0, max: 0 }.into()), }; - let mem_idx = module.resolve_mem_addr(*mem_index); - let mem = store.get_mem(mem_idx as usize)?; - - let data_len = data.len(); - if offset + size > data_len { - cold(); - return Err(Trap::MemoryOutOfBounds { offset, len: size, max: data_len }.into()); + if unlikely(offset + size > data.len()) { + return Err(Trap::MemoryOutOfBounds { offset, len: size, max: data.len() }.into()); } + let mem = store.get_mem(module.resolve_mem_addr(*mem_index) as usize)?; let mut mem = mem.borrow_mut(); - let data = &data[offset..(offset + size)]; // mem.store checks bounds - mem.store(dst, size, data)?; + mem.store(dst, size, &data[offset..(offset + size)])?; } DataDrop(data_index) => { @@ -496,29 +481,29 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M I32LtS => comp!(<, i32, stack), I64LtS => comp!(<, i64, stack), - I32LtU => comp!(<, i32, u32, stack), - I64LtU => comp!(<, i64, u64, stack), + I32LtU => comp!(<, u32, stack), + I64LtU => comp!(<, u64, stack), F32Lt => comp!(<, f32, stack), F64Lt => comp!(<, f64, stack), I32LeS => comp!(<=, i32, stack), I64LeS => comp!(<=, i64, stack), - I32LeU => comp!(<=, i32, u32, stack), - I64LeU => comp!(<=, i64, u64, stack), + I32LeU => comp!(<=, u32, stack), + I64LeU => comp!(<=, u64, stack), F32Le => comp!(<=, f32, stack), F64Le => comp!(<=, f64, stack), I32GeS => comp!(>=, i32, stack), I64GeS => comp!(>=, i64, stack), - I32GeU => comp!(>=, i32, u32, stack), - I64GeU => comp!(>=, i64, u64, stack), + I32GeU => comp!(>=, u32, stack), + I64GeU => comp!(>=, u64, stack), F32Ge => comp!(>=, f32, stack), F64Ge => comp!(>=, f64, stack), I32GtS => comp!(>, i32, stack), I64GtS => comp!(>, i64, stack), - I32GtU => comp!(>, i32, u32, stack), - I64GtU => comp!(>, i64, u64, stack), + I32GtU => comp!(>, u32, stack), + I64GtU => comp!(>, u64, stack), F32Gt => comp!(>, f32, stack), F64Gt => comp!(>, f64, stack), @@ -543,13 +528,13 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M // these can trap I32DivS => checked_int_arithmetic!(checked_div, i32, stack), I64DivS => checked_int_arithmetic!(checked_div, i64, stack), - I32DivU => checked_int_arithmetic!(checked_div, i32, u32, stack), - I64DivU => checked_int_arithmetic!(checked_div, i64, u64, stack), + I32DivU => checked_int_arithmetic!(checked_div, u32, stack), + I64DivU => checked_int_arithmetic!(checked_div, u64, stack), I32RemS => checked_int_arithmetic!(checked_wrapping_rem, i32, stack), I64RemS => checked_int_arithmetic!(checked_wrapping_rem, i64, stack), - I32RemU => checked_int_arithmetic!(checked_wrapping_rem, i32, u32, stack), - I64RemU => checked_int_arithmetic!(checked_wrapping_rem, i64, u64, stack), + I32RemU => checked_int_arithmetic!(checked_wrapping_rem, u32, stack), + I64RemU => checked_int_arithmetic!(checked_wrapping_rem, u64, stack), I32And => arithmetic!(bitand, i32, stack), I64And => arithmetic!(bitand, i64, stack), @@ -561,8 +546,8 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M I64Shl => arithmetic!(wasm_shl, i64, stack), I32ShrS => arithmetic!(wasm_shr, i32, stack), I64ShrS => arithmetic!(wasm_shr, i64, stack), - I32ShrU => arithmetic!(wasm_shr, u32, i32, stack), - I64ShrU => arithmetic!(wasm_shr, u64, i64, stack), + I32ShrU => arithmetic!(wasm_shr, u32, stack), + I64ShrU => arithmetic!(wasm_shr, u64, stack), I32Rotl => arithmetic!(wasm_rotl, i32, stack), I64Rotl => arithmetic!(wasm_rotl, i64, stack), I32Rotr => arithmetic!(wasm_rotr, i32, stack), @@ -579,16 +564,16 @@ fn exec_one(cf: &mut CallFrame, stack: &mut Stack, store: &mut Store, module: &M F32ConvertI64S => conv!(i64, f32, stack), F64ConvertI32S => conv!(i32, f64, stack), F64ConvertI64S => conv!(i64, f64, stack), - F32ConvertI32U => conv!(i32, u32, f32, stack), - F32ConvertI64U => conv!(i64, u64, f32, stack), - F64ConvertI32U => conv!(i32, u32, f64, stack), - F64ConvertI64U => conv!(i64, u64, f64, stack), - I32Extend8S => conv!(i32, i8, i32, stack), - I32Extend16S => conv!(i32, i16, i32, stack), - I64Extend8S => conv!(i64, i8, i64, stack), - I64Extend16S => conv!(i64, i16, i64, stack), - I64Extend32S => conv!(i64, i32, i64, stack), - I64ExtendI32U => conv!(i32, u32, i64, stack), + F32ConvertI32U => conv!(u32, f32, stack), + F32ConvertI64U => conv!(u64, f32, stack), + F64ConvertI32U => conv!(u32, f64, stack), + F64ConvertI64U => conv!(u64, f64, stack), + I32Extend8S => conv!(i8, i32, stack), + I32Extend16S => conv!(i16, i32, stack), + I64Extend8S => conv!(i8, i64, stack), + I64Extend16S => conv!(i16, i64, stack), + I64Extend32S => conv!(i32, i64, stack), + I64ExtendI32U => conv!(u32, i64, stack), I64ExtendI32S => conv!(i32, i64, stack), I32WrapI64 => conv!(i64, i32, stack), diff --git a/crates/tinywasm/src/runtime/interpreter/no_std_floats.rs b/crates/tinywasm/src/runtime/interpreter/no_std_floats.rs index 91c74b5..5b9471e 100644 --- a/crates/tinywasm/src/runtime/interpreter/no_std_floats.rs +++ b/crates/tinywasm/src/runtime/interpreter/no_std_floats.rs @@ -9,85 +9,26 @@ pub(super) trait NoStdFloatExt { fn copysign(self, other: Self) -> Self; } +#[rustfmt::skip] impl NoStdFloatExt for f64 { - #[inline] - fn round(self) -> Self { - libm::round(self) - } - - #[inline] - fn abs(self) -> Self { - libm::fabs(self) - } - - #[inline] - fn signum(self) -> Self { - libm::copysign(1.0, self) - } - - #[inline] - fn ceil(self) -> Self { - libm::ceil(self) - } - - #[inline] - fn floor(self) -> Self { - libm::floor(self) - } - - #[inline] - fn trunc(self) -> Self { - libm::trunc(self) - } - - #[inline] - fn sqrt(self) -> Self { - libm::sqrt(self) - } - - #[inline] - fn copysign(self, other: Self) -> Self { - libm::copysign(self, other) - } + #[inline] fn round(self) -> Self { libm::round(self) } + #[inline] fn abs(self) -> Self { libm::fabs(self) } + #[inline] fn signum(self) -> Self { libm::copysign(1.0, self) } + #[inline] fn ceil(self) -> Self { libm::ceil(self) } + #[inline] fn floor(self) -> Self { libm::floor(self) } + #[inline] fn trunc(self) -> Self { libm::trunc(self) } + #[inline] fn sqrt(self) -> Self { libm::sqrt(self) } + #[inline] fn copysign(self, other: Self) -> Self { libm::copysign(self, other) } } -impl NoStdFloatExt for f32 { - #[inline] - fn round(self) -> Self { - libm::roundf(self) - } - #[inline] - fn abs(self) -> Self { - libm::fabsf(self) - } - - #[inline] - fn signum(self) -> Self { - libm::copysignf(1.0, self) - } - - #[inline] - fn ceil(self) -> Self { - libm::ceilf(self) - } - - #[inline] - fn floor(self) -> Self { - libm::floorf(self) - } - - #[inline] - fn trunc(self) -> Self { - libm::truncf(self) - } - - #[inline] - fn sqrt(self) -> Self { - libm::sqrtf(self) - } - - #[inline] - fn copysign(self, other: Self) -> Self { - libm::copysignf(self, other) - } +#[rustfmt::skip] +impl NoStdFloatExt for f32 { + #[inline] fn round(self) -> Self { libm::roundf(self) } + #[inline] fn abs(self) -> Self { libm::fabsf(self) } + #[inline] fn signum(self) -> Self { libm::copysignf(1.0, self) } + #[inline] fn ceil(self) -> Self { libm::ceilf(self) } + #[inline] fn floor(self) -> Self { libm::floorf(self) } + #[inline] fn trunc(self) -> Self { libm::truncf(self) } + #[inline] fn sqrt(self) -> Self { libm::sqrtf(self) } + #[inline] fn copysign(self, other: Self) -> Self { libm::copysignf(self, other) } } diff --git a/crates/tinywasm/src/runtime/interpreter/traits.rs b/crates/tinywasm/src/runtime/interpreter/traits.rs index 523265b..7aeb3b7 100644 --- a/crates/tinywasm/src/runtime/interpreter/traits.rs +++ b/crates/tinywasm/src/runtime/interpreter/traits.rs @@ -24,23 +24,15 @@ macro_rules! impl_wasm_float_ops { x if x.is_infinite() || x == 0.0 => x, // preserve infinities and zeros x if (0.0..=0.5).contains(&x) => 0.0, x if (-0.5..0.0).contains(&x) => -0.0, - // x => x.round(), x => { // Handle normal and halfway cases let rounded = x.round(); let diff = (x - rounded).abs(); - - if diff == 0.5 { - // Halfway case: round to even - if rounded % 2.0 == 0.0 { - rounded // Already even - } else { - rounded - x.signum() // Make even - } - } else { - // Normal case - rounded + if diff != 0.5 || rounded % 2.0 == 0.0 { + return rounded } + + rounded - x.signum() // Make even } } } @@ -49,15 +41,11 @@ macro_rules! impl_wasm_float_ops { // Based on f32::minimum (which is not yet stable) #[inline] fn tw_minimum(self, other: Self) -> Self { - if self < other { - self - } else if other < self { - other - } else if self == other { - if self.is_sign_negative() && other.is_sign_positive() { self } else { other } - } else { - // At least one input is NaN. Use `+` to perform NaN propagation and quieting. - self + other + match self.partial_cmp(&other) { + Some(core::cmp::Ordering::Less) => self, + Some(core::cmp::Ordering::Greater) => other, + Some(core::cmp::Ordering::Equal) => if self.is_sign_negative() && other.is_sign_positive() { self } else { other }, + None => self + other, // At least one input is NaN. Use `+` to perform NaN propagation and quieting. } } @@ -65,15 +53,11 @@ macro_rules! impl_wasm_float_ops { // Based on f32::maximum (which is not yet stable) #[inline] fn tw_maximum(self, other: Self) -> Self { - if self > other { - self - } else if other > self { - other - } else if self == other { - if self.is_sign_negative() && other.is_sign_positive() { other } else { self } - } else { - // At least one input is NaN. Use `+` to perform NaN propagation and quieting. - self + other + match self.partial_cmp(&other) { + Some(core::cmp::Ordering::Greater) => self, + Some(core::cmp::Ordering::Less) => other, + Some(core::cmp::Ordering::Equal) => if self.is_sign_negative() && other.is_sign_positive() { other } else { self }, + None => self + other, // At least one input is NaN. Use `+` to perform NaN propagation and quieting. } } } diff --git a/crates/tinywasm/src/runtime/stack/call_stack.rs b/crates/tinywasm/src/runtime/stack/call_stack.rs index 14ad050..12270d1 100644 --- a/crates/tinywasm/src/runtime/stack/call_stack.rs +++ b/crates/tinywasm/src/runtime/stack/call_stack.rs @@ -143,7 +143,7 @@ impl CallFrame { self.locals[local_index] } - #[inline] + #[inline(always)] pub(crate) fn instructions(&self) -> &[Instruction] { &self.func_instance.0.instructions } diff --git a/crates/tinywasm/src/runtime/stack/value_stack.rs b/crates/tinywasm/src/runtime/stack/value_stack.rs index c6d7918..5903228 100644 --- a/crates/tinywasm/src/runtime/stack/value_stack.rs +++ b/crates/tinywasm/src/runtime/stack/value_stack.rs @@ -33,6 +33,16 @@ impl ValueStack { self.stack.extend_from_slice(values); } + #[inline] + pub(crate) fn replace_top(&mut self, func: impl FnOnce(RawWasmValue) -> RawWasmValue) { + let len = self.stack.len(); + if unlikely(len == 0) { + return; + } + let top = self.stack[len - 1]; + self.stack[len - 1] = func(top); + } + #[inline] pub(crate) fn len(&self) -> usize { self.stack.len() @@ -53,7 +63,7 @@ impl ValueStack { self.stack.drain(remove_start_index..remove_end_index); } - #[inline] + #[inline(always)] pub(crate) fn push(&mut self, value: RawWasmValue) { self.stack.push(value); } diff --git a/crates/tinywasm/src/store/mod.rs b/crates/tinywasm/src/store/mod.rs index a3d99fe..f4e0df9 100644 --- a/crates/tinywasm/src/store/mod.rs +++ b/crates/tinywasm/src/store/mod.rs @@ -172,11 +172,8 @@ impl Store { /// Set the global at the actual index in the store #[inline] pub(crate) fn set_global_val(&mut self, addr: usize, value: RawWasmValue) -> Result<()> { - self.data - .globals - .get(addr) - .ok_or_else(|| Self::not_found_error("global")) - .map(|global| global.borrow_mut().value = value) + let global = self.data.globals.get(addr).ok_or_else(|| Self::not_found_error("global")); + global.map(|global| global.borrow_mut().value = value) } } @@ -190,12 +187,10 @@ impl Store { ) -> Result> { let func_count = self.data.funcs.len(); let mut func_addrs = Vec::with_capacity(func_count); - for (i, func) in funcs.into_iter().enumerate() { self.data.funcs.push(FunctionInstance::new_wasm(func.wasm_function, idx)); func_addrs.push((i + func_count) as FuncAddr); } - Ok(func_addrs) } @@ -264,10 +259,9 @@ impl Store { let val = i64::from(global.borrow().value); // check if the global is actually a null reference - if val < 0 { - None - } else { - Some(val as u32) + match val < 0 { + true => None, + false => Some(val as u32), } } _ => return Err(Error::UnsupportedFeature(format!("const expression other than ref: {:?}", item))), @@ -300,10 +294,7 @@ impl Store { ElementKind::Passive => Some(init), // this one is not available to the runtime but needs to be initialized to declare references - ElementKind::Declared => { - // a. Execute the instruction elm.drop i - None - } + ElementKind::Declared => None, // a. Execute the instruction elm.drop i // this one is active, so we need to initialize it (essentially a `table.init` instruction) ElementKind::Active { offset, table } => { @@ -313,17 +304,17 @@ impl Store { .copied() .ok_or_else(|| Error::Other(format!("table {} not found for element {}", table, i)))?; - if let Some(table) = self.data.tables.get_mut(table_addr as usize) { - // In wasm 2.0, it's possible to call a function that hasn't been instantiated yet, - // when using a partially initialized active element segments. - // This isn't mentioned in the spec, but the "unofficial" testsuite has a test for it: - // https://github.com/WebAssembly/testsuite/blob/5a1a590603d81f40ef471abba70a90a9ae5f4627/linking.wast#L264-L276 - // I have NO IDEA why this is allowed, but it is. - if let Err(Error::Trap(trap)) = table.borrow_mut().init_raw(offset, &init) { - return Ok((elem_addrs.into_boxed_slice(), Some(trap))); - } - } else { + let Some(table) = self.data.tables.get_mut(table_addr as usize) else { return Err(Error::Other(format!("table {} not found for element {}", table, i))); + }; + + // In wasm 2.0, it's possible to call a function that hasn't been instantiated yet, + // when using a partially initialized active element segments. + // This isn't mentioned in the spec, but the "unofficial" testsuite has a test for it: + // https://github.com/WebAssembly/testsuite/blob/5a1a590603d81f40ef471abba70a90a9ae5f4627/linking.wast#L264-L276 + // I have NO IDEA why this is allowed, but it is. + if let Err(Error::Trap(trap)) = table.borrow_mut().init_raw(offset, &init) { + return Ok((elem_addrs.into_boxed_slice(), Some(trap))); } // f. Execute the instruction elm.drop i @@ -356,26 +347,20 @@ impl Store { return Err(Error::UnsupportedFeature("data segments for non-zero memories".to_string())); } - let mem_addr = mem_addrs - .get(mem_addr as usize) - .copied() - .ok_or_else(|| Error::Other(format!("memory {} not found for data segment {}", mem_addr, i)))?; + let Some(mem_addr) = mem_addrs.get(mem_addr as usize) else { + return Err(Error::Other(format!("memory {} not found for data segment {}", mem_addr, i))); + }; let offset = self.eval_i32_const(&offset)?; - - let mem = - self.data.memories.get_mut(mem_addr as usize).ok_or_else(|| { - Error::Other(format!("memory {} not found for data segment {}", mem_addr, i)) - })?; - - // See comment for active element sections in the function above why we need to do this here - if let Err(Error::Trap(trap)) = mem.borrow_mut().store(offset as usize, data.data.len(), &data.data) - { - return Ok((data_addrs.into_boxed_slice(), Some(trap))); + let Some(mem) = self.data.memories.get_mut(*mem_addr as usize) else { + return Err(Error::Other(format!("memory {} not found for data segment {}", mem_addr, i))); + }; + + match mem.borrow_mut().store(offset as usize, data.data.len(), &data.data) { + Ok(()) => None, + Err(Error::Trap(trap)) => return Ok((data_addrs.into_boxed_slice(), Some(trap))), + Err(e) => return Err(e), } - - // drop the data - None } tinywasm_types::DataKind::Passive => Some(data.data.to_vec()), }; @@ -417,10 +402,8 @@ impl Store { let val = match const_instr { I32Const(i) => *i, GlobalGet(addr) => { - let addr = *addr as usize; - let global = self.data.globals[addr].clone(); - let val = global.borrow().value; - i32::from(val) + let global = self.data.globals[*addr as usize].borrow(); + i32::from(global.value) } _ => return Err(Error::Other("expected i32".to_string())), }; @@ -441,17 +424,17 @@ impl Store { I32Const(i) => RawWasmValue::from(*i), I64Const(i) => RawWasmValue::from(*i), GlobalGet(addr) => { - let addr = module_global_addrs.get(*addr as usize).copied().ok_or_else(|| { + let addr = module_global_addrs.get(*addr as usize).ok_or_else(|| { Error::Other(format!("global {} not found. This should have been caught by the validator", addr)) })?; let global = - self.data.globals.get(addr as usize).expect("global not found. This should be unreachable"); + self.data.globals.get(*addr as usize).expect("global not found. This should be unreachable"); global.borrow().value } RefNull(t) => RawWasmValue::from(t.default_value()), - RefFunc(idx) => RawWasmValue::from(module_func_addrs.get(*idx as usize).copied().ok_or_else(|| { + RefFunc(idx) => RawWasmValue::from(*module_func_addrs.get(*idx as usize).ok_or_else(|| { Error::Other(format!("function {} not found. This should have been caught by the validator", idx)) })?), }; diff --git a/crates/tinywasm/src/store/table.rs b/crates/tinywasm/src/store/table.rs index 1b31999..d9dd9ad 100644 --- a/crates/tinywasm/src/store/table.rs +++ b/crates/tinywasm/src/store/table.rs @@ -1,4 +1,4 @@ -use crate::log; +use crate::{log, unlikely}; use crate::{Error, Result, Trap}; use alloc::{vec, vec::Vec}; use tinywasm_types::*; @@ -40,7 +40,7 @@ impl TableInstance { pub(crate) fn grow_to_fit(&mut self, new_size: usize) -> Result<()> { if new_size > self.elements.len() { - if new_size > self.kind.size_max.unwrap_or(MAX_TABLE_SIZE) as usize { + if unlikely(new_size > self.kind.size_max.unwrap_or(MAX_TABLE_SIZE) as usize) { return Err(crate::Trap::TableOutOfBounds { offset: new_size, len: 1, max: self.elements.len() }.into()); } diff --git a/crates/types/src/instructions.rs b/crates/types/src/instructions.rs index 537b8d7..9923116 100644 --- a/crates/types/src/instructions.rs +++ b/crates/types/src/instructions.rs @@ -94,7 +94,7 @@ pub enum Instruction { // LocalGet + I32Const + I32Store => I32LocalGetConstStore + I32Const // Also common, helps us skip the stack entirely. // Has to be followed by an I32Const instruction - // I32LocalGetConstStore { local: LocalAddr, offset: i32, mem_addr: MemAddr }, // I32Store + LocalGet + I32Const + // I32StoreLocal { local: LocalAddr, offset: i32, mem_addr: MemAddr }, // I64Xor + I64Const + I64RotL // Commonly used by a few crypto libraries diff --git a/crates/types/src/value.rs b/crates/types/src/value.rs index df062ce..bcd43e5 100644 --- a/crates/types/src/value.rs +++ b/crates/types/src/value.rs @@ -142,7 +142,7 @@ impl ValType { WasmValue::default_for(*self) } - pub(crate) fn to_byte(&self) -> u8 { + pub(crate) fn to_byte(self) -> u8 { match self { ValType::I32 => 0x7F, ValType::I64 => 0x7E, From cfe8b708a82dd42b65d3ed4bef7577ed8737cd22 Mon Sep 17 00:00:00 2001 From: Henry Gressmann Date: Tue, 27 Feb 2024 16:29:18 +0100 Subject: [PATCH 7/9] chore: remove recursive macro from parser Signed-off-by: Henry Gressmann --- Cargo.lock | 4 +- crates/parser/Cargo.toml | 2 +- crates/parser/src/lib.rs | 1 - crates/parser/src/visit.rs | 96 +++++++++++--------------------------- 4 files changed, 29 insertions(+), 74 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index a6fdbbd..8edaba3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2120,9 +2120,9 @@ dependencies = [ [[package]] name = "tinywasm-wasmparser" -version = "0.200.2" +version = "0.200.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b9fce1b3563499af272f7e88c8b0357e740e62c2bcf59f134992698d35af96da" +checksum = "365709f885b90cad71c71120414f99255e74d9d03f232618d9d1c6eb5db0ea99" dependencies = [ "ahash 0.8.9", "bitflags 2.4.2", diff --git a/crates/parser/Cargo.toml b/crates/parser/Cargo.toml index 73eec99..3be0bb1 100644 --- a/crates/parser/Cargo.toml +++ b/crates/parser/Cargo.toml @@ -9,7 +9,7 @@ repository.workspace=true [dependencies] # fork of wasmparser with no_std support, see https://github.com/bytecodealliance/wasmtime/issues/3495 -wasmparser={version="0.200.2", package="tinywasm-wasmparser", default-features=false} +wasmparser={version="0.200.3", package="tinywasm-wasmparser", default-features=false} log={version="0.4", optional=true} tinywasm-types={version="0.4.0", path="../types", default-features=false} diff --git a/crates/parser/src/lib.rs b/crates/parser/src/lib.rs index 5de4b03..7beb5f8 100644 --- a/crates/parser/src/lib.rs +++ b/crates/parser/src/lib.rs @@ -7,7 +7,6 @@ #![forbid(unsafe_code)] #![cfg_attr(not(feature = "std"), feature(error_in_core))] //! See [`tinywasm`](https://docs.rs/tinywasm) for documentation. -#![recursion_limit = "1028"] mod std; extern crate alloc; diff --git a/crates/parser/src/visit.rs b/crates/parser/src/visit.rs index 88b6ba5..cc9f0e2 100644 --- a/crates/parser/src/visit.rs +++ b/crates/parser/src/visit.rs @@ -71,6 +71,14 @@ macro_rules! define_primitive_operands { } )* }; + ($($name:ident, $instr:expr, $ty:ty, $ty2:ty),*) => { + $( + fn $name(&mut self, arg: $ty, arg2: $ty) -> Self::Output { + self.instructions.push($instr(arg, arg2)); + Ok(()) + } + )* + }; } macro_rules! define_mem_operands { @@ -88,34 +96,6 @@ macro_rules! define_mem_operands { }; } -macro_rules! impl_visit_operator { - ( @mvp $($rest:tt)* ) => { - impl_visit_operator!(@@skipped $($rest)*); - }; - ( @sign_extension $($rest:tt)* ) => { - impl_visit_operator!(@@skipped $($rest)*); - }; - ( @saturating_float_to_int $($rest:tt)* ) => { - impl_visit_operator!(@@skipped $($rest)*); - }; - ( @bulk_memory $($rest:tt)* ) => { - impl_visit_operator!(@@skipped $($rest)*); - }; - ( @reference_types $($rest:tt)* ) => { - impl_visit_operator!(@@skipped $($rest)*); - }; - ( @@skipped $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident $($rest:tt)* ) => { - impl_visit_operator!($($rest)*); - }; - ( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident $($rest:tt)* ) => { - fn $visit(&mut self $($(, $arg: $argty)*)?) -> Self::Output { - self.unsupported(stringify!($op)) - } - impl_visit_operator!($($rest)*); - }; - () => {}; -} - pub(crate) struct FunctionBuilder { instructions: Vec, label_ptrs: Vec, @@ -141,6 +121,10 @@ impl FunctionBuilder { impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { type Output = Result<()>; + fn visit_default(&mut self, op: &str) -> Self::Output { + self.unsupported(op) + } + define_primitive_operands! { visit_br, Instruction::Br, u32, visit_br_if, Instruction::BrIf, u32, @@ -329,7 +313,6 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { match instruction { Instruction::LocalGet(a) => *instruction = Instruction::LocalGet2(*a, idx), Instruction::LocalGet2(a, b) => *instruction = Instruction::LocalGet3(*a, *b, idx), - // Instruction::LocalGet3(a, b, c) => *instruction = Instruction::LocalGet4(*a, *b, *c, idx), Instruction::LocalTee(a) => *instruction = Instruction::LocalTeeGet(*a, idx), _ => return self.visit(Instruction::LocalGet(idx)), }; @@ -502,24 +485,14 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { // Bulk Memory Operations - fn visit_memory_init(&mut self, data_index: u32, mem: u32) -> Self::Output { - self.visit(Instruction::MemoryInit(data_index, mem)) - } - - fn visit_data_drop(&mut self, data_index: u32) -> Self::Output { - self.visit(Instruction::DataDrop(data_index)) - } - - fn visit_memory_copy(&mut self, dst_mem: u32, src_mem: u32) -> Self::Output { - self.visit(Instruction::MemoryCopy(dst_mem, src_mem)) - } - - fn visit_memory_fill(&mut self, mem: u32) -> Self::Output { - self.visit(Instruction::MemoryFill(mem)) + define_primitive_operands! { + visit_memory_init, Instruction::MemoryInit, u32, u32, + visit_memory_copy, Instruction::MemoryCopy, u32, u32, + visit_table_init, Instruction::TableInit, u32, u32 } - - fn visit_table_init(&mut self, elem_index: u32, table: u32) -> Self::Output { - self.visit(Instruction::TableInit(elem_index, table)) + define_primitive_operands! { + visit_memory_fill, Instruction::MemoryFill, u32, + visit_data_drop, Instruction::DataDrop, u32 } fn visit_elem_drop(&mut self, _elem_index: u32) -> Self::Output { @@ -540,33 +513,16 @@ impl<'a> wasmparser::VisitOperator<'a> for FunctionBuilder { self.visit(Instruction::RefIsNull) } - fn visit_ref_func(&mut self, idx: u32) -> Self::Output { - self.visit(Instruction::RefFunc(idx)) - } - fn visit_typed_select(&mut self, ty: wasmparser::ValType) -> Self::Output { self.visit(Instruction::Select(Some(convert_valtype(&ty)))) } - fn visit_table_fill(&mut self, table: u32) -> Self::Output { - self.visit(Instruction::TableFill(table)) - } - - fn visit_table_get(&mut self, table: u32) -> Self::Output { - self.visit(Instruction::TableGet(table)) - } - - fn visit_table_set(&mut self, table: u32) -> Self::Output { - self.visit(Instruction::TableSet(table)) - } - - fn visit_table_grow(&mut self, table: u32) -> Self::Output { - self.visit(Instruction::TableGrow(table)) - } - - fn visit_table_size(&mut self, table: u32) -> Self::Output { - self.visit(Instruction::TableSize(table)) + define_primitive_operands! { + visit_ref_func, Instruction::RefFunc, u32, + visit_table_fill, Instruction::TableFill, u32, + visit_table_get, Instruction::TableGet, u32, + visit_table_set, Instruction::TableSet, u32, + visit_table_grow, Instruction::TableGrow, u32, + visit_table_size, Instruction::TableSize, u32 } - - wasmparser::for_each_operator!(impl_visit_operator); } From ef13c584654e243dfd4c1c9d3979a386c297dfd3 Mon Sep 17 00:00:00 2001 From: Henry Gressmann Date: Tue, 27 Feb 2024 16:42:18 +0100 Subject: [PATCH 8/9] chore: update benchmark results Signed-off-by: Henry Gressmann --- BENCHMARKS.md | 10 +++++----- crates/benchmarks/benches/argon2id.rs | 6 +++--- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/BENCHMARKS.md b/BENCHMARKS.md index 5189b55..2cded9d 100644 --- a/BENCHMARKS.md +++ b/BENCHMARKS.md @@ -30,12 +30,12 @@ All runtimes are compiled with the following settings: | Benchmark | Native | TinyWasm\* | Wasmi | Wasmer (Single Pass) | | ------------ | -------- | ---------- | --------- | -------------------- | -| `fib` | \*\* | ` 43.81µs` | `48.60µs` | ` 43.97µs` | -| `fib-rec` | `0.26ms` | ` 20.99ms` | ` 4.64ms` | ` 0.50ms` | -| `argon2id` | `0.53ms` | `107.77ms` | `47.76ms` | ` 4.49ms` | -| `selfhosted` | `0.06ms` | ` 2.88ms` | ` 6.20ms` | `359.33ms` | +| `fib` | \*\* | ` 43.60µs` | `48.27µs` | ` 44.99µs` | +| `fib-rec` | `0.27ms` | ` 21.13ms` | ` 4.63ms` | ` 0.47ms` | +| `argon2id` | `0.53ms` | ` 99.16ms` | `45.00ms` | ` 4.59ms` | +| `selfhosted` | `0.05ms` | ` 1.84ms` | ` 6.51ms` | `446.48ms` | -_\* converting WASM to TinyWasm bytecode is not included. I takes ~7ms to convert `tinywasm.wasm` to TinyWasm bytecode._ +_\* converting WASM to TinyWasm bytecode is not included. I takes ~5.7ms to convert `tinywasm.wasm` to TinyWasm bytecode._ _\*\* essentially instant as it gets computed at compile time._ ### Fib diff --git a/crates/benchmarks/benches/argon2id.rs b/crates/benchmarks/benches/argon2id.rs index a503687..7c1ffc5 100644 --- a/crates/benchmarks/benches/argon2id.rs +++ b/crates/benchmarks/benches/argon2id.rs @@ -45,10 +45,10 @@ fn criterion_benchmark(c: &mut Criterion) { group.measurement_time(std::time::Duration::from_secs(7)); group.sample_size(10); - // group.bench_function("native", |b| b.iter(|| run_native(black_box(params)))); + group.bench_function("native", |b| b.iter(|| run_native(black_box(params)))); group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(&twasm, black_box(params), "argon2id"))); - // group.bench_function("wasmi", |b| b.iter(|| run_wasmi(ARGON2ID, black_box(params), "argon2id"))); - // group.bench_function("wasmer", |b| b.iter(|| run_wasmer(ARGON2ID, black_box(params), "argon2id"))); + group.bench_function("wasmi", |b| b.iter(|| run_wasmi(ARGON2ID, black_box(params), "argon2id"))); + group.bench_function("wasmer", |b| b.iter(|| run_wasmer(ARGON2ID, black_box(params), "argon2id"))); } criterion_group!( From 417bb70c0f8c8f8781f675481e5336affd209183 Mon Sep 17 00:00:00 2001 From: Henry Gressmann Date: Tue, 27 Feb 2024 17:00:29 +0100 Subject: [PATCH 9/9] chore: update readme Signed-off-by: Henry Gressmann --- Cargo.lock | 42 ++++++++++++++--------------- README.md | 2 +- crates/tinywasm/src/store/memory.rs | 2 +- 3 files changed, 23 insertions(+), 23 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 8edaba3..835692a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -96,7 +96,7 @@ dependencies = [ "argh_shared", "proc-macro2", "quote", - "syn 2.0.50", + "syn 2.0.51", ] [[package]] @@ -700,7 +700,7 @@ dependencies = [ "ident_case", "proc-macro2", "quote", - "syn 2.0.50", + "syn 2.0.51", ] [[package]] @@ -711,7 +711,7 @@ checksum = "a668eda54683121533a393014d8692171709ff57a7d61f187b6e782719f8933f" dependencies = [ "darling_core", "quote", - "syn 2.0.50", + "syn 2.0.51", ] [[package]] @@ -867,7 +867,7 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.50", + "syn 2.0.51", ] [[package]] @@ -1084,9 +1084,9 @@ dependencies = [ [[package]] name = "half" -version = "2.3.1" +version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bc52e53916c08643f1b56ec082790d1e86a32e58dc5268f897f313fbae7b4872" +checksum = "b5eceaaeec696539ddaf7b333340f1af35a5aa87ae3e4f3ead0532f72affab2e" dependencies = [ "cfg-if", "crunchy", @@ -1752,9 +1752,9 @@ dependencies = [ [[package]] name = "rust-embed" -version = "8.2.0" +version = "8.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a82c0bbc10308ed323529fd3c1dce8badda635aa319a5ff0e6466f33b8101e3f" +checksum = "fb78f46d0066053d16d4ca7b898e9343bc3530f71c61d5ad84cd404ada068745" dependencies = [ "rust-embed-impl", "rust-embed-utils", @@ -1763,22 +1763,22 @@ dependencies = [ [[package]] name = "rust-embed-impl" -version = "8.2.0" +version = "8.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6227c01b1783cdfee1bcf844eb44594cd16ec71c35305bf1c9fb5aade2735e16" +checksum = "b91ac2a3c6c0520a3fb3dd89321177c3c692937c4eb21893378219da10c44fc8" dependencies = [ "proc-macro2", "quote", "rust-embed-utils", - "syn 2.0.50", + "syn 2.0.51", "walkdir", ] [[package]] name = "rust-embed-utils" -version = "8.2.0" +version = "8.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8cb0a25bfbb2d4b4402179c2cf030387d9990857ce08a32592c6238db9fa8665" +checksum = "86f69089032567ffff4eada41c573fc43ff466c7db7c5688b2e7969584345581" dependencies = [ "globset", "sha2", @@ -1867,7 +1867,7 @@ checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b" dependencies = [ "proc-macro2", "quote", - "syn 2.0.50", + "syn 2.0.51", ] [[package]] @@ -1966,9 +1966,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.50" +version = "2.0.51" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74f1bdc9872430ce9b75da68329d1c1746faf50ffac5f19e02b71e37ff881ffb" +checksum = "6ab617d94515e94ae53b8406c628598680aa0c9587474ecbe58188f7b345d66c" dependencies = [ "proc-macro2", "quote", @@ -2013,7 +2013,7 @@ checksum = "a953cb265bef375dae3de6663da4d3804eee9682ea80d8e2542529b73c531c81" dependencies = [ "proc-macro2", "quote", - "syn 2.0.50", + "syn 2.0.51", ] [[package]] @@ -2150,7 +2150,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.50", + "syn 2.0.51", ] [[package]] @@ -2289,7 +2289,7 @@ dependencies = [ "once_cell", "proc-macro2", "quote", - "syn 2.0.50", + "syn 2.0.51", "wasm-bindgen-shared", ] @@ -2311,7 +2311,7 @@ checksum = "642f325be6301eb8107a83d12a8ac6c1e1c54345a7ef1a9261962dfefda09e66" dependencies = [ "proc-macro2", "quote", - "syn 2.0.50", + "syn 2.0.51", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -2859,5 +2859,5 @@ checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.50", + "syn 2.0.51", ] diff --git a/README.md b/README.md index c07fadc..c2abbf3 100644 --- a/README.md +++ b/README.md @@ -12,7 +12,7 @@ ## Why TinyWasm? -- **Tiny**: TinyWasm is designed to be as small as possible without significantly compromising performance or functionality. +- **Tiny**: TinyWasm is designed to be as small as possible without significantly compromising performance or functionality (< 6000 lines of code). - **Portable**: TinyWasm runs on any platform that Rust can target, including WebAssembly itself, with minimal external dependencies. - **Lightweight**: TinyWasm is easy to integrate and has a low call overhead, making it suitable for scripting and embedding. diff --git a/crates/tinywasm/src/store/memory.rs b/crates/tinywasm/src/store/memory.rs index 1c8acce..ea820da 100644 --- a/crates/tinywasm/src/store/memory.rs +++ b/crates/tinywasm/src/store/memory.rs @@ -2,7 +2,7 @@ use alloc::vec; use alloc::vec::Vec; use tinywasm_types::{MemoryType, ModuleInstanceAddr}; -use crate::{Error, Result}; +use crate::{log, Error, Result}; const PAGE_SIZE: usize = 65536; const MAX_PAGES: usize = 65536;