impl translation for fallible f2i conversions

Author: Robbepop

crates/wasmi/src/engine/translator/func2/mod.rs

@@ -742,6 +742,38 @@ impl FuncTranslator {
         )
     }
 
+    /// Translates a unary Wasm instruction to Wasmi bytecode.
+    fn translate_unary_fallible<T, R>(
+        &mut self,
+        make_instr: fn(result: Reg, input: Reg) -> Instruction,
+        consteval: fn(input: T) -> Result<R, TrapCode>,
+    ) -> Result<(), Error>
+    where
+        T: From<TypedVal>,
+        R: Into<TypedVal> + Typed,
+    {
+        bail_unreachable!(self);
+        let input = self.stack.pop();
+        if let Operand::Immediate(input) = input {
+            let input = T::from(input.val());
+            match consteval(input) {
+                Ok(result) => {
+                    self.stack.push_immediate(result)?;
+                }
+                Err(trap) => {
+                    self.translate_trap(trap)?;
+                }
+            }
+            return Ok(());
+        }
+        let input = self.layout.operand_to_reg(input)?;
+        self.push_instr_with_result(
+            <R as Typed>::TY,
+            |result| make_instr(result, input),
+            FuelCostsProvider::base,
+        )
+    }
+
     /// Creates a new 16-bit encoded [`Operand16`] from the given `value`.
     pub fn make_imm16<T>(&mut self, value: T) -> Result<Operand16<T>, Error>
     where

crates/wasmi/src/engine/translator/func2/visit.rs

@@ -1061,19 +1061,31 @@ impl<'a> VisitOperator<'a> for FuncTranslator {
     }
 
     fn visit_i32_trunc_f32_s(&mut self) -> Self::Output {
-        todo!()
+        self.translate_unary_fallible::<f32, i32>(
+            Instruction::i32_trunc_f32_s,
+            wasm::i32_trunc_f32_s,
+        )
     }
 
     fn visit_i32_trunc_f32_u(&mut self) -> Self::Output {
-        todo!()
+        self.translate_unary_fallible::<f32, u32>(
+            Instruction::i32_trunc_f32_u,
+            wasm::i32_trunc_f32_u,
+        )
     }
 
     fn visit_i32_trunc_f64_s(&mut self) -> Self::Output {
-        todo!()
+        self.translate_unary_fallible::<f64, i32>(
+            Instruction::i32_trunc_f64_s,
+            wasm::i32_trunc_f64_s,
+        )
     }
 
     fn visit_i32_trunc_f64_u(&mut self) -> Self::Output {
-        todo!()
+        self.translate_unary_fallible::<f64, u32>(
+            Instruction::i32_trunc_f64_u,
+            wasm::i32_trunc_f64_u,
+        )
     }
 
     fn visit_i64_extend_i32_s(&mut self) -> Self::Output {
@@ -1085,19 +1097,31 @@ impl<'a> VisitOperator<'a> for FuncTranslator {
     }
 
     fn visit_i64_trunc_f32_s(&mut self) -> Self::Output {
-        todo!()
+        self.translate_unary_fallible::<f32, i64>(
+            Instruction::i64_trunc_f32_s,
+            wasm::i64_trunc_f32_s,
+        )
     }
 
     fn visit_i64_trunc_f32_u(&mut self) -> Self::Output {
-        todo!()
+        self.translate_unary_fallible::<f32, u64>(
+            Instruction::i64_trunc_f32_u,
+            wasm::i64_trunc_f32_u,
+        )
     }
 
     fn visit_i64_trunc_f64_s(&mut self) -> Self::Output {
-        todo!()
+        self.translate_unary_fallible::<f64, i64>(
+            Instruction::i64_trunc_f64_s,
+            wasm::i64_trunc_f64_s,
+        )
     }
 
     fn visit_i64_trunc_f64_u(&mut self) -> Self::Output {
-        todo!()
+        self.translate_unary_fallible::<f64, u64>(
+            Instruction::i64_trunc_f64_u,
+            wasm::i64_trunc_f64_u,
+        )
     }
 
     fn visit_f32_convert_i32_s(&mut self) -> Self::Output {