feat: improve func type resolution, int ops

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

Author: explodingcamera

Cargo.lock

@@ -407,7 +407,8 @@ pub fn process_operators<'a>(
                 ..
             } => Instruction::CallIndirect(type_index, table_index),
             Drop => Instruction::Drop,
-            Select => Instruction::Select,
+            Select => Instruction::Select(None),
+            TypedSelect { ty } => Instruction::Select(Some(convert_valtype(&ty))),
             LocalGet { local_index } => Instruction::LocalGet(local_index),
             LocalSet { local_index } => Instruction::LocalSet(local_index),
             LocalTee { local_index } => Instruction::LocalTee(local_index),
@@ -547,6 +548,8 @@ pub fn process_operators<'a>(
             I32TruncF64U => Instruction::I32TruncF64U,
             I64ExtendI32S => Instruction::I64ExtendI32S,
             I64ExtendI32U => Instruction::I64ExtendI32U,
+            I32Extend8S => Instruction::I32Extend8S,
+            I32Extend16S => Instruction::I32Extend16S,
             I64TruncF32S => Instruction::I64TruncF32S,
             I64TruncF32U => Instruction::I64TruncF32U,
             I64TruncF64S => Instruction::I64TruncF64S,

crates/parser/src/conversion.rs

@@ -25,6 +25,7 @@ eyre={version="0.6"}
 serde_json={version="1.0"}
 serde={version="1.0", features=["derive"]}
 plotters={version="0.3"}
+pretty_env_logger="0.5"
 
 [features]
 default=["std", "parser", "logging"]

crates/tinywasm/Cargo.toml

@@ -65,9 +65,16 @@ impl ModuleInstance {
         }
 
         let export = self.0.exports.get(name, ExternalKind::Func)?;
+        log::debug!("get_func: export: {:?}", export);
+
+        log::debug!("{:?}", self.0.func_addrs);
         let func_addr = self.0.func_addrs[export.index as usize];
+        log::debug!("get_func: func index: {}", export.index);
         let func = store.get_func(func_addr as usize)?;
+        log::debug!("get_func: func_addr: {}, func: {:?}", func_addr, func);
         let ty = self.0.types[func.ty_addr() as usize].clone();
+        log::debug!("get_func: ty: {:?}", ty);
+        log::debug!("types: {:?}", self.0.types);
 
         Ok(FuncHandle {
             addr: export.index,

crates/tinywasm/src/instance.rs

@@ -59,8 +59,8 @@ impl Module {
         // imports: Option<()>,
     ) -> Result<ModuleInstance> {
         let idx = store.next_module_instance_idx();
-
         let func_addrs = store.add_funcs(self.data.funcs.into(), idx);
+
         let instance = ModuleInstance::new(
             self.data.func_types,
             self.data.start_func,

crates/tinywasm/src/module.rs

@@ -51,7 +51,7 @@ macro_rules! comp_zero {
 }
 
 /// Apply an arithmetic operation to two values on the stack
-macro_rules! arithmetic {
+macro_rules! arithmetic_op {
     ($op:tt, $ty:ty, $stack:ident) => {{
         let [a, b] = $stack.values.pop_n_const::<2>()?;
         let a: $ty = a.into();
@@ -60,19 +60,36 @@ macro_rules! arithmetic {
     }};
 }
 
+macro_rules! arithmetic_method {
+    ($op:ident, $ty:ty, $stack:ident) => {{
+        let [a, b] = $stack.values.pop_n_const::<2>()?;
+        let a: $ty = a.into();
+        let b: $ty = b.into();
+        let result = a.$op(b);
+        $stack.values.push(result.into());
+    }};
+}
+
 /// Apply an arithmetic operation to two values on the stack
-macro_rules! checked_arithmetic {
+macro_rules! checked_arithmetic_method {
     ($op:ident, $ty:ty, $stack:ident, $trap:expr) => {{
         let [a, b] = $stack.values.pop_n_const::<2>()?;
         let a: $ty = a.into();
         let b: $ty = b.into();
         let result = a.$op(b).ok_or_else(|| Error::Trap($trap))?;
+        debug!(
+            "checked_arithmetic_method: {}, a: {}, b: {}, res: {}",
+            stringify!($op),
+            a,
+            b,
+            result
+        );
         $stack.values.push(result.into());
     }};
 }
 
 /// Apply an arithmetic operation to two values on the stack (cast to ty2 before operation)
-macro_rules! checked_arithmetic_cast {
+macro_rules! checked_arithmetic_method_cast {
     ($op:ident, $ty:ty, $ty2:ty, $stack:ident, $trap:expr) => {{
         let [a, b] = $stack.values.pop_n_const::<2>()?;
         let a: $ty = a.into();
@@ -87,9 +104,10 @@ macro_rules! checked_arithmetic_cast {
     }};
 }
 
-pub(super) use arithmetic;
-pub(super) use checked_arithmetic;
-pub(super) use checked_arithmetic_cast;
+pub(super) use arithmetic_method;
+pub(super) use arithmetic_op;
+pub(super) use checked_arithmetic_method;
+pub(super) use checked_arithmetic_method_cast;
 pub(super) use comp;
 pub(super) use comp_cast;
 pub(super) use comp_zero;

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

@@ -85,7 +85,11 @@ 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(|_| ())?,
-        Select => {
+        Select(t) => {
+            if t.is_some() {
+                unimplemented!("select with type");
+            }
+
             let cond: i32 = stack.values.pop()?.into();
             let val2 = stack.values.pop()?;
 
@@ -283,34 +287,34 @@ fn exec_one(
         F32Gt => comp!(>, f32, stack),
         F64Gt => comp!(>, f64, stack),
 
-        I64Add => arithmetic!(+, i64, stack),
-        I32Add => arithmetic!(+, i32, stack),
-        F32Add => arithmetic!(+, f32, stack),
-        F64Add => arithmetic!(+, f64, stack),
+        I64Add => arithmetic_method!(wrapping_add, i64, stack),
+        I32Add => arithmetic_method!(wrapping_add, i32, stack),
+        F32Add => arithmetic_op!(+, f32, stack),
+        F64Add => arithmetic_op!(+, f64, stack),
 
-        I32Sub => arithmetic!(-, i32, stack),
-        I64Sub => arithmetic!(-, i64, stack),
-        F32Sub => arithmetic!(-, f32, stack),
-        F64Sub => arithmetic!(-, f64, stack),
+        I32Sub => arithmetic_method!(wrapping_sub, i32, stack),
+        I64Sub => arithmetic_method!(wrapping_sub, i64, stack),
+        F32Sub => arithmetic_op!(-, f32, stack),
+        F64Sub => arithmetic_op!(-, f64, stack),
 
-        F32Div => arithmetic!(/, f32, stack),
-        F64Div => arithmetic!(/, f64, stack),
+        F32Div => arithmetic_op!(/, f32, stack),
+        F64Div => arithmetic_op!(/, f64, stack),
 
-        I32Mul => arithmetic!(*, i32, stack),
-        I64Mul => arithmetic!(*, i64, stack),
-        F32Mul => arithmetic!(*, f32, stack),
-        F64Mul => arithmetic!(*, f64, stack),
+        I32Mul => arithmetic_method!(wrapping_mul, i32, stack),
+        I64Mul => arithmetic_method!(wrapping_mul, i64, stack),
+        F32Mul => arithmetic_op!(*, f32, stack),
+        F64Mul => arithmetic_op!(*, f64, stack),
 
         // these can trap
-        I32DivS => checked_arithmetic!(checked_div, i32, stack, crate::Trap::DivisionByZero),
-        I64DivS => checked_arithmetic!(checked_div, i64, stack, crate::Trap::DivisionByZero),
-        I32DivU => checked_arithmetic_cast!(checked_div, i32, u32, stack, crate::Trap::DivisionByZero),
-        I64DivU => checked_arithmetic_cast!(checked_div, i64, u64, stack, crate::Trap::DivisionByZero),
-
-        I32RemS => checked_arithmetic!(checked_rem, i32, stack, crate::Trap::DivisionByZero),
-        I64RemS => checked_arithmetic!(checked_rem, i64, stack, crate::Trap::DivisionByZero),
-        I32RemU => checked_arithmetic_cast!(checked_rem, i32, u32, stack, crate::Trap::DivisionByZero),
-        I64RemU => checked_arithmetic_cast!(checked_rem, i64, u64, stack, crate::Trap::DivisionByZero),
+        I32DivS => checked_arithmetic_method!(checked_div, i32, stack, crate::Trap::DivisionByZero),
+        I64DivS => checked_arithmetic_method!(checked_div, i64, stack, crate::Trap::DivisionByZero),
+        I32DivU => checked_arithmetic_method_cast!(checked_div, i32, u32, stack, crate::Trap::DivisionByZero),
+        I64DivU => checked_arithmetic_method_cast!(checked_div, i64, u64, stack, crate::Trap::DivisionByZero),
+
+        I32RemS => checked_arithmetic_method!(checked_rem, i32, stack, crate::Trap::DivisionByZero),
+        I64RemS => checked_arithmetic_method!(checked_rem, i64, stack, crate::Trap::DivisionByZero),
+        I32RemU => checked_arithmetic_method_cast!(checked_rem, i32, u32, stack, crate::Trap::DivisionByZero),
+        I64RemU => checked_arithmetic_method_cast!(checked_rem, i64, u64, stack, crate::Trap::DivisionByZero),
 
         F32ConvertI32S => conv_1!(i32, f32, stack),
         F32ConvertI64S => conv_1!(i64, f32, stack),

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

@@ -126,12 +126,12 @@ impl Store {
 
     pub(crate) fn add_funcs(&mut self, funcs: Vec<Function>, idx: ModuleInstanceAddr) -> Vec<FuncAddr> {
         let mut func_addrs = Vec::with_capacity(funcs.len());
-        for func in funcs.into_iter() {
+        for (i, func) in funcs.into_iter().enumerate() {
             self.data.funcs.push(Rc::new(FunctionInstance {
                 func,
                 _module_instance: idx,
             }));
-            func_addrs.push(idx as FuncAddr);
+            func_addrs.push(i as FuncAddr);
         }
         func_addrs
     }