Support non-trapping-float-to-int-conversions Wasm proposal

core/src/lib.rs

@@ -33,6 +33,7 @@ pub use self::{
         LittleEndianConvert,
         SignExtendFrom,
         TransmuteInto,
+        TruncateSaturateInto,
         TryTruncateInto,
         Value,
         ValueType,

core/src/value.rs

@@ -105,11 +105,32 @@ pub trait WrapInto<T> {
 }
 
 /// Convert one type to another by rounding to the nearest integer towards zero.
+///
+/// # Errors
+///
+/// Traps when the input float cannot be represented by the target integer or
+/// when the input float is NaN.
 pub trait TryTruncateInto<T, E> {
     /// Convert one type to another by rounding to the nearest integer towards zero.
     fn try_truncate_into(self) -> Result<T, E>;
 }
 
+/// Convert one type to another by rounding to the nearest integer towards zero.
+///
+/// # Note
+///
+/// This has saturating semantics for when the integer cannot represent the float.
+///
+/// Returns
+///
+/// - `0` when the input is NaN.
+/// - `int::MIN` when the input is -INF.
+/// - `int::MAX` when the input is +INF.
+pub trait TruncateSaturateInto<T> {
+    /// Convert one type to another by rounding to the nearest integer towards zero.
+    fn truncate_saturate_into(self) -> T;
+}
+
 /// Convert one type to another by extending with leading zeroes.
 pub trait ExtendInto<T> {
     /// Convert one type to another by extending with leading zeroes.
@@ -509,6 +530,22 @@ macro_rules! impl_try_truncate_into {
                     .ok_or(TrapCode::IntegerOverflow)
             }
         }
+
+        impl TruncateSaturateInto<$into> for $from {
+            #[inline]
+            fn truncate_saturate_into(self) -> $into {
+                if self.is_nan() {
+                    return <$into as Default>::default();
+                }
+                if self.is_infinite() && self.is_sign_positive() {
+                    return <$into>::MAX;
+                }
+                if self.is_infinite() && self.is_sign_negative() {
+                    return <$into>::MIN;
+                }
+                self as _
+            }
+        }
     };
     (@wrapped $from:ident, $intermediate:ident, $into:ident) => {
         impl TryTruncateInto<$into, TrapCode> for $from {
@@ -517,6 +554,13 @@ macro_rules! impl_try_truncate_into {
                 $intermediate::from(self).try_truncate_into()
             }
         }
+
+        impl TruncateSaturateInto<$into> for $from {
+            #[inline]
+            fn truncate_saturate_into(self) -> $into {
+                $intermediate::from(self).truncate_saturate_into()
+            }
+        }
     };
 }
 

tests/spec/v1/mod.rs

@@ -29,6 +29,14 @@ macro_rules! define_tests {
     };
 }
 
+mod saturating_float_to_int {
+    use super::run_wasm_spec_test;
+
+    define_tests! {
+        fn wasm_conversions("proposals/nontrapping-float-to-int-conversions/conversions");
+    }
+}
+
 mod sign_extension_ops {
     use super::run_wasm_spec_test;
 

wasmi_v1/src/engine/bytecode/mod.rs

@@ -195,6 +195,14 @@ pub enum Instruction {
     I64ReinterpretF64,
     F32ReinterpretI32,
     F64ReinterpretI64,
+    I32TruncSatF32S,
+    I32TruncSatF32U,
+    I32TruncSatF64S,
+    I32TruncSatF64U,
+    I64TruncSatF32S,
+    I64TruncSatF32U,
+    I64TruncSatF64S,
+    I64TruncSatF64U,
     I32Extend8S,
     I32Extend16S,
     I64Extend8S,

wasmi_v1/src/engine/bytecode/visitor.rs

@@ -169,6 +169,14 @@ pub trait VisitInstruction {
     fn visit_i64_reinterpret_f64(&mut self) -> Self::Outcome;
     fn visit_f32_reinterpret_i32(&mut self) -> Self::Outcome;
     fn visit_f64_reinterpret_i64(&mut self) -> Self::Outcome;
+    fn visit_i32_trunc_sat_f32(&mut self) -> Self::Outcome;
+    fn visit_u32_trunc_sat_f32(&mut self) -> Self::Outcome;
+    fn visit_i32_trunc_sat_f64(&mut self) -> Self::Outcome;
+    fn visit_u32_trunc_sat_f64(&mut self) -> Self::Outcome;
+    fn visit_i64_trunc_sat_f32(&mut self) -> Self::Outcome;
+    fn visit_u64_trunc_sat_f32(&mut self) -> Self::Outcome;
+    fn visit_i64_trunc_sat_f64(&mut self) -> Self::Outcome;
+    fn visit_u64_trunc_sat_f64(&mut self) -> Self::Outcome;
     fn visit_i32_sign_extend8(&mut self) -> Self::Outcome;
     fn visit_i32_sign_extend16(&mut self) -> Self::Outcome;
     fn visit_i64_sign_extend8(&mut self) -> Self::Outcome;

wasmi_v1/src/engine/code_map.rs

@@ -371,6 +371,14 @@ impl<'a> ResolvedFuncBody<'a> {
             Instruction::I64ReinterpretF64 => visitor.visit_i64_reinterpret_f64(),
             Instruction::F32ReinterpretI32 => visitor.visit_f32_reinterpret_i32(),
             Instruction::F64ReinterpretI64 => visitor.visit_f64_reinterpret_i64(),
+            Instruction::I32TruncSatF32S => visitor.visit_i32_trunc_sat_f32(),
+            Instruction::I32TruncSatF32U => visitor.visit_u32_trunc_sat_f32(),
+            Instruction::I32TruncSatF64S => visitor.visit_i32_trunc_sat_f64(),
+            Instruction::I32TruncSatF64U => visitor.visit_u32_trunc_sat_f64(),
+            Instruction::I64TruncSatF32S => visitor.visit_i64_trunc_sat_f32(),
+            Instruction::I64TruncSatF32U => visitor.visit_u64_trunc_sat_f32(),
+            Instruction::I64TruncSatF64S => visitor.visit_i64_trunc_sat_f64(),
+            Instruction::I64TruncSatF64U => visitor.visit_u64_trunc_sat_f64(),
             Instruction::I32Extend8S => visitor.visit_i32_sign_extend8(),
             Instruction::I32Extend16S => visitor.visit_i32_sign_extend16(),
             Instruction::I64Extend8S => visitor.visit_i64_sign_extend8(),

wasmi_v1/src/engine/exec_context.rs

@@ -26,6 +26,7 @@ use wasmi_core::{
     Integer,
     LittleEndianConvert,
     SignExtendFrom,
+    TruncateSaturateInto,
     TryTruncateInto,
     WrapInto,
 };
@@ -647,6 +648,17 @@ where
         Ok(ExecutionOutcome::Continue)
     }
 
+    fn execute_trunc_sat_to_int<T, U>(&mut self) -> Result<ExecutionOutcome, Trap>
+    where
+        StackEntry: From<U>,
+        T: TruncateSaturateInto<U> + FromStackEntry,
+    {
+        let entry = self.value_stack.last_mut();
+        let value = T::from_stack_entry(*entry).truncate_saturate_into();
+        *entry = value.into();
+        Ok(ExecutionOutcome::Continue)
+    }
+
     fn execute_reinterpret<T, U>(&mut self) -> Result<ExecutionOutcome, Trap>
     where
         StackEntry: From<U>,
@@ -1422,6 +1434,38 @@ where
         self.execute_reinterpret::<i64, F64>()
     }
 
+    fn visit_i32_trunc_sat_f32(&mut self) -> Self::Outcome {
+        self.execute_trunc_sat_to_int::<F32, i32>()
+    }
+
+    fn visit_u32_trunc_sat_f32(&mut self) -> Self::Outcome {
+        self.execute_trunc_sat_to_int::<F32, u32>()
+    }
+
+    fn visit_i32_trunc_sat_f64(&mut self) -> Self::Outcome {
+        self.execute_trunc_sat_to_int::<F64, i32>()
+    }
+
+    fn visit_u32_trunc_sat_f64(&mut self) -> Self::Outcome {
+        self.execute_trunc_sat_to_int::<F64, u32>()
+    }
+
+    fn visit_i64_trunc_sat_f32(&mut self) -> Self::Outcome {
+        self.execute_trunc_sat_to_int::<F32, i64>()
+    }
+
+    fn visit_u64_trunc_sat_f32(&mut self) -> Self::Outcome {
+        self.execute_trunc_sat_to_int::<F32, u64>()
+    }
+
+    fn visit_i64_trunc_sat_f64(&mut self) -> Self::Outcome {
+        self.execute_trunc_sat_to_int::<F64, i64>()
+    }
+
+    fn visit_u64_trunc_sat_f64(&mut self) -> Self::Outcome {
+        self.execute_trunc_sat_to_int::<F64, u64>()
+    }
+
     fn visit_i32_sign_extend8(&mut self) -> Self::Outcome {
         self.execute_sign_extend::<i32, i8>()
     }

wasmi_v1/src/engine/func_builder/mod.rs

@@ -1875,6 +1875,46 @@ impl<'engine, 'parser> FunctionBuilder<'engine, 'parser> {
         )
     }
 
+    /// Translate a Wasm `i32.truncate_sat_f32` instruction.
+    pub fn translate_i32_truncate_saturate_f32(&mut self) -> Result<(), ModuleError> {
+        self.translate_conversion(ValueType::F32, ValueType::I32, Instruction::I32TruncSatF32S)
+    }
+
+    /// Translate a Wasm `u32.truncate_sat_f32` instruction.
+    pub fn translate_u32_truncate_saturate_f32(&mut self) -> Result<(), ModuleError> {
+        self.translate_conversion(ValueType::F32, ValueType::I32, Instruction::I32TruncSatF32U)
+    }
+
+    /// Translate a Wasm `i32.truncate_sat_f64` instruction.
+    pub fn translate_i32_truncate_saturate_f64(&mut self) -> Result<(), ModuleError> {
+        self.translate_conversion(ValueType::F64, ValueType::I32, Instruction::I32TruncSatF64S)
+    }
+
+    /// Translate a Wasm `u32.truncate_sat_f64` instruction.
+    pub fn translate_u32_truncate_saturate_f64(&mut self) -> Result<(), ModuleError> {
+        self.translate_conversion(ValueType::F64, ValueType::I32, Instruction::I32TruncSatF64U)
+    }
+
+    /// Translate a Wasm `i64.truncate_sat_f32` instruction.
+    pub fn translate_i64_truncate_saturate_f32(&mut self) -> Result<(), ModuleError> {
+        self.translate_conversion(ValueType::F32, ValueType::I64, Instruction::I64TruncSatF32S)
+    }
+
+    /// Translate a Wasm `u64.truncate_sat_f32` instruction.
+    pub fn translate_u64_truncate_saturate_f32(&mut self) -> Result<(), ModuleError> {
+        self.translate_conversion(ValueType::F32, ValueType::I32, Instruction::I64TruncSatF32U)
+    }
+
+    /// Translate a Wasm `i64.truncate_sat_f64` instruction.
+    pub fn translate_i64_truncate_saturate_f64(&mut self) -> Result<(), ModuleError> {
+        self.translate_conversion(ValueType::F64, ValueType::I64, Instruction::I64TruncSatF64S)
+    }
+
+    /// Translate a Wasm `u64.truncate_sat_f64` instruction.
+    pub fn translate_u64_truncate_saturate_f64(&mut self) -> Result<(), ModuleError> {
+        self.translate_conversion(ValueType::F64, ValueType::I32, Instruction::I64TruncSatF64U)
+    }
+
     /// Translate a Wasm `i32.extend_8s` instruction.
     pub fn translate_i32_sign_extend8(&mut self) -> Result<(), ModuleError> {
         self.translate_unary_operation(ValueType::I32, Instruction::I32Extend8S)

wasmi_v1/src/module/compile/mod.rs

@@ -302,20 +302,20 @@ impl<'engine, 'parser> FunctionTranslator<'engine, 'parser> {
             Operator::I64ReinterpretF64 => self.translate_i64_reinterpret_f64(),
             Operator::F32ReinterpretI32 => self.translate_f32_reinterpret_i32(),
             Operator::F64ReinterpretI64 => self.translate_f64_reinterpret_i64(),
+            Operator::I32TruncSatF32S => self.translate_i32_truncate_saturate_f32(),
+            Operator::I32TruncSatF32U => self.translate_u32_truncate_saturate_f32(),
+            Operator::I32TruncSatF64S => self.translate_i32_truncate_saturate_f64(),
+            Operator::I32TruncSatF64U => self.translate_u32_truncate_saturate_f64(),
+            Operator::I64TruncSatF32S => self.translate_i64_truncate_saturate_f32(),
+            Operator::I64TruncSatF32U => self.translate_u64_truncate_saturate_f32(),
+            Operator::I64TruncSatF64S => self.translate_i64_truncate_saturate_f64(),
+            Operator::I64TruncSatF64U => self.translate_u64_truncate_saturate_f64(),
             Operator::I32Extend8S => self.translate_i32_sign_extend8(),
             Operator::I32Extend16S => self.translate_i32_sign_extend16(),
             Operator::I64Extend8S => self.translate_i64_sign_extend8(),
             Operator::I64Extend16S => self.translate_i64_sign_extend16(),
             Operator::I64Extend32S => self.translate_i64_sign_extend32(),
-            Operator::I32TruncSatF32S
-            | Operator::I32TruncSatF32U
-            | Operator::I32TruncSatF64S
-            | Operator::I32TruncSatF64U
-            | Operator::I64TruncSatF32S
-            | Operator::I64TruncSatF32U
-            | Operator::I64TruncSatF64S
-            | Operator::I64TruncSatF64U
-            | Operator::MemoryInit { .. }
+            Operator::MemoryInit { .. }
             | Operator::DataDrop { .. }
             | Operator::MemoryCopy { .. }
             | Operator::MemoryFill { .. }

wasmi_v1/src/module/compile/operator.rs

@@ -709,6 +709,22 @@ impl<'engine, 'parser> FunctionTranslator<'engine, 'parser> {
         fn translate_f32_reinterpret_i32();
         /// Translate a Wasm `f64_reinterpret_i64` instruction.
         fn translate_f64_reinterpret_i64();
+        /// Translate a Wasm `i32.truncate_saturate_f32` instruction.
+        fn translate_i32_truncate_saturate_f32();
+        /// Translate a Wasm `u32.truncate_saturate_f32` instruction.
+        fn translate_u32_truncate_saturate_f32();
+        /// Translate a Wasm `i32.truncate_saturate_f64` instruction.
+        fn translate_i32_truncate_saturate_f64();
+        /// Translate a Wasm `u32.truncate_saturate_f64` instruction.
+        fn translate_u32_truncate_saturate_f64();
+        /// Translate a Wasm `i64.truncate_saturate_f32` instruction.
+        fn translate_i64_truncate_saturate_f32();
+        /// Translate a Wasm `u64.truncate_saturate_f32` instruction.
+        fn translate_u64_truncate_saturate_f32();
+        /// Translate a Wasm `i64.truncate_saturate_f64` instruction.
+        fn translate_i64_truncate_saturate_f64();
+        /// Translate a Wasm `u64.truncate_saturate_f64` instruction.
+        fn translate_u64_truncate_saturate_f64();
         /// Translate a Wasm `i32.extend_i8` instruction.
         fn translate_i32_sign_extend8();
         /// Translate a Wasm `i32.extend_i16` instruction.