feat: more float conversions

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

Author: explodingcamera

CONTRIBUTING.md

@@ -26,5 +26,5 @@
 - **`cargo workspaces version`**\
   Bump the version of all crates in the workspace and push changes to git. This is used for releasing new versions on github.
 
-- **`cargo workspaces publish --from-git`**\
+- **`cargo workspaces publish --publish-as-is`**\
   Publish all crates in the workspace to crates.io. This should be used a new version has been released on github. After publishing, the version should be bumped to the next dev version.

Cargo.lock

@@ -17,6 +17,12 @@ pub enum Trap {
 
     /// A division by zero occurred
     DivisionByZero,
+
+    /// Invalid Integer Conversion
+    InvalidConversionToInt,
+
+    /// Integer Overflow
+    IntegerOverflow,
 }
 
 #[derive(Debug)]

crates/tinywasm/src/error.rs

@@ -10,6 +10,77 @@ macro_rules! conv_1 {
     }};
 }
 
+macro_rules! float_min_max {
+    (f32, i32) => {
+        (-2147483904.0_f32, 2147483648.0_f32)
+    };
+    (f64, i32) => {
+        (-2147483649.0_f64, 2147483648.0_f64)
+    };
+    (f32, u32) => {
+        (-1.0_f32, 4294967296.0_f32)
+    };
+    (f64, u32) => {
+        (-1.0_f64, 4294967296.0_f64)
+    };
+    (f32, i64) => {
+        (-9223373136366403584.0_f32, 9223372036854775808.0_f32)
+    };
+    (f64, i64) => {
+        (-9223372036854777856.0_f64, 9223372036854775808.0_f64)
+    };
+    (f32, u64) => {
+        (-1.0_f32, 18446744073709551616.0_f32)
+    };
+    (f64, u64) => {
+        (-1.0_f64, 18446744073709551616.0_f64)
+    };
+    // other conversions are not allowed
+    ($from:ty, $to:ty) => {
+        compile_error!("invalid float conversion");
+    };
+}
+
+// Convert a float to an int, checking for overflow
+macro_rules! checked_float_conv_1 {
+    ($from:tt, $to:tt, $stack:ident) => {{
+        let (min, max) = float_min_max!($from, $to);
+        let a: $from = $stack.values.pop()?.into();
+
+        if a.is_nan() {
+            return Err(Error::Trap(crate::Trap::InvalidConversionToInt));
+        }
+
+        if a <= min || a >= max {
+            return Err(Error::Trap(crate::Trap::IntegerOverflow));
+        }
+
+        $stack.values.push((a as $to).into());
+    }};
+}
+
+// Convert a float to an int, checking for overflow
+macro_rules! checked_float_conv_2 {
+    ($from:tt, $uty:tt, $to:tt, $stack:ident) => {{
+        let (min, max) = float_min_max!($from, $uty);
+        let a: $from = $stack.values.pop()?.into();
+
+        if a.is_nan() {
+            return Err(Error::Trap(crate::Trap::InvalidConversionToInt));
+        }
+
+        log::info!("a: {}", a);
+        log::info!("min: {}", min);
+        log::info!("max: {}", max);
+
+        if a <= min || a >= max {
+            return Err(Error::Trap(crate::Trap::IntegerOverflow));
+        }
+
+        $stack.values.push((a as $uty as $to).into());
+    }};
+}
+
 /// Convert the unsigned value on the top of the stack to a specific type
 macro_rules! conv_2 {
     ($ty:ty, $uty:ty, $to:ty, $stack:ident) => {{
@@ -133,8 +204,11 @@ pub(super) use arithmetic_method_self;
 pub(super) use arithmetic_op;
 pub(super) use checked_arithmetic_method;
 pub(super) use checked_arithmetic_method_cast;
+pub(super) use checked_float_conv_1;
+pub(super) use checked_float_conv_2;
 pub(super) use comp;
 pub(super) use comp_cast;
 pub(super) use comp_zero;
 pub(super) use conv_1;
 pub(super) use conv_2;
+pub(super) use float_min_max;

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

@@ -172,7 +172,6 @@ fn exec_one(
         }
 
         Block(args, end_offset) => {
-            // let params = stack.values.pop_block_params(*args, &module)?;
             cf.enter_label(
                 LabelFrame {
                     instr_ptr: cf.instr_ptr,
@@ -394,7 +393,20 @@ fn exec_one(
         F32ReinterpretI32 => {}
         F64ReinterpretI64 => {}
 
-        i => todo!("{:?}", i),
+        // unsigned versions of these are a bit broken atm
+        I32TruncF32S => checked_float_conv_1!(f32, i32, stack),
+        I32TruncF64S => checked_float_conv_1!(f64, i32, stack),
+        I32TruncF32U => checked_float_conv_2!(f32, u32, i32, stack),
+        I32TruncF64U => checked_float_conv_2!(f64, u32, i32, stack),
+        I64TruncF32S => checked_float_conv_1!(f32, i64, stack),
+        I64TruncF64S => checked_float_conv_1!(f64, i64, stack),
+        I64TruncF32U => checked_float_conv_2!(f32, u64, i64, stack),
+        I64TruncF64U => checked_float_conv_2!(f64, u64, i64, stack),
+
+        i => {
+            log::error!("unimplemented instruction: {:?}", i);
+            panic!("Unimplemented instruction: {:?}", i)
+        }
     };
 
     Ok(ExecResult::Ok)

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

@@ -20,8 +20,8 @@ macro_rules! impl_wasm_float_ops {
                 match self {
                     x if x.is_nan() => x,
                     x if x.is_infinite() || x == 0.0 => x,
-                    x if x > 0.0 && x <= 0.5 => 0.0,
-                    x if x < 0.0 && x >= -0.5 => -0.0,
+                    x if (0.0..=0.5).contains(&x) => 0.0,
+                    x if (-0.5..0.0).contains(&x) => -0.0,
                     x => x.round(),
                 }
             }

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

@@ -3,7 +3,7 @@ use std::borrow::Cow;
 
 use super::TestSuite;
 use eyre::{eyre, Result};
-use log::{debug, error};
+use log::{debug, error, info};
 use tinywasm_types::TinyWasmModule;
 use wast::{lexer::Lexer, parser::ParseBuffer, Wast};
 
@@ -135,23 +135,30 @@ impl TestSuite {
                         Err(err) => test_group.add_result(
                             &format!("{}-trap", name),
                             span,
-                            Err(eyre!("test panicked: {:?}", err)),
+                            Err(eyre!("test panicked: {:?}, span: {:?}", err, span.linecol_in(&wast))),
                         ),
                         Ok(Err(tinywasm::Error::Trap(_))) => {
                             test_group.add_result(&format!("{}-trap", name), span, Ok(()))
                         }
                         Ok(Err(err)) => test_group.add_result(
                             &format!("{}-trap", name),
                             span,
-                            Err(eyre!("expected trap, got error: {:?}", err)),
+                            Err(eyre!(
+                                "expected trap, got error: {:?}, span: {:?}",
+                                err,
+                                span.linecol_in(&wast)
+                            )),
+                        ),
+                        Ok(Ok(())) => test_group.add_result(
+                            &format!("{}-trap", name),
+                            span,
+                            Err(eyre!("expected trap, got ok, span: {:?}", span.linecol_in(&wast))),
                         ),
-                        Ok(Ok(())) => {
-                            test_group.add_result(&format!("{}-trap", name), span, Err(eyre!("expected trap, got ok")))
-                        }
                     }
                 }
 
                 AssertReturn { span, exec, results } => {
+                    info!("AssertReturn: {:?}", exec);
                     let res: Result<Result<()>, _> = catch_unwind_silent(|| {
                         let invoke = match exec {
                             wast::WastExecute::Wat(_) => {
@@ -200,9 +207,6 @@ impl TestSuite {
                             ));
                         }
 
-                        println!("expected: {:?}", expected);
-                        println!("outcomes: {:?}", outcomes);
-
                         outcomes
                             .iter()
                             .zip(expected)
@@ -221,10 +225,7 @@ impl TestSuite {
                     });
 
                     let res = res
-                        .map_err(|e| {
-                            error!("test panicked: {:?}", e);
-                            eyre!("test panicked: {:?}", e.downcast_ref::<&str>())
-                        })
+                        .map_err(|e| eyre!("test panicked: {:?}", e.downcast_ref::<&str>()))
                         .and_then(|r| r);
 
                     test_group.add_result(&format!("{}-return", name), span, res);

crates/tinywasm/tests/generated/mvp.csv

@@ -36,7 +36,6 @@ pub fn wastarg2tinywasmvalue(arg: wast::WastArg) -> Result<tinywasm_types::WasmV
         return Err(eyre!("unsupported arg type"));
     };
 
-    use tinywasm_types::WasmValue;
     use wast::core::WastArgCore::*;
     Ok(match arg {
         F32(f) => WasmValue::F32(f32::from_bits(f.bits)),
@@ -52,7 +51,6 @@ pub fn wastret2tinywasmvalue(arg: wast::WastRet) -> Result<tinywasm_types::WasmV
         return Err(eyre!("unsupported arg type"));
     };
 
-    use tinywasm_types::WasmValue;
     use wast::core::WastRetCore::*;
     Ok(match arg {
         F32(f) => nanpattern2tinywasmvalue(f)?,