Make min/max and copysign intrinsics generic by N1ark · Pull Request #162414 · rust-lang/rust

N1ark · 2026-09-07T10:24:24Z

Split off from #162395

Make the following intrinsics generic over the float type:

copysign, with a shared fallback (bit manipulations). Note that this required adding #[rustc_const_unstable] to the whole intrinsic, which copysignf16 and copysignf128 didn't have. This was already FCP'd, see rust-lang/rust#153834 (comment).
minimum_number_nsz, maximum_number_nsz, minimum, maximum, with shared fallbacks.

Because these are generic and require const trait impls to have a fallback, I had to add #[rustc_allow_const_fn_unstable] to them:

copysign needs const_ops, const_trait_impl
minimum_number_nsz and maximum_number_nsz need const_cmp, const_trait_impl
minimum and maximum need const_cmp, const_ops, const_trait_impl

I have also bundled in the addition of the attribute to fabs, which used these features without having a formal approval (see #162409 -- this was introduced in #153834)

See #162395 (comment)

r? RalfJung

rustbot · 2026-09-07T10:24:28Z

Some changes occurred to the intrinsics. Make sure the CTFE / Miri interpreter
gets adapted for the changes, if necessary.

cc @rust-lang/miri, @RalfJung, @oli-obk, @lcnr

rustc_codegen_cranelift is developed in its own repository. If possible, consider making this change to rust-lang/rustc_codegen_cranelift instead.

cc @bjorn3

clippy is developed in its own repository. If possible, consider making this change to rust-lang/rust-clippy instead.

cc @rust-lang/clippy

⚠️ #[miri::intrinsic_fallback_is_spec] must only be used if the function actively checks for all UB cases,
and explores the possible non-determinism of the intrinsic.

cc @rust-lang/miri

rustc_codegen_gcc is developed in its own repository. If possible, consider making this change to rust-lang/rustc_codegen_gcc instead.

cc @antoyo, @GuillaumeGomez

Some changes occurred to the CTFE / Miri interpreter

cc @rust-lang/miri

Any special-casing of Miri in the standard library requires review.

cc @rust-lang/miri

⚠️ #[rustc_intrinsic_const_stable_indirect] controls whether intrinsics can be exposed to stable const
code; adding it needs t-lang approval.

cc @rust-lang/wg-const-eval

⚠️ #[rustc_allow_const_fn_unstable] needs careful audit to avoid accidentally exposing unstable
implementation details on stable.

cc @rust-lang/wg-const-eval

Some changes occurred to the CTFE machinery

cc @RalfJung, @oli-obk, @lcnr

rustbot · 2026-09-07T10:24:31Z

RalfJung is not on the review rotation at the moment.
They may take a while to respond.

RalfJung · 2026-09-07T10:27:10Z

Because these are generic and require const trait impls to have a fallback, I had to add #[rustc_allow_const_fn_unstable] to them:

I just realized that we can maybe just use rustc_do_not_const_check for all of them? They all have built-in implementations right?

N1ark · 2026-09-07T10:33:32Z

doesn't that feel a bit hackier / risk prone that just doing it like this? though i don't mind, we are calling externs from const code in other fallbacks after all ^^'

beetrees · 2026-09-07T10:37:23Z

@@ -66,6 +71,18 @@ const unsafe impl FloatPrimitive for f16 {
    fn from_bits(bits: Self::UInt) -> Self {
        f16::from_bits(bits)
    }
+    #[inline]
+    fn is_nan(self) -> bool {
+        f16::is_nan(self)
+    }
+    #[inline]
+    fn is_sign_positive(self) -> bool {
+        f16::is_sign_positive(self)
+    }
+    #[inline]
+    fn is_sign_negative(self) -> bool {
+        f16::is_sign_negative(self)
+    }
 }

 #[rustc_const_unstable(feature = "core_intrinsics", issue = "none")]
@@ -80,6 +97,18 @@ const unsafe impl FloatPrimitive for f32 {
    fn from_bits(bits: Self::UInt) -> Self {
        f32::from_bits(bits)
    }
+    #[inline]
+    fn is_nan(self) -> bool {
+        f32::is_nan(self)
+    }
+    #[inline]
+    fn is_sign_positive(self) -> bool {
+        f32::is_sign_positive(self)
+    }
+    #[inline]
+    fn is_sign_negative(self) -> bool {
+        f32::is_sign_negative(self)
+    }
 }

 #[rustc_const_unstable(feature = "core_intrinsics", issue = "none")]
@@ -94,6 +123,18 @@ const unsafe impl FloatPrimitive for f64 {
    fn from_bits(bits: Self::UInt) -> Self {
        f64::from_bits(bits)
    }
+    #[inline]
+    fn is_nan(self) -> bool {
+        f64::is_nan(self)
+    }
+    #[inline]
+    fn is_sign_positive(self) -> bool {
+        f64::is_sign_positive(self)
+    }
+    #[inline]
+    fn is_sign_negative(self) -> bool {
+        f64::is_sign_negative(self)
+    }
 }

 #[rustc_const_unstable(feature = "core_intrinsics", issue = "none")]
@@ -108,6 +149,18 @@ const unsafe impl FloatPrimitive for f128 {
    fn from_bits(bits: Self::UInt) -> Self {
        f128::from_bits(bits)
    }
+    #[inline]
+    fn is_nan(self) -> bool {
+        f128::is_nan(self)
+    }
+    #[inline]
+    fn is_sign_positive(self) -> bool {
+        f128::is_sign_positive(self)
+    }
+    #[inline]
+    fn is_sign_negative(self) -> bool {
+        f128::is_sign_negative(self)
+    }
 }


Since this is repeating the same thing 4 times, I think it would be tidier as a macro. Something like:

Suggested change

macro_rules! impl_float_primitive {

(unsafe $($float:ident => $bits:ident),+) => {

#[rustc_const_unstable(feature = "core_intrinsics", issue = "none")]

const unsafe impl FloatPrimitive for $float {

type UInt = $bits;

const SIGN_MASK: Self::UInt = Self::SIGN_MASK;

#[inline]

fn to_bits(self) -> Self::UInt {

Self::to_bits(self)

}

#[inline]

fn from_bits(bits: Self::UInt) -> Self {

Self::from_bits(bits)

}

#[inline]

fn is_nan(self) -> bool {

Self::is_nan(self)

}

#[inline]

fn is_sign_positive(self) -> bool {

Self::is_sign_positive(self)

}

#[inline]

fn is_sign_negative(self) -> bool {

Self::is_sign_negative(self)

}

}

};

}

impl_float_primitive!(unsafe f16 => u16, f32 => u32, f64 => u64, f128 => u128);

View changes since the review

true! originally we had agreed to not use a macro but given it's growing a bit and there's a macro for ints right below this makes sense; done in 1514b9c

N1ark added 4 commits September 7, 2026 10:46

cranelift: use fallbacks for abs f16, f128

0dcb734

Make copysign generic

7b86261

Make minimum/maximum generic

78c2b96

Add rustc_allow_const_fn_unstable to fabs

a707a46

rustbot added the A-LLVM Area: Code generation parts specific to LLVM. Both correctness bugs and optimization-related issues. label Sep 7, 2026

rustbot assigned RalfJung Sep 7, 2026

N1ark mentioned this pull request Sep 7, 2026

Make more float intrinsics generic #162395

Open

beetrees suggested changes Sep 7, 2026

View reviewed changes

Replace float bound impls with a macro

1514b9c

Navigation Menu

Uh oh!

Uh oh!

Make min/max and copysign intrinsics generic - #162414

Make min/max and copysign intrinsics generic#162414
N1ark wants to merge 5 commits into
rust-lang:mainfrom
N1ark:const-unstable-float-generics

N1ark commented Sep 7, 2026 •

edited

Loading

Uh oh!

rustbot commented Sep 7, 2026

Uh oh!

rustbot commented Sep 7, 2026

Uh oh!

RalfJung commented Sep 7, 2026 •

edited

Loading

Uh oh!

N1ark commented Sep 7, 2026

Uh oh!

beetrees Sep 7, 2026 •

edited by rustbot

Loading

Uh oh!

N1ark Sep 7, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

+macro_rules! impl_float_primitive {
+    (unsafe $($float:ident => $bits:ident),+) => {
+        #[rustc_const_unstable(feature = "core_intrinsics", issue = "none")]
+        const unsafe impl FloatPrimitive for $float {
+            type UInt = $bits;
+            const SIGN_MASK: Self::UInt = Self::SIGN_MASK;
+            #[inline]
+            fn to_bits(self) -> Self::UInt {
+                Self::to_bits(self)
+            }
+            #[inline]
+            fn from_bits(bits: Self::UInt) -> Self {
+                Self::from_bits(bits)
+            }
+            #[inline]
+            fn is_nan(self) -> bool {
+                Self::is_nan(self)
+            }
+            #[inline]
+            fn is_sign_positive(self) -> bool {
+                Self::is_sign_positive(self)
+            }
+            #[inline]
+            fn is_sign_negative(self) -> bool {
+                Self::is_sign_negative(self)
+            }
+        }
+    };
+}
+impl_float_primitive!(unsafe f16 => u16, f32 => u32, f64 => u64, f128 => u128);

Uh oh!

Uh oh!

Conversation

N1ark commented Sep 7, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

rustbot commented Sep 7, 2026

Uh oh!

rustbot commented Sep 7, 2026

Uh oh!

RalfJung commented Sep 7, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

N1ark commented Sep 7, 2026

Uh oh!

beetrees Sep 7, 2026 • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

N1ark Sep 7, 2026

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

N1ark commented Sep 7, 2026 •

edited

Loading

RalfJung commented Sep 7, 2026 •

edited

Loading

beetrees Sep 7, 2026 •

edited by rustbot

Loading