mathieu/os-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

most const intrinsics don't need an explicit rustc_const_unstable any more

Browse source
This commit is contained in:
Ralf Jung 2024-11-02 08:25:30 +01:00
parent 1f0ed2b0f5
commit 5069434c81
9 changed files with 46 additions and 58 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

74
library/core/src/intrinsics.rs
View file

@ -2389,7 +2389,7 @@ pub const fn bitreverse<T: Copy>(_x: T) -> T {
/// large and difficult to optimize. /// large and difficult to optimize.
/// ///
/// The stabilized version of this intrinsic is [`Ord::cmp`]. /// The stabilized version of this intrinsic is [`Ord::cmp`].
#[rustc_const_unstable(feature = "const_three_way_compare", issue = "none")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_three_way_compare", issue = "none"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const fn three_way_compare<T: Copy>(_lhs: T, _rhss: T) -> crate::cmp::Ordering { pub const fn three_way_compare<T: Copy>(_lhs: T, _rhss: T) -> crate::cmp::Ordering {
@ -2457,7 +2457,7 @@ pub const fn mul_with_overflow<T: Copy>(_x: T, _y: T) -> (T, bool) {
/// `x % y != 0` or `y == 0` or `x == T::MIN && y == -1` /// `x % y != 0` or `y == 0` or `x == T::MIN && y == -1`
/// ///
/// This intrinsic does not have a stable counterpart. /// This intrinsic does not have a stable counterpart.
#[rustc_const_unstable(feature = "const_exact_div", issue = "none")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_exact_div", issue = "none"))]
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
@ -2784,7 +2784,7 @@ pub const unsafe fn ptr_offset_from<T>(_ptr: *const T, _base: *const T) -> isize
} }
/// See documentation of `<*const T>::sub_ptr` for details. /// See documentation of `<*const T>::sub_ptr` for details.
#[rustc_const_unstable(feature = "const_ptr_sub_ptr", issue = "95892")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_ptr_sub_ptr", issue = "95892"))]
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
@ -2796,8 +2796,7 @@ pub const unsafe fn ptr_offset_from_unsigned<T>(_ptr: *const T, _base: *const T)
/// Returns `2` if the result is unknown. /// Returns `2` if the result is unknown.
/// Returns `1` if the pointers are guaranteed equal /// Returns `1` if the pointers are guaranteed equal
/// Returns `0` if the pointers are guaranteed inequal /// Returns `0` if the pointers are guaranteed inequal
#[rustc_const_unstable(feature = "const_raw_ptr_comparison", issue = "53020")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_raw_ptr_comparison", issue = "53020"))]
#[unstable(feature = "core_intrinsics", issue = "none")]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_do_not_const_check] #[rustc_do_not_const_check]
@ -2830,7 +2829,7 @@ pub const fn ptr_guaranteed_cmp<T>(ptr: *const T, other: *const T) -> u8 {
/// ///
/// (The implementation is allowed to branch on the results of comparisons, /// (The implementation is allowed to branch on the results of comparisons,
/// which is UB if any of their inputs are `undef`.) /// which is UB if any of their inputs are `undef`.)
#[rustc_const_unstable(feature = "const_intrinsic_raw_eq", issue = "none")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_intrinsic_raw_eq", issue = "none"))]
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
@ -2852,7 +2851,10 @@ pub const unsafe fn raw_eq<T>(_a: &T, _b: &T) -> bool {
/// that differs. That allows optimizations that can read in large chunks. /// that differs. That allows optimizations that can read in large chunks.
/// ///
/// [valid]: crate::ptr#safety /// [valid]: crate::ptr#safety
#[rustc_const_unstable(feature = "const_intrinsic_compare_bytes", issue = "none")] #[cfg_attr(
bootstrap,
rustc_const_unstable(feature = "const_intrinsic_compare_bytes", issue = "none")
)]
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
@ -2863,7 +2865,7 @@ pub const unsafe fn compare_bytes(_left: *const u8, _right: *const u8, _bytes: u
/// See documentation of [`std::hint::black_box`] for details. /// See documentation of [`std::hint::black_box`] for details.
/// ///
/// [`std::hint::black_box`]: crate::hint::black_box /// [`std::hint::black_box`]: crate::hint::black_box
#[rustc_const_unstable(feature = "const_black_box", issue = "none")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_black_box", issue = "none"))]
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
@ -3036,7 +3038,7 @@ pub const fn is_val_statically_known<T: Copy>(_arg: T) -> bool {
#[rustc_nounwind] #[rustc_nounwind]
#[inline] #[inline]
#[rustc_intrinsic] #[rustc_intrinsic]
// This has fallback `const fn` MIR, so shouldn't need stability, see #122652 // Const-unstable because `swap_nonoverlapping` is const-unstable.
#[rustc_const_unstable(feature = "const_typed_swap", issue = "none")] #[rustc_const_unstable(feature = "const_typed_swap", issue = "none")]
pub const unsafe fn typed_swap<T>(x: *mut T, y: *mut T) { pub const unsafe fn typed_swap<T>(x: *mut T, y: *mut T) {
// SAFETY: The caller provided single non-overlapping items behind // SAFETY: The caller provided single non-overlapping items behind
@ -3059,7 +3061,6 @@ pub const unsafe fn typed_swap<T>(x: *mut T, y: *mut T) {
/// primarily used by [`ub_checks::assert_unsafe_precondition`]. /// primarily used by [`ub_checks::assert_unsafe_precondition`].
#[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_ub_checks", issue = "none"))] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_ub_checks", issue = "none"))]
#[cfg_attr(not(bootstrap), rustc_const_stable_intrinsic)] // just for UB checks #[cfg_attr(not(bootstrap), rustc_const_stable_intrinsic)] // just for UB checks
#[unstable(feature = "core_intrinsics", issue = "none")]
#[inline(always)] #[inline(always)]
#[rustc_intrinsic] #[rustc_intrinsic]
pub const fn ub_checks() -> bool { pub const fn ub_checks() -> bool {
@ -3075,7 +3076,6 @@ pub const fn ub_checks() -> bool {
/// - At compile time, a compile error occurs if this constraint is violated. /// - At compile time, a compile error occurs if this constraint is violated.
/// - At runtime, it is not checked. /// - At runtime, it is not checked.
#[rustc_const_unstable(feature = "const_heap", issue = "79597")] #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
#[unstable(feature = "core_intrinsics", issue = "none")]
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_intrinsic] #[rustc_intrinsic]
#[miri::intrinsic_fallback_is_spec] #[miri::intrinsic_fallback_is_spec]
@ -3175,7 +3175,7 @@ pub const fn min_align_of<T>() -> usize {
/// It's "tracking issue" is [#91971](https://github.com/rust-lang/rust/issues/91971). /// It's "tracking issue" is [#91971](https://github.com/rust-lang/rust/issues/91971).
#[rustc_nounwind] #[rustc_nounwind]
#[unstable(feature = "core_intrinsics", issue = "none")] #[unstable(feature = "core_intrinsics", issue = "none")]
#[rustc_const_unstable(feature = "const_pref_align_of", issue = "91971")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_pref_align_of", issue = "91971"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const unsafe fn pref_align_of<T>() -> usize { pub const unsafe fn pref_align_of<T>() -> usize {
@ -3193,7 +3193,7 @@ pub const unsafe fn pref_align_of<T>() -> usize {
/// The to-be-stabilized version of this intrinsic is [`crate::mem::variant_count`]. /// The to-be-stabilized version of this intrinsic is [`crate::mem::variant_count`].
#[rustc_nounwind] #[rustc_nounwind]
#[unstable(feature = "core_intrinsics", issue = "none")] #[unstable(feature = "core_intrinsics", issue = "none")]
#[rustc_const_unstable(feature = "variant_count", issue = "73662")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "variant_count", issue = "73662"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const fn variant_count<T>() -> usize { pub const fn variant_count<T>() -> usize {
@ -3209,7 +3209,7 @@ pub const fn variant_count<T>() -> usize {
/// See [`crate::mem::size_of_val_raw`] for safety conditions. /// See [`crate::mem::size_of_val_raw`] for safety conditions.
#[rustc_nounwind] #[rustc_nounwind]
#[unstable(feature = "core_intrinsics", issue = "none")] #[unstable(feature = "core_intrinsics", issue = "none")]
#[rustc_const_unstable(feature = "const_size_of_val", issue = "46571")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_size_of_val", issue = "46571"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const unsafe fn size_of_val<T: ?Sized>(_ptr: *const T) -> usize { pub const unsafe fn size_of_val<T: ?Sized>(_ptr: *const T) -> usize {
@ -3225,7 +3225,7 @@ pub const unsafe fn size_of_val<T: ?Sized>(_ptr: *const T) -> usize {
/// See [`crate::mem::align_of_val_raw`] for safety conditions. /// See [`crate::mem::align_of_val_raw`] for safety conditions.
#[rustc_nounwind] #[rustc_nounwind]
#[unstable(feature = "core_intrinsics", issue = "none")] #[unstable(feature = "core_intrinsics", issue = "none")]
#[rustc_const_unstable(feature = "const_align_of_val", issue = "46571")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_align_of_val", issue = "46571"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const unsafe fn min_align_of_val<T: ?Sized>(_ptr: *const T) -> usize { pub const unsafe fn min_align_of_val<T: ?Sized>(_ptr: *const T) -> usize {
@ -3242,7 +3242,7 @@ pub const unsafe fn min_align_of_val<T: ?Sized>(_ptr: *const T) -> usize {
/// The stabilized version of this intrinsic is [`core::any::type_name`]. /// The stabilized version of this intrinsic is [`core::any::type_name`].
#[rustc_nounwind] #[rustc_nounwind]
#[unstable(feature = "core_intrinsics", issue = "none")] #[unstable(feature = "core_intrinsics", issue = "none")]
#[rustc_const_unstable(feature = "const_type_name", issue = "63084")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_type_name", issue = "63084"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const fn type_name<T: ?Sized>() -> &'static str { pub const fn type_name<T: ?Sized>() -> &'static str {
@ -3261,7 +3261,7 @@ pub const fn type_name<T: ?Sized>() -> &'static str {
/// The stabilized version of this intrinsic is [`core::any::TypeId::of`]. /// The stabilized version of this intrinsic is [`core::any::TypeId::of`].
#[rustc_nounwind] #[rustc_nounwind]
#[unstable(feature = "core_intrinsics", issue = "none")] #[unstable(feature = "core_intrinsics", issue = "none")]
#[rustc_const_unstable(feature = "const_type_id", issue = "77125")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_type_id", issue = "77125"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const fn type_id<T: ?Sized + 'static>() -> u128 { pub const fn type_id<T: ?Sized + 'static>() -> u128 {
@ -3636,8 +3636,7 @@ pub const unsafe fn write_bytes<T>(dst: *mut T, val: u8, count: usize) {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f16::min`] /// [`f16::min`]
#[rustc_nounwind] #[rustc_nounwind]
// #[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "f16", issue = "116909"))]
#[rustc_const_unstable(feature = "f16", issue = "116909")]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const fn minnumf16(_x: f16, _y: f16) -> f16 { pub const fn minnumf16(_x: f16, _y: f16) -> f16 {
@ -3654,7 +3653,7 @@ pub const fn minnumf16(_x: f16, _y: f16) -> f16 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f32::min`] /// [`f32::min`]
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_float_methods", issue = "130843"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const fn minnumf32(_x: f32, _y: f32) -> f32 { pub const fn minnumf32(_x: f32, _y: f32) -> f32 {
@ -3671,7 +3670,7 @@ pub const fn minnumf32(_x: f32, _y: f32) -> f32 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f64::min`] /// [`f64::min`]
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_float_methods", issue = "130843"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const fn minnumf64(_x: f64, _y: f64) -> f64 { pub const fn minnumf64(_x: f64, _y: f64) -> f64 {
@ -3688,8 +3687,7 @@ pub const fn minnumf64(_x: f64, _y: f64) -> f64 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f128::min`] /// [`f128::min`]
#[rustc_nounwind] #[rustc_nounwind]
// #[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "f128", issue = "116909"))]
#[rustc_const_unstable(feature = "f128", issue = "116909")]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const fn minnumf128(_x: f128, _y: f128) -> f128 { pub const fn minnumf128(_x: f128, _y: f128) -> f128 {
@ -3706,8 +3704,7 @@ pub const fn minnumf128(_x: f128, _y: f128) -> f128 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f16::max`] /// [`f16::max`]
#[rustc_nounwind] #[rustc_nounwind]
// #[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "f16", issue = "116909"))]
#[rustc_const_unstable(feature = "f16", issue = "116909")]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const fn maxnumf16(_x: f16, _y: f16) -> f16 { pub const fn maxnumf16(_x: f16, _y: f16) -> f16 {
@ -3724,7 +3721,7 @@ pub const fn maxnumf16(_x: f16, _y: f16) -> f16 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f32::max`] /// [`f32::max`]
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_float_methods", issue = "130843"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const fn maxnumf32(_x: f32, _y: f32) -> f32 { pub const fn maxnumf32(_x: f32, _y: f32) -> f32 {
@ -3741,7 +3738,7 @@ pub const fn maxnumf32(_x: f32, _y: f32) -> f32 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f64::max`] /// [`f64::max`]
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_float_methods", issue = "130843"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const fn maxnumf64(_x: f64, _y: f64) -> f64 { pub const fn maxnumf64(_x: f64, _y: f64) -> f64 {
@ -3758,8 +3755,7 @@ pub const fn maxnumf64(_x: f64, _y: f64) -> f64 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f128::max`] /// [`f128::max`]
#[rustc_nounwind] #[rustc_nounwind]
// #[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "f128", issue = "116909"))]
#[rustc_const_unstable(feature = "f128", issue = "116909")]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const fn maxnumf128(_x: f128, _y: f128) -> f128 { pub const fn maxnumf128(_x: f128, _y: f128) -> f128 {
@ -3771,8 +3767,7 @@ pub const fn maxnumf128(_x: f128, _y: f128) -> f128 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f16::abs`](../../std/primitive.f16.html#method.abs) /// [`f16::abs`](../../std/primitive.f16.html#method.abs)
#[rustc_nounwind] #[rustc_nounwind]
// #[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "f16", issue = "116909"))]
#[rustc_const_unstable(feature = "f16", issue = "116909")]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const unsafe fn fabsf16(_x: f16) -> f16 { pub const unsafe fn fabsf16(_x: f16) -> f16 {
@ -3784,7 +3779,7 @@ pub const unsafe fn fabsf16(_x: f16) -> f16 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f32::abs`](../../std/primitive.f32.html#method.abs) /// [`f32::abs`](../../std/primitive.f32.html#method.abs)
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_float_methods", issue = "130843"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const unsafe fn fabsf32(_x: f32) -> f32 { pub const unsafe fn fabsf32(_x: f32) -> f32 {
@ -3796,7 +3791,7 @@ pub const unsafe fn fabsf32(_x: f32) -> f32 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f64::abs`](../../std/primitive.f64.html#method.abs) /// [`f64::abs`](../../std/primitive.f64.html#method.abs)
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_float_methods", issue = "130843"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const unsafe fn fabsf64(_x: f64) -> f64 { pub const unsafe fn fabsf64(_x: f64) -> f64 {
@ -3808,8 +3803,7 @@ pub const unsafe fn fabsf64(_x: f64) -> f64 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f128::abs`](../../std/primitive.f128.html#method.abs) /// [`f128::abs`](../../std/primitive.f128.html#method.abs)
#[rustc_nounwind] #[rustc_nounwind]
// #[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "f128", issue = "116909"))]
#[rustc_const_unstable(feature = "f128", issue = "116909")]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const unsafe fn fabsf128(_x: f128) -> f128 { pub const unsafe fn fabsf128(_x: f128) -> f128 {
@ -3821,8 +3815,7 @@ pub const unsafe fn fabsf128(_x: f128) -> f128 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f16::copysign`](../../std/primitive.f16.html#method.copysign) /// [`f16::copysign`](../../std/primitive.f16.html#method.copysign)
#[rustc_nounwind] #[rustc_nounwind]
// #[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "f16", issue = "116909"))]
#[rustc_const_unstable(feature = "f16", issue = "116909")]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const unsafe fn copysignf16(_x: f16, _y: f16) -> f16 { pub const unsafe fn copysignf16(_x: f16, _y: f16) -> f16 {
@ -3834,7 +3827,7 @@ pub const unsafe fn copysignf16(_x: f16, _y: f16) -> f16 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f32::copysign`](../../std/primitive.f32.html#method.copysign) /// [`f32::copysign`](../../std/primitive.f32.html#method.copysign)
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_float_methods", issue = "130843"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const unsafe fn copysignf32(_x: f32, _y: f32) -> f32 { pub const unsafe fn copysignf32(_x: f32, _y: f32) -> f32 {
@ -3845,7 +3838,7 @@ pub const unsafe fn copysignf32(_x: f32, _y: f32) -> f32 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f64::copysign`](../../std/primitive.f64.html#method.copysign) /// [`f64::copysign`](../../std/primitive.f64.html#method.copysign)
#[rustc_nounwind] #[rustc_nounwind]
#[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "const_float_methods", issue = "130843"))]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const unsafe fn copysignf64(_x: f64, _y: f64) -> f64 { pub const unsafe fn copysignf64(_x: f64, _y: f64) -> f64 {
@ -3857,8 +3850,7 @@ pub const unsafe fn copysignf64(_x: f64, _y: f64) -> f64 {
/// The stabilized version of this intrinsic is /// The stabilized version of this intrinsic is
/// [`f128::copysign`](../../std/primitive.f128.html#method.copysign) /// [`f128::copysign`](../../std/primitive.f128.html#method.copysign)
#[rustc_nounwind] #[rustc_nounwind]
// #[rustc_const_unstable(feature = "const_float_methods", issue = "130843")] #[cfg_attr(bootstrap, rustc_const_unstable(feature = "f128", issue = "116909"))]
#[rustc_const_unstable(feature = "f128", issue = "116909")]
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden] #[rustc_intrinsic_must_be_overridden]
pub const unsafe fn copysignf128(_x: f128, _y: f128) -> f128 { pub const unsafe fn copysignf128(_x: f128, _y: f128) -> f128 {

2
library/core/src/lib.rs
View file

@ -107,6 +107,7 @@
// //
// Library features: // Library features:
// tidy-alphabetical-start // tidy-alphabetical-start
#![cfg_attr(bootstrap, feature(const_exact_div))]
#![cfg_attr(bootstrap, feature(const_fmt_arguments_new))] #![cfg_attr(bootstrap, feature(const_fmt_arguments_new))]
#![feature(array_ptr_get)] #![feature(array_ptr_get)]
#![feature(asm_experimental_arch)] #![feature(asm_experimental_arch)]
@ -116,7 +117,6 @@
#![feature(const_black_box)] #![feature(const_black_box)]
#![feature(const_char_encode_utf16)] #![feature(const_char_encode_utf16)]
#![feature(const_eval_select)] #![feature(const_eval_select)]
#![feature(const_exact_div)]
#![feature(const_float_methods)] #![feature(const_float_methods)]
#![feature(const_heap)] #![feature(const_heap)]
#![feature(const_nonnull_new)] #![feature(const_nonnull_new)]

2
library/core/tests/lib.rs
View file

@ -1,4 +1,5 @@
// tidy-alphabetical-start // tidy-alphabetical-start
#![cfg_attr(bootstrap, feature(const_three_way_compare))]
#![cfg_attr(bootstrap, feature(strict_provenance))] #![cfg_attr(bootstrap, feature(strict_provenance))]
#![cfg_attr(not(bootstrap), feature(strict_provenance_lints))] #![cfg_attr(not(bootstrap), feature(strict_provenance_lints))]
#![cfg_attr(target_has_atomic = "128", feature(integer_atomics))] #![cfg_attr(target_has_atomic = "128", feature(integer_atomics))]
@ -22,7 +23,6 @@
#![feature(const_nonnull_new)] #![feature(const_nonnull_new)]
#![feature(const_option_ext)] #![feature(const_option_ext)]
#![feature(const_pin_2)] #![feature(const_pin_2)]
#![feature(const_three_way_compare)]
#![feature(const_trait_impl)] #![feature(const_trait_impl)]
#![feature(core_intrinsics)] #![feature(core_intrinsics)]
#![feature(core_io_borrowed_buf)] #![feature(core_io_borrowed_buf)]

1
tests/ui/consts/const-compare-bytes-ub.rs
View file

@ -1,7 +1,6 @@
//@ check-fail //@ check-fail
#![feature(core_intrinsics)] #![feature(core_intrinsics)]
#![feature(const_intrinsic_compare_bytes)]
use std::intrinsics::compare_bytes; use std::intrinsics::compare_bytes;
use std::mem::MaybeUninit; use std::mem::MaybeUninit;

16
tests/ui/consts/const-compare-bytes-ub.stderr
View file

@ -1,47 +1,47 @@
error[E0080]: evaluation of constant value failed error[E0080]: evaluation of constant value failed
--> $DIR/const-compare-bytes-ub.rs:10:9 --> $DIR/const-compare-bytes-ub.rs:9:9
| |
LL | compare_bytes(0 as *const u8, 2 as *const u8, 1) LL | compare_bytes(0 as *const u8, 2 as *const u8, 1)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: expected a pointer to 1 byte of memory, but got a null pointer | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: expected a pointer to 1 byte of memory, but got a null pointer
error[E0080]: evaluation of constant value failed error[E0080]: evaluation of constant value failed
--> $DIR/const-compare-bytes-ub.rs:14:9 --> $DIR/const-compare-bytes-ub.rs:13:9
| |
LL | compare_bytes(1 as *const u8, 0 as *const u8, 1) LL | compare_bytes(1 as *const u8, 0 as *const u8, 1)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: expected a pointer to 1 byte of memory, but got 0x1[noalloc] which is a dangling pointer (it has no provenance) | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: expected a pointer to 1 byte of memory, but got 0x1[noalloc] which is a dangling pointer (it has no provenance)
error[E0080]: evaluation of constant value failed error[E0080]: evaluation of constant value failed
--> $DIR/const-compare-bytes-ub.rs:18:9 --> $DIR/const-compare-bytes-ub.rs:17:9
| |
LL | compare_bytes(1 as *const u8, 2 as *const u8, 1) LL | compare_bytes(1 as *const u8, 2 as *const u8, 1)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: expected a pointer to 1 byte of memory, but got 0x1[noalloc] which is a dangling pointer (it has no provenance) | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: expected a pointer to 1 byte of memory, but got 0x1[noalloc] which is a dangling pointer (it has no provenance)
error[E0080]: evaluation of constant value failed error[E0080]: evaluation of constant value failed
--> $DIR/const-compare-bytes-ub.rs:22:9 --> $DIR/const-compare-bytes-ub.rs:21:9
| |
LL | compare_bytes([1, 2, 3].as_ptr(), [1, 2, 3, 4].as_ptr(), 4) LL | compare_bytes([1, 2, 3].as_ptr(), [1, 2, 3, 4].as_ptr(), 4)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: expected a pointer to 4 bytes of memory, but got ALLOC0 which is only 3 bytes from the end of the allocation | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: expected a pointer to 4 bytes of memory, but got ALLOC0 which is only 3 bytes from the end of the allocation
error[E0080]: evaluation of constant value failed error[E0080]: evaluation of constant value failed
--> $DIR/const-compare-bytes-ub.rs:26:9 --> $DIR/const-compare-bytes-ub.rs:25:9
| |
LL | compare_bytes([1, 2, 3, 4].as_ptr(), [1, 2, 3].as_ptr(), 4) LL | compare_bytes([1, 2, 3, 4].as_ptr(), [1, 2, 3].as_ptr(), 4)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: expected a pointer to 4 bytes of memory, but got ALLOC1 which is only 3 bytes from the end of the allocation | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: expected a pointer to 4 bytes of memory, but got ALLOC1 which is only 3 bytes from the end of the allocation
error[E0080]: evaluation of constant value failed error[E0080]: evaluation of constant value failed
--> $DIR/const-compare-bytes-ub.rs:30:9 --> $DIR/const-compare-bytes-ub.rs:29:9
| |
LL | compare_bytes(MaybeUninit::uninit().as_ptr(), [1].as_ptr(), 1) LL | compare_bytes(MaybeUninit::uninit().as_ptr(), [1].as_ptr(), 1)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reading memory at ALLOC2[0x0..0x1], but memory is uninitialized at [0x0..0x1], and this operation requires initialized memory | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reading memory at ALLOC2[0x0..0x1], but memory is uninitialized at [0x0..0x1], and this operation requires initialized memory
error[E0080]: evaluation of constant value failed error[E0080]: evaluation of constant value failed
--> $DIR/const-compare-bytes-ub.rs:34:9 --> $DIR/const-compare-bytes-ub.rs:33:9
| |
LL | compare_bytes([1].as_ptr(), MaybeUninit::uninit().as_ptr(), 1) LL | compare_bytes([1].as_ptr(), MaybeUninit::uninit().as_ptr(), 1)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reading memory at ALLOC3[0x0..0x1], but memory is uninitialized at [0x0..0x1], and this operation requires initialized memory | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reading memory at ALLOC3[0x0..0x1], but memory is uninitialized at [0x0..0x1], and this operation requires initialized memory
error[E0080]: evaluation of constant value failed error[E0080]: evaluation of constant value failed
--> $DIR/const-compare-bytes-ub.rs:38:9 --> $DIR/const-compare-bytes-ub.rs:37:9
| |
LL | compare_bytes([&1].as_ptr().cast(), [&2].as_ptr().cast(), std::mem::size_of::<usize>()) LL | compare_bytes([&1].as_ptr().cast(), [&2].as_ptr().cast(), std::mem::size_of::<usize>())
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unable to turn pointer into integer | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unable to turn pointer into integer

1
tests/ui/consts/const-compare-bytes.rs
View file

@ -1,7 +1,6 @@
//@ run-pass //@ run-pass
#![feature(core_intrinsics)] #![feature(core_intrinsics)]
#![feature(const_intrinsic_compare_bytes)]
use std::intrinsics::compare_bytes; use std::intrinsics::compare_bytes;
fn main() { fn main() {

1
tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs
View file

@ -1,5 +1,4 @@
#![feature(core_intrinsics)] #![feature(core_intrinsics)]
#![feature(const_intrinsic_raw_eq)]
const RAW_EQ_PADDING: bool = unsafe { const RAW_EQ_PADDING: bool = unsafe {
std::intrinsics::raw_eq(&(1_u8, 2_u16), &(1_u8, 2_u16)) std::intrinsics::raw_eq(&(1_u8, 2_u16), &(1_u8, 2_u16))

6
tests/ui/intrinsics/intrinsic-raw_eq-const-bad.stderr
View file

@ -1,11 +1,11 @@
error[E0080]: evaluation of constant value failed error[E0080]: evaluation of constant value failed
--> $DIR/intrinsic-raw_eq-const-bad.rs:5:5 --> $DIR/intrinsic-raw_eq-const-bad.rs:4:5
| |
LL | std::intrinsics::raw_eq(&(1_u8, 2_u16), &(1_u8, 2_u16)) LL | std::intrinsics::raw_eq(&(1_u8, 2_u16), &(1_u8, 2_u16))
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reading memory at ALLOC0[0x0..0x4], but memory is uninitialized at [0x1..0x2], and this operation requires initialized memory | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ reading memory at ALLOC0[0x0..0x4], but memory is uninitialized at [0x1..0x2], and this operation requires initialized memory
error[E0080]: evaluation of constant value failed error[E0080]: evaluation of constant value failed
--> $DIR/intrinsic-raw_eq-const-bad.rs:11:5 --> $DIR/intrinsic-raw_eq-const-bad.rs:10:5
| |
LL | std::intrinsics::raw_eq(&(&0), &(&1)) LL | std::intrinsics::raw_eq(&(&0), &(&1))
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unable to turn pointer into integer | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unable to turn pointer into integer
@ -14,7 +14,7 @@ LL | std::intrinsics::raw_eq(&(&0), &(&1))
= help: the absolute address of a pointer is not known at compile-time, so such operations are not supported = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
error[E0080]: evaluation of constant value failed error[E0080]: evaluation of constant value failed
--> $DIR/intrinsic-raw_eq-const-bad.rs:19:5 --> $DIR/intrinsic-raw_eq-const-bad.rs:18:5
| |
LL | std::intrinsics::raw_eq(aref, aref) LL | std::intrinsics::raw_eq(aref, aref)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ accessing memory with alignment 1, but alignment 4 is required | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ accessing memory with alignment 1, but alignment 4 is required

1
tests/ui/intrinsics/intrinsic-raw_eq-const.rs
View file

@ -1,7 +1,6 @@
//@ run-pass //@ run-pass
#![feature(core_intrinsics)] #![feature(core_intrinsics)]
#![feature(const_intrinsic_raw_eq)]
pub fn main() { pub fn main() {
use std::intrinsics::raw_eq; use std::intrinsics::raw_eq;