From 4250bfe11c5e9c44e17029f3e14284f16d0afd6f Mon Sep 17 00:00:00 2001
From: "aaishwarymishra@gmail.com" <aaishwarymishra@gmail.com>
Date: Sat, 16 Nov 2024 19:40:39 +0530
Subject: [PATCH 1/7] changes old intrinsic declaration to new declaration

---
 library/core/src/intrinsics/mod.rs | 1544 +++++++++++++++++-----------
 1 file changed, 949 insertions(+), 595 deletions(-)

diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 72e34e5faf5a7..eb6a44e460bb4 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -2007,628 +2007,982 @@ pub fn ptr_mask<T>(_ptr: *const T, _mask: usize) -> *const T {
     unreachable!()
 }
 
-extern "rust-intrinsic" {
-    /// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with
-    /// a size of `count` * `size_of::<T>()` and an alignment of
-    /// `min_align_of::<T>()`
-    ///
-    /// The volatile parameter is set to `true`, so it will not be optimized out
-    /// unless size is equal to zero.
-    ///
-    /// This intrinsic does not have a stable counterpart.
-    #[rustc_nounwind]
-    pub fn volatile_copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: usize);
-    /// Equivalent to the appropriate `llvm.memmove.p0i8.0i8.*` intrinsic, with
-    /// a size of `count * size_of::<T>()` and an alignment of
-    /// `min_align_of::<T>()`
-    ///
-    /// The volatile parameter is set to `true`, so it will not be optimized out
-    /// unless size is equal to zero.
-    ///
-    /// This intrinsic does not have a stable counterpart.
-    #[rustc_nounwind]
-    pub fn volatile_copy_memory<T>(dst: *mut T, src: *const T, count: usize);
-    /// Equivalent to the appropriate `llvm.memset.p0i8.*` intrinsic, with a
-    /// size of `count * size_of::<T>()` and an alignment of
-    /// `min_align_of::<T>()`.
-    ///
-    /// The volatile parameter is set to `true`, so it will not be optimized out
-    /// unless size is equal to zero.
-    ///
-    /// This intrinsic does not have a stable counterpart.
-    #[rustc_nounwind]
-    pub fn volatile_set_memory<T>(dst: *mut T, val: u8, count: usize);
+/// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with
+/// a size of `count` * `size_of::<T>()` and an alignment of
+/// `min_align_of::<T>()`
+///
+/// The volatile parameter is set to `true`, so it will not be optimized out
+/// unless size is equal to zero.
+///
+/// This intrinsic does not have a stable counterpart.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn volatile_copy_nonoverlapping_memory<T>(_dst: *mut T, _src: *const T, _count: usize) {
+    unreachable!()
+}
+/// Equivalent to the appropriate `llvm.memmove.p0i8.0i8.*` intrinsic, with
+/// a size of `count * size_of::<T>()` and an alignment of
+/// `min_align_of::<T>()`
+///
+/// The volatile parameter is set to `true`, so it will not be optimized out
+/// unless size is equal to zero.
+///
+/// This intrinsic does not have a stable counterpart.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn volatile_copy_memory<T>(_dst: *mut T, _src: *const T, _count: usize) {
+    unreachable!()
+}
+/// Equivalent to the appropriate `llvm.memset.p0i8.*` intrinsic, with a
+/// size of `count * size_of::<T>()` and an alignment of
+/// `min_align_of::<T>()`.
+///
+/// The volatile parameter is set to `true`, so it will not be optimized out
+/// unless size is equal to zero.
+///
+/// This intrinsic does not have a stable counterpart.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn volatile_set_memory<T>(_dst: *mut T, _val: u8, _count: usize) {
+    unreachable!()
+}
 
-    /// Performs a volatile load from the `src` pointer.
-    ///
-    /// The stabilized version of this intrinsic is [`core::ptr::read_volatile`].
-    #[rustc_nounwind]
-    pub fn volatile_load<T>(src: *const T) -> T;
-    /// Performs a volatile store to the `dst` pointer.
-    ///
-    /// The stabilized version of this intrinsic is [`core::ptr::write_volatile`].
-    #[rustc_nounwind]
-    pub fn volatile_store<T>(dst: *mut T, val: T);
+/// Performs a volatile load from the `src` pointer.
+///
+/// The stabilized version of this intrinsic is [`core::ptr::read_volatile`].
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn volatile_load<T>(_src: *const T) -> T {
+    unreachable!()
+}
+/// Performs a volatile store to the `dst` pointer.
+///
+/// The stabilized version of this intrinsic is [`core::ptr::write_volatile`].
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn volatile_store<T>(_dst: *mut T, _val: T) {
+    unreachable!()
+}
 
-    /// Performs a volatile load from the `src` pointer
-    /// The pointer is not required to be aligned.
-    ///
-    /// This intrinsic does not have a stable counterpart.
-    #[rustc_nounwind]
-    #[rustc_diagnostic_item = "intrinsics_unaligned_volatile_load"]
-    pub fn unaligned_volatile_load<T>(src: *const T) -> T;
-    /// Performs a volatile store to the `dst` pointer.
-    /// The pointer is not required to be aligned.
-    ///
-    /// This intrinsic does not have a stable counterpart.
-    #[rustc_nounwind]
-    #[rustc_diagnostic_item = "intrinsics_unaligned_volatile_store"]
-    pub fn unaligned_volatile_store<T>(dst: *mut T, val: T);
+/// Performs a volatile load from the `src` pointer
+/// The pointer is not required to be aligned.
+///
+/// This intrinsic does not have a stable counterpart.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+#[rustc_diagnostic_item = "intrinsics_unaligned_volatile_load"]
+pub unsafe fn unaligned_volatile_load<T>(_src: *const T) -> T {
+    unreachable!()
+}
+/// Performs a volatile store to the `dst` pointer.
+/// The pointer is not required to be aligned.
+///
+/// This intrinsic does not have a stable counterpart.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+#[rustc_diagnostic_item = "intrinsics_unaligned_volatile_store"]
+pub unsafe fn unaligned_volatile_store<T>(_dst: *mut T, _val: T) {
+    unreachable!()
+}
 
-    /// Returns the square root of an `f16`
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::sqrt`](../../std/primitive.f16.html#method.sqrt)
-    #[rustc_nounwind]
-    pub fn sqrtf16(x: f16) -> f16;
-    /// Returns the square root of an `f32`
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::sqrt`](../../std/primitive.f32.html#method.sqrt)
-    #[rustc_nounwind]
-    pub fn sqrtf32(x: f32) -> f32;
-    /// Returns the square root of an `f64`
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::sqrt`](../../std/primitive.f64.html#method.sqrt)
-    #[rustc_nounwind]
-    pub fn sqrtf64(x: f64) -> f64;
-    /// Returns the square root of an `f128`
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::sqrt`](../../std/primitive.f128.html#method.sqrt)
-    #[rustc_nounwind]
-    pub fn sqrtf128(x: f128) -> f128;
+/// Returns the square root of an `f16`
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::sqrt`](../../std/primitive.f16.html#method.sqrt)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn sqrtf16(_x: f16) -> f16 {
+    unreachable!()
+}
+/// Returns the square root of an `f32`
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::sqrt`](../../std/primitive.f32.html#method.sqrt)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn sqrtf32(_x: f32) -> f32 {
+    unreachable!()
+}
+/// Returns the square root of an `f64`
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::sqrt`](../../std/primitive.f64.html#method.sqrt)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn sqrtf64(_x: f64) -> f64 {
+    unreachable!()
+}
+/// Returns the square root of an `f128`
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::sqrt`](../../std/primitive.f128.html#method.sqrt)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn sqrtf128(_x: f128) -> f128 {
+    unreachable!()
+}
 
-    /// Raises an `f16` to an integer power.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::powi`](../../std/primitive.f16.html#method.powi)
-    #[rustc_nounwind]
-    pub fn powif16(a: f16, x: i32) -> f16;
-    /// Raises an `f32` to an integer power.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::powi`](../../std/primitive.f32.html#method.powi)
-    #[rustc_nounwind]
-    pub fn powif32(a: f32, x: i32) -> f32;
-    /// Raises an `f64` to an integer power.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::powi`](../../std/primitive.f64.html#method.powi)
-    #[rustc_nounwind]
-    pub fn powif64(a: f64, x: i32) -> f64;
-    /// Raises an `f128` to an integer power.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::powi`](../../std/primitive.f128.html#method.powi)
-    #[rustc_nounwind]
-    pub fn powif128(a: f128, x: i32) -> f128;
+/// Raises an `f16` to an integer power.
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::powi`](../../std/primitive.f16.html#method.powi)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn powif16(_a: f16, _x: i32) -> f16 {
+    unreachable!()
+}
+/// Raises an `f32` to an integer power.
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::powi`](../../std/primitive.f32.html#method.powi)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn powif32(_a: f32, _x: i32) -> f32 {
+    unreachable!()
+}
+/// Raises an `f64` to an integer power.
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::powi`](../../std/primitive.f64.html#method.powi)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn powif64(_a: f64, _x: i32) -> f64 {
+    unreachable!()
+}
+/// Raises an `f128` to an integer power.
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::powi`](../../std/primitive.f128.html#method.powi)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn powif128(_a: f128, _x: i32) -> f128 {
+    unreachable!()
+}
 
-    /// Returns the sine of an `f16`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::sin`](../../std/primitive.f16.html#method.sin)
-    #[rustc_nounwind]
-    pub fn sinf16(x: f16) -> f16;
-    /// Returns the sine of an `f32`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::sin`](../../std/primitive.f32.html#method.sin)
-    #[rustc_nounwind]
-    pub fn sinf32(x: f32) -> f32;
-    /// Returns the sine of an `f64`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::sin`](../../std/primitive.f64.html#method.sin)
-    #[rustc_nounwind]
-    pub fn sinf64(x: f64) -> f64;
-    /// Returns the sine of an `f128`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::sin`](../../std/primitive.f128.html#method.sin)
-    #[rustc_nounwind]
-    pub fn sinf128(x: f128) -> f128;
+/// Returns the sine of an `f16`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::sin`](../../std/primitive.f16.html#method.sin)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn sinf16(_x: f16) -> f16 {
+    unreachable!()
+}
+/// Returns the sine of an `f32`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::sin`](../../std/primitive.f32.html#method.sin)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn sinf32(_x: f32) -> f32 {
+    unreachable!()
+}
+/// Returns the sine of an `f64`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::sin`](../../std/primitive.f64.html#method.sin)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn sinf64(_x: f64) -> f64 {
+    unreachable!()
+}
+/// Returns the sine of an `f128`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::sin`](../../std/primitive.f128.html#method.sin)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn sinf128(_x: f128) -> f128 {
+    unreachable!()
+}
 
-    /// Returns the cosine of an `f16`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::cos`](../../std/primitive.f16.html#method.cos)
-    #[rustc_nounwind]
-    pub fn cosf16(x: f16) -> f16;
-    /// Returns the cosine of an `f32`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::cos`](../../std/primitive.f32.html#method.cos)
-    #[rustc_nounwind]
-    pub fn cosf32(x: f32) -> f32;
-    /// Returns the cosine of an `f64`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::cos`](../../std/primitive.f64.html#method.cos)
-    #[rustc_nounwind]
-    pub fn cosf64(x: f64) -> f64;
-    /// Returns the cosine of an `f128`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::cos`](../../std/primitive.f128.html#method.cos)
-    #[rustc_nounwind]
-    pub fn cosf128(x: f128) -> f128;
+/// Returns the cosine of an `f16`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::cos`](../../std/primitive.f16.html#method.cos)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn cosf16(_x: f16) -> f16 {
+    unreachable!()
+}
+/// Returns the cosine of an `f32`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::cos`](../../std/primitive.f32.html#method.cos)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn cosf32(_x: f32) -> f32 {
+    unreachable!()
+}
+/// Returns the cosine of an `f64`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::cos`](../../std/primitive.f64.html#method.cos)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn cosf64(_x: f64) -> f64 {
+    unreachable!()
+}
+/// Returns the cosine of an `f128`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::cos`](../../std/primitive.f128.html#method.cos)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn cosf128(_x: f128) -> f128 {
+    unreachable!()
+}
 
-    /// Raises an `f16` to an `f16` power.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::powf`](../../std/primitive.f16.html#method.powf)
-    #[rustc_nounwind]
-    pub fn powf16(a: f16, x: f16) -> f16;
-    /// Raises an `f32` to an `f32` power.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::powf`](../../std/primitive.f32.html#method.powf)
-    #[rustc_nounwind]
-    pub fn powf32(a: f32, x: f32) -> f32;
-    /// Raises an `f64` to an `f64` power.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::powf`](../../std/primitive.f64.html#method.powf)
-    #[rustc_nounwind]
-    pub fn powf64(a: f64, x: f64) -> f64;
-    /// Raises an `f128` to an `f128` power.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::powf`](../../std/primitive.f128.html#method.powf)
-    #[rustc_nounwind]
-    pub fn powf128(a: f128, x: f128) -> f128;
+/// Raises an `f16` to an `f16` power.
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::powf`](../../std/primitive.f16.html#method.powf)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn powf16(_a: f16, _x: f16) -> f16 {
+    unreachable!()
+}
+/// Raises an `f32` to an `f32` power.
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::powf`](../../std/primitive.f32.html#method.powf)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn powf32(_a: f32, _x: f32) -> f32 {
+    unreachable!()
+}
+/// Raises an `f64` to an `f64` power.
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::powf`](../../std/primitive.f64.html#method.powf)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn powf64(_a: f64, _x: f64) -> f64 {
+    unreachable!()
+}
+/// Raises an `f128` to an `f128` power.
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::powf`](../../std/primitive.f128.html#method.powf)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn powf128(_a: f128, _x: f128) -> f128 {
+    unreachable!()
+}
 
-    /// Returns the exponential of an `f16`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::exp`](../../std/primitive.f16.html#method.exp)
-    #[rustc_nounwind]
-    pub fn expf16(x: f16) -> f16;
-    /// Returns the exponential of an `f32`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::exp`](../../std/primitive.f32.html#method.exp)
-    #[rustc_nounwind]
-    pub fn expf32(x: f32) -> f32;
-    /// Returns the exponential of an `f64`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::exp`](../../std/primitive.f64.html#method.exp)
-    #[rustc_nounwind]
-    pub fn expf64(x: f64) -> f64;
-    /// Returns the exponential of an `f128`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::exp`](../../std/primitive.f128.html#method.exp)
-    #[rustc_nounwind]
-    pub fn expf128(x: f128) -> f128;
+/// Returns the exponential of an `f16`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::exp`](../../std/primitive.f16.html#method.exp)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn expf16(_x: f16) -> f16 {
+    unreachable!()
+}
+/// Returns the exponential of an `f32`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::exp`](../../std/primitive.f32.html#method.exp)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn expf32(_x: f32) -> f32 {
+    unreachable!()
+}
+/// Returns the exponential of an `f64`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::exp`](../../std/primitive.f64.html#method.exp)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn expf64(_x: f64) -> f64 {
+    unreachable!()
+}
+/// Returns the exponential of an `f128`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::exp`](../../std/primitive.f128.html#method.exp)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn expf128(_x: f128) -> f128 {
+    unreachable!()
+}
 
-    /// Returns 2 raised to the power of an `f16`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::exp2`](../../std/primitive.f16.html#method.exp2)
-    #[rustc_nounwind]
-    pub fn exp2f16(x: f16) -> f16;
-    /// Returns 2 raised to the power of an `f32`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::exp2`](../../std/primitive.f32.html#method.exp2)
-    #[rustc_nounwind]
-    pub fn exp2f32(x: f32) -> f32;
-    /// Returns 2 raised to the power of an `f64`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::exp2`](../../std/primitive.f64.html#method.exp2)
-    #[rustc_nounwind]
-    pub fn exp2f64(x: f64) -> f64;
-    /// Returns 2 raised to the power of an `f128`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::exp2`](../../std/primitive.f128.html#method.exp2)
-    #[rustc_nounwind]
-    pub fn exp2f128(x: f128) -> f128;
+/// Returns 2 raised to the power of an `f16`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::exp2`](../../std/primitive.f16.html#method.exp2)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn exp2f16(_x: f16) -> f16 {
+    unreachable!()
+}
+/// Returns 2 raised to the power of an `f32`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::exp2`](../../std/primitive.f32.html#method.exp2)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn exp2f32(_x: f32) -> f32 {
+    unreachable!()
+}
+/// Returns 2 raised to the power of an `f64`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::exp2`](../../std/primitive.f64.html#method.exp2)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn exp2f64(_x: f64) -> f64 {
+    unreachable!()
+}
+/// Returns 2 raised to the power of an `f128`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::exp2`](../../std/primitive.f128.html#method.exp2)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn exp2f128(_x: f128) -> f128 {
+    unreachable!()
+}
 
-    /// Returns the natural logarithm of an `f16`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::ln`](../../std/primitive.f16.html#method.ln)
-    #[rustc_nounwind]
-    pub fn logf16(x: f16) -> f16;
-    /// Returns the natural logarithm of an `f32`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::ln`](../../std/primitive.f32.html#method.ln)
-    #[rustc_nounwind]
-    pub fn logf32(x: f32) -> f32;
-    /// Returns the natural logarithm of an `f64`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::ln`](../../std/primitive.f64.html#method.ln)
-    #[rustc_nounwind]
-    pub fn logf64(x: f64) -> f64;
-    /// Returns the natural logarithm of an `f128`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::ln`](../../std/primitive.f128.html#method.ln)
-    #[rustc_nounwind]
-    pub fn logf128(x: f128) -> f128;
+/// Returns the natural logarithm of an `f16`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::ln`](../../std/primitive.f16.html#method.ln)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn logf16(_x: f16) -> f16 {
+    unreachable!()
+}
+/// Returns the natural logarithm of an `f32`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::ln`](../../std/primitive.f32.html#method.ln)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn logf32(_x: f32) -> f32 {
+    unreachable!()
+}
+/// Returns the natural logarithm of an `f64`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::ln`](../../std/primitive.f64.html#method.ln)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn logf64(_x: f64) -> f64 {
+    unreachable!()
+}
+/// Returns the natural logarithm of an `f128`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::ln`](../../std/primitive.f128.html#method.ln)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn logf128(_x: f128) -> f128 {
+    unreachable!()
+}
 
-    /// Returns the base 10 logarithm of an `f16`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::log10`](../../std/primitive.f16.html#method.log10)
-    #[rustc_nounwind]
-    pub fn log10f16(x: f16) -> f16;
-    /// Returns the base 10 logarithm of an `f32`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::log10`](../../std/primitive.f32.html#method.log10)
-    #[rustc_nounwind]
-    pub fn log10f32(x: f32) -> f32;
-    /// Returns the base 10 logarithm of an `f64`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::log10`](../../std/primitive.f64.html#method.log10)
-    #[rustc_nounwind]
-    pub fn log10f64(x: f64) -> f64;
-    /// Returns the base 10 logarithm of an `f128`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::log10`](../../std/primitive.f128.html#method.log10)
-    #[rustc_nounwind]
-    pub fn log10f128(x: f128) -> f128;
+/// Returns the base 10 logarithm of an `f16`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::log10`](../../std/primitive.f16.html#method.log10)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn log10f16(_x: f16) -> f16 {
+    unreachable!()
+}
+/// Returns the base 10 logarithm of an `f32`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::log10`](../../std/primitive.f32.html#method.log10)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn log10f32(_x: f32) -> f32 {
+    unreachable!()
+}
+/// Returns the base 10 logarithm of an `f64`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::log10`](../../std/primitive.f64.html#method.log10)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn log10f64(_x: f64) -> f64 {
+    unreachable!()
+}
+/// Returns the base 10 logarithm of an `f128`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::log10`](../../std/primitive.f128.html#method.log10)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn log10f128(_x: f128) -> f128 {
+    unreachable!()
+}
 
-    /// Returns the base 2 logarithm of an `f16`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::log2`](../../std/primitive.f16.html#method.log2)
-    #[rustc_nounwind]
-    pub fn log2f16(x: f16) -> f16;
-    /// Returns the base 2 logarithm of an `f32`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::log2`](../../std/primitive.f32.html#method.log2)
-    #[rustc_nounwind]
-    pub fn log2f32(x: f32) -> f32;
-    /// Returns the base 2 logarithm of an `f64`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::log2`](../../std/primitive.f64.html#method.log2)
-    #[rustc_nounwind]
-    pub fn log2f64(x: f64) -> f64;
-    /// Returns the base 2 logarithm of an `f128`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::log2`](../../std/primitive.f128.html#method.log2)
-    #[rustc_nounwind]
-    pub fn log2f128(x: f128) -> f128;
+/// Returns the base 2 logarithm of an `f16`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::log2`](../../std/primitive.f16.html#method.log2)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn log2f16(_x: f16) -> f16 {
+    unreachable!()
+}
+/// Returns the base 2 logarithm of an `f32`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::log2`](../../std/primitive.f32.html#method.log2)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn log2f32(_x: f32) -> f32 {
+    unreachable!()
+}
+/// Returns the base 2 logarithm of an `f64`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::log2`](../../std/primitive.f64.html#method.log2)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn log2f64(_x: f64) -> f64 {
+    unreachable!()
+}
+/// Returns the base 2 logarithm of an `f128`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::log2`](../../std/primitive.f128.html#method.log2)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn log2f128(_x: f128) -> f128 {
+    unreachable!()
+}
 
-    /// Returns `a * b + c` for `f16` values.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::mul_add`](../../std/primitive.f16.html#method.mul_add)
-    #[rustc_nounwind]
-    pub fn fmaf16(a: f16, b: f16, c: f16) -> f16;
-    /// Returns `a * b + c` for `f32` values.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::mul_add`](../../std/primitive.f32.html#method.mul_add)
-    #[rustc_nounwind]
-    pub fn fmaf32(a: f32, b: f32, c: f32) -> f32;
-    /// Returns `a * b + c` for `f64` values.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::mul_add`](../../std/primitive.f64.html#method.mul_add)
-    #[rustc_nounwind]
-    pub fn fmaf64(a: f64, b: f64, c: f64) -> f64;
-    /// Returns `a * b + c` for `f128` values.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::mul_add`](../../std/primitive.f128.html#method.mul_add)
-    #[rustc_nounwind]
-    pub fn fmaf128(a: f128, b: f128, c: f128) -> f128;
+/// Returns `a * b + c` for `f16` values.
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::mul_add`](../../std/primitive.f16.html#method.mul_add)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn fmaf16(_a: f16, _b: f16, _c: f16) -> f16 {
+    unreachable!()
+}
+/// Returns `a * b + c` for `f32` values.
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::mul_add`](../../std/primitive.f32.html#method.mul_add)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn fmaf32(_a: f32, _b: f32, _c: f32) -> f32 {
+    unreachable!()
+}
+/// Returns `a * b + c` for `f64` values.
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::mul_add`](../../std/primitive.f64.html#method.mul_add)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn fmaf64(_a: f64, _b: f64, _c: f64) -> f64 {
+    unreachable!()
+}
+/// Returns `a * b + c` for `f128` values.
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::mul_add`](../../std/primitive.f128.html#method.mul_add)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn fmaf128(_a: f128, _b: f128, _c: f128) -> f128 {
+    unreachable!()
+}
 
-    /// Returns `a * b + c` for `f16` values, non-deterministically executing
-    /// either a fused multiply-add or two operations with rounding of the
-    /// intermediate result.
-    ///
-    /// The operation is fused if the code generator determines that target
-    /// instruction set has support for a fused operation, and that the fused
-    /// operation is more efficient than the equivalent, separate pair of mul
-    /// and add instructions. It is unspecified whether or not a fused operation
-    /// is selected, and that may depend on optimization level and context, for
-    /// example.
-    #[rustc_nounwind]
-    pub fn fmuladdf16(a: f16, b: f16, c: f16) -> f16;
-    /// Returns `a * b + c` for `f32` values, non-deterministically executing
-    /// either a fused multiply-add or two operations with rounding of the
-    /// intermediate result.
-    ///
-    /// The operation is fused if the code generator determines that target
-    /// instruction set has support for a fused operation, and that the fused
-    /// operation is more efficient than the equivalent, separate pair of mul
-    /// and add instructions. It is unspecified whether or not a fused operation
-    /// is selected, and that may depend on optimization level and context, for
-    /// example.
-    #[rustc_nounwind]
-    pub fn fmuladdf32(a: f32, b: f32, c: f32) -> f32;
-    /// Returns `a * b + c` for `f64` values, non-deterministically executing
-    /// either a fused multiply-add or two operations with rounding of the
-    /// intermediate result.
-    ///
-    /// The operation is fused if the code generator determines that target
-    /// instruction set has support for a fused operation, and that the fused
-    /// operation is more efficient than the equivalent, separate pair of mul
-    /// and add instructions. It is unspecified whether or not a fused operation
-    /// is selected, and that may depend on optimization level and context, for
-    /// example.
-    #[rustc_nounwind]
-    pub fn fmuladdf64(a: f64, b: f64, c: f64) -> f64;
-    /// Returns `a * b + c` for `f128` values, non-deterministically executing
-    /// either a fused multiply-add or two operations with rounding of the
-    /// intermediate result.
-    ///
-    /// The operation is fused if the code generator determines that target
-    /// instruction set has support for a fused operation, and that the fused
-    /// operation is more efficient than the equivalent, separate pair of mul
-    /// and add instructions. It is unspecified whether or not a fused operation
-    /// is selected, and that may depend on optimization level and context, for
-    /// example.
-    #[rustc_nounwind]
-    pub fn fmuladdf128(a: f128, b: f128, c: f128) -> f128;
+/// Returns `a * b + c` for `f16` values, non-deterministically executing
+/// either a fused multiply-add or two operations with rounding of the
+/// intermediate result.
+///
+/// The operation is fused if the code generator determines that target
+/// instruction set has support for a fused operation, and that the fused
+/// operation is more efficient than the equivalent, separate pair of mul
+/// and add instructions. It is unspecified whether or not a fused operation
+/// is selected, and that may depend on optimization level and context, for
+/// example.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn fmuladdf16(_a: f16, _b: f16, _c: f16) -> f16 {
+    unreachable!()
+}
+/// Returns `a * b + c` for `f32` values, non-deterministically executing
+/// either a fused multiply-add or two operations with rounding of the
+/// intermediate result.
+///
+/// The operation is fused if the code generator determines that target
+/// instruction set has support for a fused operation, and that the fused
+/// operation is more efficient than the equivalent, separate pair of mul
+/// and add instructions. It is unspecified whether or not a fused operation
+/// is selected, and that may depend on optimization level and context, for
+/// example.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn fmuladdf32(_a: f32, _b: f32, _c: f32) -> f32 {
+    unreachable!()
+}
+/// Returns `a * b + c` for `f64` values, non-deterministically executing
+/// either a fused multiply-add or two operations with rounding of the
+/// intermediate result.
+///
+/// The operation is fused if the code generator determines that target
+/// instruction set has support for a fused operation, and that the fused
+/// operation is more efficient than the equivalent, separate pair of mul
+/// and add instructions. It is unspecified whether or not a fused operation
+/// is selected, and that may depend on optimization level and context, for
+/// example.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn fmuladdf64(_a: f64, _b: f64, _c: f64) -> f64 {
+    unreachable!()
+}
+/// Returns `a * b + c` for `f128` values, non-deterministically executing
+/// either a fused multiply-add or two operations with rounding of the
+/// intermediate result.
+///
+/// The operation is fused if the code generator determines that target
+/// instruction set has support for a fused operation, and that the fused
+/// operation is more efficient than the equivalent, separate pair of mul
+/// and add instructions. It is unspecified whether or not a fused operation
+/// is selected, and that may depend on optimization level and context, for
+/// example.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn fmuladdf128(_a: f128, _b: f128, _c: f128) -> f128 {
+    unreachable!()
+}
 
-    /// Returns the largest integer less than or equal to an `f16`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::floor`](../../std/primitive.f16.html#method.floor)
-    #[rustc_nounwind]
-    pub fn floorf16(x: f16) -> f16;
-    /// Returns the largest integer less than or equal to an `f32`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::floor`](../../std/primitive.f32.html#method.floor)
-    #[rustc_nounwind]
-    pub fn floorf32(x: f32) -> f32;
-    /// Returns the largest integer less than or equal to an `f64`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::floor`](../../std/primitive.f64.html#method.floor)
-    #[rustc_nounwind]
-    pub fn floorf64(x: f64) -> f64;
-    /// Returns the largest integer less than or equal to an `f128`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::floor`](../../std/primitive.f128.html#method.floor)
-    #[rustc_nounwind]
-    pub fn floorf128(x: f128) -> f128;
+/// Returns the largest integer less than or equal to an `f16`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::floor`](../../std/primitive.f16.html#method.floor)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn floorf16(_x: f16) -> f16 {
+    unreachable!()
+}
+/// Returns the largest integer less than or equal to an `f32`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::floor`](../../std/primitive.f32.html#method.floor)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn floorf32(_x: f32) -> f32 {
+    unreachable!()
+}
+/// Returns the largest integer less than or equal to an `f64`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::floor`](../../std/primitive.f64.html#method.floor)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn floorf64(_x: f64) -> f64 {
+    unreachable!()
+}
+/// Returns the largest integer less than or equal to an `f128`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::floor`](../../std/primitive.f128.html#method.floor)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn floorf128(_x: f128) -> f128 {
+    unreachable!()
+}
 
-    /// Returns the smallest integer greater than or equal to an `f16`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::ceil`](../../std/primitive.f16.html#method.ceil)
-    #[rustc_nounwind]
-    pub fn ceilf16(x: f16) -> f16;
-    /// Returns the smallest integer greater than or equal to an `f32`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::ceil`](../../std/primitive.f32.html#method.ceil)
-    #[rustc_nounwind]
-    pub fn ceilf32(x: f32) -> f32;
-    /// Returns the smallest integer greater than or equal to an `f64`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::ceil`](../../std/primitive.f64.html#method.ceil)
-    #[rustc_nounwind]
-    pub fn ceilf64(x: f64) -> f64;
-    /// Returns the smallest integer greater than or equal to an `f128`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::ceil`](../../std/primitive.f128.html#method.ceil)
-    #[rustc_nounwind]
-    pub fn ceilf128(x: f128) -> f128;
+/// Returns the smallest integer greater than or equal to an `f16`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::ceil`](../../std/primitive.f16.html#method.ceil)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn ceilf16(_x: f16) -> f16 {
+    unreachable!()
+}
+/// Returns the smallest integer greater than or equal to an `f32`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::ceil`](../../std/primitive.f32.html#method.ceil)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn ceilf32(_x: f32) -> f32 {
+    unreachable!()
+}
+/// Returns the smallest integer greater than or equal to an `f64`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::ceil`](../../std/primitive.f64.html#method.ceil)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn ceilf64(_x: f64) -> f64 {
+    unreachable!()
+}
+/// Returns the smallest integer greater than or equal to an `f128`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::ceil`](../../std/primitive.f128.html#method.ceil)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn ceilf128(_x: f128) -> f128 {
+    unreachable!()
+}
 
-    /// Returns the integer part of an `f16`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::trunc`](../../std/primitive.f16.html#method.trunc)
-    #[rustc_nounwind]
-    pub fn truncf16(x: f16) -> f16;
-    /// Returns the integer part of an `f32`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::trunc`](../../std/primitive.f32.html#method.trunc)
-    #[rustc_nounwind]
-    pub fn truncf32(x: f32) -> f32;
-    /// Returns the integer part of an `f64`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::trunc`](../../std/primitive.f64.html#method.trunc)
-    #[rustc_nounwind]
-    pub fn truncf64(x: f64) -> f64;
-    /// Returns the integer part of an `f128`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::trunc`](../../std/primitive.f128.html#method.trunc)
-    #[rustc_nounwind]
-    pub fn truncf128(x: f128) -> f128;
+/// Returns the integer part of an `f16`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::trunc`](../../std/primitive.f16.html#method.trunc)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn truncf16(_x: f16) -> f16 {
+    unreachable!()
+}
+/// Returns the integer part of an `f32`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::trunc`](../../std/primitive.f32.html#method.trunc)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn truncf32(_x: f32) -> f32 {
+    unreachable!()
+}
+/// Returns the integer part of an `f64`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::trunc`](../../std/primitive.f64.html#method.trunc)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn truncf64(_x: f64) -> f64 {
+    unreachable!()
+}
+/// Returns the integer part of an `f128`.
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::trunc`](../../std/primitive.f128.html#method.trunc)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+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`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::round_ties_even`](../../std/primitive.f16.html#method.round_ties_even)
-    #[rustc_nounwind]
-    pub fn rintf16(x: f16) -> f16;
-    /// 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`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::round_ties_even`](../../std/primitive.f32.html#method.round_ties_even)
-    #[rustc_nounwind]
-    pub fn rintf32(x: f32) -> f32;
-    /// 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_nounwind]
-    pub fn rintf64(x: f64) -> f64;
-    /// 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`.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::round_ties_even`](../../std/primitive.f128.html#method.round_ties_even)
-    #[rustc_nounwind]
-    pub fn rintf128(x: f128) -> f128;
+/// 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`.
+///
+/// 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 {
+    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`.
+///
+/// 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 {
+    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!()
+}
+/// 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`.
+///
+/// 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 rintf128(_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.
-    ///
-    /// This intrinsic does not have a stable counterpart.
-    #[rustc_nounwind]
-    pub fn nearbyintf16(x: f16) -> f16;
-    /// 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_nounwind]
-    pub fn nearbyintf32(x: f32) -> f32;
-    /// 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.
-    ///
-    /// This intrinsic does not have a stable counterpart.
-    #[rustc_nounwind]
-    pub fn nearbyintf64(x: f64) -> f64;
-    /// 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_nounwind]
-    pub fn nearbyintf128(x: f128) -> f128;
+/// 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!()
+}
+/// 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!()
+}
+/// 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.
+///
+/// This intrinsic does not have a stable counterpart.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn nearbyintf64(_x: f64) -> f64 {
+    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!()
+}
 
-    /// Returns the nearest integer to an `f16`. Rounds half-way cases away from zero.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f16::round`](../../std/primitive.f16.html#method.round)
-    #[rustc_nounwind]
-    pub fn roundf16(x: f16) -> f16;
-    /// Returns the nearest integer to an `f32`. Rounds half-way cases away from zero.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f32::round`](../../std/primitive.f32.html#method.round)
-    #[rustc_nounwind]
-    pub fn roundf32(x: f32) -> f32;
-    /// Returns the nearest integer to an `f64`. Rounds half-way cases away from zero.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f64::round`](../../std/primitive.f64.html#method.round)
-    #[rustc_nounwind]
-    pub fn roundf64(x: f64) -> f64;
-    /// Returns the nearest integer to an `f128`. Rounds half-way cases away from zero.
-    ///
-    /// The stabilized version of this intrinsic is
-    /// [`f128::round`](../../std/primitive.f128.html#method.round)
-    #[rustc_nounwind]
-    pub fn roundf128(x: f128) -> f128;
+/// Returns the nearest integer to an `f16`. Rounds half-way cases away from zero.
+///
+/// The stabilized version of this intrinsic is
+/// [`f16::round`](../../std/primitive.f16.html#method.round)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn roundf16(_x: f16) -> f16 {
+    unreachable!()
+}
+/// Returns the nearest integer to an `f32`. Rounds half-way cases away from zero.
+///
+/// The stabilized version of this intrinsic is
+/// [`f32::round`](../../std/primitive.f32.html#method.round)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn roundf32(_x: f32) -> f32 {
+    unreachable!()
+}
+/// Returns the nearest integer to an `f64`. Rounds half-way cases away from zero.
+///
+/// The stabilized version of this intrinsic is
+/// [`f64::round`](../../std/primitive.f64.html#method.round)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn roundf64(_x: f64) -> f64 {
+    unreachable!()
+}
+/// Returns the nearest integer to an `f128`. Rounds half-way cases away from zero.
+///
+/// The stabilized version of this intrinsic is
+/// [`f128::round`](../../std/primitive.f128.html#method.round)
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+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_nounwind]
-    pub fn roundevenf16(x: f16) -> f16;
-    /// 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_nounwind]
-    pub fn roundevenf32(x: f32) -> f32;
-    /// 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_nounwind]
-    pub fn roundevenf64(x: f64) -> f64;
-    /// 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_nounwind]
-    pub fn roundevenf128(x: f128) -> f128;
+/// 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.
-    ///
-    /// This intrinsic does not have a stable counterpart.
-    #[rustc_nounwind]
-    pub fn fadd_fast<T: Copy>(a: T, b: T) -> T;
+/// Float addition that allows optimizations based on algebraic rules.
+/// May assume inputs are finite.
+///
+/// This intrinsic does not have a stable counterpart.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn fadd_fast<T: Copy>(_a: T, _b: T) -> T {
+    unreachable!()
+}
 
-    /// Float subtraction that allows optimizations based on algebraic rules.
-    /// May assume inputs are finite.
-    ///
-    /// This intrinsic does not have a stable counterpart.
-    #[rustc_nounwind]
-    pub fn fsub_fast<T: Copy>(a: T, b: T) -> T;
+/// Float subtraction that allows optimizations based on algebraic rules.
+/// May assume inputs are finite.
+///
+/// This intrinsic does not have a stable counterpart.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn fsub_fast<T: Copy>(_a: T, _b: T) -> T {
+    unreachable!()
+}
 
-    /// Float multiplication that allows optimizations based on algebraic rules.
-    /// May assume inputs are finite.
-    ///
-    /// This intrinsic does not have a stable counterpart.
-    #[rustc_nounwind]
-    pub fn fmul_fast<T: Copy>(a: T, b: T) -> T;
+/// Float multiplication that allows optimizations based on algebraic rules.
+/// May assume inputs are finite.
+///
+/// This intrinsic does not have a stable counterpart.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn fmul_fast<T: Copy>(_a: T, _b: T) -> T {
+    unreachable!()
+}
 
-    /// Float division that allows optimizations based on algebraic rules.
-    /// May assume inputs are finite.
-    ///
-    /// This intrinsic does not have a stable counterpart.
-    #[rustc_nounwind]
-    pub fn fdiv_fast<T: Copy>(a: T, b: T) -> T;
+/// Float division that allows optimizations based on algebraic rules.
+/// May assume inputs are finite.
+///
+/// This intrinsic does not have a stable counterpart.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn fdiv_fast<T: Copy>(_a: T, _b: T) -> T {
+    unreachable!()
+}
 
-    /// Float remainder that allows optimizations based on algebraic rules.
-    /// May assume inputs are finite.
-    ///
-    /// This intrinsic does not have a stable counterpart.
-    #[rustc_nounwind]
-    pub fn frem_fast<T: Copy>(a: T, b: T) -> T;
+/// Float remainder that allows optimizations based on algebraic rules.
+/// May assume inputs are finite.
+///
+/// This intrinsic does not have a stable counterpart.
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn frem_fast<T: Copy>(_a: T, _b: T) -> T {
+    unreachable!()
+}
 
-    /// Converts with LLVM’s fptoui/fptosi, which may return undef for values out of range
-    /// (<https://github.com/rust-lang/rust/issues/10184>)
-    ///
-    /// Stabilized as [`f32::to_int_unchecked`] and [`f64::to_int_unchecked`].
-    #[rustc_nounwind]
-    pub fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
+/// Converts with LLVM’s fptoui/fptosi, which may return undef for values out of range
+/// (<https://github.com/rust-lang/rust/issues/10184>)
+///
+/// Stabilized as [`f32::to_int_unchecked`] and [`f64::to_int_unchecked`].
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+#[rustc_nounwind]
+pub unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int {
+    unreachable!()
 }
 
 /// Float addition that allows optimizations based on algebraic rules.

From 030ddeecabb73b4e3d93735ee719c566baa2f388 Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Wed, 20 Nov 2024 17:04:05 +0800
Subject: [PATCH 2/7] don't require const stability for const impls

---
 compiler/rustc_passes/src/stability.rs                | 11 +----------
 .../ui/stability-attribute/missing-const-stability.rs |  2 +-
 .../missing-const-stability.stderr                    | 11 +----------
 3 files changed, 3 insertions(+), 21 deletions(-)

diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 4a793f1875ec8..2809ad453ff4a 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -590,16 +590,7 @@ impl<'tcx> MissingStabilityAnnotations<'tcx> {
     }
 
     fn check_missing_const_stability(&self, def_id: LocalDefId, span: Span) {
-        // if the const impl is derived using the `derive_const` attribute,
-        // then it would be "stable" at least for the impl.
-        // We gate usages of it using `feature(const_trait_impl)` anyways
-        // so there is no unstable leakage
-        if self.tcx.is_automatically_derived(def_id.to_def_id()) {
-            return;
-        }
-
-        let is_const = self.tcx.is_const_fn(def_id.to_def_id())
-            || self.tcx.is_const_trait_impl(def_id.to_def_id());
+        let is_const = self.tcx.is_const_fn(def_id.to_def_id());
 
         // Reachable const fn must have a stability attribute.
         if is_const
diff --git a/tests/ui/stability-attribute/missing-const-stability.rs b/tests/ui/stability-attribute/missing-const-stability.rs
index 10c31d7943866..1982073073621 100644
--- a/tests/ui/stability-attribute/missing-const-stability.rs
+++ b/tests/ui/stability-attribute/missing-const-stability.rs
@@ -27,7 +27,7 @@ pub trait Bar {
 }
 #[stable(feature = "stable", since = "1.0.0")]
 impl const Bar for Foo {
-    //~^ ERROR implementation has missing const stability attribute
+    // ok because all users must enable `const_trait_impl`
     fn fun() {}
 }
 
diff --git a/tests/ui/stability-attribute/missing-const-stability.stderr b/tests/ui/stability-attribute/missing-const-stability.stderr
index ad8a1fa9d36e1..baa4c34af0600 100644
--- a/tests/ui/stability-attribute/missing-const-stability.stderr
+++ b/tests/ui/stability-attribute/missing-const-stability.stderr
@@ -4,15 +4,6 @@ error: function has missing const stability attribute
 LL | pub const fn foo() {}
    | ^^^^^^^^^^^^^^^^^^^^^
 
-error: implementation has missing const stability attribute
-  --> $DIR/missing-const-stability.rs:29:1
-   |
-LL | / impl const Bar for Foo {
-LL | |
-LL | |     fn fun() {}
-LL | | }
-   | |_^
-
 error: function has missing const stability attribute
   --> $DIR/missing-const-stability.rs:36:1
    |
@@ -25,5 +16,5 @@ error: associated function has missing const stability attribute
 LL |     pub const fn foo() {}
    |     ^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 

From 514ef180fd631b01c0f119991baaf217735ca849 Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Wed, 20 Nov 2024 17:04:14 +0800
Subject: [PATCH 3/7] constify `Add`

---
 library/core/src/lib.rs                       |  1 +
 library/core/src/ops/arith.rs                 | 13 ++++++++++++
 .../call-const-trait-method-pass.stderr       | 19 +-----------------
 .../const-and-non-const-impl.stderr           | 20 +------------------
 tests/ui/traits/const-traits/generic-bound.rs |  3 ++-
 .../traits/const-traits/generic-bound.stderr  | 20 -------------------
 6 files changed, 18 insertions(+), 58 deletions(-)
 delete mode 100644 tests/ui/traits/const-traits/generic-bound.stderr

diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 3b8ac20e52734..a03d357e005a6 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -175,6 +175,7 @@
 #![feature(const_is_char_boundary)]
 #![feature(const_precise_live_drops)]
 #![feature(const_str_split_at)]
+#![feature(const_trait_impl)]
 #![feature(decl_macro)]
 #![feature(deprecated_suggestion)]
 #![feature(doc_cfg)]
diff --git a/library/core/src/ops/arith.rs b/library/core/src/ops/arith.rs
index 133ae04f02618..565bccf589826 100644
--- a/library/core/src/ops/arith.rs
+++ b/library/core/src/ops/arith.rs
@@ -73,6 +73,7 @@
     append_const_msg
 )]
 #[doc(alias = "+")]
+#[cfg_attr(not(bootstrap), const_trait)]
 pub trait Add<Rhs = Self> {
     /// The resulting type after applying the `+` operator.
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -94,6 +95,7 @@ pub trait Add<Rhs = Self> {
 macro_rules! add_impl {
     ($($t:ty)*) => ($(
         #[stable(feature = "rust1", since = "1.0.0")]
+        #[cfg(bootstrap)]
         impl Add for $t {
             type Output = $t;
 
@@ -103,6 +105,17 @@ macro_rules! add_impl {
             fn add(self, other: $t) -> $t { self + other }
         }
 
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[cfg(not(bootstrap))]
+        impl const Add for $t {
+            type Output = $t;
+
+            #[inline]
+            #[track_caller]
+            #[rustc_inherit_overflow_checks]
+            fn add(self, other: $t) -> $t { self + other }
+        }
+
         forward_ref_binop! { impl Add, add for $t, $t }
     )*)
 }
diff --git a/tests/ui/traits/const-traits/call-const-trait-method-pass.stderr b/tests/ui/traits/const-traits/call-const-trait-method-pass.stderr
index 9ae1ed18e3511..1e48a0331cca2 100644
--- a/tests/ui/traits/const-traits/call-const-trait-method-pass.stderr
+++ b/tests/ui/traits/const-traits/call-const-trait-method-pass.stderr
@@ -1,12 +1,3 @@
-error: const `impl` for trait `Add` which is not marked with `#[const_trait]`
-  --> $DIR/call-const-trait-method-pass.rs:7:12
-   |
-LL | impl const std::ops::Add for Int {
-   |            ^^^^^^^^^^^^^
-   |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
 error: const `impl` for trait `PartialEq` which is not marked with `#[const_trait]`
   --> $DIR/call-const-trait-method-pass.rs:15:12
    |
@@ -16,14 +7,6 @@ LL | impl const PartialEq for Int {
    = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
-error[E0015]: cannot call non-const operator in constants
-  --> $DIR/call-const-trait-method-pass.rs:39:22
-   |
-LL | const ADD_INT: Int = Int(1i32) + Int(2i32);
-   |                      ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: calls in constants are limited to constant functions, tuple structs and tuple variants
-
 error[E0015]: cannot call non-const fn `<Int as PartialEq>::eq` in constant functions
   --> $DIR/call-const-trait-method-pass.rs:20:15
    |
@@ -32,6 +15,6 @@ LL |         !self.eq(other)
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/traits/const-traits/const-and-non-const-impl.stderr b/tests/ui/traits/const-traits/const-and-non-const-impl.stderr
index cf7af41cd4e47..4eb1517734700 100644
--- a/tests/ui/traits/const-traits/const-and-non-const-impl.stderr
+++ b/tests/ui/traits/const-traits/const-and-non-const-impl.stderr
@@ -1,21 +1,3 @@
-error: const `impl` for trait `Add` which is not marked with `#[const_trait]`
-  --> $DIR/const-and-non-const-impl.rs:7:12
-   |
-LL | impl const std::ops::Add for i32 {
-   |            ^^^^^^^^^^^^^
-   |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
-error: const `impl` for trait `Add` which is not marked with `#[const_trait]`
-  --> $DIR/const-and-non-const-impl.rs:23:12
-   |
-LL | impl const std::ops::Add for Int {
-   |            ^^^^^^^^^^^^^
-   |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
 error[E0119]: conflicting implementations of trait `Add` for type `Int`
   --> $DIR/const-and-non-const-impl.rs:23:1
    |
@@ -38,7 +20,7 @@ LL | impl const std::ops::Add for i32 {
    = note: for more information see https://doc.rust-lang.org/reference/items/implementations.html#orphan-rules
    = note: define and implement a trait or new type instead
 
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0117, E0119.
 For more information about an error, try `rustc --explain E0117`.
diff --git a/tests/ui/traits/const-traits/generic-bound.rs b/tests/ui/traits/const-traits/generic-bound.rs
index 620e3259917eb..5eb236acde22c 100644
--- a/tests/ui/traits/const-traits/generic-bound.rs
+++ b/tests/ui/traits/const-traits/generic-bound.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #110395
+//@ check-pass
 
 #![feature(const_trait_impl)]
 
@@ -26,5 +26,6 @@ const fn twice<T: std::ops::Add>(arg: S<T>) -> S<T> {
 }
 
 fn main() {
+    const _: S<i32> = twice(S(PhantomData));
     let _ = twice(S(PhantomData::<i32>));
 }
diff --git a/tests/ui/traits/const-traits/generic-bound.stderr b/tests/ui/traits/const-traits/generic-bound.stderr
deleted file mode 100644
index 0444c3195773e..0000000000000
--- a/tests/ui/traits/const-traits/generic-bound.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error: const `impl` for trait `Add` which is not marked with `#[const_trait]`
-  --> $DIR/generic-bound.rs:16:15
-   |
-LL | impl<T> const std::ops::Add for S<T> {
-   |               ^^^^^^^^^^^^^
-   |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
-error[E0015]: cannot call non-const operator in constant functions
-  --> $DIR/generic-bound.rs:25:5
-   |
-LL |     arg + arg
-   |     ^^^^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0015`.

From 02f51ec2bd72092f7f97ef9415fc1e658f6752e3 Mon Sep 17 00:00:00 2001
From: Xing Xue <xingxue@outlook.com>
Date: Tue, 19 Nov 2024 14:16:47 -0500
Subject: [PATCH 4/7] Change to pass "strip" options in an array of string
 slices and add option "-X32_64" for AIX.

---
 compiler/rustc_codegen_ssa/src/back/link.rs | 22 +++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index fd1126e852848..fdf1d0a8690d8 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1107,14 +1107,14 @@ fn link_natively(
         let stripcmd = "rust-objcopy";
         match (strip, crate_type) {
             (Strip::Debuginfo, _) => {
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, Some("-S"))
+                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &["-S"])
             }
             // Per the manpage, `-x` is the maximum safe strip level for dynamic libraries. (#93988)
             (Strip::Symbols, CrateType::Dylib | CrateType::Cdylib | CrateType::ProcMacro) => {
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, Some("-x"))
+                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &["-x"])
             }
             (Strip::Symbols, _) => {
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, None)
+                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &[])
             }
             (Strip::None, _) => {}
         }
@@ -1131,7 +1131,7 @@ fn link_natively(
         match strip {
             // Always preserve the symbol table (-x).
             Strip::Debuginfo => {
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, Some("-x"))
+                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &["-x"])
             }
             // Strip::Symbols is handled via the --strip-all linker option.
             Strip::Symbols => {}
@@ -1148,11 +1148,15 @@ fn link_natively(
         match strip {
             Strip::Debuginfo => {
                 // FIXME: AIX's strip utility only offers option to strip line number information.
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, Some("-l"))
+                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &[
+                    "-X32_64", "-l",
+                ])
             }
             Strip::Symbols => {
                 // Must be noted this option might remove symbol __aix_rust_metadata and thus removes .info section which contains metadata.
-                strip_symbols_with_external_utility(sess, stripcmd, out_filename, Some("-r"))
+                strip_symbols_with_external_utility(sess, stripcmd, out_filename, &[
+                    "-X32_64", "-r",
+                ])
             }
             Strip::None => {}
         }
@@ -1165,12 +1169,10 @@ fn strip_symbols_with_external_utility(
     sess: &Session,
     util: &str,
     out_filename: &Path,
-    option: Option<&str>,
+    options: &[&str],
 ) {
     let mut cmd = Command::new(util);
-    if let Some(option) = option {
-        cmd.arg(option);
-    }
+    cmd.args(options);
 
     let mut new_path = sess.get_tools_search_paths(false);
     if let Some(path) = env::var_os("PATH") {

From 3d67fd4cf4dfcdfb93e880a09ed7d41d95170226 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Fri, 22 Nov 2024 19:32:02 -0500
Subject: [PATCH 5/7] Add language tests for aggregate types

---
 .../ui/layout/aggregate-lang/struct-align.rs  | 31 +++++++
 .../layout/aggregate-lang/struct-offsets.rs   | 93 +++++++++++++++++++
 tests/ui/layout/aggregate-lang/struct-size.rs | 57 ++++++++++++
 tests/ui/layout/aggregate-lang/union-align.rs | 31 +++++++
 .../ui/layout/aggregate-lang/union-offsets.rs | 46 +++++++++
 tests/ui/layout/aggregate-lang/union-size.rs  | 54 +++++++++++
 6 files changed, 312 insertions(+)
 create mode 100644 tests/ui/layout/aggregate-lang/struct-align.rs
 create mode 100644 tests/ui/layout/aggregate-lang/struct-offsets.rs
 create mode 100644 tests/ui/layout/aggregate-lang/struct-size.rs
 create mode 100644 tests/ui/layout/aggregate-lang/union-align.rs
 create mode 100644 tests/ui/layout/aggregate-lang/union-offsets.rs
 create mode 100644 tests/ui/layout/aggregate-lang/union-size.rs

diff --git a/tests/ui/layout/aggregate-lang/struct-align.rs b/tests/ui/layout/aggregate-lang/struct-align.rs
new file mode 100644
index 0000000000000..931d686798daa
--- /dev/null
+++ b/tests/ui/layout/aggregate-lang/struct-align.rs
@@ -0,0 +1,31 @@
+//@ run-pass
+//@ reference: layout.aggregate.struct-size-align
+//@ edition: 2018
+
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+#[allow(dead_code)]
+pub struct Overaligned(u8);
+
+#[allow(dead_code)]
+struct ReprRustStruct {
+    x: i32,
+    y: [u32; 4],
+    z: f32,
+    a: u128,
+    b: Overaligned,
+}
+
+#[cfg_attr(test, test)]
+fn test_alignment_contains_all_fields() {
+    assert!(core::mem::align_of::<ReprRustStruct>() >= core::mem::align_of::<i32>());
+    assert!(core::mem::align_of::<ReprRustStruct>() >= core::mem::align_of::<[u32; 4]>());
+    assert!(core::mem::align_of::<ReprRustStruct>() >= core::mem::align_of::<f32>());
+    assert!(core::mem::align_of::<ReprRustStruct>() >= core::mem::align_of::<u128>());
+    assert!(core::mem::align_of::<ReprRustStruct>() >= core::mem::align_of::<Overaligned>());
+}
+
+#[cfg(not(test))]
+fn main() {
+    test_alignment_contains_all_fields();
+}
diff --git a/tests/ui/layout/aggregate-lang/struct-offsets.rs b/tests/ui/layout/aggregate-lang/struct-offsets.rs
new file mode 100644
index 0000000000000..62e16e6d8434e
--- /dev/null
+++ b/tests/ui/layout/aggregate-lang/struct-offsets.rs
@@ -0,0 +1,93 @@
+//@ run-pass
+//@ reference: layout.aggregate.struct-offsets
+//@ edition: 2018
+
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+#[allow(dead_code)]
+pub struct Overaligned(u8);
+
+#[allow(dead_code)]
+struct ReprRustStruct {
+    x: i32,
+    y: [u32; 4],
+    z: f32,
+    a: u128,
+    b: Overaligned,
+}
+
+macro_rules! span_of {
+    ($ty:ty , $field:tt) => {{
+        let __field = unsafe { ::core::mem::zeroed::<$ty>() };
+
+        (
+            core::mem::offset_of!($ty, $field),
+            core::mem::offset_of!($ty, $field) + core::mem::size_of_val(&__field.$field),
+        )
+    }};
+}
+
+fn test_fields_make_sense(a: &(usize, usize)) {
+    assert!(a.0 <= a.1);
+}
+
+// order is `begin, end`
+fn test_non_overlapping(a: &(usize, usize), b: &(usize, usize)) {
+    assert!((a.1 <= b.0) || (b.1 <= a.0));
+}
+
+#[cfg_attr(test, test)]
+fn test_fields_non_overlapping() {
+    let fields = [
+        span_of!(ReprRustStruct, x),
+        span_of!(ReprRustStruct, y),
+        span_of!(ReprRustStruct, z),
+        span_of!(ReprRustStruct, a),
+        span_of!(ReprRustStruct, b),
+    ];
+
+    test_fields_make_sense(&fields[0]);
+    test_fields_make_sense(&fields[1]);
+    test_fields_make_sense(&fields[2]);
+    test_fields_make_sense(&fields[3]);
+    test_fields_make_sense(&fields[4]);
+
+    test_non_overlapping(&fields[0], &fields[1]);
+    test_non_overlapping(&fields[0], &fields[2]);
+    test_non_overlapping(&fields[0], &fields[3]);
+    test_non_overlapping(&fields[0], &fields[4]);
+    test_non_overlapping(&fields[1], &fields[2]);
+    test_non_overlapping(&fields[2], &fields[3]);
+    test_non_overlapping(&fields[2], &fields[4]);
+    test_non_overlapping(&fields[3], &fields[4]);
+}
+
+#[cfg_attr(test, test)]
+fn test_fields_aligned() {
+    assert_eq!(
+        (core::mem::offset_of!(ReprRustStruct, x) % (core::mem::align_of::<i32>())),
+        0
+    );
+    assert_eq!(
+        (core::mem::offset_of!(ReprRustStruct, y) % (core::mem::align_of::<[u32; 4]>())),
+        0
+    );
+    assert_eq!(
+        (core::mem::offset_of!(ReprRustStruct, z) % (core::mem::align_of::<f32>())),
+        0
+    );
+    assert_eq!(
+        (core::mem::offset_of!(ReprRustStruct, a) % (core::mem::align_of::<u128>())),
+        0
+    );
+    assert_eq!(
+        (core::mem::offset_of!(ReprRustStruct, b) % (core::mem::align_of::<Overaligned>())),
+        0
+    );
+}
+
+#[cfg(not(test))]
+fn main() {
+    test_fields_non_overlapping();
+    test_fields_aligned();
+}
diff --git a/tests/ui/layout/aggregate-lang/struct-size.rs b/tests/ui/layout/aggregate-lang/struct-size.rs
new file mode 100644
index 0000000000000..3d93a8dca3487
--- /dev/null
+++ b/tests/ui/layout/aggregate-lang/struct-size.rs
@@ -0,0 +1,57 @@
+//@ run-pass
+//@ reference: layout.aggregate.struct-size-align
+//@ edition: 2018
+
+#[allow(dead_code)]
+struct ReprRustStruct {
+    x: i32,
+    y: [u32; 4],
+    z: f32,
+    a: u128,
+}
+
+#[cfg_attr(test, test)]
+fn test_size_contains_all_types() {
+    assert!(
+        core::mem::size_of::<ReprRustStruct>()
+            >= (core::mem::size_of::<i32>()
+                + core::mem::size_of::<[u32; 4]>()
+                + core::mem::size_of::<f32>()
+                + core::mem::size_of::<u128>())
+    );
+}
+
+#[cfg_attr(test, test)]
+fn test_size_contains_all_fields() {
+    assert!(
+        (core::mem::offset_of!(ReprRustStruct, x) + core::mem::size_of::<i32>())
+            <= core::mem::size_of::<ReprRustStruct>()
+    );
+    assert!(
+        (core::mem::offset_of!(ReprRustStruct, y) + core::mem::size_of::<[u32; 4]>())
+            <= core::mem::size_of::<ReprRustStruct>()
+    );
+    assert!(
+        (core::mem::offset_of!(ReprRustStruct, z) + core::mem::size_of::<f32>())
+            <= core::mem::size_of::<ReprRustStruct>()
+    );
+    assert!(
+        (core::mem::offset_of!(ReprRustStruct, a) + core::mem::size_of::<u128>())
+            <= core::mem::size_of::<ReprRustStruct>()
+    );
+}
+
+#[cfg_attr(test, test)]
+fn test_size_modulo_align() {
+    assert_eq!(
+        core::mem::size_of::<ReprRustStruct>() % core::mem::align_of::<ReprRustStruct>(),
+        0
+    );
+}
+
+#[cfg(not(test))]
+fn main() {
+    test_size_contains_all_fields();
+    test_size_contains_all_types();
+    test_size_modulo_align();
+}
diff --git a/tests/ui/layout/aggregate-lang/union-align.rs b/tests/ui/layout/aggregate-lang/union-align.rs
new file mode 100644
index 0000000000000..a37d94abfa832
--- /dev/null
+++ b/tests/ui/layout/aggregate-lang/union-align.rs
@@ -0,0 +1,31 @@
+//@ run-pass
+//@ reference: layout.aggregate.struct-size-align
+//@ edition: 2018
+
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+#[allow(dead_code)]
+pub struct Overaligned(u8);
+
+#[allow(dead_code)]
+union ReprRustUnion {
+    x: i32,
+    y: [u32; 4],
+    z: f32,
+    a: u128,
+    b: Overaligned,
+}
+
+#[cfg_attr(test, test)]
+fn test_alignment_contains_all_fields() {
+    assert!(core::mem::align_of::<ReprRustUnion>() >= core::mem::align_of::<i32>());
+    assert!(core::mem::align_of::<ReprRustUnion>() >= core::mem::align_of::<[u32; 4]>());
+    assert!(core::mem::align_of::<ReprRustUnion>() >= core::mem::align_of::<f32>());
+    assert!(core::mem::align_of::<ReprRustUnion>() >= core::mem::align_of::<u128>());
+    assert!(core::mem::align_of::<ReprRustUnion>() >= core::mem::align_of::<Overaligned>());
+}
+
+#[cfg(not(test))]
+fn main() {
+    test_alignment_contains_all_fields();
+}
diff --git a/tests/ui/layout/aggregate-lang/union-offsets.rs b/tests/ui/layout/aggregate-lang/union-offsets.rs
new file mode 100644
index 0000000000000..2a2f7d9c790b7
--- /dev/null
+++ b/tests/ui/layout/aggregate-lang/union-offsets.rs
@@ -0,0 +1,46 @@
+//@ run-pass
+//@ reference: layout.aggregate.struct-offsets
+//@ edition: 2018
+
+#[repr(align(64))]
+#[derive(Copy, Clone)]
+#[allow(dead_code)]
+pub struct Overaligned(u8);
+
+#[allow(dead_code)]
+union ReprRustUnion {
+    x: i32,
+    y: [u32; 4],
+    z: f32,
+    a: u128,
+    b: Overaligned,
+}
+
+#[cfg_attr(test, test)]
+fn test_fields_aligned() {
+    assert_eq!(
+        (core::mem::offset_of!(ReprRustUnion, x) % (core::mem::align_of::<i32>())),
+        0
+    );
+    assert_eq!(
+        (core::mem::offset_of!(ReprRustUnion, y) % (core::mem::align_of::<[u32; 4]>())),
+        0
+    );
+    assert_eq!(
+        (core::mem::offset_of!(ReprRustUnion, z) % (core::mem::align_of::<f32>())),
+        0
+    );
+    assert_eq!(
+        (core::mem::offset_of!(ReprRustUnion, a) % (core::mem::align_of::<u128>())),
+        0
+    );
+    assert_eq!(
+        (core::mem::offset_of!(ReprRustUnion, b) % (core::mem::align_of::<Overaligned>())),
+        0
+    );
+}
+
+#[cfg(not(test))]
+fn main() {
+    test_fields_aligned();
+}
diff --git a/tests/ui/layout/aggregate-lang/union-size.rs b/tests/ui/layout/aggregate-lang/union-size.rs
new file mode 100644
index 0000000000000..f82412f50899a
--- /dev/null
+++ b/tests/ui/layout/aggregate-lang/union-size.rs
@@ -0,0 +1,54 @@
+//@ run-pass
+//@ reference: layout.aggregate.struct-size-align
+//@ edition: 2018
+
+#[allow(dead_code)]
+union ReprRustUnion {
+    x: i32,
+    y: [u32; 4],
+    z: f32,
+    a: u128,
+}
+
+#[cfg_attr(test, test)]
+fn test_size_contains_each_type() {
+    assert!(core::mem::size_of::<i32>() <= core::mem::size_of::<ReprRustUnion>());
+    assert!(core::mem::size_of::<[u32; 4]>() <= core::mem::size_of::<ReprRustUnion>());
+    assert!(core::mem::size_of::<f32>() <= core::mem::size_of::<ReprRustUnion>());
+    assert!(core::mem::size_of::<u128>() <= core::mem::size_of::<ReprRustUnion>());
+}
+
+#[cfg_attr(test, test)]
+fn test_size_contains_all_fields() {
+    assert!(
+        (core::mem::offset_of!(ReprRustUnion, x) + core::mem::size_of::<i32>())
+            <= core::mem::size_of::<ReprRustUnion>()
+    );
+    assert!(
+        (core::mem::offset_of!(ReprRustUnion, y) + core::mem::size_of::<[u32; 4]>())
+            <= core::mem::size_of::<ReprRustUnion>()
+    );
+    assert!(
+        (core::mem::offset_of!(ReprRustUnion, z) + core::mem::size_of::<f32>())
+            <= core::mem::size_of::<ReprRustUnion>()
+    );
+    assert!(
+        (core::mem::offset_of!(ReprRustUnion, a) + core::mem::size_of::<u128>())
+            <= core::mem::size_of::<ReprRustUnion>()
+    );
+}
+
+#[cfg_attr(test, test)]
+fn test_size_modulo_align() {
+    assert_eq!(
+        core::mem::size_of::<ReprRustUnion>() % core::mem::align_of::<ReprRustUnion>(),
+        0
+    );
+}
+
+#[cfg(not(test))]
+fn main() {
+    test_size_contains_each_type();
+    test_size_contains_all_fields();
+    test_size_modulo_align();
+}

From 8578ccc7add524147a8c524a336b050fb7647087 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Fri, 22 Nov 2024 21:07:02 -0500
Subject: [PATCH 6/7] Remove `#[cfg(test)]` related stubs

---
 .../ui/layout/aggregate-lang/struct-align.rs  |  2 --
 .../layout/aggregate-lang/struct-offsets.rs   | 23 ++++---------------
 tests/ui/layout/aggregate-lang/struct-size.rs |  9 +-------
 tests/ui/layout/aggregate-lang/union-align.rs |  2 --
 .../ui/layout/aggregate-lang/union-offsets.rs | 22 ++++--------------
 tests/ui/layout/aggregate-lang/union-size.rs  |  9 +-------
 6 files changed, 10 insertions(+), 57 deletions(-)

diff --git a/tests/ui/layout/aggregate-lang/struct-align.rs b/tests/ui/layout/aggregate-lang/struct-align.rs
index 931d686798daa..f3b88a6d85d3e 100644
--- a/tests/ui/layout/aggregate-lang/struct-align.rs
+++ b/tests/ui/layout/aggregate-lang/struct-align.rs
@@ -16,7 +16,6 @@ struct ReprRustStruct {
     b: Overaligned,
 }
 
-#[cfg_attr(test, test)]
 fn test_alignment_contains_all_fields() {
     assert!(core::mem::align_of::<ReprRustStruct>() >= core::mem::align_of::<i32>());
     assert!(core::mem::align_of::<ReprRustStruct>() >= core::mem::align_of::<[u32; 4]>());
@@ -25,7 +24,6 @@ fn test_alignment_contains_all_fields() {
     assert!(core::mem::align_of::<ReprRustStruct>() >= core::mem::align_of::<Overaligned>());
 }
 
-#[cfg(not(test))]
 fn main() {
     test_alignment_contains_all_fields();
 }
diff --git a/tests/ui/layout/aggregate-lang/struct-offsets.rs b/tests/ui/layout/aggregate-lang/struct-offsets.rs
index 62e16e6d8434e..ca199bdfeb104 100644
--- a/tests/ui/layout/aggregate-lang/struct-offsets.rs
+++ b/tests/ui/layout/aggregate-lang/struct-offsets.rs
@@ -36,7 +36,6 @@ fn test_non_overlapping(a: &(usize, usize), b: &(usize, usize)) {
     assert!((a.1 <= b.0) || (b.1 <= a.0));
 }
 
-#[cfg_attr(test, test)]
 fn test_fields_non_overlapping() {
     let fields = [
         span_of!(ReprRustStruct, x),
@@ -62,31 +61,17 @@ fn test_fields_non_overlapping() {
     test_non_overlapping(&fields[3], &fields[4]);
 }
 
-#[cfg_attr(test, test)]
 fn test_fields_aligned() {
-    assert_eq!(
-        (core::mem::offset_of!(ReprRustStruct, x) % (core::mem::align_of::<i32>())),
-        0
-    );
-    assert_eq!(
-        (core::mem::offset_of!(ReprRustStruct, y) % (core::mem::align_of::<[u32; 4]>())),
-        0
-    );
-    assert_eq!(
-        (core::mem::offset_of!(ReprRustStruct, z) % (core::mem::align_of::<f32>())),
-        0
-    );
-    assert_eq!(
-        (core::mem::offset_of!(ReprRustStruct, a) % (core::mem::align_of::<u128>())),
-        0
-    );
+    assert_eq!((core::mem::offset_of!(ReprRustStruct, x) % (core::mem::align_of::<i32>())), 0);
+    assert_eq!((core::mem::offset_of!(ReprRustStruct, y) % (core::mem::align_of::<[u32; 4]>())), 0);
+    assert_eq!((core::mem::offset_of!(ReprRustStruct, z) % (core::mem::align_of::<f32>())), 0);
+    assert_eq!((core::mem::offset_of!(ReprRustStruct, a) % (core::mem::align_of::<u128>())), 0);
     assert_eq!(
         (core::mem::offset_of!(ReprRustStruct, b) % (core::mem::align_of::<Overaligned>())),
         0
     );
 }
 
-#[cfg(not(test))]
 fn main() {
     test_fields_non_overlapping();
     test_fields_aligned();
diff --git a/tests/ui/layout/aggregate-lang/struct-size.rs b/tests/ui/layout/aggregate-lang/struct-size.rs
index 3d93a8dca3487..f9fb605c32486 100644
--- a/tests/ui/layout/aggregate-lang/struct-size.rs
+++ b/tests/ui/layout/aggregate-lang/struct-size.rs
@@ -10,7 +10,6 @@ struct ReprRustStruct {
     a: u128,
 }
 
-#[cfg_attr(test, test)]
 fn test_size_contains_all_types() {
     assert!(
         core::mem::size_of::<ReprRustStruct>()
@@ -21,7 +20,6 @@ fn test_size_contains_all_types() {
     );
 }
 
-#[cfg_attr(test, test)]
 fn test_size_contains_all_fields() {
     assert!(
         (core::mem::offset_of!(ReprRustStruct, x) + core::mem::size_of::<i32>())
@@ -41,15 +39,10 @@ fn test_size_contains_all_fields() {
     );
 }
 
-#[cfg_attr(test, test)]
 fn test_size_modulo_align() {
-    assert_eq!(
-        core::mem::size_of::<ReprRustStruct>() % core::mem::align_of::<ReprRustStruct>(),
-        0
-    );
+    assert_eq!(core::mem::size_of::<ReprRustStruct>() % core::mem::align_of::<ReprRustStruct>(), 0);
 }
 
-#[cfg(not(test))]
 fn main() {
     test_size_contains_all_fields();
     test_size_contains_all_types();
diff --git a/tests/ui/layout/aggregate-lang/union-align.rs b/tests/ui/layout/aggregate-lang/union-align.rs
index a37d94abfa832..03825f1df2137 100644
--- a/tests/ui/layout/aggregate-lang/union-align.rs
+++ b/tests/ui/layout/aggregate-lang/union-align.rs
@@ -16,7 +16,6 @@ union ReprRustUnion {
     b: Overaligned,
 }
 
-#[cfg_attr(test, test)]
 fn test_alignment_contains_all_fields() {
     assert!(core::mem::align_of::<ReprRustUnion>() >= core::mem::align_of::<i32>());
     assert!(core::mem::align_of::<ReprRustUnion>() >= core::mem::align_of::<[u32; 4]>());
@@ -25,7 +24,6 @@ fn test_alignment_contains_all_fields() {
     assert!(core::mem::align_of::<ReprRustUnion>() >= core::mem::align_of::<Overaligned>());
 }
 
-#[cfg(not(test))]
 fn main() {
     test_alignment_contains_all_fields();
 }
diff --git a/tests/ui/layout/aggregate-lang/union-offsets.rs b/tests/ui/layout/aggregate-lang/union-offsets.rs
index 2a2f7d9c790b7..29ab0a9ce5490 100644
--- a/tests/ui/layout/aggregate-lang/union-offsets.rs
+++ b/tests/ui/layout/aggregate-lang/union-offsets.rs
@@ -16,31 +16,17 @@ union ReprRustUnion {
     b: Overaligned,
 }
 
-#[cfg_attr(test, test)]
 fn test_fields_aligned() {
-    assert_eq!(
-        (core::mem::offset_of!(ReprRustUnion, x) % (core::mem::align_of::<i32>())),
-        0
-    );
-    assert_eq!(
-        (core::mem::offset_of!(ReprRustUnion, y) % (core::mem::align_of::<[u32; 4]>())),
-        0
-    );
-    assert_eq!(
-        (core::mem::offset_of!(ReprRustUnion, z) % (core::mem::align_of::<f32>())),
-        0
-    );
-    assert_eq!(
-        (core::mem::offset_of!(ReprRustUnion, a) % (core::mem::align_of::<u128>())),
-        0
-    );
+    assert_eq!((core::mem::offset_of!(ReprRustUnion, x) % (core::mem::align_of::<i32>())), 0);
+    assert_eq!((core::mem::offset_of!(ReprRustUnion, y) % (core::mem::align_of::<[u32; 4]>())), 0);
+    assert_eq!((core::mem::offset_of!(ReprRustUnion, z) % (core::mem::align_of::<f32>())), 0);
+    assert_eq!((core::mem::offset_of!(ReprRustUnion, a) % (core::mem::align_of::<u128>())), 0);
     assert_eq!(
         (core::mem::offset_of!(ReprRustUnion, b) % (core::mem::align_of::<Overaligned>())),
         0
     );
 }
 
-#[cfg(not(test))]
 fn main() {
     test_fields_aligned();
 }
diff --git a/tests/ui/layout/aggregate-lang/union-size.rs b/tests/ui/layout/aggregate-lang/union-size.rs
index f82412f50899a..6d1b51b172db1 100644
--- a/tests/ui/layout/aggregate-lang/union-size.rs
+++ b/tests/ui/layout/aggregate-lang/union-size.rs
@@ -10,7 +10,6 @@ union ReprRustUnion {
     a: u128,
 }
 
-#[cfg_attr(test, test)]
 fn test_size_contains_each_type() {
     assert!(core::mem::size_of::<i32>() <= core::mem::size_of::<ReprRustUnion>());
     assert!(core::mem::size_of::<[u32; 4]>() <= core::mem::size_of::<ReprRustUnion>());
@@ -18,7 +17,6 @@ fn test_size_contains_each_type() {
     assert!(core::mem::size_of::<u128>() <= core::mem::size_of::<ReprRustUnion>());
 }
 
-#[cfg_attr(test, test)]
 fn test_size_contains_all_fields() {
     assert!(
         (core::mem::offset_of!(ReprRustUnion, x) + core::mem::size_of::<i32>())
@@ -38,15 +36,10 @@ fn test_size_contains_all_fields() {
     );
 }
 
-#[cfg_attr(test, test)]
 fn test_size_modulo_align() {
-    assert_eq!(
-        core::mem::size_of::<ReprRustUnion>() % core::mem::align_of::<ReprRustUnion>(),
-        0
-    );
+    assert_eq!(core::mem::size_of::<ReprRustUnion>() % core::mem::align_of::<ReprRustUnion>(), 0);
 }
 
-#[cfg(not(test))]
 fn main() {
     test_size_contains_each_type();
     test_size_contains_all_fields();

From d7303194b971eb4bbe1929a05efebfb26656a91f Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 23 Nov 2024 09:15:25 +0100
Subject: [PATCH 7/7] show abi_unsupported_vector_types lint in future breakage
 reports

---
 compiler/rustc_lint_defs/src/builtin.rs       |   2 +-
 tests/ui/simd-abi-checks-empty-list.stderr    |  11 ++
 tests/ui/simd-abi-checks-s390x.z10.stderr     | 164 ++++++++++++++++++
 ...simd-abi-checks-s390x.z13_no_vector.stderr | 164 ++++++++++++++++++
 ...imd-abi-checks-s390x.z13_soft_float.stderr | 164 ++++++++++++++++++
 tests/ui/simd-abi-checks.stderr               | 108 ++++++++++++
 tests/ui/sse-abi-checks.stderr                |  12 ++
 7 files changed, 624 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index 9036741e07877..3b406c7e161a0 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -5173,7 +5173,7 @@ declare_lint! {
     Warn,
     "this function call or definition uses a vector type which is not enabled",
     @future_incompatible = FutureIncompatibleInfo {
-        reason: FutureIncompatibilityReason::FutureReleaseErrorDontReportInDeps,
+        reason: FutureIncompatibilityReason::FutureReleaseErrorReportInDeps,
         reference: "issue #116558 <https://github.com/rust-lang/rust/issues/116558>",
     };
 }
diff --git a/tests/ui/simd-abi-checks-empty-list.stderr b/tests/ui/simd-abi-checks-empty-list.stderr
index d7ce52eab80fd..c49fe1a01de5e 100644
--- a/tests/ui/simd-abi-checks-empty-list.stderr
+++ b/tests/ui/simd-abi-checks-empty-list.stderr
@@ -10,3 +10,14 @@ LL | pub extern "C" fn pass_by_vec(_: SimdVec) {}
 
 warning: 1 warning emitted
 
+Future incompatibility report: Future breakage diagnostic:
+warning: this function definition uses a SIMD vector type that is not currently supported with the chosen ABI
+  --> $DIR/simd-abi-checks-empty-list.rs:17:1
+   |
+LL | pub extern "C" fn pass_by_vec(_: SimdVec) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = note: `#[warn(abi_unsupported_vector_types)]` on by default
+
diff --git a/tests/ui/simd-abi-checks-s390x.z10.stderr b/tests/ui/simd-abi-checks-s390x.z10.stderr
index a91322ec05839..cf135afb428f4 100644
--- a/tests/ui/simd-abi-checks-s390x.z10.stderr
+++ b/tests/ui/simd-abi-checks-s390x.z10.stderr
@@ -109,3 +109,167 @@ LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>)
 
 error: aborting due to 10 previous errors
 
+Future incompatibility report: Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:46:1
+   |
+LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:52:1
+   |
+LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:99:1
+   |
+LL | / extern "C" fn vector_transparent_wrapper_ret_small(
+LL | |     x: &TransparentWrapper<i8x8>,
+LL | | ) -> TransparentWrapper<i8x8> {
+   | |_____________________________^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:107:1
+   |
+LL | / extern "C" fn vector_transparent_wrapper_ret(
+LL | |     x: &TransparentWrapper<i8x16>,
+LL | | ) -> TransparentWrapper<i8x16> {
+   | |______________________________^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:123:1
+   |
+LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:129:1
+   |
+LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:141:1
+   |
+LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:147:1
+   |
+LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:159:1
+   |
+LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:165:1
+   |
+LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
diff --git a/tests/ui/simd-abi-checks-s390x.z13_no_vector.stderr b/tests/ui/simd-abi-checks-s390x.z13_no_vector.stderr
index a91322ec05839..cf135afb428f4 100644
--- a/tests/ui/simd-abi-checks-s390x.z13_no_vector.stderr
+++ b/tests/ui/simd-abi-checks-s390x.z13_no_vector.stderr
@@ -109,3 +109,167 @@ LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>)
 
 error: aborting due to 10 previous errors
 
+Future incompatibility report: Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:46:1
+   |
+LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:52:1
+   |
+LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:99:1
+   |
+LL | / extern "C" fn vector_transparent_wrapper_ret_small(
+LL | |     x: &TransparentWrapper<i8x8>,
+LL | | ) -> TransparentWrapper<i8x8> {
+   | |_____________________________^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:107:1
+   |
+LL | / extern "C" fn vector_transparent_wrapper_ret(
+LL | |     x: &TransparentWrapper<i8x16>,
+LL | | ) -> TransparentWrapper<i8x16> {
+   | |______________________________^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:123:1
+   |
+LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:129:1
+   |
+LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:141:1
+   |
+LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:147:1
+   |
+LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:159:1
+   |
+LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:165:1
+   |
+LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
diff --git a/tests/ui/simd-abi-checks-s390x.z13_soft_float.stderr b/tests/ui/simd-abi-checks-s390x.z13_soft_float.stderr
index a91322ec05839..cf135afb428f4 100644
--- a/tests/ui/simd-abi-checks-s390x.z13_soft_float.stderr
+++ b/tests/ui/simd-abi-checks-s390x.z13_soft_float.stderr
@@ -109,3 +109,167 @@ LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>)
 
 error: aborting due to 10 previous errors
 
+Future incompatibility report: Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:46:1
+   |
+LL | extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:52:1
+   |
+LL | extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:99:1
+   |
+LL | / extern "C" fn vector_transparent_wrapper_ret_small(
+LL | |     x: &TransparentWrapper<i8x8>,
+LL | | ) -> TransparentWrapper<i8x8> {
+   | |_____________________________^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:107:1
+   |
+LL | / extern "C" fn vector_transparent_wrapper_ret(
+LL | |     x: &TransparentWrapper<i8x16>,
+LL | | ) -> TransparentWrapper<i8x16> {
+   | |______________________________^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:123:1
+   |
+LL | extern "C" fn vector_arg_small(x: i8x8) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:129:1
+   |
+LL | extern "C" fn vector_arg(x: i8x16) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:141:1
+   |
+LL | extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:147:1
+   |
+LL | extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:159:1
+   |
+LL | extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+error: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `vector` target feature, which is not enabled
+  --> $DIR/simd-abi-checks-s390x.rs:165:1
+   |
+LL | extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+vector`) or locally (`#[target_feature(enable="vector")]`)
+note: the lint level is defined here
+  --> $DIR/simd-abi-checks-s390x.rs:15:9
+   |
+LL | #![deny(abi_unsupported_vector_types)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
diff --git a/tests/ui/simd-abi-checks.stderr b/tests/ui/simd-abi-checks.stderr
index 7d2915f7dea64..cd04cfa6e1418 100644
--- a/tests/ui/simd-abi-checks.stderr
+++ b/tests/ui/simd-abi-checks.stderr
@@ -91,3 +91,111 @@ LL | unsafe extern "C" fn w(_: Wrapper) {
 
 warning: 9 warnings emitted
 
+Future incompatibility report: Future breakage diagnostic:
+warning: this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
+  --> $DIR/simd-abi-checks.rs:55:11
+   |
+LL |         f(g());
+   |           ^^^ function called here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+   = note: `#[warn(abi_unsupported_vector_types)]` on by default
+
+Future breakage diagnostic:
+warning: this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
+  --> $DIR/simd-abi-checks.rs:55:9
+   |
+LL |         f(g());
+   |         ^^^^^^ function called here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+   = note: `#[warn(abi_unsupported_vector_types)]` on by default
+
+Future breakage diagnostic:
+warning: this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
+  --> $DIR/simd-abi-checks.rs:63:14
+   |
+LL |         gavx(favx());
+   |              ^^^^^^ function called here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+   = note: `#[warn(abi_unsupported_vector_types)]` on by default
+
+Future breakage diagnostic:
+warning: this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
+  --> $DIR/simd-abi-checks.rs:63:9
+   |
+LL |         gavx(favx());
+   |         ^^^^^^^^^^^^ function called here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+   = note: `#[warn(abi_unsupported_vector_types)]` on by default
+
+Future breakage diagnostic:
+warning: this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
+  --> $DIR/simd-abi-checks.rs:75:19
+   |
+LL |         w(Wrapper(g()));
+   |                   ^^^ function called here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+   = note: `#[warn(abi_unsupported_vector_types)]` on by default
+
+Future breakage diagnostic:
+warning: this function call uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled in the caller
+  --> $DIR/simd-abi-checks.rs:75:9
+   |
+LL |         w(Wrapper(g()));
+   |         ^^^^^^^^^^^^^^^ function called here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+   = note: `#[warn(abi_unsupported_vector_types)]` on by default
+
+Future breakage diagnostic:
+warning: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled
+  --> $DIR/simd-abi-checks.rs:26:1
+   |
+LL | unsafe extern "C" fn g() -> __m256 {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+   = note: `#[warn(abi_unsupported_vector_types)]` on by default
+
+Future breakage diagnostic:
+warning: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled
+  --> $DIR/simd-abi-checks.rs:20:1
+   |
+LL | unsafe extern "C" fn f(_: __m256) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+   = note: `#[warn(abi_unsupported_vector_types)]` on by default
+
+Future breakage diagnostic:
+warning: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `avx` target feature, which is not enabled
+  --> $DIR/simd-abi-checks.rs:14:1
+   |
+LL | unsafe extern "C" fn w(_: Wrapper) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+avx`) or locally (`#[target_feature(enable="avx")]`)
+   = note: `#[warn(abi_unsupported_vector_types)]` on by default
+
diff --git a/tests/ui/sse-abi-checks.stderr b/tests/ui/sse-abi-checks.stderr
index 7dd13af5091ac..e08b2d4e19179 100644
--- a/tests/ui/sse-abi-checks.stderr
+++ b/tests/ui/sse-abi-checks.stderr
@@ -11,3 +11,15 @@ LL | pub unsafe extern "C" fn f(_: SseVector) {
 
 warning: 1 warning emitted
 
+Future incompatibility report: Future breakage diagnostic:
+warning: this function definition uses a SIMD vector type that (with the chosen ABI) requires the `sse` target feature, which is not enabled
+  --> $DIR/sse-abi-checks.rs:21:1
+   |
+LL | pub unsafe extern "C" fn f(_: SseVector) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ function defined here
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116558 <https://github.com/rust-lang/rust/issues/116558>
+   = help: consider enabling it globally (`-C target-feature=+sse`) or locally (`#[target_feature(enable="sse")]`)
+   = note: `#[warn(abi_unsupported_vector_types)]` on by default
+