feat: implicit function lable

Signed-off-by: Henry Gressmann <[email protected]>

Author: explodingcamera

crates/tinywasm/src/error.rs

@@ -54,6 +54,9 @@ pub enum Error {
     /// The label stack is empty
     LabelStackUnderflow,
 
+    /// An invalid label type was encountered
+    InvalidLabelType,
+
     /// The call stack is empty
     CallStackEmpty,
 
@@ -72,6 +75,7 @@ impl Display for Error {
 
             Self::Trap(trap) => write!(f, "trap: {:?}", trap),
 
+            Self::InvalidLabelType => write!(f, "invalid label type"),
             Self::Other(message) => write!(f, "unknown error: {}", message),
             Self::UnsupportedFeature(feature) => write!(f, "unsupported feature: {}", feature),
             Self::FuncDidNotReturn => write!(f, "function did not return"),

crates/tinywasm/src/func.rs

@@ -57,10 +57,9 @@ impl FuncHandle {
         let call_frame = CallFrame::new(self.addr as usize, params, func_inst.locals().to_vec());
 
         // 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)
         stack.call_stack.push(call_frame);
 
-        // 8. Push the values to the stack (Not needed since the call frame owns the values)
-
         // 9. Invoke the function instance
         let runtime = store.runtime();
         runtime.exec(store, &mut stack, self.module.clone())?;

crates/tinywasm/src/imports.rs

@@ -11,8 +11,6 @@ use tinywasm_types::{Global, GlobalType, ModuleInstanceAddr, WasmValue};
 pub enum Extern {
     /// A global value
     Global(Global),
-    /// A registered module
-    Module(String),
     // Func(HostFunc),
     // Table(Table),
 }

crates/tinywasm/src/runtime/executor/mod.rs

@@ -74,6 +74,24 @@ enum ExecResult {
     Trap(crate::Trap),
 }
 
+// Break to a block at the given index (relative to the current frame)
+// If there is no block at the given index, return or call the parent function
+macro_rules! break_to {
+    ($cf:ident, $stack:ident, $break_to_relative:ident) => {{
+        let res = $cf.break_to(*$break_to_relative, &mut $stack.values);
+        match res {
+            Some(()) => {}
+            None => match $stack.call_stack.is_empty() {
+                true => return Ok(ExecResult::Return),
+                false => {
+                    *$cf = $stack.call_stack.pop()?;
+                    return Ok(ExecResult::Call);
+                }
+            },
+        }
+    }};
+}
+
 /// Run a single step of the interpreter
 /// A seperate function is used so later, we can more easily implement
 /// a step-by-step debugger (using generators once they're stable?)
@@ -207,10 +225,10 @@ fn exec_one(
             todo!("br_table");
         }
 
-        Br(v) => cf.break_to(*v, &mut stack.values)?,
+        Br(v) => break_to!(cf, stack, v),
         BrIf(v) => {
             if stack.values.pop_t::<i32>()? > 0 {
-                cf.break_to(*v, &mut stack.values)?
+                break_to!(cf, stack, v);
             }
         }
 

crates/tinywasm/src/runtime/stack/blocks.rs

@@ -1,10 +1,10 @@
-use alloc::vec::Vec;
+use alloc::{vec, vec::Vec};
 use log::info;
 use tinywasm_types::BlockArgs;
 
 use crate::{ModuleInstance, Result};
 
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Clone, Default)]
 pub(crate) struct Labels(Vec<LabelFrame>);
 
 impl Labels {
@@ -13,15 +13,18 @@ impl Labels {
     }
 
     #[inline]
-    pub(crate) fn push(&mut self, block: LabelFrame) {
-        self.0.push(block);
+    pub(crate) fn push(&mut self, label: LabelFrame) {
+        self.0.push(label);
     }
 
     #[inline]
-    /// get the block at the given index, where 0 is the top of the stack
+    /// get the label at the given index, where 0 is the top of the stack
     pub(crate) fn get_relative_to_top(&self, index: usize) -> Option<&LabelFrame> {
-        info!("get block: {}", index);
-        info!("blocks: {:?}", self.0);
+        let len = self.0.len();
+        if index >= len {
+            return None;
+        }
+
         self.0.get(self.0.len() - index - 1)
     }
 

crates/tinywasm/src/runtime/stack/call_stack.rs

@@ -89,12 +89,12 @@ impl CallFrame {
     }
 
     /// Break to a block at the given index (relative to the current frame)
+    /// Returns `None` if there is no block at the given index (e.g. if we need to return, this is validated by the parser)
     #[inline]
-    pub(crate) fn break_to(&mut self, break_to_relative: u32, value_stack: &mut super::ValueStack) -> Result<()> {
-        let break_to = self
-            .labels
-            .get_relative_to_top(break_to_relative as usize)
-            .ok_or(Error::LabelStackUnderflow)?;
+    pub(crate) fn break_to(&mut self, break_to_relative: u32, value_stack: &mut super::ValueStack) -> Option<()> {
+        let Some(break_to) = self.labels.get_relative_to_top(break_to_relative as usize) else {
+            return None;
+        };
 
         value_stack.break_to(break_to.stack_ptr, break_to.args.results);
 
@@ -131,7 +131,7 @@ impl CallFrame {
         // // };
 
         // self.block_frames.trim(block_index as usize);
-        Ok(())
+        Some(())
     }
 
     pub(crate) fn new_raw(func_ptr: usize, params: &[RawWasmValue], local_types: Vec<ValType>) -> Self {