From 117f6856af8a05ed4a78e1fbd40e1aa66171c553 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Sat, 11 Jan 2025 21:24:06 +0000
Subject: [PATCH] Use `core::arch::wasm` functions rather than intrinsics

These wasm functions are available in `core::arch::wasm32` since [1], so
we can use them while avoiding the possibly-recursive `intrinsics::*`
calls (in practice none of those should always lower to libcalls on
wasm, but that is up to LLVM).

Since these require an unstable feature, they are still gated under
`unstable-intrinsics`.

[1]: https://github.com/rust-lang/stdarch/pull/1677
---
 src/lib.rs              |  1 +
 src/math/arch/wasm32.rs | 30 ++++++++++--------------------
 2 files changed, 11 insertions(+), 20 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 327e3d6e6..b0e431211 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,6 +2,7 @@
 #![no_std]
 #![cfg_attr(intrinsics_enabled, allow(internal_features))]
 #![cfg_attr(intrinsics_enabled, feature(core_intrinsics))]
+#![cfg_attr(all(intrinsics_enabled, target_family = "wasm"), feature(wasm_numeric_instr))]
 #![cfg_attr(f128_enabled, feature(f128))]
 #![cfg_attr(f16_enabled, feature(f16))]
 #![allow(clippy::assign_op_pattern)]
diff --git a/src/math/arch/wasm32.rs b/src/math/arch/wasm32.rs
index 09df8624e..384445f12 100644
--- a/src/math/arch/wasm32.rs
+++ b/src/math/arch/wasm32.rs
@@ -1,16 +1,12 @@
-//! Wasm asm is not stable; just use intrinsics for operations that have asm routine equivalents.
-//!
-//! Note that we need to be absolutely certain that everything here lowers to assembly operations,
-//! otherwise libcalls will be recursive.
+//! Wasm has builtins for simple float operations. Use the unstable `core::arch` intrinsics which
+//! are significantly faster than soft float operations.
 
 pub fn ceil(x: f64) -> f64 {
-    // SAFETY: safe intrinsic with no preconditions
-    unsafe { core::intrinsics::ceilf64(x) }
+    core::arch::wasm32::f64_ceil(x)
 }
 
 pub fn ceilf(x: f32) -> f32 {
-    // SAFETY: safe intrinsic with no preconditions
-    unsafe { core::intrinsics::ceilf32(x) }
+    core::arch::wasm32::f32_ceil(x)
 }
 
 pub fn fabs(x: f64) -> f64 {
@@ -22,31 +18,25 @@ pub fn fabsf(x: f32) -> f32 {
 }
 
 pub fn floor(x: f64) -> f64 {
-    // SAFETY: safe intrinsic with no preconditions
-    unsafe { core::intrinsics::floorf64(x) }
+    core::arch::wasm32::f64_floor(x)
 }
 
 pub fn floorf(x: f32) -> f32 {
-    // SAFETY: safe intrinsic with no preconditions
-    unsafe { core::intrinsics::floorf32(x) }
+    core::arch::wasm32::f32_floor(x)
 }
 
 pub fn sqrt(x: f64) -> f64 {
-    // SAFETY: safe intrinsic with no preconditions
-    unsafe { core::intrinsics::sqrtf64(x) }
+    core::arch::wasm32::f64_sqrt(x)
 }
 
 pub fn sqrtf(x: f32) -> f32 {
-    // SAFETY: safe intrinsic with no preconditions
-    unsafe { core::intrinsics::sqrtf32(x) }
+    core::arch::wasm32::f32_sqrt(x)
 }
 
 pub fn trunc(x: f64) -> f64 {
-    // SAFETY: safe intrinsic with no preconditions
-    unsafe { core::intrinsics::truncf64(x) }
+    core::arch::wasm32::f64_trunc(x)
 }
 
 pub fn truncf(x: f32) -> f32 {
-    // SAFETY: safe intrinsic with no preconditions
-    unsafe { core::intrinsics::truncf32(x) }
+    core::arch::wasm32::f32_trunc(x)
 }