Add ARM64 FJCVTZS instruction optimization for ToInt32 implementation

Co-authored-by: sapphi-red <49056869+sapphi-red@users.noreply.github.com>

Author: Copilot

crates/oxc_ecmascript/src/lib.rs

@@ -47,7 +47,7 @@ pub use self::{
     string_to_number::StringToNumber,
     to_big_int::ToBigInt,
     to_boolean::ToBoolean,
-    to_int_32::ToInt32,
+    to_int_32::{ToInt32, ToUint32},
     to_integer_index::ToIntegerIndex,
     to_number::ToNumber,
     to_primitive::ToPrimitive,

crates/oxc_ecmascript/src/to_int_32.rs

@@ -10,71 +10,142 @@ pub trait ToInt32 {
 impl ToInt32 for f64 {
     #[expect(clippy::float_cmp, clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
     fn to_int_32(&self) -> i32 {
-        const SIGN_MASK: u64 = 0x8000_0000_0000_0000;
-        const EXPONENT_MASK: u64 = 0x7FF0_0000_0000_0000;
-        const SIGNIFICAND_MASK: u64 = 0x000F_FFFF_FFFF_FFFF;
-        const HIDDEN_BIT: u64 = 0x0010_0000_0000_0000;
-        const PHYSICAL_SIGNIFICAND_SIZE: i32 = 52; // Excludes the hidden bit.
-        const SIGNIFICAND_SIZE: i32 = 53;
-
-        const EXPONENT_BIAS: i32 = 0x3FF + PHYSICAL_SIGNIFICAND_SIZE;
-        const DENORMAL_EXPONENT: i32 = -EXPONENT_BIAS + 1;
-
-        fn is_denormal(number: f64) -> bool {
-            (number.to_bits() & EXPONENT_MASK) == 0
+        #[cfg(target_arch = "aarch64")]
+        {
+            f64_to_int32_arm64(*self)
         }
+        #[cfg(not(target_arch = "aarch64"))]
+        {
+            f64_to_int32_generic(*self)
+        }
+    }
+}
 
-        fn exponent(number: f64) -> i32 {
-            if is_denormal(number) {
-                return DENORMAL_EXPONENT;
-            }
+/// Converts a 64-bit floating point number to an `i32` using [`FJCVTZS`][FJCVTZS] instruction on ARM64.
+///
+/// [FJCVTZS]: https://developer.arm.com/documentation/dui0801/h/A64-Floating-point-Instructions/FJCVTZS
+#[cfg(target_arch = "aarch64")]
+fn f64_to_int32_arm64(number: f64) -> i32 {
+    if number.is_nan() {
+        return 0;
+    }
+    let ret: i32;
+    // SAFETY: Number is not nan so no floating-point exception should throw.
+    unsafe {
+        std::arch::asm!(
+            "fjcvtzs {dst:w}, {src:d}",
+            src = in(vreg) number,
+            dst = out(reg) ret,
+        )
+    }
+    ret
+}
 
-            let d64 = number.to_bits();
-            let biased_e = ((d64 & EXPONENT_MASK) >> PHYSICAL_SIGNIFICAND_SIZE) as i32;
+/// Generic implementation of ToInt32 for non-ARM64 architectures
+#[cfg(not(target_arch = "aarch64"))]
+fn f64_to_int32_generic(number: f64) -> i32 {
+    const SIGN_MASK: u64 = 0x8000_0000_0000_0000;
+    const EXPONENT_MASK: u64 = 0x7FF0_0000_0000_0000;
+    const SIGNIFICAND_MASK: u64 = 0x000F_FFFF_FFFF_FFFF;
+    const HIDDEN_BIT: u64 = 0x0010_0000_0000_0000;
+    const PHYSICAL_SIGNIFICAND_SIZE: i32 = 52; // Excludes the hidden bit.
+    const SIGNIFICAND_SIZE: i32 = 53;
+
+    const EXPONENT_BIAS: i32 = 0x3FF + PHYSICAL_SIGNIFICAND_SIZE;
+    const DENORMAL_EXPONENT: i32 = -EXPONENT_BIAS + 1;
+
+    fn is_denormal(number: f64) -> bool {
+        (number.to_bits() & EXPONENT_MASK) == 0
+    }
 
-            biased_e - EXPONENT_BIAS
+    fn exponent(number: f64) -> i32 {
+        if is_denormal(number) {
+            return DENORMAL_EXPONENT;
         }
 
-        fn significand(number: f64) -> u64 {
-            let d64 = number.to_bits();
-            let significand = d64 & SIGNIFICAND_MASK;
+        let d64 = number.to_bits();
+        let biased_e = ((d64 & EXPONENT_MASK) >> PHYSICAL_SIGNIFICAND_SIZE) as i32;
 
-            if is_denormal(number) { significand } else { significand + HIDDEN_BIT }
-        }
+        biased_e - EXPONENT_BIAS
+    }
 
-        fn sign(number: f64) -> i64 {
-            if (number.to_bits() & SIGN_MASK) == 0 { 1 } else { -1 }
-        }
+    fn significand(number: f64) -> u64 {
+        let d64 = number.to_bits();
+        let significand = d64 & SIGNIFICAND_MASK;
+
+        if is_denormal(number) { significand } else { significand + HIDDEN_BIT }
+    }
+
+    fn sign(number: f64) -> i64 {
+        if (number.to_bits() & SIGN_MASK) == 0 { 1 } else { -1 }
+    }
 
-        let number = *self;
+    // NOTE: this also matches with negative zero
+    if !number.is_finite() || number == 0.0 {
+        return 0;
+    }
 
-        // NOTE: this also matches with negative zero
-        if !number.is_finite() || number == 0.0 {
+    if number.is_finite() && number <= f64::from(i32::MAX) && number >= f64::from(i32::MIN) {
+        let i = number as i32;
+        if f64::from(i) == number {
+            return i;
+        }
+    }
+
+    let exponent = exponent(number);
+    let bits = if exponent < 0 {
+        if exponent <= -SIGNIFICAND_SIZE {
             return 0;
         }
 
-        if number.is_finite() && number <= f64::from(i32::MAX) && number >= f64::from(i32::MIN) {
-            let i = number as i32;
-            if f64::from(i) == number {
-                return i;
-            }
+        significand(number) >> -exponent
+    } else {
+        if exponent > 31 {
+            return 0;
         }
 
-        let exponent = exponent(number);
-        let bits = if exponent < 0 {
-            if exponent <= -SIGNIFICAND_SIZE {
-                return 0;
-            }
+        (significand(number) << exponent) & 0xFFFF_FFFF
+    };
+
+    (sign(number) * (bits as i64)) as i32
+}
 
-            significand(number) >> -exponent
-        } else {
-            if exponent > 31 {
-                return 0;
-            }
+/// Converts a 64-bit floating point number to an `u32` according to the [`ToUint32`][ToUint32] algorithm.
+///
+/// [ToUint32]: https://tc39.es/ecma262/#sec-touint32
+pub trait ToUint32 {
+    fn to_uint_32(&self) -> u32;
+}
 
-            (significand(number) << exponent) & 0xFFFF_FFFF
-        };
+impl ToUint32 for f64 {
+    fn to_uint_32(&self) -> u32 {
+        self.to_int_32() as u32
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn f64_to_int32_conversion() {
+        assert_eq!(0.0_f64.to_int_32(), 0);
+        assert_eq!((-0.0_f64).to_int_32(), 0);
+        assert_eq!(f64::NAN.to_int_32(), 0);
+        assert_eq!(f64::INFINITY.to_int_32(), 0);
+        assert_eq!(f64::NEG_INFINITY.to_int_32(), 0);
+        assert_eq!(((i64::from(i32::MAX) + 1) as f64).to_int_32(), i32::MIN);
+        assert_eq!(((i64::from(i32::MIN) - 1) as f64).to_int_32(), i32::MAX);
+
+        // Test edge cases with maximum safe integers
+        assert_eq!((9007199254740992.0_f64).to_int_32(), 0); // 2^53
+        assert_eq!((-9007199254740992.0_f64).to_int_32(), 0); // -2^53
+    }
 
-        (sign(number) * (bits as i64)) as i32
+    #[test]
+    fn f64_to_uint32_conversion() {
+        assert_eq!(0.0_f64.to_uint_32(), 0);
+        assert_eq!((-1.0_f64).to_uint_32(), 4294967295); // -1 as u32 is 2^32 - 1
+        assert_eq!(f64::NAN.to_uint_32(), 0);
     }
 }