Rustc pull update

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,8 @@
     maybe_uninit_as_bytes,
     movrs_target_feature,
     clflushopt_target_feature,
-    min_adt_const_params
+    min_adt_const_params,
+    lang_items
 )]
 #![cfg_attr(
     test,

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.
+#[lang = "ppcf128"]
+#[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)]
+pub struct ppcf128(u128);
+
+#[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/stdarch-gen-loongarch/src/main.rs

@@ -151,8 +151,8 @@ fn gen_spec(in_file: String, ext_name: &str) -> io::Result<()> {
     Ok(())
 }
 
-fn gen_bind(in_file: &str, ext_name: &str, out_path: &Path) -> io::Result<()> {
-    let f = File::open(in_file).unwrap_or_else(|_| panic!("Failed to open {in_file}"));
+fn gen_bind(path: &Path, filename: &str, ext_name: &str, out_path: &Path) -> io::Result<()> {
+    let f = File::open(path).unwrap_or_else(|_| panic!("Failed to open {path:?}"));
     let f = BufReader::new(f);
 
     let target: TargetFeature = TargetFeature::new(ext_name);
@@ -167,15 +167,15 @@ fn gen_bind(in_file: &str, ext_name: &str, out_path: &Path) -> io::Result<()> {
     out.push_str(&format!(
         r#"// This code is automatically generated. DO NOT MODIFY.
 //
-// Instead, modify `{in_file}` and run the following command to re-generate this file:
+// Instead, modify `crates/stdarch-gen-loongarch/{filename}` and run the following command to re-generate this file:
 //
 // ```
-// OUT_DIR=`pwd`/crates/core_arch cargo run -p stdarch-gen-loongarch -- {in_file}
+// OUT_DIR=`pwd`/crates/core_arch cargo run -p stdarch-gen-loongarch -- crates/stdarch-gen-loongarch/{filename}
 // ```
 
 use crate::mem::transmute;
 use super::super::*;
-"#
+"#,
     ));
 
     out.push_str(
@@ -1631,10 +1631,11 @@ pub fn main() -> Result<(), String> {
     let arguments = &args.arguments;
     if arguments.len() == 1 && (arguments[0] == "lsx" || arguments[0] == "lasx") {
         let extension = arguments[0].as_str();
-        let spec_rel = format!("crates/stdarch-gen-loongarch/{extension}.spec");
+        let filename = format!("{extension}.spec");
+        let path = crate_dir.join(&filename);
         let committed = core_arch_src.join("loongarch64").join(extension);
         run_generator(&ctx, &committed, mode, |out_dir| {
-            gen_bind(&spec_rel, extension, out_dir)
+            gen_bind(&path, &filename, extension, out_dir)
         })
         .map_err(|e| e.to_string())?;
     } else {
@@ -1660,7 +1661,8 @@ pub fn main() -> Result<(), String> {
             .join("src")
             .join("loongarch64")
             .join(ext_name);
-        gen_bind(&in_file, ext_name, &out_path).map_err(|e| e.to_string())?;
+        gen_bind(Path::new(&in_file), &in_file_name, ext_name, &out_path)
+            .map_err(|e| e.to_string())?;
     }
     Ok(())
 }

rust-version

@@ -1 +1 @@
-260f1acad9d7f70b5b56a636a9dc5a7f76150417
+03cbd412d98691c83227b65eddadb7b01db4a190