Rollup merge of rust-lang#136543 - RalfJung:round-ties-even, r=tgross35

intrinsics: unify rint, roundeven, nearbyint in a single round_ties_even intrinsic

LLVM has three intrinsics here that all do the same thing (when used in the default FP environment). There's no reason Rust needs to copy that historically-grown mess -- let's just have one intrinsic and leave it up to the LLVM backend to decide how to lower that.

Suggested by `@hanna-kruppe` in rust-lang#136459; Cc `@tgross35`

try-job: test-various

Author: tgross35

core/src/intrinsics/mod.rs

@@ -2731,110 +2731,124 @@ pub unsafe fn truncf128(_x: f128) -> f128 {
     unreachable!()
 }
 
-/// Returns the nearest integer to an `f16`. Changing the rounding mode is not possible in Rust,
-/// so this rounds half-way cases to the number with an even least significant digit.
-///
-/// May raise an inexact floating-point exception if the argument is not an integer.
-/// However, Rust assumes floating-point exceptions cannot be observed, so these exceptions
-/// cannot actually be utilized from Rust code.
-/// In other words, this intrinsic is equivalent in behavior to `nearbyintf16` and `roundevenf16`.
+/// Returns the nearest integer to an `f16`. Rounds half-way cases to the number with an even
+/// least significant digit.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::round_ties_even`](../../std/primitive.f16.html#method.round_ties_even)
 #[rustc_intrinsic]
 #[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn rintf16(_x: f16) -> f16 {
+#[cfg(not(bootstrap))]
+pub fn round_ties_even_f16(_x: f16) -> f16 {
     unreachable!()
 }
-/// Returns the nearest integer to an `f32`. Changing the rounding mode is not possible in Rust,
-/// so this rounds half-way cases to the number with an even least significant digit.
-///
-/// May raise an inexact floating-point exception if the argument is not an integer.
-/// However, Rust assumes floating-point exceptions cannot be observed, so these exceptions
-/// cannot actually be utilized from Rust code.
-/// In other words, this intrinsic is equivalent in behavior to `nearbyintf32` and `roundevenf32`.
+
+/// To be removed on next bootstrap bump.
+#[cfg(bootstrap)]
+pub fn round_ties_even_f16(x: f16) -> f16 {
+    #[rustc_intrinsic]
+    #[rustc_intrinsic_must_be_overridden]
+    #[rustc_nounwind]
+    unsafe fn rintf16(_x: f16) -> f16 {
+        unreachable!()
+    }
+
+    // SAFETY: this intrinsic isn't actually unsafe
+    unsafe { rintf16(x) }
+}
+
+/// Returns the nearest integer to an `f32`. Rounds half-way cases to the number with an even
+/// least significant digit.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::round_ties_even`](../../std/primitive.f32.html#method.round_ties_even)
 #[rustc_intrinsic]
 #[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn rintf32(_x: f32) -> f32 {
+#[cfg(not(bootstrap))]
+pub fn round_ties_even_f32(_x: f32) -> f32 {
     unreachable!()
 }
-/// Returns the nearest integer to an `f64`. Changing the rounding mode is not possible in Rust,
-/// so this rounds half-way cases to the number with an even least significant digit.
-///
-/// May raise an inexact floating-point exception if the argument is not an integer.
-/// However, Rust assumes floating-point exceptions cannot be observed, so these exceptions
-/// cannot actually be utilized from Rust code.
-/// In other words, this intrinsic is equivalent in behavior to `nearbyintf64` and `roundevenf64`.
-///
-/// The stabilized version of this intrinsic is
-/// [`f64::round_ties_even`](../../std/primitive.f64.html#method.round_ties_even)
-#[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-#[rustc_nounwind]
-pub unsafe fn rintf64(_x: f64) -> f64 {
-    unreachable!()
+
+/// To be removed on next bootstrap bump.
+#[cfg(bootstrap)]
+pub fn round_ties_even_f32(x: f32) -> f32 {
+    #[rustc_intrinsic]
+    #[rustc_intrinsic_must_be_overridden]
+    #[rustc_nounwind]
+    unsafe fn rintf32(_x: f32) -> f32 {
+        unreachable!()
+    }
+
+    // SAFETY: this intrinsic isn't actually unsafe
+    unsafe { rintf32(x) }
 }
-/// Returns the nearest integer to an `f128`. Changing the rounding mode is not possible in Rust,
-/// so this rounds half-way cases to the number with an even least significant digit.
-///
-/// May raise an inexact floating-point exception if the argument is not an integer.
-/// However, Rust assumes floating-point exceptions cannot be observed, so these exceptions
-/// cannot actually be utilized from Rust code.
-/// In other words, this intrinsic is equivalent in behavior to `nearbyintf128` and `roundevenf128`.
+
+/// Provided for compatibility with stdarch. DO NOT USE.
+#[inline(always)]
+pub unsafe fn rintf32(x: f32) -> f32 {
+    round_ties_even_f32(x)
+}
+
+/// Returns the nearest integer to an `f64`. Rounds half-way cases to the number with an even
+/// least significant digit.
 ///
 /// The stabilized version of this intrinsic is
-/// [`f128::round_ties_even`](../../std/primitive.f128.html#method.round_ties_even)
+/// [`f64::round_ties_even`](../../std/primitive.f64.html#method.round_ties_even)
 #[rustc_intrinsic]
 #[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn rintf128(_x: f128) -> f128 {
+#[cfg(not(bootstrap))]
+pub fn round_ties_even_f64(_x: f64) -> f64 {
     unreachable!()
 }
 
-/// Returns the nearest integer to an `f16`. Changing the rounding mode is not possible in Rust,
-/// so this rounds half-way cases to the number with an even least significant digit.
-///
-/// This intrinsic does not have a stable counterpart.
-#[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-#[rustc_nounwind]
-pub unsafe fn nearbyintf16(_x: f16) -> f16 {
-    unreachable!()
+/// To be removed on next bootstrap bump.
+#[cfg(bootstrap)]
+pub fn round_ties_even_f64(x: f64) -> f64 {
+    #[rustc_intrinsic]
+    #[rustc_intrinsic_must_be_overridden]
+    #[rustc_nounwind]
+    unsafe fn rintf64(_x: f64) -> f64 {
+        unreachable!()
+    }
+
+    // SAFETY: this intrinsic isn't actually unsafe
+    unsafe { rintf64(x) }
 }
-/// Returns the nearest integer to an `f32`. Changing the rounding mode is not possible in Rust,
-/// so this rounds half-way cases to the number with an even least significant digit.
-///
-/// This intrinsic does not have a stable counterpart.
-#[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-#[rustc_nounwind]
-pub unsafe fn nearbyintf32(_x: f32) -> f32 {
-    unreachable!()
+
+/// Provided for compatibility with stdarch. DO NOT USE.
+#[inline(always)]
+pub unsafe fn rintf64(x: f64) -> f64 {
+    round_ties_even_f64(x)
 }
-/// Returns the nearest integer to an `f64`. Changing the rounding mode is not possible in Rust,
-/// so this rounds half-way cases to the number with an even least significant digit.
+
+/// Returns the nearest integer to an `f128`. Rounds half-way cases to the number with an even
+/// least significant digit.
 ///
-/// This intrinsic does not have a stable counterpart.
+/// The stabilized version of this intrinsic is
+/// [`f128::round_ties_even`](../../std/primitive.f128.html#method.round_ties_even)
 #[rustc_intrinsic]
 #[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn nearbyintf64(_x: f64) -> f64 {
+#[cfg(not(bootstrap))]
+pub fn round_ties_even_f128(_x: f128) -> f128 {
     unreachable!()
 }
-/// Returns the nearest integer to an `f128`. Changing the rounding mode is not possible in Rust,
-/// so this rounds half-way cases to the number with an even least significant digit.
-///
-/// This intrinsic does not have a stable counterpart.
-#[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-#[rustc_nounwind]
-pub unsafe fn nearbyintf128(_x: f128) -> f128 {
-    unreachable!()
+
+/// To be removed on next bootstrap bump.
+#[cfg(bootstrap)]
+pub fn round_ties_even_f128(x: f128) -> f128 {
+    #[rustc_intrinsic]
+    #[rustc_intrinsic_must_be_overridden]
+    #[rustc_nounwind]
+    unsafe fn rintf128(_x: f128) -> f128 {
+        unreachable!()
+    }
+
+    // SAFETY: this intrinsic isn't actually unsafe
+    unsafe { rintf128(x) }
 }
 
 /// Returns the nearest integer to an `f16`. Rounds half-way cases away from zero.
@@ -2878,47 +2892,6 @@ pub unsafe fn roundf128(_x: f128) -> f128 {
     unreachable!()
 }
 
-/// Returns the nearest integer to an `f16`. Rounds half-way cases to the number
-/// with an even least significant digit.
-///
-/// This intrinsic does not have a stable counterpart.
-#[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-#[rustc_nounwind]
-pub unsafe fn roundevenf16(_x: f16) -> f16 {
-    unreachable!()
-}
-/// Returns the nearest integer to an `f32`. Rounds half-way cases to the number
-/// with an even least significant digit.
-///
-/// This intrinsic does not have a stable counterpart.
-#[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-#[rustc_nounwind]
-pub unsafe fn roundevenf32(_x: f32) -> f32 {
-    unreachable!()
-}
-/// Returns the nearest integer to an `f64`. Rounds half-way cases to the number
-/// with an even least significant digit.
-///
-/// This intrinsic does not have a stable counterpart.
-#[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-#[rustc_nounwind]
-pub unsafe fn roundevenf64(_x: f64) -> f64 {
-    unreachable!()
-}
-/// Returns the nearest integer to an `f128`. Rounds half-way cases to the number
-/// with an even least significant digit.
-///
-/// This intrinsic does not have a stable counterpart.
-#[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-#[rustc_nounwind]
-pub unsafe fn roundevenf128(_x: f128) -> f128 {
-    unreachable!()
-}
-
 /// Float addition that allows optimizations based on algebraic rules.
 /// May assume inputs are finite.
 ///

std/src/f128.rs

@@ -126,7 +126,7 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn round_ties_even(self) -> f128 {
-        unsafe { intrinsics::rintf128(self) }
+        intrinsics::round_ties_even_f128(self)
     }
 
     /// Returns the integer part of `self`.

std/src/f16.rs

@@ -126,7 +126,7 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn round_ties_even(self) -> f16 {
-        unsafe { intrinsics::rintf16(self) }
+        intrinsics::round_ties_even_f16(self)
     }
 
     /// Returns the integer part of `self`.

std/src/f32.rs

@@ -122,7 +122,7 @@ impl f32 {
     #[stable(feature = "round_ties_even", since = "1.77.0")]
     #[inline]
     pub fn round_ties_even(self) -> f32 {
-        unsafe { intrinsics::rintf32(self) }
+        intrinsics::round_ties_even_f32(self)
     }
 
     /// Returns the integer part of `self`.

std/src/f64.rs

@@ -122,7 +122,7 @@ impl f64 {
     #[stable(feature = "round_ties_even", since = "1.77.0")]
     #[inline]
     pub fn round_ties_even(self) -> f64 {
-        unsafe { intrinsics::rintf64(self) }
+        intrinsics::round_ties_even_f64(self)
     }
 
     /// Returns the integer part of `self`.