Auto merge of #149115 - matthiaskrgr:rollup-g28pfke, r=matthiaskrgr

Rollup of 6 pull requests

Successful merges:

 - #146925 (Add doc for va_list APIs)
 - #147035 (alloc: fix `Debug` implementation of `ExtractIf`)
 - #147173 (Add support for hexagon-unknown-qurt target)
 - #149041 (ignore unsized types in mips64 and sparc64 callconvs)
 - #149056 (fix the fragment_in_dst_padding_gets_overwritten test on s390x)
 - #149095 (rustc-dev-guide subtree update)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_target/src/callconv/mips64.rs

@@ -148,12 +148,12 @@ where
     Ty: TyAbiInterface<'a, C> + Copy,
     C: HasDataLayout,
 {
-    if !fn_abi.ret.is_ignore() {
+    if !fn_abi.ret.is_ignore() && fn_abi.ret.layout.is_sized() {
         classify_ret(cx, &mut fn_abi.ret);
     }
 
     for arg in fn_abi.args.iter_mut() {
-        if arg.is_ignore() {
+        if arg.is_ignore() || !arg.layout.is_sized() {
             continue;
         }
         classify_arg(cx, arg);

compiler/rustc_target/src/callconv/sparc64.rs

@@ -216,11 +216,14 @@ where
     Ty: TyAbiInterface<'a, C> + Copy,
     C: HasDataLayout + HasTargetSpec,
 {
-    if !fn_abi.ret.is_ignore() {
+    if !fn_abi.ret.is_ignore() && fn_abi.ret.layout.is_sized() {
         classify_arg(cx, &mut fn_abi.ret, Size::from_bytes(32));
     }
 
     for arg in fn_abi.args.iter_mut() {
+        if !arg.layout.is_sized() {
+            continue;
+        }
         if arg.is_ignore() {
             // sparc64-unknown-linux-{gnu,musl,uclibc} doesn't ignore ZSTs.
             if cx.target_spec().os == Os::Linux

compiler/rustc_target/src/spec/mod.rs

@@ -1490,6 +1490,7 @@ supported_targets! {
     ("mips64el-unknown-linux-muslabi64", mips64el_unknown_linux_muslabi64),
     ("hexagon-unknown-linux-musl", hexagon_unknown_linux_musl),
     ("hexagon-unknown-none-elf", hexagon_unknown_none_elf),
+    ("hexagon-unknown-qurt", hexagon_unknown_qurt),
 
     ("mips-unknown-linux-uclibc", mips_unknown_linux_uclibc),
     ("mipsel-unknown-linux-uclibc", mipsel_unknown_linux_uclibc),
@@ -1958,6 +1959,7 @@ crate::target_spec_enum! {
         OpenBsd = "openbsd",
         Psp = "psp",
         Psx = "psx",
+        Qurt = "qurt",
         Redox = "redox",
         Rtems = "rtems",
         Solaris = "solaris",

compiler/rustc_target/src/spec/targets/hexagon_unknown_qurt.rs

@@ -0,0 +1,45 @@
+use crate::spec::{Arch, Cc, LinkerFlavor, Lld, Os, Target, TargetMetadata, TargetOptions, cvs};
+
+pub(crate) fn target() -> Target {
+    let mut base = TargetOptions::default();
+    base.add_pre_link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), &["-G0"]);
+
+    Target {
+        llvm_target: "hexagon-unknown-elf".into(),
+        metadata: TargetMetadata {
+            description: Some("Hexagon QuRT".into()),
+            tier: Some(3),
+            host_tools: Some(false),
+            std: Some(false),
+        },
+        pointer_width: 32,
+        data_layout: "\
+            e-m:e-p:32:32:32-a:0-n16:32-i64:64:64-i32:32\
+            :32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-v32\
+            :32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048\
+            :2048:2048"
+            .into(),
+        arch: Arch::Hexagon,
+        options: TargetOptions {
+            os: Os::Qurt,
+            vendor: "unknown".into(),
+            cpu: "hexagonv69".into(),
+            linker: Some("rust-lld".into()),
+            linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
+            exe_suffix: ".elf".into(),
+            dynamic_linking: true,
+            executables: true,
+            families: cvs!["unix"],
+            has_thread_local: true,
+            has_rpath: false,
+            crt_static_default: false,
+            crt_static_respected: true,
+            crt_static_allows_dylibs: true,
+            no_default_libraries: false,
+            max_atomic_width: Some(32),
+            features: "-small-data,+hvx-length128b".into(),
+            c_enum_min_bits: Some(8),
+            ..base
+        },
+    }
+}

library/alloc/src/vec/extract_if.rs

@@ -130,7 +130,20 @@ where
     A: Allocator,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let peek = if self.idx < self.end { self.vec.get(self.idx) } else { None };
+        let peek = if self.idx < self.end {
+            // This has to use pointer arithmetic as `self.vec[self.idx]` or
+            // `self.vec.get_unchecked(self.idx)` wouldn't work since we
+            // temporarily set the length of `self.vec` to zero.
+            //
+            // SAFETY:
+            // Since `self.idx` is smaller than `self.end` and `self.end` is
+            // smaller than `self.old_len`, `idx` is valid for indexing the
+            // buffer. Also, per the invariant of `self.idx`, this element
+            // has not been inspected/moved out yet.
+            Some(unsafe { &*self.vec.as_ptr().add(self.idx) })
+        } else {
+            None
+        };
         f.debug_struct("ExtractIf").field("peek", &peek).finish_non_exhaustive()
     }
 }

library/alloctests/tests/vec.rs

@@ -1650,6 +1650,17 @@ fn extract_if_unconsumed() {
     assert_eq!(vec, [1, 2, 3, 4]);
 }
 
+#[test]
+fn extract_if_debug() {
+    let mut vec = vec![1, 2];
+    let mut drain = vec.extract_if(.., |&mut x| x % 2 != 0);
+    assert!(format!("{drain:?}").contains("Some(1)"));
+    drain.next();
+    assert!(format!("{drain:?}").contains("Some(2)"));
+    drain.next();
+    assert!(format!("{drain:?}").contains("None"));
+}
+
 #[test]
 fn test_reserve_exact() {
     // This is all the same as test_reserve

library/core/src/ffi/va_list.rs

@@ -243,10 +243,11 @@ impl<'f> VaListImpl<'f> {
     ///
     /// # Safety
     ///
-    /// This function is only sound to call when the next variable argument:
+    /// This function is only sound to call when:
     ///
-    /// - has a type that is ABI-compatible with the type `T`
-    /// - has a value that is a properly initialized value of type `T`
+    /// - there is a next variable argument available.
+    /// - the next argument's type must be ABI-compatible with the type `T`.
+    /// - the next argument must have a properly initialized value of type `T`.
     ///
     /// Calling this function with an incompatible type, an invalid value, or when there
     /// are no more variable arguments, is unsound.

library/core/src/intrinsics/mod.rs

@@ -3350,22 +3350,41 @@ pub(crate) const fn miri_promise_symbolic_alignment(ptr: *const (), align: usize
 
 /// Copies the current location of arglist `src` to the arglist `dst`.
 ///
-/// FIXME: document safety requirements
+/// # Safety
+///
+/// You must check the following invariants before you call this function:
+///
+/// - `dest` must be non-null and point to valid, writable memory.
+/// - `dest` must not alias `src`.
+///
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub unsafe fn va_copy<'f>(dest: *mut VaListImpl<'f>, src: &VaListImpl<'f>);
 
 /// Loads an argument of type `T` from the `va_list` `ap` and increment the
 /// argument `ap` points to.
 ///
-/// FIXME: document safety requirements
+/// # Safety
+///
+/// This function is only sound to call when:
+///
+/// - there is a next variable argument available.
+/// - the next argument's type must be ABI-compatible with the type `T`.
+/// - the next argument must have a properly initialized value of type `T`.
+///
+/// Calling this function with an incompatible type, an invalid value, or when there
+/// are no more variable arguments, is unsound.
+///
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub unsafe fn va_arg<T: VaArgSafe>(ap: &mut VaListImpl<'_>) -> T;
 
 /// Destroy the arglist `ap` after initialization with `va_start` or `va_copy`.
 ///
-/// FIXME: document safety requirements
+/// # Safety
+///
+/// `ap` must not be used to access variable arguments after this call.
+///
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub unsafe fn va_end(ap: &mut VaListImpl<'_>);

src/bootstrap/src/core/sanity.rs

@@ -41,6 +41,7 @@ const STAGE0_MISSING_TARGETS: &[&str] = &[
     "sparc64-unknown-helenos",
     // just a dummy comment so the list doesn't get onelined
     "riscv64gc-unknown-redox",
+    "hexagon-unknown-qurt",
 ];
 
 /// Minimum version threshold for libstdc++ required when using prebuilt LLVM

src/doc/rustc-dev-guide/.github/workflows/ci.yml

@@ -22,7 +22,7 @@ jobs:
       BASE_SHA: ${{ github.event.pull_request.base.sha }}
       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           # linkcheck needs the base commit.
           fetch-depth: 0
@@ -83,8 +83,18 @@ jobs:
           git commit -m "Deploy ${GITHUB_SHA} to gh-pages"
           git push --quiet -f "https://x-token:${{ secrets.GITHUB_TOKEN }}@github.com/${GITHUB_REPOSITORY}" HEAD:gh-pages
 
+      - name: Cache sembr build
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            ci/sembr/target/
+          key: sembr-${{ hashFiles('ci/sembr/Cargo.lock') }}
+
       - name: Check if files comply with semantic line breaks
         continue-on-error: true
         run: |
           # using split_inclusive that uses regex feature that uses an unstable feature
-          RUSTC_BOOTSTRAP=1 cargo run --manifest-path ci/sembr/Cargo.toml src
+          RUSTC_BOOTSTRAP=1 cargo run --release --manifest-path ci/sembr/Cargo.toml src