chore: remove block stack

Signed-off-by: Henry <mail@henrygressmann.de>

Author: explodingcamera

.cargo/config.toml

@@ -4,3 +4,4 @@ test-wasm-1="test --package tinywasm --test test-wasm-1 --release"
 test-wasm-2="test --package tinywasm --test test-wasm-2 --release"
 test-wasm-3="test --package tinywasm --test test-wasm-3 --release"
 test-wast="test --package tinywasm --test test-wast"
+test-wasm-custom="test --package tinywasm --test test-wasm-custom --release"

.vscode/settings.json

@@ -72,6 +72,10 @@ harness=false
 name="test-wasm-custom-page-sizes"
 harness=false
 
+[[test]]
+name="test-wasm-custom"
+harness=false
+
 [[test]]
 name="test-wasm-tail-call"
 harness=false

crates/parser/src/visit.rs

@@ -5,6 +5,10 @@ use types::TinyWasmModule;
 
 const WASM: &[u8] = include_bytes!("../../../examples/rust/out/argon2id.opt.wasm");
 
+fn init_log() {
+    let _ = pretty_env_logger::formatted_timed_builder().filter_level(log::LevelFilter::Off).try_init();
+}
+
 fn argon2id_parse() -> Result<TinyWasmModule> {
     let parser = tinywasm_parser::Parser::new();
     let data = parser.parse_module_bytes(WASM)?;
@@ -30,6 +34,7 @@ fn argon2id_run(module: TinyWasmModule) -> Result<()> {
 }
 
 fn criterion_benchmark(c: &mut Criterion) {
+    init_log();
     let module = argon2id_parse().expect("argon2id_parse");
     let twasm = argon2id_to_twasm(&module).expect("argon2id_to_twasm");
 

crates/tinywasm/Cargo.toml

@@ -35,9 +35,9 @@ fn criterion_benchmark(c: &mut Criterion) {
     let module = tinywasm_parse().expect("tinywasm_parse");
     let twasm = tinywasm_to_twasm(&module).expect("tinywasm_to_twasm");
 
-    c.bench_function("tinywasm_parse", |b| b.iter(tinywasm_parse));
-    c.bench_function("tinywasm_to_twasm", |b| b.iter(|| tinywasm_to_twasm(&module)));
-    c.bench_function("tinywasm_from_twasm", |b| b.iter(|| tinywasm_from_twasm(&twasm)));
+    // c.bench_function("tinywasm_parse", |b| b.iter(tinywasm_parse));
+    // c.bench_function("tinywasm_to_twasm", |b| b.iter(|| tinywasm_to_twasm(&module)));
+    // c.bench_function("tinywasm_from_twasm", |b| b.iter(|| tinywasm_from_twasm(&twasm)));
     c.bench_function("tinywasm", |b| b.iter(|| tinywasm_run(module.clone())));
 }
 

crates/tinywasm/benches/argon2id.rs

@@ -51,9 +51,6 @@ pub const DEFAULT_VALUE_STACK_128_SIZE: usize = 4 * 1024; // 4k slots
 /// Default initial size for the reference value stack (funcref, externref values).
 pub const DEFAULT_VALUE_STACK_REF_SIZE: usize = 4 * 1024; // 4k slots
 
-/// Default initial size for the block stack (control frames).
-pub const DEFAULT_BLOCK_STACK_SIZE: usize = 2048; // 1024 frames
-
 /// Default initial size for the call stack (function frames).
 pub const DEFAULT_CALL_STACK_SIZE: usize = 2048; // 1024 frames
 
@@ -71,9 +68,6 @@ pub struct Config {
     pub stack_ref_size: usize,
     /// Initial size of the call stack.
     pub call_stack_size: usize,
-
-    /// Initial size of the block stack.
-    pub block_stack_initial_size: usize,
 }
 
 impl Config {
@@ -91,7 +85,6 @@ impl Default for Config {
             stack_128_size: DEFAULT_VALUE_STACK_128_SIZE,
             stack_ref_size: DEFAULT_VALUE_STACK_REF_SIZE,
             call_stack_size: DEFAULT_CALL_STACK_SIZE,
-            block_stack_initial_size: DEFAULT_BLOCK_STACK_SIZE,
         }
     }
 }

crates/tinywasm/benches/tinywasm.rs

@@ -121,9 +121,6 @@ pub enum Trap {
     /// Call stack overflow
     CallStackOverflow,
 
-    /// Block stack overflow
-    BlockStackOverflow,
-
     /// Value stack overflow
     ValueStackOverflow,
 
@@ -159,7 +156,6 @@ impl Trap {
             Self::InvalidConversionToInt => "invalid conversion to integer",
             Self::IntegerOverflow => "integer overflow",
             Self::CallStackOverflow => "call stack exhausted",
-            Self::BlockStackOverflow => "block stack exhausted",
             Self::ValueStackOverflow => "value stack exhausted",
             Self::UndefinedElement { .. } => "undefined element",
             Self::UninitializedElement { .. } => "uninitialized element",
@@ -243,7 +239,6 @@ impl Display for Trap {
             Self::InvalidConversionToInt => write!(f, "invalid conversion to integer"),
             Self::IntegerOverflow => write!(f, "integer overflow"),
             Self::CallStackOverflow => write!(f, "call stack exhausted"),
-            Self::BlockStackOverflow => write!(f, "block stack exhausted"),
             Self::ValueStackOverflow => write!(f, "value stack exhausted"),
             Self::UndefinedElement { index } => write!(f, "undefined element: index={index}"),
             Self::UninitializedElement { index } => {

crates/tinywasm/src/engine.rs

@@ -56,7 +56,7 @@ impl FuncHandle {
         };
 
         // 6. Let f be the dummy frame
-        let callframe = CallFrame::new_with_params(wasm_func.locals, self.addr, func_inst.owner, params, 0);
+        let callframe = CallFrame::new_with_params(wasm_func.locals, self.addr, func_inst.owner, params);
 
         // 7. Push the frame f to the call stack
         // & 8. Push the values to the stack

crates/tinywasm/src/error.rs

@@ -10,7 +10,6 @@ use interpreter::stack::CallFrame;
 use tinywasm_types::*;
 
 use super::num_helpers::*;
-use super::stack::{BlockFrame, BlockType};
 use super::values::*;
 use crate::instance::ModuleInstanceInner;
 use crate::interpreter::Value128;
@@ -88,7 +87,7 @@ impl<'store> Executor<'store> {
 
         #[rustfmt::skip]
         match next {
-            Nop | BrLabel(_) | I32ReinterpretF32 | I64ReinterpretF64 | F32ReinterpretI32 | F64ReinterpretI64 => {}
+            Nop | I32ReinterpretF32 | I64ReinterpretF64 | F32ReinterpretI32 | F64ReinterpretI64 => {}
             Unreachable => return ControlFlow::Break(Some(Trap::Unreachable.into())),
             Drop32 => self.store.stack.values.drop::<Value32>(),
             Drop64 => self.store.stack.values.drop::<Value64>(),
@@ -102,21 +101,70 @@ impl<'store> Executor<'store> {
             CallIndirect(ty, table) => return self.exec_call_indirect::<false>(*ty, *table),
             ReturnCall(v) => return self.exec_call_direct::<true>(*v),
             ReturnCallIndirect(ty, table) => return self.exec_call_indirect::<true>(*ty, *table),
-            If(end, el) => self.exec_if(*end, *el, (StackHeight::default(), StackHeight::default())),
-            IfWithType(ty, end, el) => self.exec_if(*end, *el, (StackHeight::default(), (*ty).into())),
-            IfWithFuncType(ty, end, el) => self.exec_if(*end, *el, self.resolve_functype(*ty)),
-            Else(end_offset) => self.exec_else(*end_offset),
-            Loop(end) => self.enter_block(*end, BlockType::Loop, (StackHeight::default(), StackHeight::default())),
-            LoopWithType(ty, end) => self.enter_block(*end, BlockType::Loop, (StackHeight::default(), (*ty).into())),
-            LoopWithFuncType(ty, end) => self.enter_block(*end, BlockType::Loop, self.resolve_functype(*ty)),
-            Block(end) => self.enter_block(*end, BlockType::Block, (StackHeight::default(), StackHeight::default())),
-            BlockWithType(ty, end) => self.enter_block(*end, BlockType::Block, (StackHeight::default(), (*ty).into())),
-            BlockWithFuncType(ty, end) => self.enter_block(*end, BlockType::Block, self.resolve_functype(*ty)),
-            Br(v) => return self.exec_br(*v),
-            BrIf(v) => return self.exec_br_if(*v),
-            BrTable(default, len) => return self.exec_brtable(*default, *len),
+            Jump(ip) => {
+                self.cf.instr_ptr = *ip as usize;
+                return ControlFlow::Continue(());
+            }
+            JumpIfZero(ip) => {
+                let cond = self.store.stack.values.pop::<i32>();
+
+                if cond == 0 {
+                    self.cf.instr_ptr = *ip as usize;
+                } else {
+                    self.cf.incr_instr_ptr();
+                }
+                return ControlFlow::Continue(());
+            }
+            DropKeepSmall { base32, keep32, base64, keep64, base128, keep128, base_ref, keep_ref } => {
+                let b32 = self.cf.stack_base.s32 as usize + *base32 as usize;
+                let k32 = *keep32 as usize;
+                self.store.stack.values.stack_32.truncate_keep(b32, k32);
+                let b64 = self.cf.stack_base.s64 as usize + *base64 as usize;
+                let k64 = *keep64 as usize;
+                self.store.stack.values.stack_64.truncate_keep(b64, k64);
+                let b128 = self.cf.stack_base.s128 as usize + *base128 as usize;
+                let k128 = *keep128 as usize;
+                self.store.stack.values.stack_128.truncate_keep(b128, k128);
+                let bref = self.cf.stack_base.sref as usize + *base_ref as usize;
+                let kref = *keep_ref as usize;
+                self.store.stack.values.stack_ref.truncate_keep(bref, kref);
+            }
+            DropKeep32(base, keep) => {
+                let b = self.cf.stack_base.s32 as usize + *base as usize;
+                let k = *keep as usize;
+                self.store.stack.values.stack_32.truncate_keep(b, k);
+            }
+            DropKeep64(base, keep) => {
+                let b = self.cf.stack_base.s64 as usize + *base as usize;
+                let k = *keep as usize;
+                self.store.stack.values.stack_64.truncate_keep(b, k);
+            }
+            DropKeep128(base, keep) => {
+                let b = self.cf.stack_base.s128 as usize + *base as usize;
+                let k = *keep as usize;
+                self.store.stack.values.stack_128.truncate_keep(b, k);
+            }
+            DropKeepRef(base, keep) => {
+                let b = self.cf.stack_base.sref as usize + *base as usize;
+                let k = *keep as usize;
+                self.store.stack.values.stack_ref.truncate_keep(b, k);
+            }
+            BranchTable(default_ip, len) => {
+                let idx = self.store.stack.values.pop::<i32>();
+                let start = self.cf.instr_ptr + 1;
+
+                let target_ip = if idx >= 0 && (idx as u32) < *len {
+                    match self.instructions.0.get(start + idx as usize) {
+                        Some(Instruction::BranchTableTarget(ip)) => *ip,
+                        _ => *default_ip,
+                    }
+                } else {
+                    *default_ip
+                };
+                self.cf.instr_ptr = target_ip as usize;
+                return ControlFlow::Continue(());
+            }
             Return => return self.exec_return(),
-            EndBlockFrame => self.exec_end_block(),
             LocalGet32(local_index) => self.store.stack.values.push(self.cf.locals.get::<Value32>(*local_index)).to_cf()?,
             LocalGet64(local_index) => self.store.stack.values.push(self.cf.locals.get::<Value64>(*local_index)).to_cf()?,
             LocalGet128(local_index) => self.store.stack.values.push(self.cf.locals.get::<Value128>(*local_index)).to_cf()?,
@@ -588,10 +636,12 @@ impl<'store> Executor<'store> {
 
         if IS_RETURN_CALL {
             let locals = self.store.stack.values.pop_locals(wasm_func.params, wasm_func.locals);
-            self.cf.reuse_for(func_addr, locals, self.store.stack.blocks.len() as u32, owner);
+            let stack_base = self.store.stack.values.height();
+            self.cf.reuse_for(func_addr, locals, owner, stack_base);
         } else {
             let locals = self.store.stack.values.pop_locals(wasm_func.params, wasm_func.locals);
-            let new_call_frame = CallFrame::new(func_addr, owner, locals, self.store.stack.blocks.len() as u32);
+            let stack_base = self.store.stack.values.height();
+            let new_call_frame = CallFrame::new(func_addr, owner, locals, stack_base);
             self.cf.incr_instr_ptr(); // skip the call instruction
             self.store.stack.call_stack.push(core::mem::replace(&mut self.cf, new_call_frame)).to_cf()?;
         }
@@ -661,84 +711,7 @@ impl<'store> Executor<'store> {
         }
     }
 
-    fn exec_if(&mut self, else_offset: u32, end_offset: u32, (params, results): (StackHeight, StackHeight)) {
-        // truthy value is on the top of the stack, so enter the then block
-        if self.store.stack.values.pop::<i32>() != 0 {
-            self.enter_block(end_offset, BlockType::If, (params, results));
-            return;
-        }
-
-        // falsy value is on the top of the stack
-        if else_offset == 0 {
-            self.cf.jump(end_offset);
-            return;
-        }
-
-        self.cf.jump(else_offset);
-        self.enter_block(end_offset - else_offset, BlockType::Else, (params, results));
-    }
-    fn exec_else(&mut self, end_offset: u32) {
-        self.exec_end_block();
-        self.cf.jump(end_offset);
-    }
-    fn resolve_functype(&self, idx: u32) -> (StackHeight, StackHeight) {
-        let ty = self.module.func_ty(idx);
-        ((&*ty.params).into(), (&*ty.results).into())
-    }
-    fn enter_block(&mut self, end_instr_offset: u32, ty: BlockType, (params, results): (StackHeight, StackHeight)) {
-        self.store.stack.blocks.push(BlockFrame {
-            instr_ptr: self.cf.instr_ptr as u32,
-            end_instr_offset,
-            stack_ptr: self.store.stack.values.height(),
-            results,
-            params,
-            ty,
-        })
-    }
-    fn exec_br(&mut self, to: u32) -> ControlFlow<Option<Error>> {
-        if self.cf.break_to(to, &mut self.store.stack.values, &mut self.store.stack.blocks).is_none() {
-            return self.exec_return();
-        }
-
-        self.cf.incr_instr_ptr();
-        ControlFlow::Continue(())
-    }
-    fn exec_br_if(&mut self, to: u32) -> ControlFlow<Option<Error>> {
-        if self.store.stack.values.pop::<i32>() != 0
-            && self.cf.break_to(to, &mut self.store.stack.values, &mut self.store.stack.blocks).is_none()
-        {
-            return self.exec_return();
-        }
-        self.cf.incr_instr_ptr();
-        ControlFlow::Continue(())
-    }
-    fn exec_brtable(&mut self, default: u32, len: u32) -> ControlFlow<Option<Error>> {
-        let start = self.cf.instr_ptr + 1;
-        let end = start + len as usize;
-        if end > self.func.instructions.len() {
-            return ControlFlow::Break(Some(Error::Other(format!(
-                "br_table out of bounds: {} >= {}",
-                end,
-                self.func.instructions.len()
-            ))));
-        }
-
-        let idx = self.store.stack.values.pop::<i32>();
-        let to = match self.func.instructions[start..end].get(idx as usize) {
-            None => default,
-            Some(Instruction::BrLabel(to)) => *to,
-            _ => return ControlFlow::Break(Some(Error::Other("br_table out of bounds".to_string()))),
-        };
-
-        if self.cf.break_to(to, &mut self.store.stack.values, &mut self.store.stack.blocks).is_none() {
-            return self.exec_return();
-        }
-
-        self.cf.incr_instr_ptr();
-        ControlFlow::Continue(())
-    }
     fn exec_return(&mut self) -> ControlFlow<Option<Error>> {
-        let old = self.cf.block_ptr;
         let Some(cf) = self.store.stack.call_stack.pop() else { return ControlFlow::Break(None) };
 
         if cf.func_addr != self.cf.func_addr {
@@ -750,18 +723,9 @@ impl<'store> Executor<'store> {
             }
         }
 
-        if old > cf.block_ptr {
-            self.store.stack.blocks.truncate(old);
-        }
-
         self.cf = cf;
         ControlFlow::Continue(())
     }
-    fn exec_end_block(&mut self) {
-        let block = self.store.stack.blocks.pop();
-        self.store.stack.values.truncate_keep(block.stack_ptr, block.results);
-    }
-
     fn exec_global_get(&mut self, global_index: u32) -> Result<()> {
         self.store.stack.values.push_dyn(self.store.state.get_global_val(self.module.resolve_global_addr(global_index)))
     }