feat: if/else

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

Author: explodingcamera

crates/parser/src/conversion.rs

@@ -114,9 +114,9 @@ pub fn process_operators<'a>(
     mut validator: FuncValidator<ValidatorResources>,
 ) -> Result<Box<[Instruction]>> {
     let mut instructions = Vec::new();
-    let mut labels_ptrs = Vec::new();
+    let mut labels_ptrs = Vec::new(); // indexes into the instructions array
 
-    for (i, op) in ops.enumerate() {
+    for op in ops {
         info!("op: {:?}", op);
 
         let op = op?;
@@ -146,17 +146,42 @@ pub fn process_operators<'a>(
             }
             If { blockty } => {
                 labels_ptrs.push(instructions.len());
-                Instruction::If(convert_blocktype(blockty), 0)
+                Instruction::If(convert_blocktype(blockty), None, 0)
+            }
+            Else => {
+                labels_ptrs.push(instructions.len());
+                Instruction::Else(0)
             }
             End => {
                 if let Some(label_pointer) = labels_ptrs.pop() {
+                    info!("ending block: {:?}", instructions[label_pointer]);
+
+                    let current_instr_ptr = instructions.len();
+
                     // last_label_pointer is Some if we're ending a block
                     match instructions[label_pointer] {
-                        Instruction::Block(_, ref mut end)
-                        | Instruction::Loop(_, ref mut end)
-                        | Instruction::Else(ref mut end)
-                        | Instruction::If(_, ref mut end) => {
-                            *end = i + 1; // Set the end position to be one after the End instruction
+                        Instruction::Else(ref mut else_instr_end_offset) => {
+                            *else_instr_end_offset = current_instr_ptr - label_pointer;
+
+                            // since we're ending an else block, we need to end the if block as well
+                            let if_label_pointer = labels_ptrs.pop().ok_or(crate::ParseError::UnsupportedOperator(
+                                "Expected to end an if block, but the last label was not an if".to_string(),
+                            ))?;
+
+                            let if_instruction = &mut instructions[if_label_pointer];
+                            let Instruction::If(_, ref mut else_offset, ref mut end_offset) = if_instruction else {
+                                return Err(crate::ParseError::UnsupportedOperator(
+                                    "Expected to end an if block, but the last label was not an if".to_string(),
+                                ));
+                            };
+
+                            *else_offset = Some(label_pointer - if_label_pointer);
+                            *end_offset = current_instr_ptr - if_label_pointer;
+                        }
+                        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;
                         }
                         _ => {
                             return Err(crate::ParseError::UnsupportedOperator(
@@ -171,26 +196,7 @@ pub fn process_operators<'a>(
                     Instruction::EndFunc
                 }
             }
-            Else => {
-                let Some(label_pointer) = labels_ptrs.pop() else {
-                    return Err(crate::ParseError::UnsupportedOperator(
-                        "Expected to end an if block, but the last label was None".to_string(),
-                    ));
-                };
-
-                match instructions[label_pointer] {
-                    Instruction::If(_, ref mut end) => {
-                        *end = i + 1; // Set the end position to be one after the Else instruction
-                    }
-                    _ => {
-                        return Err(crate::ParseError::UnsupportedOperator(
-                            "Expected to end an if block, but the last label was not an if".to_string(),
-                        ));
-                    }
-                }
 
-                Instruction::Else(0)
-            }
             Br { relative_depth } => Instruction::Br(relative_depth),
             BrIf { relative_depth } => Instruction::BrIf(relative_depth),
             Return => Instruction::Return,

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

@@ -84,7 +84,6 @@ fn exec_one(
         Nop => { /* do nothing */ }
         Unreachable => return Ok(ExecResult::Trap(crate::Trap::Unreachable)), // we don't need to include the call frame here because it's already on the stack
         Drop => stack.values.pop().map(|_| ())?,
-        Return => todo!("called function returned"),
         Select => {
             let cond: i32 = stack.values.pop()?.into();
             let val2 = stack.values.pop()?;
@@ -117,6 +116,38 @@ fn exec_one(
             return Ok(ExecResult::Call);
         }
 
+        Return => todo!("called function returned"),
+
+        If(args, else_offset, end_offset) => {
+            let end_instr_ptr = cf.instr_ptr + *end_offset;
+
+            info!(
+                "if it's true, we'll jump to the next instruction (@{})",
+                cf.instr_ptr + 1
+            );
+
+            if let Some(else_offset) = else_offset {
+                info!(
+                    "else: {:?} (@{})",
+                    instrs[cf.instr_ptr + else_offset],
+                    cf.instr_ptr + else_offset
+                );
+            };
+
+            info!("end: {:?} (@{})", instrs[end_instr_ptr], end_instr_ptr);
+
+            if stack.values.pop_t::<i32>()? != 0 {
+                cf.labels.push(LabelFrame {
+                    instr_ptr: cf.instr_ptr,
+                    end_instr_ptr: cf.instr_ptr + *end_offset,
+                    stack_ptr: stack.values.len(),
+                    args: *args,
+                    ty: BlockType::If,
+                });
+                stack.values.push_block_args(*args)?;
+            }
+        }
+
         Loop(args, end_offset) => {
             cf.labels.push(LabelFrame {
                 instr_ptr: cf.instr_ptr,

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

@@ -105,15 +105,12 @@ impl CallFrame {
             BlockType::Block => {
                 debug!("current instr_ptr: {}", self.instr_ptr);
 
-                // this is a block, so we want to jump to the end of the block
-                self.instr_ptr = break_to.end_instr_ptr;
+                // this is a block, so we want to jump to the next instruction after the block ends
+                self.instr_ptr = break_to.end_instr_ptr + 1;
                 value_stack.trim(break_to.stack_ptr);
 
                 // we also want to trim the label stack, including the block
                 self.labels.trim(self.labels.len() - break_to_relative as usize + 1);
-
-                debug!("break_to.end_instr_ptr: {}", self.instr_ptr);
-
                 panic!()
             }
             _ => unimplemented!("break to block type: {:?}", current_label.ty),

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

@@ -40,8 +40,8 @@ impl ValueStack {
     pub(crate) fn push_block_args(&self, args: BlockArgs) -> Result<()> {
         match args {
             BlockArgs::Empty => Ok(()),
-            BlockArgs::Type(_t) => todo!(),
-            BlockArgs::FuncType(_t) => todo!(),
+            BlockArgs::Type(_t) => todo!("support block args (type)"),
+            BlockArgs::FuncType(_t) => todo!("support block args (func type)"),
         }
     }
 
@@ -65,7 +65,7 @@ impl ValueStack {
     #[inline]
     pub(crate) fn pop_t<T: From<RawWasmValue>>(&mut self) -> Result<T> {
         self.top -= 1;
-        Ok(self.pop()?.into())
+        Ok(self.stack.pop().ok_or(Error::StackUnderflow)?.into())
     }
 
     #[inline]

crates/tinywasm/tests/charts/progress.rs

@@ -20,8 +20,8 @@ pub fn create_progress_chart(csv_path: &Path, output_path: &Path) -> Result<()>
 
         if parts.len() > 3 {
             let version = format!("v{}", parts[0]);
-            let failed: u32 = parts[1].parse()?;
-            let passed: u32 = parts[2].parse()?;
+            let passed: u32 = parts[1].parse()?;
+            let failed: u32 = parts[2].parse()?;
             let total = failed + passed;
 
             if total > max_tests {