Rustc pull update

crates/core_arch/src/aarch64/neon/generated.rs

@@ -8793,7 +8793,7 @@ pub fn vfma_n_f64(a: float64x1_t, b: float64x1_t, c: f64) -> float64x1_t {
 pub fn vfmad_lane_f64<const LANE: i32>(a: f64, b: f64, c: float64x1_t) -> f64 {
     static_assert!(LANE == 0);
     let c: f64 = vget_lane_f64::<LANE>(c);
-    fmaf64(b, c, a)
+    fma(b, c, a)
 }
 #[doc = "Floating-point fused multiply-add to accumulator"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmah_f16)"]
@@ -8803,7 +8803,7 @@ pub fn vfmad_lane_f64<const LANE: i32>(a: f64, b: f64, c: float64x1_t) -> f64 {
 #[unstable(feature = "stdarch_neon_f16", issue = "136306")]
 #[cfg(not(target_arch = "arm64ec"))]
 pub fn vfmah_f16(a: f16, b: f16, c: f16) -> f16 {
-    fmaf16(b, c, a)
+    fma(b, c, a)
 }
 #[doc = "Floating-point fused multiply-add to accumulator"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmah_lane_f16)"]
@@ -8874,7 +8874,7 @@ pub fn vfmaq_n_f64(a: float64x2_t, b: float64x2_t, c: f64) -> float64x2_t {
 pub fn vfmas_lane_f32<const LANE: i32>(a: f32, b: f32, c: float32x2_t) -> f32 {
     static_assert_uimm_bits!(LANE, 1);
     let c: f32 = vget_lane_f32::<LANE>(c);
-    fmaf32(b, c, a)
+    fma(b, c, a)
 }
 #[doc = "Floating-point fused multiply-add to accumulator"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmas_laneq_f32)"]
@@ -8886,7 +8886,7 @@ pub fn vfmas_lane_f32<const LANE: i32>(a: f32, b: f32, c: float32x2_t) -> f32 {
 pub fn vfmas_laneq_f32<const LANE: i32>(a: f32, b: f32, c: float32x4_t) -> f32 {
     static_assert_uimm_bits!(LANE, 2);
     let c: f32 = vgetq_lane_f32::<LANE>(c);
-    fmaf32(b, c, a)
+    fma(b, c, a)
 }
 #[doc = "Floating-point fused multiply-add to accumulator"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmad_laneq_f64)"]
@@ -8898,7 +8898,7 @@ pub fn vfmas_laneq_f32<const LANE: i32>(a: f32, b: f32, c: float32x4_t) -> f32 {
 pub fn vfmad_laneq_f64<const LANE: i32>(a: f64, b: f64, c: float64x2_t) -> f64 {
     static_assert_uimm_bits!(LANE, 1);
     let c: f64 = vgetq_lane_f64::<LANE>(c);
-    fmaf64(b, c, a)
+    fma(b, c, a)
 }
 #[doc = "Floating-point fused Multiply-Add Long to accumulator (vector)."]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vfmlal_high_f16)"]
@@ -22160,7 +22160,7 @@ pub fn vrndaq_f64(a: float64x2_t) -> float64x2_t {
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frinta))]
 pub fn vrndah_f16(a: f16) -> f16 {
-    roundf16(a)
+    round(a)
 }
 #[doc = "Floating-point round to integral, to nearest with ties to away"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndh_f16)"]
@@ -22170,7 +22170,7 @@ pub fn vrndah_f16(a: f16) -> f16 {
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintz))]
 pub fn vrndh_f16(a: f16) -> f16 {
-    truncf16(a)
+    trunc(a)
 }
 #[doc = "Floating-point round to integral, using current rounding mode"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndi_f16)"]
@@ -22351,7 +22351,7 @@ pub fn vrndmq_f64(a: float64x2_t) -> float64x2_t {
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintm))]
 pub fn vrndmh_f16(a: f16) -> f16 {
-    floorf16(a)
+    floor(a)
 }
 #[doc = "Floating-point round to integral, to nearest with ties to even"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndn_f64)"]
@@ -22482,7 +22482,7 @@ pub fn vrndpq_f64(a: float64x2_t) -> float64x2_t {
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintp))]
 pub fn vrndph_f16(a: f16) -> f16 {
-    ceilf16(a)
+    ceil(a)
 }
 #[doc = "Floating-point round to integral exact, using current rounding mode"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrndx_f16)"]
@@ -22548,7 +22548,7 @@ pub fn vrndxq_f64(a: float64x2_t) -> float64x2_t {
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(frintx))]
 pub fn vrndxh_f16(a: f16) -> f16 {
-    round_ties_even_f16(a)
+    round_ties_even(a)
 }
 #[doc = "Signed rounding shift left"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vrshld_s64)"]
@@ -24346,7 +24346,7 @@ pub fn vsqrtq_f64(a: float64x2_t) -> float64x2_t {
 #[cfg(not(target_arch = "arm64ec"))]
 #[cfg_attr(test, assert_instr(fsqrt))]
 pub fn vsqrth_f16(a: f16) -> f16 {
-    sqrtf16(a)
+    sqrt(a)
 }
 #[doc = "Shift Right and Insert (immediate)"]
 #[doc = "[Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsri_n_s8)"]

crates/core_arch/src/arm_shared/hints.rs

@@ -17,8 +17,11 @@
 ))]
 #[inline(always)]
 #[unstable(feature = "stdarch_arm_hints", issue = "117218")]
-pub unsafe fn __wfi() {
-    hint(HINT_WFI);
+pub fn __wfi() {
+    // SAFETY: The right HINT_WFI constant is passed to the llvm intrinsic。
+    unsafe {
+        hint(HINT_WFI);
+    }
 }
 
 /// Generates a WFE (wait for event) hint instruction, or nothing.
@@ -36,8 +39,11 @@ pub unsafe fn __wfi() {
 ))]
 #[inline(always)]
 #[unstable(feature = "stdarch_arm_hints", issue = "117218")]
-pub unsafe fn __wfe() {
-    hint(HINT_WFE);
+pub fn __wfe() {
+    // SAFETY: The right HINT_WFE constant is passed to the llvm intrinsic。
+    unsafe {
+        hint(HINT_WFE);
+    }
 }
 
 /// Generates a SEV (send a global event) hint instruction.
@@ -54,8 +60,11 @@ pub unsafe fn __wfe() {
 ))]
 #[inline(always)]
 #[unstable(feature = "stdarch_arm_hints", issue = "117218")]
-pub unsafe fn __sev() {
-    hint(HINT_SEV);
+pub fn __sev() {
+    // SAFETY: The right HINT_SEV constant is passed to the llvm intrinsic。
+    unsafe {
+        hint(HINT_SEV);
+    }
 }
 
 /// Generates a send a local event hint instruction.
@@ -72,8 +81,11 @@ pub unsafe fn __sev() {
 ))]
 #[inline(always)]
 #[unstable(feature = "stdarch_arm_hints", issue = "117218")]
-pub unsafe fn __sevl() {
-    hint(HINT_SEVL);
+pub fn __sevl() {
+    // SAFETY: The right HINT_SEVL constant is passed to the llvm intrinsic。
+    unsafe {
+        hint(HINT_SEVL);
+    }
 }
 
 /// Generates a YIELD hint instruction.
@@ -94,8 +106,11 @@ pub unsafe fn __sevl() {
 ))]
 #[inline(always)]
 #[unstable(feature = "stdarch_arm_hints", issue = "117218")]
-pub unsafe fn __yield() {
-    hint(HINT_YIELD);
+pub fn __yield() {
+    // SAFETY: The right HINT_YIELD constant is passed to the llvm intrinsic。
+    unsafe {
+        hint(HINT_YIELD);
+    }
 }
 
 /// Generates an unspecified no-op instruction.
@@ -106,8 +121,11 @@ pub unsafe fn __yield() {
 /// will increase execution time.
 #[inline(always)]
 #[unstable(feature = "stdarch_arm_hints", issue = "117218")]
-pub unsafe fn __nop() {
-    crate::arch::asm!("nop", options(nomem, nostack, preserves_flags));
+pub fn __nop() {
+    // SAFETY: `nop` performs no operation.
+    unsafe {
+        crate::arch::asm!("nop", options(nomem, nostack, preserves_flags));
+    }
 }
 
 unsafe extern "llvm-intrinsic" {

crates/core_arch/src/lib.rs

@@ -39,7 +39,12 @@
     maybe_uninit_as_bytes,
     movrs_target_feature,
     clflushopt_target_feature,
-    min_adt_const_params
+    min_adt_const_params,
+    num_internals
+)]
+#![cfg_attr(
+    any(target_arch = "powerpc", target_arch = "powerpc64"),
+    feature(powerpc_ppcf128)
 )]
 #![cfg_attr(
     test,
@@ -103,4 +108,4 @@ pub mod arch {
 }
 
 #[allow(unused_imports)]
-use core::{array, cmp, convert, ffi, fmt, hint, intrinsics, marker, mem, ops, ptr, sync};
+use core::{array, cmp, convert, ffi, fmt, hint, intrinsics, marker, mem, num, ops, ptr, sync};

crates/core_arch/src/powerpc/mod.rs

@@ -2,6 +2,47 @@
 
 pub(crate) mod macros;
 
+/// The IBM extended-precision (double-double) floating-point type.
+// FIXME(ppcf128) improve the docs.
+#[doc(alias = "__ibm128")]
+#[doc(alias = "doubledouble")]
+#[doc(alias = "f64f64")]
+#[unstable(feature = "powerpc_ppcf128", issue = "163323")]
+#[allow(non_camel_case_types)]
+#[doc(cfg(any(target_arch = "powerpc", target_arch = "powerpc64")))]
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+pub struct ppcf128(crate::num::imp::ppcf128::ppcf128);
+
+#[unstable(feature = "powerpc_ppcf128", issue = "163323")]
+impl crate::fmt::Debug for ppcf128 {
+    fn fmt(&self, f: &mut crate::fmt::Formatter<'_>) -> crate::fmt::Result {
+        let (hi, lo) = self.to_components();
+        write!(f, "ppcf128({hi:?}, {lo:?})")
+    }
+}
+
+impl ppcf128 {
+    /// Returns the memory representation of this floating point number as a byte array in
+    /// native byte order.
+    #[unstable(feature = "powerpc_ppcf128", issue = "163323")]
+    #[inline]
+    pub const fn to_ne_bytes(self) -> [u8; 16] {
+        // SAFETY: every bit pattern of a `ppcf128` is a valid `[u8; 16]`.
+        unsafe { crate::mem::transmute::<ppcf128, [u8; 16]>(self) }
+    }
+
+    /// Returns the large and small component of this floating point number.
+    #[unstable(feature = "powerpc_ppcf128", issue = "163323")]
+    #[rustc_const_unstable(feature = "powerpc_ppcf128", issue = "163323")]
+    #[inline]
+    pub const fn to_components(self) -> (f64, f64) {
+        // SAFETY: every bit pattern of a `ppcf128` is a valid `[f64; 2]`.
+        let [large, small] = unsafe { crate::mem::transmute::<ppcf128, [f64; 2]>(self) };
+        (large, small)
+    }
+}
+
 mod altivec;
 #[unstable(feature = "stdarch_powerpc", issue = "111145")]
 pub use self::altivec::*;

crates/core_arch/src/wasm32/mod.rs

@@ -43,7 +43,7 @@ pub fn unreachable() -> ! {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f32_ceil(a: f32) -> f32 {
-    crate::intrinsics::ceilf32(a)
+    crate::intrinsics::ceil(a)
 }
 
 /// Generates the [`f32.floor`] instruction, returning the largest integer less than or equal to `a`.
@@ -57,7 +57,7 @@ pub fn f32_ceil(a: f32) -> f32 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f32_floor(a: f32) -> f32 {
-    crate::intrinsics::floorf32(a)
+    crate::intrinsics::floor(a)
 }
 
 /// Generates the [`f32.trunc`] instruction, roundinging to the nearest integer towards zero.
@@ -71,7 +71,7 @@ pub fn f32_floor(a: f32) -> f32 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f32_trunc(a: f32) -> f32 {
-    crate::intrinsics::truncf32(a)
+    crate::intrinsics::trunc(a)
 }
 
 /// Generates the [`f32.nearest`] instruction, roundinging to the nearest integer. Rounds half-way
@@ -86,7 +86,7 @@ pub fn f32_trunc(a: f32) -> f32 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f32_nearest(a: f32) -> f32 {
-    crate::intrinsics::round_ties_even_f32(a)
+    crate::intrinsics::round_ties_even(a)
 }
 
 /// Generates the [`f32.sqrt`] instruction, returning the square root of the number `a`.
@@ -100,7 +100,7 @@ pub fn f32_nearest(a: f32) -> f32 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f32_sqrt(a: f32) -> f32 {
-    crate::intrinsics::sqrtf32(a)
+    crate::intrinsics::sqrt(a)
 }
 
 /// Generates the [`f64.ceil`] instruction, returning the smallest integer greater than or equal to `a`.
@@ -114,7 +114,7 @@ pub fn f32_sqrt(a: f32) -> f32 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f64_ceil(a: f64) -> f64 {
-    crate::intrinsics::ceilf64(a)
+    crate::intrinsics::ceil(a)
 }
 
 /// Generates the [`f64.floor`] instruction, returning the largest integer less than or equal to `a`.
@@ -128,7 +128,7 @@ pub fn f64_ceil(a: f64) -> f64 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f64_floor(a: f64) -> f64 {
-    crate::intrinsics::floorf64(a)
+    crate::intrinsics::floor(a)
 }
 
 /// Generates the [`f64.trunc`] instruction, roundinging to the nearest integer towards zero.
@@ -142,7 +142,7 @@ pub fn f64_floor(a: f64) -> f64 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f64_trunc(a: f64) -> f64 {
-    crate::intrinsics::truncf64(a)
+    crate::intrinsics::trunc(a)
 }
 
 /// Generates the [`f64.nearest`] instruction, roundinging to the nearest integer. Rounds half-way
@@ -157,7 +157,7 @@ pub fn f64_trunc(a: f64) -> f64 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f64_nearest(a: f64) -> f64 {
-    crate::intrinsics::round_ties_even_f64(a)
+    crate::intrinsics::round_ties_even(a)
 }
 
 /// Generates the [`f64.sqrt`] instruction, returning the square root of the number `a`.
@@ -171,5 +171,5 @@ pub fn f64_nearest(a: f64) -> f64 {
 #[must_use = "method returns a new number and does not mutate the original value"]
 #[unstable(feature = "wasm_numeric_instr", issue = "133908")]
 pub fn f64_sqrt(a: f64) -> f64 {
-    crate::intrinsics::sqrtf64(a)
+    crate::intrinsics::sqrt(a)
 }