Move float-to-int conversion libcalls into compiled code (#9679)

This commit moves these conversion libcalls into compiled code to make
them easier to work with on Pulley since there's no need to manage the
hostcall boundary. This should in theory also speed things up slightly
relative to actually calling out to the libcall itself.

Author: alexcrichton

crates/cranelift/src/func_environ.rs

@@ -4,7 +4,7 @@ use crate::translate::{
 };
 use crate::{gc, BuiltinFunctionSignatures, TRAP_INTERNAL_ASSERT};
 use cranelift_codegen::cursor::FuncCursor;
-use cranelift_codegen::ir::condcodes::IntCC;
+use cranelift_codegen::ir::condcodes::{FloatCC, IntCC};
 use cranelift_codegen::ir::immediates::{Imm64, Offset32};
 use cranelift_codegen::ir::pcc::Fact;
 use cranelift_codegen::ir::types::*;
@@ -1103,31 +1103,41 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         self.conditionally_trap(builder, is_integer_overflow, ir::TrapCode::INTEGER_OVERFLOW);
     }
 
-    /// Helper used when `!self.signals_based_traps()` is enabled to perform
-    /// trapping float-to-int conversions.
-    fn fcvt_to_int(
+    /// Helper used when `!self.signals_based_traps()` is enabled to guard the
+    /// traps from float-to-int conversions.
+    fn guard_fcvt_to_int(
         &mut self,
         builder: &mut FunctionBuilder,
         ty: ir::Type,
         val: ir::Value,
-        i32: fn(&mut Self, &mut Function) -> ir::FuncRef,
-        i64: fn(&mut Self, &mut Function) -> ir::FuncRef,
-    ) -> ir::Value {
+        range32: (f64, f64),
+        range64: (f64, f64),
+    ) {
         assert!(!self.signals_based_traps());
         let val_ty = builder.func.dfg.value_type(val);
         let val = if val_ty == F64 {
             val
         } else {
             builder.ins().fpromote(F64, val)
         };
-        let libcall = match ty {
-            I32 => i32(self, &mut builder.func),
-            I64 => i64(self, &mut builder.func),
+        let isnan = builder.ins().fcmp(FloatCC::NotEqual, val, val);
+        self.trapnz(builder, isnan, ir::TrapCode::BAD_CONVERSION_TO_INTEGER);
+        let val = builder.ins().trunc(val);
+        let (lower_bound, upper_bound) = match ty {
+            I32 => range32,
+            I64 => range64,
             _ => unreachable!(),
         };
-        let vmctx = self.vmctx_val(&mut builder.cursor());
-        let call = builder.ins().call(libcall, &[vmctx, val]);
-        *builder.func.dfg.inst_results(call).first().unwrap()
+        let lower_bound = builder.ins().f64const(lower_bound);
+        let too_small = builder
+            .ins()
+            .fcmp(FloatCC::LessThanOrEqual, val, lower_bound);
+        self.trapnz(builder, too_small, ir::TrapCode::INTEGER_OVERFLOW);
+        let upper_bound = builder.ins().f64const(upper_bound);
+        let too_large = builder
+            .ins()
+            .fcmp(FloatCC::GreaterThanOrEqual, val, upper_bound);
+        self.trapnz(builder, too_large, ir::TrapCode::INTEGER_OVERFLOW);
     }
 
     /// Get the `ir::Type` for a `VMSharedTypeIndex`.
@@ -3338,17 +3348,16 @@ impl<'module_environment> crate::translate::FuncEnvironment
     ) -> ir::Value {
         // NB: for now avoid translating this entire instruction to CLIF and
         // just do it in a libcall.
-        if self.signals_based_traps() {
-            builder.ins().fcvt_to_sint(ty, val)
-        } else {
-            self.fcvt_to_int(
+        if !self.signals_based_traps() {
+            self.guard_fcvt_to_int(
                 builder,
                 ty,
                 val,
-                |me, func| me.builtin_functions.f64_to_i32(func),
-                |me, func| me.builtin_functions.f64_to_i64(func),
-            )
+                (-2147483649.0, 2147483648.0),
+                (-9223372036854777856.0, 9223372036854775808.0),
+            );
         }
+        builder.ins().fcvt_to_sint(ty, val)
     }
 
     fn translate_fcvt_to_uint(
@@ -3357,19 +3366,16 @@ impl<'module_environment> crate::translate::FuncEnvironment
         ty: ir::Type,
         val: ir::Value,
     ) -> ir::Value {
-        // NB: for now avoid translating this entire instruction to CLIF and
-        // just do it in a libcall.
-        if self.signals_based_traps() {
-            builder.ins().fcvt_to_uint(ty, val)
-        } else {
-            self.fcvt_to_int(
+        if !self.signals_based_traps() {
+            self.guard_fcvt_to_int(
                 builder,
                 ty,
                 val,
-                |me, func| me.builtin_functions.f64_to_u32(func),
-                |me, func| me.builtin_functions.f64_to_u64(func),
-            )
+                (-1.0, 4294967296.0),
+                (-1.0, 18446744073709551616.0),
+            );
         }
+        builder.ins().fcvt_to_uint(ty, val)
     }
 }
 

crates/cranelift/src/lib.rs

@@ -386,10 +386,6 @@ impl BuiltinFunctionSignatures {
         AbiParam::new(ir::types::I64)
     }
 
-    fn f64(&self) -> AbiParam {
-        AbiParam::new(ir::types::F64)
-    }
-
     fn u8(&self) -> AbiParam {
         AbiParam::new(ir::types::I8)
     }

crates/environ/src/builtin.rs

@@ -198,16 +198,6 @@ macro_rules! foreach_builtin_function {
 
             // Raises an unconditional trap.
             trap(vmctx: vmctx, code: u8);
-
-            // Implementation of `i{32,64}.trunc_f{32,64}_{u,s}` when host trap
-            // handlers are disabled. These will raise a trap if necessary. Note
-            // that f32 inputs are always converted to f64 as the argument. Also
-            // note that the signed-ness of the result is not reflected in the
-            // type here.
-            f64_to_i64(vmctx: vmctx, float: f64) -> i64;
-            f64_to_u64(vmctx: vmctx, float: f64) -> i64;
-            f64_to_i32(vmctx: vmctx, float: f64) -> i32;
-            f64_to_u32(vmctx: vmctx, float: f64) -> i32;
         }
     };
 }

crates/wasmtime/src/runtime/vm/libcalls.rs

@@ -61,7 +61,6 @@ use crate::runtime::vm::{Instance, TrapReason, VMGcRef, VMStore};
 use core::ptr::NonNull;
 #[cfg(feature = "threads")]
 use core::time::Duration;
-use wasmtime_environ::Unsigned;
 use wasmtime_environ::{DataIndex, ElemIndex, FuncIndex, MemoryIndex, TableIndex, Trap};
 #[cfg(feature = "wmemcheck")]
 use wasmtime_wmemcheck::AccessError::{
@@ -143,7 +142,6 @@ pub mod raw {
 
         (@ty i32) => (u32);
         (@ty i64) => (u64);
-        (@ty f64) => (f64);
         (@ty u8) => (u8);
         (@ty reference) => (u32);
         (@ty pointer) => (*mut u8);
@@ -1257,70 +1255,6 @@ fn trap(_store: &mut dyn VMStore, _instance: &mut Instance, code: u8) -> Result<
     ))
 }
 
-fn f64_to_i64(
-    _store: &mut dyn VMStore,
-    _instance: &mut Instance,
-    val: f64,
-) -> Result<u64, TrapReason> {
-    if val.is_nan() {
-        return Err(TrapReason::Wasm(Trap::BadConversionToInteger));
-    }
-    let val = relocs::truncf64(val);
-    if val <= -9223372036854777856.0 || val >= 9223372036854775808.0 {
-        return Err(TrapReason::Wasm(Trap::IntegerOverflow));
-    }
-    #[allow(clippy::cast_possible_truncation)]
-    return Ok((val as i64).unsigned());
-}
-
-fn f64_to_u64(
-    _store: &mut dyn VMStore,
-    _instance: &mut Instance,
-    val: f64,
-) -> Result<u64, TrapReason> {
-    if val.is_nan() {
-        return Err(TrapReason::Wasm(Trap::BadConversionToInteger));
-    }
-    let val = relocs::truncf64(val);
-    if val <= -1.0 || val >= 18446744073709551616.0 {
-        return Err(TrapReason::Wasm(Trap::IntegerOverflow));
-    }
-    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
-    return Ok(val as u64);
-}
-
-fn f64_to_i32(
-    _store: &mut dyn VMStore,
-    _instance: &mut Instance,
-    val: f64,
-) -> Result<u32, TrapReason> {
-    if val.is_nan() {
-        return Err(TrapReason::Wasm(Trap::BadConversionToInteger));
-    }
-    let val = relocs::truncf64(val);
-    if val <= -2147483649.0 || val >= 2147483648.0 {
-        return Err(TrapReason::Wasm(Trap::IntegerOverflow));
-    }
-    #[allow(clippy::cast_possible_truncation)]
-    return Ok((val as i32).unsigned());
-}
-
-fn f64_to_u32(
-    _store: &mut dyn VMStore,
-    _instance: &mut Instance,
-    val: f64,
-) -> Result<u32, TrapReason> {
-    if val.is_nan() {
-        return Err(TrapReason::Wasm(Trap::BadConversionToInteger));
-    }
-    let val = relocs::truncf64(val);
-    if val <= -1.0 || val >= 4294967296.0 {
-        return Err(TrapReason::Wasm(Trap::IntegerOverflow));
-    }
-    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
-    return Ok(val as u32);
-}
-
 /// This module contains functions which are used for resolving relocations at
 /// runtime if necessary.
 ///

crates/wasmtime/src/runtime/vm/vmcontext.rs

@@ -796,7 +796,6 @@ macro_rules! define_builtin_array {
 
     (@ty i32) => (u32);
     (@ty i64) => (u64);
-    (@ty f64) => (f64);
     (@ty u8) => (u8);
     (@ty reference) => (u32);
     (@ty pointer) => (*mut u8);