[experiment] bootstrap: leverage cargo trim-paths

[weihanglo]

View all comments

What

Leverage Cargo's -Ztrim-paths to remap compiler and library. See rust-lang/cargo#17309.

I'll do some dist jobs and see if artifacts are remapped correctly.

try-jobs: dist-x86_64-msvc
try-jobs: dist-x86_64-linux
try-jobs: dist-aarch64-apple

🤖 LLM disclosure: I used LLM to do the first pass of bootstrap integration and temporary stage0 bump. The usage was signed off here on Zulip: #llm-reviews > Experiment with Cargo's trim-path in bootstrap

[weihanglo]

@bors try

[weihanglo]

@bors try cancel

[rust-bors]

Try build cancelled. Cancelled workflows:

• https://github.com/rust-lang/rust/actions/runs/31703558440

[weihanglo]

@bors try jobs=dist-x86_64-msvc,dist-x86_64-linux,dist-aarch64-apple

[rust-bors]

💔 Test for bd743b7 failed: CI. Failed jobs:

• try - dist-aarch64-apple (web logs, enhanced plaintext logs)
• try - dist-x86_64-linux (web logs, enhanced plaintext logs)
• try - dist-x86_64-msvc (web logs, enhanced plaintext logs)

[weihanglo]

@bors try jobs=dist-x86_64-msvc,dist-x86_64-linux,dist-aarch64-apple

[rust-bors]

☀️ Try build successful (CI)
Build commit: 67c6105 (67c6105718f0714463e9014eca86d60e96ba0b12)
Base parent: ba28ff7 (ba28ff76f353a722f31c4f3dd2ac4e437d36411b)

[weihanglo]

@bors try jobs=dist-x86_64-msvc,dist-x86_64-linux,dist-aarch64-apple

[rust-log-analyzer]

The job tidy failed! Check out the build log: (web) (plain enhanced) (plain)

Click to see the possible cause of the failure (guessed by this bot)

#14 3.221 Building wheels for collected packages: reuse
#14 3.222   Building wheel for reuse (pyproject.toml): started
#14 3.436   Building wheel for reuse (pyproject.toml): finished with status 'done'
#14 3.438   Created wheel for reuse: filename=reuse-4.0.3-cp310-cp310-manylinux_2_35_x86_64.whl size=132857 sha256=6a78a69541e3df9c7c106367722bab90241125ee6b7cdb81c5e40637268f85a9
#14 3.438   Stored in directory: /tmp/pip-ephem-wheel-cache-3lxn_g7q/wheels/3d/8d/0a/e0fc6aba4494b28a967ab5eaf951c121d9c677958714e34532
#14 3.441 Successfully built reuse
#14 3.441 Installing collected packages: boolean-py, binaryornot, tomlkit, reuse, python-debian, markupsafe, license-expression, jinja2, chardet, attrs
#14 3.834 Successfully installed attrs-23.2.0 binaryornot-0.4.4 boolean-py-4.0 chardet-5.2.0 jinja2-3.1.4 license-expression-30.3.0 markupsafe-2.1.5 python-debian-0.1.49 reuse-4.0.3 tomlkit-0.13.0
#14 3.834 WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
#14 4.389 Collecting virtualenv
---
[TIMING:end] format::InternalRustfmt {  } -- 13.740
Diff in /checkout/tests/run-make/remap-path-prefix-std/rmake.rs:102:
     }
 
     // `-Zembed-metadata=no` creates separate rmeta that may leak absolute paths
-    let all_rmetas = shallow_find_files(&target_libdir, |p| {
-        p.extension().is_some_and(|ext| ext == "rmeta")
-    });
+    let all_rmetas =
+        shallow_find_files(&target_libdir, |p| p.extension().is_some_and(|ext| ext == "rmeta"));
     assert!(!all_rmetas.is_empty(), "no rmeta files found in target libdir {target_libdir:?}");
 
     for rmeta in &all_rmetas {
Diff in /checkout/compiler/rustc_codegen_gcc/src/context.rs:495:
         let entry_name = self.sess().target.entry_name.as_ref();
         if !self.functions.borrow().contains_key(entry_name) {
             let conv = cfg_select! {
-                feature = "master" => conv_to_fn_attribute(self.sess(), self.sess().target.entry_abi),
+                feature = "master" => {
+                    conv_to_fn_attribute(self.sess(), self.sess().target.entry_abi)
+                }
                 _ => None,
             };
             Some(self.declare_entry_fn(entry_name, fn_type, conv))
Diff in /checkout/library/panic_unwind/src/seh.rs:290:
     }
 }
 cfg_select! {
-   target_arch = "x86" => {
-       define_cleanup!("thiscall" "thiscall-unwind");
-   }
-   _ => {
-       define_cleanup!("C" "C-unwind");
-   }
+    target_arch = "x86" => {
+        define_cleanup!("thiscall" "thiscall-unwind");
+    }
+    _ => {
+        define_cleanup!("C" "C-unwind");
+    }
 }
 
 pub(crate) unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
Diff in /checkout/library/std_detect/src/detect/cache.rs:121:
                     use alloc::vec;
                     #[link(name = "kernel32")]
                     unsafe extern "system" {
-                        fn GetEnvironmentVariableA(name: *const u8, buffer: *mut u8, size: u32) -> u32;
+                        fn GetEnvironmentVariableA(
+                            name: *const u8,
+                            buffer: *mut u8,
+                            size: u32,
+                        ) -> u32;
                     }
-                    let len = unsafe { GetEnvironmentVariableA(RUST_STD_DETECT_UNSTABLE.as_ptr().cast::<u8>(), core::ptr::null_mut(), 0) };
+                    let len = unsafe {
+                        GetEnvironmentVariableA(
+                            RUST_STD_DETECT_UNSTABLE.as_ptr().cast::<u8>(),
+                            core::ptr::null_mut(),
+                            0,
+                        )
+                    };
                     if len > 0 {
                         // +1 to include the null terminator.
                         let mut env = vec![0; len as usize + 1];
Diff in /checkout/library/std_detect/src/detect/cache.rs:130:
-                        let len = unsafe { GetEnvironmentVariableA(RUST_STD_DETECT_UNSTABLE.as_ptr().cast::<u8>(), env.as_mut_ptr(), len + 1) };
+                        let len = unsafe {
+                            GetEnvironmentVariableA(
+                                RUST_STD_DETECT_UNSTABLE.as_ptr().cast::<u8>(),
+                                env.as_mut_ptr(),
+                                len + 1,
+                            )
+                        };
                         if len > 0 {
                             disable_features(&env[..len as usize], &mut value);
                         }
Diff in /checkout/library/std_detect/src/detect/cache.rs:134:
                     }
                 }
                 _ => {
-                    let env = unsafe {
-                        libc::getenv(RUST_STD_DETECT_UNSTABLE.as_ptr())
-                    };
+                    let env = unsafe { libc::getenv(RUST_STD_DETECT_UNSTABLE.as_ptr()) };
                     if !env.is_null() {
                         let len = unsafe { libc::strlen(env) };
                         let env = unsafe { core::slice::from_raw_parts(env as *const u8, len) };
Diff in /checkout/library/std_detect/src/detect/arch/mod.rs:67:
         // Unimplemented architecture:
         #[doc(hidden)]
         pub(crate) enum Feature {
-            Null
---
Diff in /checkout/library/std_detect/src/detect/arch/mod.rs:75:
 
         impl Feature {
             #[doc(hidden)]
-            pub(crate) fn from_str(_s: &str) -> Result<Feature, ()> { Err(()) }
+            pub(crate) fn from_str(_s: &str) -> Result<Feature, ()> {
+                Err(())
+            }
             #[doc(hidden)]
-            pub(crate) fn to_str(self) -> &'static str { "" }
+            pub(crate) fn to_str(self) -> &'static str {
---
 }
Diff in /checkout/library/std_detect/src/detect/os/linux/auxvec/tests.rs:47:
         // files on disk, so we need to embed them with `include_bytes!`.
         #[test]
         fn linux_rpi3() {
-            let auxv = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-rpi3.auxv"));
+            let auxv = include_bytes!(concat!(
+                env!("CARGO_MANIFEST_DIR"),
+                "/src/detect/test_data/linux-rpi3.auxv"
+            ));
             let v = auxv_from_file_bytes(auxv).unwrap();
             assert_eq!(v.hwcap, 4174038);
             assert_eq!(v.hwcap2, 16);
Diff in /checkout/library/std_detect/src/detect/os/linux/auxvec/tests.rs:55:
 
         #[test]
         fn linux_macos_vb() {
-            let auxv = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv"));
+            let auxv = include_bytes!(concat!(
+                env!("CARGO_MANIFEST_DIR"),
+                "/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv"
+            ));
             // The file contains HWCAP but not HWCAP2. In that case, we treat HWCAP2 as zero.
             let v = auxv_from_file_bytes(auxv).unwrap();
             assert_eq!(v.hwcap, 126614527);
Diff in /checkout/library/std_detect/src/detect/os/linux/auxvec/tests.rs:66:
         #[cfg(target_endian = "little")]
         #[test]
         fn linux_artificial_aarch64() {
-            let auxv = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-artificial-aarch64.auxv"));
+            let auxv = include_bytes!(concat!(
+                env!("CARGO_MANIFEST_DIR"),
+                "/src/detect/test_data/linux-artificial-aarch64.auxv"
+            ));
             let v = auxv_from_file_bytes(auxv).unwrap();
             assert_eq!(v.hwcap, 0x0123456789abcdef);
             assert_eq!(v.hwcap2, 0x02468ace13579bdf);
Diff in /checkout/library/std_detect/src/detect/os/linux/auxvec/tests.rs:74:
         #[cfg(target_endian = "little")]
         #[test]
         fn linux_no_hwcap2_aarch64() {
-            let auxv = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv"));
+            let auxv = include_bytes!(concat!(
+                env!("CARGO_MANIFEST_DIR"),
+                "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv"
+            ));
             let v = auxv_from_file_bytes(auxv).unwrap();
             // An absent HWCAP2 is treated as zero, and does not prevent acceptance of HWCAP.
             assert_ne!(v.hwcap, 0);
Diff in /checkout/library/std/src/sys/exit.rs:34:
             // async-signal-safe, so this function is available in all imaginable
             // circumstances.
             let this_thread_id = crate::sys::io::errno_location();
-            match EXITING_THREAD_ID.compare_exchange(ptr::null_mut(), this_thread_id, Acquire, Relaxed) {
+            match EXITING_THREAD_ID.compare_exchange(
+                ptr::null_mut(),
+                this_thread_id,
+                Acquire,
+                Relaxed,
---
 cfg_select! {
-    any(
-        target_family = "unix",
-        target_os = "wasi",
-    ) => {
+    any(target_family = "unix", target_os = "wasi",) => {
         // Used by rustc for checking the definitions of other function with the same symbol names
         //
         // See the `invalid_runtime_symbols_definitions` lint.
Diff in /checkout/library/std/src/sys/exit.rs:89:
 
---
-                unique_thread_exit();
-                libc::exit(code)
-            }
-        }
-        target_os = "motor" => {
-            moto_rt::process::exit(code)
-        }
+        target_os = "hermit" => unsafe { hermit_abi::exit(code) },
+        target_os = "linux" => unsafe {
+            unique_thread_exit();
+            libc::exit(code)
+        },
+        target_os = "motor" => moto_rt::process::exit(code),
         all(target_vendor = "fortanix", target_env = "sgx") => {
             crate::sys::pal::abi::exit_with_code(code as _)
         }
Diff in /checkout/library/std/src/sys/exit.rs:131:
             }
             crate::intrinsics::abort()
         }
-        any(
-            target_family = "unix",
-            target_os = "wasi",
-        ) => {
-            unsafe { libc::exit(code as crate::ffi::c_int) }
-        }
+        any(target_family = "unix", target_os = "wasi",) => unsafe {
+            libc::exit(code as crate::ffi::c_int)
+        },
         target_os = "vexos" => {
             let _ = code;
 
Diff in /checkout/library/std/src/sys/exit.rs:148:
                 }
             }
         }
-        target_os = "windows" => {
-            unsafe { crate::sys::pal::c::ExitProcess(code as u32) }
-        }
-        target_os = "xous" => {
-            crate::os::xous::ffi::exit(code as u32)
-        }
+        target_os = "windows" => unsafe { crate::sys::pal::c::ExitProcess(code as u32) },
+        target_os = "xous" => crate::os::xous::ffi::exit(code as u32),
         _ => {
             let _ = code;
             crate::intrinsics::abort()
Diff in /checkout/library/std/src/sync/reentrant_lock.rs:87:
 
 cfg_select!(
     target_has_atomic = "64" => {
-        use crate::sync::atomic::{Atomic, AtomicU64, Ordering::Relaxed};
+        use crate::sync::atomic::Ordering::Relaxed;
+        use crate::sync::atomic::{Atomic, AtomicU64};
 
         struct Tid(Atomic<u64>);
 
Diff in /checkout/library/std/src/sync/reentrant_lock.rs:118:
             X.with(|p| <*const u8>::addr(p))
         }
 
-        use crate::sync::atomic::{
-            Atomic,
-            AtomicUsize,
-            Ordering,
-        };
+        use crate::sync::atomic::{Atomic, AtomicUsize, Ordering};
 
         struct Tid {
             // When a thread calls `set()`, this value gets updated to
Diff in /checkout/library/std/src/sys/fs/unix.rs:337:
                     // fallback to procfs as last resort
                     let mut p = PathBuf::from("/proc/self/fd");
                     p.push(&fd.to_string());
-                    return run_path_with_cstr(&p, &readlink).ok()
+                    return run_path_with_cstr(&p, &readlink).ok();
                 }
                 _ => {
                     return None;
Diff in /checkout/library/std/src/sys/fs/unix.rs:832:
 
                         let mut entry = MaybeUninit::uninit();
                         let mut entry_ptr: *mut dirent64 = ptr::null_mut();
-                        let err = libc::readdir_r(self.inner.dirp.0, entry.as_mut_ptr(), &mut entry_ptr);
+                        let err =
+                            libc::readdir_r(self.inner.dirp.0, entry.as_mut_ptr(), &mut entry_ptr);
                         if err != 0 {
                             if entry_ptr.is_null() {
                                 // We encountered an error (which will be returned in this iteration), but
Diff in /checkout/library/std/src/sys/fs/unix.rs:862:
                             target_os = "l4re"
                         ))]
                         use libc::readdir64;
+
                         use crate::sys::io::{errno, set_errno};
 
                         set_errno(0);
Diff in /checkout/library/std/src/sys/fs/unix.rs:1336:
                 cvt(unsafe { libc::flock(self.as_raw_fd(), libc::LOCK_EX) })?;
                 Ok(())
             }
-            _ => {
-                Err(io::const_error!(io::ErrorKind::Unsupported, "lock() not supported"))
-            }
+            _ => Err(io::const_error!(io::ErrorKind::Unsupported, "lock() not supported")),
         }
     }
 
Diff in /checkout/library/std/src/sys/fs/unix.rs:1360:
                 cvt(unsafe { libc::flock(self.as_raw_fd(), libc::LOCK_SH) })?;
                 Ok(())
             }
-            _ => {
-                Err(io::const_error!(io::ErrorKind::Unsupported, "lock_shared() not supported"))
-            }
+            _ => Err(io::const_error!(io::ErrorKind::Unsupported, "lock_shared() not supported")),
         }
     }
 
Diff in /checkout/library/std/src/sys/fs/unix.rs:1381:
                 target_os = "android",
                 target_vendor = "apple",
             ) => {
-                let result = cvt(unsafe { libc::flock(self.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) });
+                let result =
+                    cvt(unsafe { libc::flock(self.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) });
                 if let Err(err) = result {
                     if err.kind() == io::ErrorKind::WouldBlock {
                         Err(TryLockError::WouldBlock)
Diff in /checkout/library/std/src/sys/fs/unix.rs:1392:
                     Ok(())
                 }
             }
-            _ => {
---
                 target_os = "hurd",
Diff in /checkout/library/std/src/sys/fs/unix.rs:1416:
                 target_os = "android",
                 target_vendor = "apple",
             ) => {
-                let result = cvt(unsafe { libc::flock(self.as_raw_fd(), libc::LOCK_SH | libc::LOCK_NB) });
+                let result =
+                    cvt(unsafe { libc::flock(self.as_raw_fd(), libc::LOCK_SH | libc::LOCK_NB) });
                 if let Err(err) = result {
                     if err.kind() == io::ErrorKind::WouldBlock {
                         Err(TryLockError::WouldBlock)
Diff in /checkout/library/std/src/sys/fs/unix.rs:1427:
                     Ok(())
                 }
             }
-            _ => {
---
         }
     }
 
Diff in /checkout/library/std/src/sys/fs/unix.rs:1454:
                 cvt(unsafe { libc::flock(self.as_raw_fd(), libc::LOCK_UN) })?;
                 Ok(())
             }
-            _ => {
-                Err(io::const_error!(io::ErrorKind::Unsupported, "unlock() not supported"))
-            }
+            _ => Err(io::const_error!(io::ErrorKind::Unsupported, "unlock() not supported")),
         }
     }
 
Diff in /checkout/library/std/src/sys/fs/unix.rs:1557:
 
     pub fn set_times(&self, times: FileTimes) -> io::Result<()> {
         cfg_select! {
-            any(target_os = "redox", target_os = "espidf", target_os = "horizon", target_os = "nuttx", target_os = "l4re") => {
+            any(
+                target_os = "redox",
+                target_os = "espidf",
+                target_os = "horizon",
+                target_os = "nuttx",
+                target_os = "l4re"
+            ) => {
                 // Redox doesn't appear to support `UTIME_OMIT`.
                 // ESP-IDF and HorizonOS do not support `futimens` at all and the behavior for those OS is therefore
                 // the same as for Redox.
Diff in /checkout/library/std/src/sys/fs/unix.rs:1569:
             }
             target_vendor = "apple" => {
                 let ta = TimesAttrlist::from_times(&times)?;
-                cvt(unsafe { libc::fsetattrlist(
-                    self.as_raw_fd(),
-                    ta.attrlist(),
-                    ta.times_buf(),
-                    ta.times_buf_size(),
-                    0
-                ) })?;
+                cvt(unsafe {
+                    libc::fsetattrlist(
+                        self.as_raw_fd(),
+                        ta.attrlist(),
+                        ta.times_buf(),
+                        ta.times_buf_size(),
+                        0,
+                    )
+                })?;
                 Ok(())
             }
             target_os = "android" => {
Diff in /checkout/library/std/src/sys/fs/unix.rs:1582:
-                let times = [file_time_to_timespec(times.accessed)?, file_time_to_timespec(times.modified)?];
+                let times = [
+                    file_time_to_timespec(times.accessed)?,
+                    file_time_to_timespec(times.modified)?,
+                ];
                 // futimens requires Android API level 19
                 cvt(unsafe {
                     weak!(
Diff in /checkout/library/std/src/sys/fs/unix.rs:1587:
                     );
                     match futimens.get() {
                         Some(futimens) => futimens(self.as_raw_fd(), times.as_ptr()),
-                        None => return Err(io::const_error!(
-                            io::ErrorKind::Unsupported,
-                            "setting file times requires Android API level >= 19",
-                        )),
+                        None => {
---
                 Ok(())
Diff in /checkout/library/std/src/sys/fs/unix.rs:1597:
             }
             _ => {
-                #[cfg(all(target_os = "linux", target_env = "gnu", target_pointer_width = "32", not(target_arch = "riscv32")))]
+                #[cfg(all(
+                    target_os = "linux",
+                    target_env = "gnu",
+                    target_pointer_width = "32",
+                    not(target_arch = "riscv32")
---
                     weak!(
Diff in /checkout/library/std/src/sys/fs/unix.rs:1606:
                     );
 
                     if let Some(futimens64) = __futimens64.get() {
-                        let to_timespec = |time: Option<SystemTime>| time.map(|time| time.t.to_timespec64())
-                            .unwrap_or(__timespec64::new(0, libc::UTIME_OMIT as _));
+                        let to_timespec = |time: Option<SystemTime>| {
+                            time.map(|time| time.t.to_timespec64())
+                                .unwrap_or(__timespec64::new(0, libc::UTIME_OMIT as _))
+                        };
                         let times = [to_timespec(times.accessed), to_timespec(times.modified)];
                         cvt(unsafe { futimens64(self.as_raw_fd(), times.as_ptr()) })?;
                         return Ok(());
Diff in /checkout/library/std/src/sys/fs/unix.rs:1614:
                     }
                 }
-                let times = [file_time_to_timespec(times.accessed)?, file_time_to_timespec(times.modified)?];
+                let times = [
+                    file_time_to_timespec(times.accessed)?,
+                    file_time_to_timespec(times.modified)?,
+                ];
                 cvt(unsafe { libc::futimens(self.as_raw_fd(), times.as_ptr()) })?;
                 Ok(())
             }
Diff in /checkout/library/std/src/sys/fs/unix.rs:1873:
         // wasm32-wasip1 targets do not support fchmodat, so we fall down to
         // open + fchmod
---
             use crate::os::wasi::ffi::OsStrExt;
             use crate::os::wasi::fs::OpenOptionsExt;
 
Diff in /checkout/library/std/src/sys/fs/unix.rs:1890:
                 libc::fchmodat(libc::AT_FDCWD, p.as_ptr(), perm.mode, libc::AT_SYMLINK_NOFOLLOW)
             })
             .map(|_| ())
-        },
-        _ => {
-            cvt_r(|| unsafe {
-                libc::fchmodat(libc::AT_FDCWD, p.as_ptr(), perm.mode, 0)
-            })
-            .map(|_| ())
         }
+        _ => cvt_r(|| unsafe { libc::fchmodat(libc::AT_FDCWD, p.as_ptr(), perm.mode, 0) }).map(|_| ()),
     }
 }
 
Diff in /checkout/library/std/src/sys/fs/unix.rs:1955:
         _ => {
             // Where we can, use `linkat` instead of `link`; see the comment above
             // this one for details on why.
-            cvt(unsafe { libc::linkat(libc::AT_FDCWD, original.as_ptr(), libc::AT_FDCWD, link.as_ptr(), 0) })?;
+            cvt(unsafe {
+                libc::linkat(libc::AT_FDCWD, original.as_ptr(), libc::AT_FDCWD, link.as_ptr(), 0)
+            })?;
         }
     }
     Ok(())
Diff in /checkout/library/std/src/sys/fs/unix.rs:2021:
 
 fn set_times_impl(p: &CStr, times: FileTimes, follow_symlinks: bool) -> io::Result<()> {
     cfg_select! {
-       any(target_os = "redox", target_os = "espidf", target_os = "horizon", target_os = "nuttx", target_os = "vita", target_os = "rtems") => {
+        any(
+            target_os = "redox",
+            target_os = "espidf",
+            target_os = "horizon",
+            target_os = "nuttx",
---
-                io::ErrorKind::Unsupported,
-                "setting file times not supported",
-            ))
-       }
-       target_vendor = "apple" => {
+            Err(io::const_error!(io::ErrorKind::Unsupported, "setting file times not supported",))
+        }
+        target_vendor = "apple" => {
             // Apple platforms use setattrlist which supports setting times on symlinks
             let ta = TimesAttrlist::from_times(&times)?;
-            let options = if follow_symlinks {
-                0
-            } else {
-                libc::FSOPT_NOFOLLOW
-            };
+            let options = if follow_symlinks { 0 } else { libc::FSOPT_NOFOLLOW };
 
-            cvt(unsafe { libc::setattrlist(
-                p.as_ptr(),
-                ta.attrlist(),
-                ta.times_buf(),
-                ta.times_buf_size(),
-                options as u32
-            ) })?;
+            cvt(unsafe {
+                libc::setattrlist(
+                    p.as_ptr(),
+                    ta.attrlist(),
+                    ta.times_buf(),
+                    ta.times_buf_size(),
+                    options as u32,
+                )
+            })?;
             Ok(())
-       }
-       target_os = "android" => {
-            let times = [file_time_to_timespec(times.accessed)?, file_time_to_timespec(times.modified)?];
+        }
+        target_os = "android" => {
+            let times =
+                [file_time_to_timespec(times.accessed)?, file_time_to_timespec(times.modified)?];
             let flags = if follow_symlinks { 0 } else { libc::AT_SYMLINK_NOFOLLOW };
             // utimensat requires Android API level 19
             cvt(unsafe {
Diff in /checkout/library/std/src/sys/fs/unix.rs:2054:
                 weak!(
-                    fn utimensat(dirfd: c_int, path: *const libc::c_char, times: *const libc::timespec, flags: c_int) -> c_int;
+                    fn utimensat(
+                        dirfd: c_int,
+                        path: *const libc::c_char,
+                        times: *const libc::timespec,
+                        flags: c_int,
+                    ) -> c_int;
                 );
                 match utimensat.get() {
                     Some(utimensat) => utimensat(libc::AT_FDCWD, p.as_ptr(), times.as_ptr(), flags),
Diff in /checkout/library/std/src/sys/fs/unix.rs:2059:
-                    None => return Err(io::const_error!(
-                        io::ErrorKind::Unsupported,
-                        "setting file times requires Android API level >= 19",
-                    )),
---
-       }
-       _ => {
+        }
+        _ => {
             let flags = if follow_symlinks { 0 } else { libc::AT_SYMLINK_NOFOLLOW };
-            #[cfg(all(target_os = "linux", target_env = "gnu", target_pointer_width = "32", not(target_arch = "riscv32")))]
+            #[cfg(all(
+                target_os = "linux",
+                target_env = "gnu",
+                target_pointer_width = "32",
+                not(target_arch = "riscv32")
---
 
                 // Added in glibc 2.34
                 weak!(
Diff in /checkout/library/std/src/sys/fs/unix.rs:2075:
-                    fn __utimensat64(dirfd: c_int, path: *const c_char, times: *const __timespec64, flags: c_int) -> c_int;
+                    fn __utimensat64(
+                        dirfd: c_int,
+                        path: *const c_char,
+                        times: *const __timespec64,
+                        flags: c_int,
+                    ) -> c_int;
                 );
 
                 if let Some(utimensat64) = __utimensat64.get() {
Diff in /checkout/library/std/src/sys/fs/unix.rs:2079:
-                    let to_timespec = |time: Option<SystemTime>| time.map(|time| time.t.to_timespec64())
-                        .unwrap_or(__timespec64::new(0, libc::UTIME_OMIT as _));
+                    let to_timespec = |time: Option<SystemTime>| {
+                        time.map(|time| time.t.to_timespec64())
+                            .unwrap_or(__timespec64::new(0, libc::UTIME_OMIT as _))
+                    };
                     let times = [to_timespec(times.accessed), to_timespec(times.modified)];
                     cvt(unsafe { utimensat64(libc::AT_FDCWD, p.as_ptr(), times.as_ptr(), flags) })?;
                     return Ok(());
Diff in /checkout/library/std/src/sys/fs/unix.rs:2084:
                 }
             }
-            let times = [file_time_to_timespec(times.accessed)?, file_time_to_timespec(times.modified)?];
+            let times =
+                [file_time_to_timespec(times.accessed)?, file_time_to_timespec(times.modified)?];
             cvt(unsafe { libc::utimensat(libc::AT_FDCWD, p.as_ptr(), times.as_ptr(), flags) })?;
             Ok(())
-         }
+        }
     }
 }
 
Diff in /checkout/library/std/src/sys/fs/unix/dir.rs:1:
 use libc::{c_int, renameat, unlinkat};
 
 cfg_select! {
-    not(
-        any(
-            all(target_os = "linux", not(target_env = "musl")),
-            target_os = "l4re",
-            target_os = "android",
-            target_os = "hurd",
-        )
-    ) => {
+    not(any(
+        all(target_os = "linux", not(target_env = "musl")),
+        target_os = "l4re",
+        target_os = "android",
+        target_os = "hurd",
+    )) => {
         use libc::{open as open64, openat as openat64};
     }
     _ => {
Diff in /checkout/library/std/src/sys/pal/unix/mod.rs:302:
 
 cfg_select! {
     target_os = "android" => {
-        #[link(name = "dl", kind = "static", modifiers = "-bundle",
-            cfg(target_feature = "crt-static"))]
+        #[link(
+            name = "dl",
+            kind = "static",
+            modifiers = "-bundle",
+            cfg(target_feature = "crt-static")
+        )]
         #[link(name = "dl", cfg(not(target_feature = "crt-static")))]
         #[link(name = "log", cfg(not(target_feature = "crt-static")))]
         unsafe extern "C" {}
Diff in /checkout/library/std/src/sys/fs/mod.rs:9:
     any(target_family = "unix", target_os = "wasi") => {
         mod unix;
         use unix as imp;
-        #[cfg(not(target_os = "wasi"))]
-        pub use unix::{chown, fchown, lchown, mkfifo};
Diff in /checkout/library/std/src/thread/main_thread.rs:14:
 cfg_select! {
     target_has_atomic = "64" => {
         use super::id::ThreadId;
-        use crate::sync::atomic::{Atomic, AtomicU64};
---
-        use crate::sync::atomic::{Atomic, AtomicBool};
         use crate::sync::atomic::Ordering::{Acquire, Release};
+        use crate::sync::atomic::{Atomic, AtomicBool};
 
         static INIT: Atomic<bool> = AtomicBool::new(false);
         static mut MAIN: MaybeUninit<ThreadId> = MaybeUninit::uninit();
Diff in /checkout/library/std/src/thread/main_thread.rs:40:
 
         pub(super) fn get() -> Option<ThreadId> {
-            if INIT.load(Acquire) {
-                Some(unsafe { MAIN.assume_init() })
-            } else {
-                None
-            }
+            if INIT.load(Acquire) { Some(unsafe { MAIN.assume_init() }) } else { None }
         }
 
         /// # Safety
+        #[cfg(any(target_os = "linux", target_os = "android"))]
+        pub(super) use unix::CachedFileMetadata;
         #[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
         pub use unix::chroot;
         #[cfg(not(target_os = "wasi"))]
Diff in /checkout/library/std/src/sys/fs/mod.rs:17:
         pub(crate) use unix::debug_assert_fd_is_open;
-        #[cfg(any(target_os = "linux", target_os = "android"))]
-        pub(super) use unix::CachedFileMetadata;
+        #[cfg(not(target_os = "wasi"))]
+        pub use unix::{chown, fchown, lchown, mkfifo};
+
         use crate::sys::helpers::run_path_with_cstr as with_native_path;
     }
     target_os = "windows" => {
Diff in /checkout/library/std/src/sys/fs/mod.rs:23:
---
 
-                    match COUNTER.compare_exchange_weak(last, id, Ordering::Relaxed, Ordering::Relaxed) {
+                    match COUNTER.compare_exchange_weak(
+                        last,
+                        id,
+                        Ordering::Relaxed,
+                        Ordering::Relaxed,
+                    ) {
                         Ok(_) => return ThreadId(NonZero::new(id).unwrap()),
                         Err(id) => last = id,
                     }
Diff in /checkout/library/std/src/sys/thread_local/mod.rs:52:
     }
     _ => {
         mod os;
-        pub use os::{Storage, thread_local_inner, value_align};
         pub(crate) use os::{LocalPointer, local_pointer};
+        pub use os::{Storage, thread_local_inner, value_align};
     }
 }
 
Diff in /checkout/library/std/src/sys/thread_local/mod.rs:126:
                 use crate::rt::thread_cleanup;
             }
         }
-        any(
-            target_os = "hermit",
-            target_os = "xous",
-        ) => {
+        any(target_os = "hermit", target_os = "xous",) => {
             // `std` is the only runtime, so it just calls the destructor functions
             // itself when the time comes.
             pub(crate) fn enable() {}
Diff in /checkout/library/std/src/sys/thread_local/mod.rs:154:
 pub(crate) mod key {
     cfg_select! {
         any(
---
             all(target_os = "wasi", target_env = "p3"),
Diff in /checkout/library/std/src/sys/thread_local/mod.rs:168:
             #[cfg(test)]
             mod tests;
             pub(super) use racy::LazyKey;
-            pub(super) use unix::{Key, set};
             #[cfg(any(not(target_thread_local), test))]
             pub(super) use unix::get;
+            pub(super) use unix::{Key, set};
             use unix::{create, destroy};
         }
         all(not(target_thread_local), target_os = "windows") => {
Diff in /checkout/library/std/src/sys/thread_local/mod.rs:202:
             mod racy;
             #[cfg(test)]
             mod tests;
-            pub(super) use racy::LazyKey;
             pub(super) use moto_rt::tls::{Key, get, set};
             use moto_rt::tls::{create, destroy};
+            pub(super) use racy::LazyKey;
         }
         _ => {}
     }
Diff in /checkout/library/std/src/os/unix/net/stream.rs:1:
Diff in /checkout/library/std/src/sys/time/mod.rs:18:
         mod uefi;
         use uefi as imp;
     }
-    any(
-        target_os = "teeos",
-        target_family = "unix",
-        target_os = "wasi",
-    ) => {
+    any(target_os = "teeos", target_family = "unix", target_os = "wasi",) => {
         mod unix;
         use unix as imp;
     }
Diff in /checkout/library/std/src/sys/time/mod.rs:32:
         mod unsupported;
 
         mod imp {
-            pub use super::vexos::Instant;
             pub use super::unsupported::{SystemTime, UNIX_EPOCH};
+            pub use super::vexos::Instant;
         }
     }
     target_os = "windows" => {
 cfg_select! {
     any(
-        target_os = "linux", target_os = "android",
+        target_os = "linux",
+        target_os = "android",
         target_os = "hurd",
-        target_os = "dragonfly", target_os = "freebsd",
-        target_os = "openbsd", target_os = "netbsd",
-        target_os = "solaris", target_os = "illumos",
-        target_os = "haiku", target_os = "nto",
-        target_os = "qnx", target_os = "cygwin",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "openbsd",
+        target_os = "netbsd",
+        target_os = "solaris",
+        target_os = "illumos",
+        target_os = "haiku",
+        target_os = "nto",
+        target_os = "qnx",
+        target_os = "cygwin",
     ) => {
         use libc::MSG_NOSIGNAL;
     }
Diff in /checkout/library/std/src/sys/pipe/unix.rs:23:
             target_os = "openbsd",
             target_os = "cygwin",
             target_os = "redox"
-        ) => {
-            unsafe {
-                cvt(libc::pipe2(fds.as_mut_ptr(), libc::O_CLOEXEC))?;
-                Ok((Pipe::from_raw_fd(fds[0]), Pipe::from_raw_fd(fds[1])))
-            }
-        }
-        _ => {
-            unsafe {
-                cvt(libc::pipe(fds.as_mut_ptr()))?;
+        ) => unsafe {
+            cvt(libc::pipe2(fds.as_mut_ptr(), libc::O_CLOEXEC))?;
+            Ok((Pipe::from_raw_fd(fds[0]), Pipe::from_raw_fd(fds[1])))
+        },
+        _ => unsafe {
+            cvt(libc::pipe(fds.as_mut_ptr()))?;
 
-                let fd0 = Pipe::from_raw_fd(fds[0]);
-                let fd1 = Pipe::from_raw_fd(fds[1]);
-                fd0.set_cloexec()?;
-                fd1.set_cloexec()?;
-                Ok((fd0, fd1))
-            }
-        }
+            let fd0 = Pipe::from_raw_fd(fds[0]);
+            let fd1 = Pipe::from_raw_fd(fds[1]);
+            fd0.set_cloexec()?;
+            fd1.set_cloexec()?;
+            Ok((fd0, fd1))
+        },
     }
 }
 
Diff in /checkout/library/std/tests/env_modify.rs:128:
                 assert_ne!(home_dir(), Some(PathBuf::from("/home/MountainView")));
             }
 
-            if let Some(oldhome) = oldhome { unsafe { set_var("HOME", oldhome); } }
+            if let Some(oldhome) = oldhome {
+                unsafe {
+                    set_var("HOME", oldhome);
+                }
+            }
         }
         windows => {
             let oldhome = var_to_os_string(var("HOME"));
Diff in /checkout/library/std/tests/env_modify.rs:141:
                 assert!(home_dir().is_some());
 
                 set_var("HOME", "/home/PaloAlto");
-                assert_ne!(home_dir(), Some(PathBuf::from("/home/PaloAlto")), "HOME must not be used");
+                assert_ne!(
+                    home_dir(),
+                    Some(PathBuf::from("/home/PaloAlto")),
+                    "HOME must not be used"
+                );
 
                 set_var("USERPROFILE", "/home/MountainView");
                 assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
Diff in /checkout/library/std/tests/env_modify.rs:151:
                 assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
 
                 set_var("USERPROFILE", "");
-                assert_ne!(home_dir(), Some(PathBuf::from("")), "Empty USERPROFILE must be ignored");
+                assert_ne!(
+                    home_dir(),
+                    Some(PathBuf::from("")),
+                    "Empty USERPROFILE must be ignored"
+                );
 
                 remove_var("USERPROFILE");
 
Diff in /checkout/library/std/tests/env_modify.rs:158:
-                if let Some(oldhome) = oldhome { set_var("HOME", oldhome); }
-                if let Some(olduserprofile) = olduserprofile { set_var("USERPROFILE", olduserprofile); }
+                if let Some(oldhome) = oldhome {
+                    set_var("HOME", oldhome);
+                }
+                if let Some(olduserprofile) = olduserprofile {
+                    set_var("USERPROFILE", olduserprofile);
+                }
             }
         }
         _ => {}
Diff in /checkout/library/std/src/sys/alloc/mod.rs:64:
Diff in /checkout/library/std/src/os/unix/io/mod.rs:212:
 fn replace_stdio_fd(this: BorrowedFd<'_>, other: OwnedFd) -> io::Result<()> {
     cfg_select! {
         all(target_os = "wasi", target_env = "p1") => {
-            cvt(unsafe { libc::__wasilibc_fd_renumber(other.as_raw_fd(), this.as_raw_fd()) }).map(|_| ())
+            cvt(unsafe { libc::__wasilibc_fd_renumber(other.as_raw_fd(), this.as_raw_fd()) })
+                .map(|_| ())
         }
         not(any(
             all(target_arch = "wasm32", not(target_os = "emscripten")),
Diff in /checkout/library/std/src/os/unix/io/mod.rs:219:
             target_os = "hermit",
             target_os = "trusty",
             target_os = "motor"
-        )) => {
-            cvt(unsafe {libc::dup2(other.as_raw_fd(), this.as_raw_fd())}).map(|_| ())
-        }
+        )) => cvt(unsafe { libc::dup2(other.as_raw_fd(), this.as_raw_fd()) }).map(|_| ()),
         _ => {
             let _ = (this, other);
             Err(io::Error::UNSUPPORTED_PLATFORM)
 }
 
 cfg_select! {
-    any(
-        target_family = "unix",
-        target_os = "wasi",
-        target_os = "teeos",
-        target_os = "trusty",
-    ) => {
+    any(target_family = "unix", target_os = "wasi", target_os = "teeos", target_os = "trusty",) => {
         mod unix;
         use unix as imp;
     }
Diff in /checkout/library/std/src/sys/alloc/mod.rs:118:
 pub use imp::{alloc, dealloc, realloc};
 
 cfg_select! {
-    any(
-        target_os = "hermit",
-        target_os = "solid_asp3",
-        target_os = "uefi",
-        target_os = "zkvm",
-    ) => {
+    any(target_os = "hermit", target_os = "solid_asp3", target_os = "uefi", target_os = "zkvm",) => {
         #[inline]
         pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
             let ptr = unsafe { alloc(layout) };
Diff in /checkout/library/std/src/sys/net/connection/socket/unix.rs:88:
                 // DragonFlyBSD, FreeBSD and NetBSD use `SO_NOSIGPIPE` as a `setsockopt`
                 // flag to disable `SIGPIPE` emission on socket.
                 #[cfg(any(target_os = "freebsd", target_os = "netbsd", target_os = "dragonfly"))]
-                unsafe { setsockopt(&socket, libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1)? };
+                unsafe {
+                    setsockopt(&socket, libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1)?
Diff in /checkout/library/std/tests/sync/rwlock.rs:905:
     let mut read_lock_ctr: u32 = 0;
     let rwlock: RwLock<i32> = RwLock::new(0);
 
-    const MAX_READERS: u32 = cfg_select! {
-        miri => 100,
-        any(
-            all(target_os = "windows", not(target_vendor = "win7")),
---
-        },
-        any(
-            target_family = "unix",
-            all(target_os = "windows", target_vendor = "win7", target_pointer_width = "64"),
-            all(target_vendor = "fortanix", target_env = "sgx"),
-            target_os = "xous",
-            target_os = "teeos",
-        ) => {
-            u32::MAX
-        },
-        // Otherwise a form of deadlock is observed.
-        all(target_os = "windows", target_vendor = "win7", target_pointer_width = "32") => {
-            (1 << 28) - 1
---
+            ) => (1 << 30) - 2,
+            any(
+                target_family = "unix",
+                all(target_os = "windows", target_vendor = "win7", target_pointer_width = "64"),
+                all(target_vendor = "fortanix", target_env = "sgx"),
+                target_os = "xous",
+                target_os = "teeos",
+            ) => u32::MAX,
+            // Otherwise a form of deadlock is observed.
+            all(target_os = "windows", target_vendor = "win7", target_pointer_width = "32") => {
+                (1 << 28) - 1
+            }
+            target_os = "solid_asp3" => (1 << 30),
+            _ => u32::MAX,
+        };
 
     while read_lock_ctr < MAX_READERS {
         let lock = rwlock.read();
+                };
 
                 Ok(socket)
             }
Diff in /checkout/library/std/src/sys/net/connection/socket/unix.rs:101:
                 // macOS and iOS use `SO_NOSIGPIPE` as a `setsockopt`
                 // flag to disable `SIGPIPE` emission on socket.
                 #[cfg(target_vendor = "apple")]
-                unsafe { setsockopt(&socket, libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1)? };
+                unsafe {
+                    setsockopt(&socket, libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1)?
+                };
 
                 Ok(socket)
             }
Diff in /checkout/library/std/src/sys/net/connection/socket/unix.rs:129:
                 ) => {
                     // Like above, set cloexec atomically
                     cvt(libc::socketpair(fam, ty | libc::SOCK_CLOEXEC, 0, fds.as_mut_ptr()))?;
-                    Ok((Socket(FileDesc::from_raw_fd(fds[0])), Socket(FileDesc::from_raw_fd(fds[1]))))
+                    Ok((
+                        Socket(FileDesc::from_raw_fd(fds[0])),
+                        Socket(FileDesc::from_raw_fd(fds[1])),
+                    ))
                 }
                 _ => {
                     cvt(libc::socketpair(fam, ty, 0, fds.as_mut_ptr()))?;
Diff in /checkout/library/std/src/sys/net/connection/socket/unix.rs:256:
                 target_os = "netbsd",
                 target_os = "openbsd",
                 target_os = "cygwin",
-            ) => {
-                unsafe {
-                    let fd = cvt_r(|| libc::accept4(self.as_raw_fd(), storage, len, libc::SOCK_CLOEXEC))?;
-                    Ok(Socket(FileDesc::from_raw_fd(fd)))
-                }
-            }
-            _ => {
-                unsafe {
-                    let fd = cvt_r(|| libc::accept(self.as_raw_fd(), storage, len))?;
-                    let fd = FileDesc::from_raw_fd(fd);
-                    fd.set_cloexec()?;
-                    Ok(Socket(fd))
-                }
-            }
+            ) => unsafe {
+                let fd =
+                    cvt_r(|| libc::accept4(self.as_raw_fd(), storage, len, libc::SOCK_CLOEXEC))?;
+                Ok(Socket(FileDesc::from_raw_fd(fd)))
+            },
+            _ => unsafe {
+                let fd = cvt_r(|| libc::accept(self.as_raw_fd(), storage, len))?;
+                let fd = FileDesc::from_raw_fd(fd);
+                fd.set_cloexec()?;
+                Ok(Socket(fd))
+            },
         }
     }
 
Diff in /checkout/library/std/src/sys/net/connection/socket/mod.rs:54:
         target_os = "nuttx",
         target_vendor = "apple",
     ) => {
-        use c::IPV6_JOIN_GROUP as IPV6_ADD_MEMBERSHIP;
-        use c::IPV6_LEAVE_GROUP as IPV6_DROP_MEMBERSHIP;
+        use c::{IPV6_JOIN_GROUP as IPV6_ADD_MEMBERSHIP, IPV6_LEAVE_GROUP as IPV6_DROP_MEMBERSHIP};
     }
     _ => {
-        use c::IPV6_ADD_MEMBERSHIP;
-        use c::IPV6_DROP_MEMBERSHIP;
+        use c::{IPV6_ADD_MEMBERSHIP, IPV6_DROP_MEMBERSHIP};
     }
 }
 
Diff in /checkout/library/std/src/sys/net/connection/socket/mod.rs:66:
 cfg_select! {
---
-        target_os = "solaris", target_os = "illumos",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "openbsd",
+        target_os = "netbsd",
+        target_os = "solaris",
+        target_os = "illumos",
         target_os = "haiku",
-        target_os = "nto", target_os = "qnx",
+        target_os = "nto",
+        target_os = "qnx",
         target_os = "cygwin",
     ) => {
         use libc::MSG_NOSIGNAL;
Diff in /checkout/library/std/src/sys/net/connection/socket/mod.rs:83:
 
 cfg_select! {
     any(
-        target_os = "dragonfly", target_os = "freebsd",
-        target_os = "openbsd", target_os = "netbsd",
-        target_os = "solaris", target_os = "illumos",
-        target_os = "nto", target_os = "qnx",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "openbsd",
+        target_os = "netbsd",
+        target_os = "solaris",
+        target_os = "illumos",
+        target_os = "nto",
+        target_os = "qnx",
     ) => {
         use crate::ffi::c_uchar;
         type IpV4MultiCastType = c_uchar;
Diff in /checkout/library/std/src/sys/process/unix/unix.rs:21:
 
 cfg_select! {
     any(target_os = "nto", target_os = "qnx") => {
-        use crate::thread;
         use libc::{c_char, posix_spawn_file_actions_t, posix_spawnattr_t};
-        use crate::time::Duration;
+
         use crate::sync::LazyLock;
+        use crate::thread;
+        use crate::time::Duration;
         // Get smallest amount of time we can sleep.
         // Return a common value if it cannot be determined.
         fn get_clock_resolution() -> Duration {
Diff in /checkout/library/std/src/sys/process/unix/unix.rs:31:
             static MIN_DELAY: LazyLock<Duration, fn() -> Duration> = LazyLock::new(|| {
                 let mut mindelay = libc::timespec { tv_sec: 0, tv_nsec: 0 };
-                if unsafe { libc::clock_getres(libc::CLOCK_MONOTONIC, &mut mindelay) } == 0
-                {
+                if unsafe { libc::clock_getres(libc::CLOCK_MONOTONIC, &mut mindelay) } == 0 {
                     Duration::from_nanos(mindelay.tv_nsec as u64)
                 } else {
                     Duration::from_millis(1)
Diff in /checkout/library/std/src/sys/process/unix/unix.rs:512:
                                 support = FORK_EXEC;
                                 // but for the fast path we need both spawnp and the
                                 // pidfd -> pid conversion to work.
-                                if pidfd_spawnp.get().is_some() && let Ok(pid) = pidfd.pid() {
+                                if pidfd_spawnp.get().is_some()
+                                    && let Ok(pid) = pidfd.pid()
+                                {
                                     assert_eq!(pid, crate::process::id(), "sanity check");
                                     support = SPAWN;
                                 }
Diff in /checkout/library/std/src/sys/process/unix/unix.rs:519:
                             }
-                            Err(e) if matches!(e.raw_os_error(), Some(libc::EMFILE | libc::ENFILE | libc::ENOMEM)) => {
+                            Err(e)
+                                if matches!(
+                                    e.raw_os_error(),
+                                    Some(libc::EMFILE | libc::ENFILE | libc::ENOMEM)
+                                ) =>
+                            {
                                 // We're temporarily(?) out of file descriptors or memory. In this case pidfd_spawnp would also fail
                                 // Don't update the support flag so we can probe again later.
-                                return Err(e)
+                                return Err(e);
                             }
                             _ => {
                                 // pidfd_open not available? likely an old kernel without pidfd support.
Diff in /checkout/library/std/src/sys/process/unix/common.rs:24:
 cfg_select! {
     target_os = "fuchsia" => {
         // fuchsia doesn't have /dev/null
-    },
+    }
     target_os = "l4re" => {
         // l4re doesn't have /dev/null
     }
Diff in /checkout/library/std/src/sys/process/unix/common.rs:51:
 
         #[allow(dead_code)]
         pub unsafe fn sigaddset(set: *mut libc::sigset_t, signum: libc::c_int) -> libc::c_int {
-            use crate::slice;
             use libc::{c_ulong, sigset_t};
 
+            use crate::slice;
+
             // The implementations from bionic (android libc) type pun `sigset_t` as an
             // array of `c_ulong`. This works, but lets add a smoke check to make sure
             // that doesn't change.
Diff in /checkout/library/std/src/sys/process/unix/common.rs:78:
     }
     _ => {
         #[allow(unused_imports)]
-        pub use libc::{sigemptyset, sigaddset};
+        pub use libc::{sigaddset, sigemptyset};
     }
 }
 
Diff in /checkout/library/std/src/sys/random/mod.rs:11:
     target_vendor = "apple" => {
---
         mod getrandom;
         pub use getrandom::fill_bytes;
     }
-    any(
-        target_os = "aix",
-        target_os = "hurd",
-        target_os = "nto",
-        target_os = "qnx",
-    ) => {
+    any(target_os = "aix", target_os = "hurd", target_os = "nto", target_os = "qnx",) => {
         mod unix_legacy;
         pub use unix_legacy::fill_bytes;
     }
Diff in /checkout/library/std/src/sys/process/unix/mod.rs:13:
         mod vxworks;
         use vxworks as imp;
     }
-    any(target_os = "espidf", target_os = "horizon", target_os = "vita", target_os = "nuttx", target_os = "l4re") => {
+    any(
+        target_os = "espidf",
+        target_os = "horizon",
+        target_os = "vita",
+        target_os = "nuttx",
---
         pub use unsupported::output;
Diff in /checkout/library/std/src/sys/sync/condvar/mod.rs:1:
 cfg_select! {
     any(
-        all(target_os = "windows", not(target_vendor="win7")),
+        all(target_os = "windows", not(target_vendor = "win7")),
         target_os = "linux",
         target_os = "android",
         target_os = "freebsd",
Diff in /checkout/library/std/src/sys/sync/condvar/mod.rs:15:
         mod futex;
         pub use futex::Condvar;
     }
-    any(
-        target_family = "unix",
-        target_os = "teeos",
-    ) => {
+    any(target_family = "unix", target_os = "teeos",) => {
         mod pthread;
         pub use pthread::Condvar;
     }
Diff in /checkout/library/std/src/sys/fd/unix.rs:40:
             -1
         }
     }
-    any(
-        all(target_os = "linux", not(target_env = "musl")),
-        target_os = "android",
-        target_os = "hurd",
-    ) => {
+    any(all(target_os = "linux", not(target_env = "musl")), target_os = "android", target_os = "hurd",) =>
+    {
         // Prefer explicit pread64 for 64-bit offset independently of libc
         // #[cfg(gnu_file_offset_bits64)].
-        use libc::pread64;
-        use libc::pwrite64;
+        use libc::{pread64, pwrite64};
     }
     _ => {
-        use libc::pread as pread64;
-        use libc::pwrite as pwrite64;
+        use libc::{pread as pread64, pwrite as pwrite64};
     }
 }
 
Diff in /checkout/library/std/src/sys/sync/thread_parking/mod.rs:36:
Diff in /checkout/library/std/src/fs/tests.rs:639:
                 permission_bits.set_readonly(false);
                 check!(fs::set_permissions_nofollow(&filename, permission_bits));
             }
-        },
+        }
         _ => {
             let error_kind = result.unwrap_err().kind();
             assert_eq!(error_kind, crate::io::ErrorKind::Unsupported);
Diff in /checkout/library/std/src/fs/tests.rs:668:
     let result = fs::set_permissions_nofollow(&symlink_name, permission_bits);
 
     cfg_select! {
-        any(windows, target_os = "android", target_os = "macos", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd", target_os = "dragonfly") => {
+        any(
+            windows,
+            target_os = "android",
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "openbsd",
+            target_os = "netbsd",
+            target_os = "dragonfly"
+        ) => {
             assert_eq!(result.unwrap(), ());
             let metadata0 = check!(fs::symlink_metadata(&symlink_name));
             // So seems like BSD-based systems trying to set permissions
Diff in /checkout/library/std/src/fs/tests.rs:689:
                 permission_bits.set_readonly(false);
                 check!(fs::set_permissions_nofollow(&symlink_name, permission_bits));
             }
-        },
+        }
         _ => {
             let error_kind = result.unwrap_err().kind();
             assert_eq!(error_kind, crate::io::ErrorKind::Unsupported);
         mod xous;
         pub use xous::Parker;
     }
-    any(
-        target_family = "unix",
-        target_os = "teeos",
-    ) => {
+    any(target_family = "unix", target_os = "teeos",) => {
         mod pthread;
         pub use pthread::Parker;
     }
Diff in /checkout/library/std/src/sys/sync/mutex/mod.rs:18:
         mod fuchsia;
         pub use fuchsia::Mutex;
     }
-    any(
-        target_family = "unix",
-        target_os = "teeos",
-    ) => {
+    any(target_family = "unix", target_os = "teeos",) => {
         mod pthread;
         pub use pthread::Mutex;
     }
Diff in /checkout/library/std/src/sys/sync/futex/unix.rs:67:
                         expected,
                         timespec.as_ref().map_or(null(), |t| t as *const libc::timespec),
                         null::<u32>(), // This argument is unused for FUTEX_WAIT_BITSET.
-                        !0u32,         // A full bitmask, to make it behave like a regular FUTEX_WAIT.
+                        !0u32, // A full bitmask, to make it behave like a regular FUTEX_WAIT.
                     )
                 }
                 _ => {
Diff in /checkout/library/std/src/sys/args/mod.rs:15:
 
 cfg_select! {
     any(
-        all(target_family = "unix", not(any(all(target_family = "wasm", target_os = "linux"), target_os = "espidf", target_os = "vita"))),
+        all(
+            target_family = "unix",
+            not(any(
+                all(target_family = "wasm", target_os = "linux"),
+                target_os = "espidf",
---
Diff in /checkout/library/std/src/sys/sync/once/mod.rs:9:
 
 cfg_select! {
     any(
-        all(target_os = "windows", not(target_vendor="win7")),
+        all(target_os = "windows", not(target_vendor = "win7")),
         target_os = "linux",
         target_os = "android",
         all(target_family = "wasm", target_feature = "atomics"),
Diff in /checkout/library/std/src/sys/personality/gcc.rs:94:
 // https://github.com/gcc-mirror/gcc/blob/trunk/libgcc/unwind-c.c
 
 cfg_select! {
-    all(
-        target_arch = "arm",
-        not(target_vendor = "apple"),
-        not(target_os = "netbsd"),
-    ) => {
+    all(target_arch = "arm", not(target_vendor = "apple"), not(target_os = "netbsd"),) => {
         /// personality fn called by [ARM EHABI][armeabi-eh]
         ///
         /// 32-bit ARM on iOS/tvOS/watchOS does not use ARM EHABI, it uses
Diff in /checkout/library/std/src/sys/personality/gcc.rs:138:
                 // take only the context pointer, GCC personality routines stash a pointer to
                 // exception_object in the context, using location reserved for ARM's
                 // "scratch register" (r12).
-                uw::_Unwind_SetGR(context, uw::UNWIND_POINTER_REG, exception_object as uw::_Unwind_Ptr);
+                uw::_Unwind_SetGR(
+                    context,
+                    uw::UNWIND_POINTER_REG,
+                    exception_object as uw::_Unwind_Ptr,
+                );
                 // ...A more principled approach would be to provide the full definition of ARM's
                 // _Unwind_Context in our libunwind bindings and fetch the required data from there
                 // directly, bypassing DWARF compatibility functions.
Diff in /checkout/library/std/src/sys/personality/gcc.rs:164:
                 } else {
                     match eh_action {
                         EHAction::None => return continue_unwind(exception_object, context),
-                        EHAction::Filter(_) if state & uw::_US_FORCE_UNWIND as c_int != 0 => return continue_unwind(exception_object, context),
-                        EHAction::Cleanup(lpad) | EHAction::Catch(lpad) | EHAction::Filter(lpad) => {
+                        EHAction::Filter(_) if state & uw::_US_FORCE_UNWIND as c_int != 0 => {
+                            return continue_unwind(exception_object, context);
+                        }
+                        EHAction::Cleanup(lpad)
+                        | EHAction::Catch(lpad)
+                        | EHAction::Filter(lpad) => {
                             uw::_Unwind_SetGR(
                                 context,
                                 UNWIND_DATA_REG.0,
Diff in /checkout/library/std/src/sys/personality/gcc.rs:260:
                     match eh_action {
                         EHAction::None => uw::_URC_CONTINUE_UNWIND,
                         // Forced unwinding hits a terminate action.
-                        EHAction::Filter(_) if actions & uw::_UA_FORCE_UNWIND != 0 => uw::_URC_CONTINUE_UNWIND,
-                        EHAction::Cleanup(lpad) | EHAction::Catch(lpad) | EHAction::Filter(lpad) => {
-                            uw::_Unwind_SetGR(
-                                context,
-                                UNWIND_DATA_REG.0,
-                                exception_object.cast(),
-                            );
+                        EHAction::Filter(_) if actions & uw::_UA_FORCE_UNWIND != 0 => {
+                            uw::_URC_CONTINUE_UNWIND
+                        }
+                        EHAction::Cleanup(lpad)
+                        | EHAction::Catch(lpad)
+                        | EHAction::Filter(lpad) => {
+                            uw::_Unwind_SetGR(context, UNWIND_DATA_REG.0, exception_object.cast());
                             uw::_Unwind_SetGR(context, UNWIND_DATA_REG.1, core::ptr::null());
                             let maybe_signed_lpad = sign_lpad(context, lpad);
                             uw::_Unwind_SetIP(context, maybe_signed_lpad);
Diff in /checkout/library/std/src/sys/personality/gcc.rs:280:
 
         cfg_select! {
             any(
-                all(windows, any(target_arch = "aarch64", target_arch = "x86_64"), target_env = "gnu"),
+                all(
+                    windows,
+                    any(target_arch = "aarch64", target_arch = "x86_64"),
+                    target_env = "gnu"
+                ),
                 target_os = "cygwin",
             ) => {
                 /// personality fn called by [Windows Structured Exception Handling][windows-eh]
Diff in /checkout/library/std/src/sys/io/kernel_copy/mod.rs:2:
     any(target_os = "linux", target_os = "android") => {
         mod linux;
     }
-    _ => { }
+    _ => {}
 }
 
---
-            feature = "optimize_for_size" => {
-                partition_lomuto_branchless_simple::<T, F>
-            }
-            _ => {
-                partition_lomuto_branchless_cyclic::<T, F>
-            }
+            feature = "optimize_for_size" => partition_lomuto_branchless_simple::<T, F>,
+            _ => partition_lomuto_branchless_cyclic::<T, F>,
         }
     } else {
         partition_hoare_branchy_cyclic::<T, F>
Diff in /checkout/library/std/src/sys/io/error/mod.rs:31:
         mod xous;
         pub use xous::*;
     }
-    any(
-        target_os = "vexos",
-        target_family = "wasm",
-        target_os = "zkvm",
-        target_os = "trusty",
-    ) => {
+    any(target_os = "vexos", target_family = "wasm", target_os = "zkvm", target_os = "trusty",) => {
         mod generic;
         pub use generic::*;
     }
Diff in /checkout/library/std/src/sys/random/uefi.rs:57:
 mod rdrand {
     cfg_select! {
         target_arch = "x86_64" => {
-            use crate::arch::x86_64 as arch;
             use arch::_rdrand64_step as rdrand_step;
+
+            use crate::arch::x86_64 as arch;
             type Word = u64;
         }
         target_arch = "x86" => {
Diff in /checkout/library/std/src/sys/random/uefi.rs:65:
-            use crate::arch::x86 as arch;
             use arch::_rdrand32_step as rdrand_step;
+
+            use crate::arch::x86 as arch;
             type Word = u32;
         }
     }
Diff in /checkout/library/core/src/num/f32.rs:1203:
                 all(target_arch = "arm", target_feature = "vfp2"),
                 target_arch = "wasm32",
                 target_arch = "wasm64",
-            ) => {
-                ((self as f64 + other as f64) * 0.5) as f32
-            }
+            ) => ((self as f64 + other as f64) * 0.5) as f32,
             _ => {
                 const HI: f32 = f32::MAX * 0.5;
 
Diff in /checkout/library/std/src/sys/thread/unix.rs:181:
                         // none was explicitly set.
                         // In that case we use the sysconf fallback.
                         if let Some(count) = NonZero::new(count) {
---
+            target_os = "netbsd",
         ) => {
             use crate::ptr;
 
Diff in /checkout/library/std/src/sys/thread/unix.rs:215:
                         -1,
                         size_of::<libc::cpuset_t>(),
                         &mut set,
-                    ) == 0 {
+                    ) == 0
+                    {
                         let count = libc::CPU_COUNT(&set) as usize;
                         if count > 0 {
                             return Ok(NonZero::new_unchecked(count));
Diff in /checkout/library/std/src/sys/thread/unix.rs:230:
                     let set = libc::_cpuset_create();
                     if !set.is_null() {
                         let mut count: usize = 0;
-                        if libc::pthread_getaffinity_np(libc::pthread_self(), libc::_cpuset_size(set), set) == 0 {
+                        if libc::pthread_getaffinity_np(
+                            libc::pthread_self(),
+                            libc::_cpuset_size(set),
+                            set,
+                        ) == 0
+                        {
                             for i in 0..libc::cpuid_t::MAX {
                                 match libc::_cpuset_isset(i, set) {
                                     -1 => break,
Diff in /checkout/library/std/src/sys/thread/unix.rs:278:
 
             Ok(unsafe { NonZero::new_unchecked(cpus as usize) })
         }
-        any(target_os = "nto", target_os = "qnx") => {
-            unsafe {
-                use libc::_syspage_ptr;
-                if _syspage_ptr.is_null() {
-                    Err(io::const_error!(io::ErrorKind::NotFound, "no syspage available"))
-                } else {
-                    let cpus = (*_syspage_ptr).num_cpu;
-                    NonZero::new(cpus as usize)
-                        .ok_or(io::Error::UNKNOWN_THREAD_COUNT)
-                }
+        any(target_os = "nto", target_os = "qnx") => unsafe {
+            use libc::_syspage_ptr;
+            if _syspage_ptr.is_null() {
+                Err(io::const_error!(io::ErrorKind::NotFound, "no syspage available"))
+            } else {
+                let cpus = (*_syspage_ptr).num_cpu;
+                NonZero::new(cpus as usize).ok_or(io::Error::UNKNOWN_THREAD_COUNT)
             }
-        }
+        },
         any(target_os = "solaris", target_os = "illumos") => {
             let mut cpus = 0u32;
-            if unsafe { libc::pset_info(libc::PS_MYID, core::ptr::null_mut(), &mut cpus, core::ptr::null_mut()) } != 0 {
+            if unsafe {
+                libc::pset_info(
+                    libc::PS_MYID,
+                    core::ptr::null_mut(),
+                    &mut cpus,
+                    core::ptr::null_mut(),
+                )
+            } != 0
+            {
                 return Err(io::Error::UNKNOWN_THREAD_COUNT);
             }
             Ok(unsafe { NonZero::new_unchecked(cpus as usize) })
Diff in /checkout/library/std/src/sys/thread/unix.rs:316:
             // expectations than the actual cores availability.
 
             // SAFETY: `vxCpuEnabledGet` always fetches a mask with at least one bit set
-            unsafe{
+            unsafe {
                 let set = libc::vxCpuEnabledGet();
                 Ok(NonZero::new_unchecked(set.count_ones() as usize))
             }
Diff in /checkout/library/std/src/sys/thread/unix.rs:323:
         }
         _ => {
             // FIXME: implement on l4re
-            Err(io::const_error!(io::ErrorKind::Unsupported, "getting the number of hardware threads is not supported on the target platform"))
+            Err(io::const_error!(
+                io::ErrorKind::Unsupported,
+                "getting the number of hardware threads is not supported on the target platform"
+            ))
         }
     }
 }
Diff in /checkout/library/std/src/sys/thread/unix.rs:341:
 
             // `libc::gettid` is only available on glibc 2.30+, but the syscall is available
             // since Linux 2.4.11.
-            syscall!(fn gettid() -> libc::pid_t;);
+            syscall!(
+                fn gettid() -> libc::pid_t;
+            );
 
             // SAFETY: FFI call with no preconditions.
             let id: libc::pid_t = unsafe { gettid() };
Diff in /checkout/library/std/src/sys/thread/unix.rs:378:
             let mut id = 0u64;
             // SAFETY: `thread_id` is a valid pointer, no other preconditions.
             let status: libc::c_int = unsafe { libc::pthread_threadid_np(0, &mut id) };
-            if status == 0 {
-                Some(id)
-            } else {
-                None
-            }
+            if status == 0 { Some(id) } else { None }
         }
         // Other platforms don't have an OS thread ID or don't have a way to access it.
         _ => None,
Diff in /checkout/library/std/src/sys/thread/unix.rs:563:
             // wasi-libc prior to WebAssembly/wasi-libc#696 has a broken implementation
             // of `nanosleep` which used `CLOCK_REALTIME` even though it is unsupported
             // on WASIp2. Using `clock_nanosleep` directly bypasses the issue.
-            unsafe fn nanosleep(rqtp: *const libc::timespec, rmtp: *mut libc::timespec) -> libc::c_int {
+            unsafe fn nanosleep(
+                rqtp: *const libc::timespec,
+                rmtp: *mut libc::timespec,
+            ) -> libc::c_int {
                 unsafe { libc::clock_nanosleep(crate::sys::time::Instant::CLOCK_ID, 0, rqtp, rmtp) }
             }
         }
Diff in /checkout/library/std/src/sys/thread/unix.rs:570:
         _ => {
-            unsafe fn nanosleep(rqtp: *const libc::timespec, rmtp: *mut libc::timespec) -> libc::c_int {
+            unsafe fn nanosleep(
+                rqtp: *const libc::timespec,
+                rmtp: *mut libc::timespec,
+            ) -> libc::c_int {
                 let r = unsafe { libc::nanosleep(rqtp, rmtp) };
                 // `clock_nanosleep` returns the error number directly, so mimic
                 // that behaviour to make the shared code below simpler.
Diff in /checkout/library/std/src/sys/thread/mod.rs:1:
 cfg_select! {
     target_os = "hermit" => {
         mod hermit;
-        pub use hermit::{Thread, available_parallelism, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+        pub use hermit::{DEFAULT_MIN_STACK_SIZE, Thread, available_parallelism, sleep, yield_now};
         #[expect(dead_code)]
         mod unsupported;
         pub use unsupported::{current_os_id, set_name};
Diff in /checkout/library/std/src/sys/thread/mod.rs:12:
     }
     all(target_vendor = "fortanix", target_env = "sgx") => {
         mod sgx;
-        pub use sgx::{Thread, current_os_id, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+        pub use sgx::{DEFAULT_MIN_STACK_SIZE, Thread, current_os_id, sleep, yield_now};
 
         // SGX should protect in-enclave data from outside attackers, so there
         // must not be any data leakage to the OS, particularly no 1-1 mapping
Diff in /checkout/library/std/src/sys/thread/mod.rs:29:
     }
     target_os = "solid_asp3" => {
         mod solid;
-        pub use solid::{Thread, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+        pub use solid::{DEFAULT_MIN_STACK_SIZE, Thread, sleep, yield_now};
         #[expect(dead_code)]
         mod unsupported;
         pub use unsupported::{available_parallelism, current_os_id, set_name};
Diff in /checkout/library/std/src/sys/thread/mod.rs:36:
     }
     target_os = "teeos" => {
         mod teeos;
-        pub use teeos::{Thread, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+        pub use teeos::{DEFAULT_MIN_STACK_SIZE, Thread, sleep, yield_now};
         #[expect(dead_code)]
         mod unsupported;
         pub use unsupported::{available_parallelism, current_os_id, set_name};
Diff in /checkout/library/std/src/sys/thread/mod.rs:46:
         pub use uefi::{available_parallelism, sleep};
         #[expect(dead_code)]
         mod unsupported;
-        pub use unsupported::{Thread, current_os_id, set_name, yield_now, DEFAULT_MIN_STACK_SIZE};
+        pub use unsupported::{DEFAULT_MIN_STACK_SIZE, Thread, current_os_id, set_name, yield_now};
     }
     any(target_family = "unix", target_os = "wasi") => {
         mod unix;
Diff in /checkout/library/std/src/sys/thread/mod.rs:53:
-        pub use unix::{Thread, available_parallelism, current_os_id, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
         #[cfg(not(any(
             target_env = "newlib",
             target_os = "l4re",
Diff in /checkout/library/std/src/sys/thread/mod.rs:75:
             target_vendor = "apple",
         ))]
         pub use unix::sleep_until;
+        pub use unix::{
+            DEFAULT_MIN_STACK_SIZE, Thread, available_parallelism, current_os_id, sleep, yield_now,
+        };
         #[expect(dead_code)]
         mod unsupported;
         #[cfg(any(
Diff in /checkout/library/std/src/sys/thread/mod.rs:93:
         pub use vexos::{sleep, sleep_until, yield_now};
         #[expect(dead_code)]
         mod unsupported;
-        pub use unsupported::{Thread, available_parallelism, current_os_id, set_name, DEFAULT_MIN_STACK_SIZE};
+        pub use unsupported::{
+            DEFAULT_MIN_STACK_SIZE, Thread, available_parallelism, current_os_id, set_name,
+        };
     }
     all(target_family = "wasm", target_feature = "atomics") => {
         mod wasm;
Diff in /checkout/library/std/src/sys/thread/mod.rs:101:
 
         #[expect(dead_code)]
         mod unsupported;
-        pub use unsupported::{Thread, available_parallelism, current_os_id, set_name, yield_now, DEFAULT_MIN_STACK_SIZE};
+        pub use unsupported::{
+            DEFAULT_MIN_STACK_SIZE, Thread, available_parallelism, current_os_id, set_name,
+            yield_now,
+        };
     }
     target_os = "windows" => {
         mod windows;
Diff in /checkout/library/std/src/sys/thread/mod.rs:108:
-        pub use windows::{Thread, available_parallelism, current_os_id, set_name, set_name_wide, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+        pub use windows::{
+            DEFAULT_MIN_STACK_SIZE, Thread, available_parallelism, current_os_id, set_name,
+            set_name_wide, sleep, yield_now,
+        };
     }
     target_os = "xous" => {
         mod xous;
Diff in /checkout/library/std/src/sys/thread/mod.rs:112:
-        pub use xous::{Thread, available_parallelism, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+        pub use xous::{DEFAULT_MIN_STACK_SIZE, Thread, available_parallelism, sleep, yield_now};
 
         #[expect(dead_code)]
         mod unsupported;
Diff in /checkout/library/std/src/sys/thread/mod.rs:117:
     }
     _ => {
         mod unsupported;
-        pub use unsupported::{Thread, available_parallelism, current_os_id, set_name, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+        pub use unsupported::{
+            DEFAULT_MIN_STACK_SIZE, Thread, available_parallelism, current_os_id, set_name, sleep,
+            yield_now,
+        };
     }
 }
 
Diff in /checkout/library/core/src/ffi/va_list.rs:39:
---
-        target_arch = "aarch64",
-        not(target_vendor = "apple"),
-        not(target_os = "uefi"),
-        not(windows),
-    ) => {
+    all(target_arch = "aarch64", not(target_vendor = "apple"), not(target_os = "uefi"), not(windows),) =>
+    {
         /// AArch64 ABI implementation of a `va_list`.
         ///
         /// See the [AArch64 Procedure Call Standard] for more details.
Diff in /checkout/library/std/src/sys/paths/mod.rs:5:
         mod unsupported;
         mod imp {
             pub use super::hermit::{getcwd, temp_dir};
-            pub use super::unsupported::{chdir, SplitPaths, split_paths, JoinPathsError, join_paths, current_exe, home_dir};
+            pub use super::unsupported::{
+                JoinPathsError, SplitPaths, chdir, current_exe, home_dir, join_paths, split_paths,
+            };
         }
     }
     target_os = "motor" => {
Diff in /checkout/library/std/src/sys/paths/mod.rs:13:
         #[expect(dead_code)]
         mod unsupported;
         mod imp {
-            pub use super::motor::{getcwd, chdir, current_exe, temp_dir};
-            pub use super::unsupported::{SplitPaths, split_paths, JoinPathsError, join_paths, home_dir};
+            pub use super::motor::{chdir, current_exe, getcwd, temp_dir};
+            pub use super::unsupported::{
+                JoinPathsError, SplitPaths, home_dir, join_paths, split_paths,
+            };
         }
     }
     all(target_vendor = "fortanix", target_env = "sgx") => {
Diff in /checkout/library/std/src/sys/paths/mod.rs:23:
         mod unsupported;
         mod imp {
             pub use super::sgx::chdir;
-            pub use super::unsupported::{getcwd, SplitPaths, split_paths, JoinPathsError, join_paths, current_exe, temp_dir, home_dir};
+            pub use super::unsupported::{
+                JoinPathsError, SplitPaths, current_exe, getcwd, home_dir, join_paths, split_paths,
+                temp_dir,
+            };
         }
     }
     target_os = "uefi" => {
Diff in /checkout/library/std/src/sys/paths/mod.rs:39:
         #[expect(dead_code)]
         mod unsupported;
         mod imp {
-            pub use super::wasi::{getcwd, chdir, temp_dir};
-            pub use super::unsupported::{current_exe, SplitPaths, split_paths, JoinPathsError, join_paths, home_dir};
+            pub use super::unsupported::{
+                JoinPathsError, SplitPaths, current_exe, home_dir, join_paths, split_paths,
+            };
+            pub use super::wasi::{chdir, getcwd, temp_dir};
         }
     }
     target_os = "windows" => {
fmt: checked 7152 files
Diff in /checkout/library/core/src/io/io_slice.rs:3:
 use crate::ops::{Deref, DerefMut};
 
 cfg_select! {
-    any(target_family = "unix", target_os = "hermit", target_os = "solid_asp3", target_os = "trusty", target_os = "wasi") => {
+    any(
+        target_family = "unix",
+        target_os = "hermit",
+        target_os = "solid_asp3",
+        target_os = "trusty",
+        target_os = "wasi"
+    ) => {
         #[path = "io_slice/repr_iovec.rs"]
         mod repr;
     }
Diff in /checkout/library/unwind/src/libunwind.rs:66:
             pub fn _Unwind_GetGR(ctx: *mut _Unwind_Context, reg_index: c_int) -> _Unwind_Word;
             pub fn _Unwind_SetGR(ctx: *mut _Unwind_Context, reg_index: c_int, value: _Unwind_Word);
             pub fn _Unwind_SetIP(ctx: *mut _Unwind_Context, value: _Unwind_Word);
-            pub fn _Unwind_GetIPInfo(ctx: *mut _Unwind_Context, ip_before_insn: *mut c_int)
-                                     -> _Unwind_Word;
+            pub fn _Unwind_GetIPInfo(
+                ctx: *mut _Unwind_Context,
+                ip_before_insn: *mut c_int,
+            ) -> _Unwind_Word;
         }
-
     }
     _ => {
         // ARM EHABI
Diff in /checkout/library/unwind/src/libunwind.rs:120:
             link(name = "unwind", kind = "static", modifiers = "-bundle")
         )]
         unsafe extern "C" {
-            fn _Unwind_VRS_Get(ctx: *mut _Unwind_Context,
-                               regclass: _Unwind_VRS_RegClass,
-                               regno: _Unwind_Word,
-                               repr: _Unwind_VRS_DataRepresentation,
-                               data: *mut c_void)
-                               -> _Unwind_VRS_Result;
+            fn _Unwind_VRS_Get(
+                ctx: *mut _Unwind_Context,
+                regclass: _Unwind_VRS_RegClass,
+                regno: _Unwind_Word,
+                repr: _Unwind_VRS_DataRepresentation,
+                data: *mut c_void,
+            ) -> _Unwind_VRS_Result;
 
-            fn _Unwind_VRS_Set(ctx: *mut _Unwind_Context,
-                               regclass: _Unwind_VRS_RegClass,
-                               regno: _Unwind_Word,
-                               repr: _Unwind_VRS_DataRepresentation,
-                               data: *mut c_void)
-                               -> _Unwind_VRS_Result;
+            fn _Unwind_VRS_Set(
+                ctx: *mut _Unwind_Context,
+                regclass: _Unwind_VRS_RegClass,
+                regno: _Unwind_Word,
+                repr: _Unwind_VRS_DataRepresentation,
+                data: *mut c_void,
+            ) -> _Unwind_VRS_Result;
         }
 
         // On Android or ARM/Linux, these are implemented as macros:
Diff in /checkout/library/unwind/src/libunwind.rs:139:
 
         pub unsafe fn _Unwind_GetGR(ctx: *mut _Unwind_Context, reg_index: c_int) -> _Unwind_Word {
             let mut val: _Unwind_Word = core::ptr::null();
-            unsafe { _Unwind_VRS_Get(ctx, _UVRSC_CORE, reg_index as _Unwind_Word, _UVRSD_UINT32,
-                            (&raw mut val) as *mut c_void); }
+            unsafe {
+                _Unwind_VRS_Get(
+                    ctx,
+                    _UVRSC_CORE,
+                    reg_index as _Unwind_Word,
+                    _UVRSD_UINT32,
+                    (&raw mut val) as *mut c_void,
+                );
+            }
             val
         }
 
---
-            value: _Unwind_Word
+            value: _Unwind_Word,
         ) {
             let mut value = value;
-            unsafe { _Unwind_VRS_Set(ctx, _UVRSC_CORE, reg_index as _Unwind_Word, _UVRSD_UINT32,
-                            (&raw mut value) as *mut c_void); }
+            unsafe {
+                _Unwind_VRS_Set(
+                    ctx,
+                    _UVRSC_CORE,
+                    reg_index as _Unwind_Word,
+                    _UVRSD_UINT32,
+                    (&raw mut value) as *mut c_void,
+                );
+            }
         }
 
-        pub unsafe fn _Unwind_SetIP(ctx: *mut _Unwind_Context,
-                                    value: _Unwind_Word) {
+        pub unsafe fn _Unwind_SetIP(ctx: *mut _Unwind_Context, value: _Unwind_Word) {
             // Propagate thumb bit to instruction pointer
             let thumb_state = unsafe { _Unwind_GetGR(ctx, UNWIND_IP_REG).addr() & 1 };
             let value = value.map_addr(|v| v | thumb_state);
Diff in /checkout/library/unwind/src/libunwind.rs:162:
-            unsafe { _Unwind_SetGR(ctx, UNWIND_IP_REG, value); }
+            unsafe {
+                _Unwind_SetGR(ctx, UNWIND_IP_REG, value);
+            }
         }
 
-        pub unsafe fn _Unwind_GetIPInfo(ctx: *mut _Unwind_Context,
-                                        ip_before_insn: *mut c_int)
-                                        -> _Unwind_Word {
+        pub unsafe fn _Unwind_GetIPInfo(
+            ctx: *mut _Unwind_Context,
+            ip_before_insn: *mut c_int,
+        ) -> _Unwind_Word {
             unsafe { *ip_before_insn = 0 };
             let val = unsafe { _Unwind_GetGR(ctx, UNWIND_IP_REG) };
             val.map_addr(|v| v & !1)
Diff in /checkout/library/unwind/src/libunwind.rs:197:
         pub enum CONTEXT {}
         pub enum DISPATCHER_CONTEXT {}
         pub type EXCEPTION_DISPOSITION = c_int;
-        type PersonalityFn = unsafe extern "C" fn(version: c_int,
-                                                  actions: _Unwind_Action,
-                                                  exception_class: _Unwind_Exception_Class,
-                                                  exception_object: *mut _Unwind_Exception,
-                                                  context: *mut _Unwind_Context)
-                                                  -> _Unwind_Reason_Code;
+        type PersonalityFn = unsafe extern "C" fn(
+            version: c_int,
+            actions: _Unwind_Action,
+            exception_class: _Unwind_Exception_Class,
+            exception_object: *mut _Unwind_Exception,
+            context: *mut _Unwind_Context,
+        ) -> _Unwind_Reason_Code;
 
         unsafe extern "C" {
-            pub fn _GCC_specific_handler(exceptionRecord: *mut EXCEPTION_RECORD,
-                                    establisherFrame: LPVOID,
-                                    contextRecord: *mut CONTEXT,
-                                    dispatcherContext: *mut DISPATCHER_CONTEXT,
-                                    personality: PersonalityFn)
-                                    -> EXCEPTION_DISPOSITION;
+            pub fn _GCC_specific_handler(
---
         // Windows MSVC no extra unwinder support needed
     }
-    any(
-        target_os = "none",
-        target_os = "espidf",
-        target_os = "nuttx",
-    ) => {
+    any(target_os = "none", target_os = "espidf", target_os = "nuttx",) => {
         // These "unix" family members do not have unwinder.
     }
     any(
Diff in /checkout/library/unwind/src/lib.rs:65:
 #[cfg(all(target_env = "musl", not(target_abi = "pauthtest")))]
 cfg_select! {
     all(feature = "llvm-libunwind", feature = "system-llvm-libunwind") => {
-        compile_error!("`llvm-libunwind` and `system-llvm-libunwind` cannot be enabled at the same time");
+        compile_error!(
+            "`llvm-libunwind` and `system-llvm-libunwind` cannot be enabled at the same time"
+        );
     }
     feature = "llvm-libunwind" => {
---
         unsafe extern "C" {}
     }
Diff in /checkout/library/unwind/src/lib.rs:79:
     _ => {
-        #[link(name = "unwind", kind = "static", modifiers = "-bundle", cfg(target_feature = "crt-static"))]
-        #[link(name = "gcc_s", cfg(all(not(target_feature = "crt-static"), not(target_arch = "hexagon"))))]
+        #[link(
+            name = "unwind",
+            kind = "static",
+            modifiers = "-bundle",
+            cfg(target_feature = "crt-static")
---
     }
Diff in /checkout/library/unwind/src/lib.rs:105:
 #[cfg(target_env = "ohos")]
 cfg_select! {
     all(feature = "llvm-libunwind", feature = "system-llvm-libunwind") => {
-        compile_error!("`llvm-libunwind` and `system-llvm-libunwind` cannot be enabled at the same time");
+        compile_error!(
+            "`llvm-libunwind` and `system-llvm-libunwind` cannot be enabled at the same time"
+        );
     }
     feature = "llvm-libunwind" => {
---
Diff in /checkout/library/unwind/src/types.rs:19:
 pub type _Unwind_Exception_Class = u64;
 pub type _Unwind_Word = *const u8;
 
-pub const unwinder_private_data_size: usize = cfg_select! {
-    target_arch = "x86" => 5,
-    all(target_arch = "x86_64", not(any(target_os = "windows", target_os = "cygwin"))) => 2,
-    all(target_arch = "x86_64", any(target_os = "windows", target_os = "cygwin")) => 6,
-    all(target_arch = "arm", not(target_vendor = "apple")) => 20,
-    all(target_arch = "arm", target_vendor = "apple") => 5,
-    all(target_arch = "aarch64", target_pointer_width = "64", not(target_os = "windows")) => 2,
-    all(target_arch = "aarch64", target_pointer_width = "64", target_os = "windows") => 6,
-    all(target_arch = "aarch64", target_pointer_width = "32") => 5,
-    target_arch = "m68k" => 2,
-    any(target_arch = "mips", target_arch = "mips32r6") => 2,
-    target_arch = "csky" => 2,
-    any(target_arch = "mips64", target_arch = "mips64r6") => 2,
-    any(target_arch = "powerpc", target_arch = "powerpc64") => 2,
-    target_arch = "s390x" => 2,
-    any(target_arch = "sparc", target_arch = "sparc64") => 2,
-    any(target_arch = "riscv64", target_arch = "riscv32") => 2,
-    all(target_family = "wasm", target_os = "emscripten") => 20,
-    target_family = "wasm" => 2,
-    target_arch = "hexagon" => 5,
-    any(target_arch = "loongarch32", target_arch = "loongarch64") => 2,
-};
+pub const unwinder_private_data_size: usize =
+    cfg_select! {
+        target_arch = "x86" => 5,
+        all(target_arch = "x86_64", not(any(target_os = "windows", target_os = "cygwin"))) => 2,
+        all(target_arch = "x86_64", any(target_os = "windows", target_os = "cygwin")) => 6,
+        all(target_arch = "arm", not(target_vendor = "apple")) => 20,
+        all(target_arch = "arm", target_vendor = "apple") => 5,
+        all(target_arch = "aarch64", target_pointer_width = "64", not(target_os = "windows")) => 2,
+        all(target_arch = "aarch64", target_pointer_width = "64", target_os = "windows") => 6,
+        all(target_arch = "aarch64", target_pointer_width = "32") => 5,
+        target_arch = "m68k" => 2,
+        any(target_arch = "mips", target_arch = "mips32r6") => 2,
+        target_arch = "csky" => 2,
+        any(target_arch = "mips64", target_arch = "mips64r6") => 2,
+        any(target_arch = "powerpc", target_arch = "powerpc64") => 2,
+        target_arch = "s390x" => 2,
+        any(target_arch = "sparc", target_arch = "sparc64") => 2,
+        any(target_arch = "riscv64", target_arch = "riscv32") => 2,
+        all(target_family = "wasm", target_os = "emscripten") => 20,
+        target_family = "wasm" => 2,
+        target_arch = "hexagon" => 5,
+        any(target_arch = "loongarch32", target_arch = "loongarch64") => 2,
+    };
 
 #[repr(C)]
 pub struct _Unwind_Exception {
Diff in /checkout/library/coretests/tests/macros.rs:49:
 #[test]
 fn cfg_select_basic() {
     cfg_select! {
-        target_pointer_width = "64" => { fn f0_() -> bool { true }}
+        target_pointer_width = "64" => {
+            fn f0_() -> bool {
+                true
+            }
+        }
         _ => {}
     }
 
Diff in /checkout/library/coretests/tests/macros.rs:56:
     cfg_select! {
-        unix => { fn f1_() -> bool { true } }
-        _ => { fn f1_() -> bool { false }}
+        unix => {
+            fn f1_() -> bool {
+                true
+            }
+        }
+        _ => {
+            fn f1_() -> bool {
+                false
+            }
+        }
     }
 
     cfg_select! {
Diff in /checkout/library/coretests/tests/macros.rs:62:
-        target_pointer_width = "32" => { fn f2_() -> bool { false } }
-        target_pointer_width = "64" => { fn f2_() -> bool { true } }
+        target_pointer_width = "32" => {
+            fn f2_() -> bool {
+                false
+            }
+        }
+        target_pointer_width = "64" => {
+            fn f2_() -> bool {
+                true
+            }
+        }
     }
 
     cfg_select! {
Diff in /checkout/library/coretests/tests/macros.rs:67:
-        target_pointer_width = "16" => { fn f3_() -> i32 { 1 } }
-        _ => { fn f3_() -> i32 { 2 }}
+        target_pointer_width = "16" => {
+            fn f3_() -> i32 {
+                1
+            }
+        }
+        _ => {
+            fn f3_() -> i32 {
+                2
+            }
+        }
     }
 
---
-            assert_eq!(4, 2+2);
+            assert_eq!(4, 2 + 2);
         }
         _ => {
             assert!(cfg!(not(debug_assertions)));
Diff in /checkout/library/coretests/tests/macros.rs:97:
-            assert_eq!(10, 5+5);
+            assert_eq!(10, 5 + 5);
         }
     }
 }
Diff in /checkout/library/coretests/tests/macros.rs:121:
     cfg_select! {
         test => {
             use core::option::Option as Option2;
-            fn works1() -> Option2<u32> { Some(1) }
+            fn works1() -> Option2<u32> {
+                Some(1)
+            }
         }
-        _ => { fn works1() -> Option<u32> { None } }
+        _ => {
+            fn works1() -> Option<u32> {
+                None
+            }
+        }
     }
 
     cfg_select! {
Diff in /checkout/library/coretests/tests/macros.rs:130:
-        feature = "foo" => { fn works2() -> bool { false } }
-        test => { fn works2() -> bool { true } }
-        _ => { fn works2() -> bool { false } }
+        feature = "foo" => {
+            fn works2() -> bool {
+                false
+            }
+        }
+        test => {
+            fn works2() -> bool {
---
     }
 
     cfg_select! {
Diff in /checkout/library/coretests/tests/macros.rs:136:
-        feature = "foo" => { fn works3() -> bool { false } }
-        _ => { fn works3() -> bool { true } }
+        feature = "foo" => {
+            fn works3() -> bool {
+                false
+            }
+        }
+        _ => {
+            fn works3() -> bool {
---
     cfg_select! {
Diff in /checkout/library/coretests/tests/macros.rs:141:
         test => {
             use core::option::Option as Option3;
-            fn works4() -> Option3<u32> { Some(1) }
+            fn works4() -> Option3<u32> {
+                Some(1)
+            }
         }
     }
 
Diff in /checkout/library/coretests/tests/macros.rs:147:
     cfg_select! {
-        feature = "foo" => { fn works5() -> bool { false } }
-        test => { fn works5() -> bool { true } }
+        feature = "foo" => {
+            fn works5() -> bool {
+                false
+            }
+        }
+        test => {
+            fn works5() -> bool {
+                true
+            }
+        }
     }
 
     assert!(works1().is_some());
Diff in /checkout/library/coretests/tests/macros.rs:183:
 
 fn _accepts_expressions() -> i32 {
     cfg_select! {
-        unix => { 1 }
-        _ => { 2 }
+        unix => 1,
+        _ => 2,
     }
 }
 
Diff in /checkout/library/coretests/tests/macros.rs:191:
 fn _accepts_only_wildcard() -> i32 {
     cfg_select! {
-        _ => { 1 }
+        _ => 1,
     }
 }
 
Diff in /checkout/library/coretests/tests/macros.rs:200:
     let one = 1;
     let two = 2;
     cfg_select! {
-        unix => { one * two; }
-        _ => { one + two; }
+        unix => {
+            one * two;
+        }
+        _ => {
+            one + two;
+        }
     }
---
-        }
-        _ => {
-            ""
-        }
+        windows => " XP",
+        _ => "",
     );
 }
 
Diff in /checkout/library/alloc/src/io/read.rs:776:
 #[doc(hidden)]
 #[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
 pub const DEFAULT_BUF_SIZE: usize = cfg_select! {
-    target_os = "espidf" => { 512 },
-    _ => { 8 * 1024 }
+    target_os = "espidf" => 512,
+    _ => 8 * 1024,
 };
 
 /// Several `read_to_string` and `read_line` methods in the standard library will
Bootstrap failed while executing `test src/tools/tidy tidyselftest --extra-checks=py,cpp,js,spellcheck`
Currently active steps:

[rust-bors]

☀️ Try build successful (CI)
Build commit: f892cbb (f892cbbbe88f259c7f3fa04cba1d2d9e1f496627)
Base parent: 93c9086 (93c9086fdd5b80d286480a19ac047746ecc5fa1f)

[weihanglo]

cc @Urgau. I think this is pretty solid. I haven't verified artifacts manually yet I did have some agents comprehensive reports for all three platforms. Let me know if you want to take a look of them.

[weihanglo]

rust-lang/cc-rs#1794 this is the thing that helps remap rustc_llvm.

[Urgau]

bootstraps also sets C/C++ arguments at

rust/src/bootstrap/src/lib.rs

Lines 1262 to 1271 in 2fb4ed8

	if let Some(map_to) = self.debuginfo_map_to(which, RemapScheme::NonCompiler) {
	let map = format!("{}={}", self.src.display(), map_to);
	let cc = self.cc_tool(target);
	if cc.is_like_clang() || cc.is_like_gnu() {
	base.push(format!("-fdebug-prefix-map={map}"));
	} else if cc.is_like_clang_cl() {
	base.push("-Xclang".into());
	base.push(format!("-fdebug-prefix-map={map}"));
	}
	}

, we should probably also remove that part