Auto merge of #157882 - jhpratt:rollup-0Jd14n0, r=jhpratt

bors · bors · commit 9ae5f5231868 · 2026-06-14T03:57:23.000Z
Rollup of 5 pull requests Successful merges: - #157837 ([tiny] Remove some unecessary `.into()` calls) - #157538 (std: move `PidFd` to `sys::process`) - #157791 (Add regression test for pclmulqdq inlining across target feature) - #157867 (std: sys: xous: clamp condvar wait_timeout instead of truncating) - #157876 (Stabilize `#![feature(box_as_ptr)]`)
diff --git a/compiler/rustc_builtin_macros/src/autodiff.rs b/compiler/rustc_builtin_macros/src/autodiff.rs
@@ -567,8 +567,7 @@ mod llvm_enzyme {
                     PatKind::Ident(_, ident, _) => ecx.expr_path(ecx.path_ident(span, ident)),
                     _ => todo!(),
                 })
-                .collect::<ThinVec<_>>()
-                .into(),
+                .collect::<ThinVec<_>>(),
         );
 
         let enzyme_path_idents = ecx.std_path(&[sym::intrinsics, sym::autodiff]);
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -773,7 +773,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             _ => return interp_ok(false),
         }
 
-        trace!("{:?}", self.dump_place(&dest.clone().into()));
+        trace!("{:?}", self.dump_place(&dest));
         self.return_to_block(ret)?;
         interp_ok(true)
     }
diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
@@ -27,10 +27,10 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![allow(rustc::direct_use_of_rustc_type_ir)]
+#![cfg_attr(bootstrap, feature(box_as_ptr))]
 #![cfg_attr(doc, feature(intra_doc_pointers))]
 #![feature(allocator_api)]
 #![feature(associated_type_defaults)]
-#![feature(box_as_ptr)]
 #![feature(closure_track_caller)]
 #![feature(const_default)]
 #![feature(const_trait_impl)]
diff --git a/compiler/rustc_symbol_mangling/src/lib.rs b/compiler/rustc_symbol_mangling/src/lib.rs
@@ -219,7 +219,7 @@ fn compute_symbol_name<'tcx>(
         // However, we don't have the wasm import module map there yet.
         tcx.is_foreign_item(def_id)
             && tcx.sess.target.is_like_wasm
-            && tcx.wasm_import_module_map(def_id.krate).contains_key(&def_id.into())
+            && tcx.wasm_import_module_map(def_id.krate).contains_key(&def_id)
     };
 
     if !wasm_import_module_exception_force_mangling {
diff --git a/compiler/rustc_traits/src/normalize_projection_ty.rs b/compiler/rustc_traits/src/normalize_projection_ty.rs
@@ -54,7 +54,7 @@ fn normalize_canonicalized_projection<'tcx>(
             let normalized_term = traits::normalize_projection_term(
                 selcx,
                 param_env,
-                goal.into(),
+                goal,
                 cause,
                 0,
                 &mut obligations,
diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
@@ -1763,8 +1763,6 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     /// Due to the aliasing guarantee, the following code is legal:
     ///
     /// ```rust
-    /// #![feature(box_as_ptr)]
-    ///
     /// unsafe {
     ///     let mut b = Box::new(0);
     ///     let ptr1 = Box::as_mut_ptr(&mut b);
@@ -1778,7 +1776,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     ///
     /// [`as_mut_ptr`]: Self::as_mut_ptr
     /// [`as_ptr`]: Self::as_ptr
-    #[unstable(feature = "box_as_ptr", issue = "129090")]
+    #[stable(feature = "box_as_ptr", since = "CURRENT_RUSTC_VERSION")]
     #[rustc_never_returns_null_ptr]
     #[rustc_as_ptr]
     #[inline]
@@ -1809,8 +1807,6 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     /// Due to the aliasing guarantee, the following code is legal:
     ///
     /// ```rust
-    /// #![feature(box_as_ptr)]
-    ///
     /// unsafe {
     ///     let mut v = Box::new(0);
     ///     let ptr1 = Box::as_ptr(&v);
@@ -1827,7 +1823,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     ///
     /// [`as_mut_ptr`]: Self::as_mut_ptr
     /// [`as_ptr`]: Self::as_ptr
-    #[unstable(feature = "box_as_ptr", issue = "129090")]
+    #[stable(feature = "box_as_ptr", since = "CURRENT_RUSTC_VERSION")]
     #[rustc_never_returns_null_ptr]
     #[rustc_as_ptr]
     #[inline]
diff --git a/library/core/src/mem/maybe_dangling.rs b/library/core/src/mem/maybe_dangling.rs
@@ -13,7 +13,6 @@ use crate::{mem, ptr};
 /// executing (particularly in concurrent code). As a somewhat absurd example, consider this code:
 ///
 /// ```rust,no_run
-/// #![feature(box_as_ptr)]
 /// # use std::alloc::{dealloc, Layout};
 /// # use std::mem;
 ///
@@ -35,7 +34,7 @@ use crate::{mem, ptr};
 ///
 // FIXME: remove `no_run` once the semantics are actually implemented
 /// ```rust,no_run
-/// #![feature(maybe_dangling, box_as_ptr)]
+/// #![feature(maybe_dangling)]
 /// # use std::alloc::{dealloc, Layout};
 /// # use std::mem::{self, MaybeDangling};
 ///
diff --git a/library/std/src/os/linux/process.rs b/library/std/src/os/linux/process.rs
@@ -9,7 +9,7 @@ use crate::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, Owned
 use crate::process::{self, ExitStatus};
 use crate::sys::{AsInner, AsInnerMut, FromInner, IntoInner};
 #[cfg(not(doc))]
-use crate::sys::{fd::FileDesc, linux::pidfd::PidFd as InnerPidFd};
+use crate::sys::{fd::FileDesc, process::PidFd as InnerPidFd};
 
 #[cfg(doc)]
 struct InnerPidFd;
diff --git a/library/std/src/sys/pal/unix/linux/mod.rs b/library/std/src/sys/pal/unix/linux/mod.rs
diff --git a/library/std/src/sys/pal/unix/mod.rs b/library/std/src/sys/pal/unix/mod.rs
@@ -6,8 +6,6 @@ pub mod conf;
 #[cfg(target_os = "fuchsia")]
 pub mod fuchsia;
 pub mod futex;
-#[cfg(target_os = "linux")]
-pub mod linux;
 pub mod stack_overflow;
 pub mod sync;
 pub mod thread_parking;
diff --git a/library/std/src/sys/process/mod.rs b/library/std/src/sys/process/mod.rs
@@ -29,6 +29,8 @@ mod env;
 pub use env::CommandEnvs;
 #[unstable(feature = "command_resolved_envs", issue = "149070")]
 pub use env::CommandResolvedEnvs;
+#[cfg(target_os = "linux")]
+pub use imp::PidFd;
 #[cfg(target_family = "unix")]
 pub use imp::getppid;
 pub use imp::{
diff --git a/library/std/src/sys/process/unix/mod.rs b/library/std/src/sys/process/unix/mod.rs
@@ -21,7 +21,12 @@ cfg_select! {
     }
 }
 
+#[cfg(target_os = "linux")]
+mod pidfd;
+
 pub use imp::{ExitStatus, ExitStatusError, Process};
+#[cfg(target_os = "linux")]
+pub use pidfd::PidFd;
 
 pub use self::common::{
     ChildPipe, Command, CommandArgs, ExitCode, Stdio, getpid, getppid, read_output,
diff --git a/library/std/src/sys/process/unix/pidfd.rs b/library/std/src/sys/process/unix/pidfd.rs
@@ -1,29 +1,29 @@
+use super::ExitStatus;
 use crate::io;
 use crate::os::fd::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
 use crate::sys::fd::FileDesc;
-use crate::sys::process::ExitStatus;
 use crate::sys::{AsInner, FromInner, IntoInner, cvt};
 
 #[cfg(test)]
 mod tests;
 
 #[derive(Debug)]
-pub(crate) struct PidFd(FileDesc);
+pub struct PidFd(FileDesc);
 
 impl PidFd {
     pub fn kill(&self) -> io::Result<()> {
         self.send_signal(libc::SIGKILL)
     }
 
     #[cfg(any(test, target_env = "gnu", target_env = "musl"))]
-    pub(crate) fn current_process() -> io::Result<PidFd> {
+    pub fn current_process() -> io::Result<PidFd> {
         let pid = crate::process::id();
         let pidfd = cvt(unsafe { libc::syscall(libc::SYS_pidfd_open, pid, 0) })?;
         Ok(unsafe { PidFd::from_raw_fd(pidfd as RawFd) })
     }
 
     #[cfg(any(test, target_env = "gnu", target_env = "musl"))]
-    pub(crate) fn pid(&self) -> io::Result<u32> {
+    pub fn pid(&self) -> io::Result<u32> {
         use crate::sys::weak::weak;
 
         // since kernel 6.13
@@ -82,7 +82,7 @@ impl PidFd {
         }
     }
 
-    pub(crate) fn send_signal(&self, signal: i32) -> io::Result<()> {
+    pub fn send_signal(&self, signal: i32) -> io::Result<()> {
         cvt(unsafe {
             libc::syscall(
                 libc::SYS_pidfd_send_signal,
@@ -95,7 +95,7 @@ impl PidFd {
         .map(drop)
     }
 
-    pub(crate) fn send_process_group_signal(&self, signal: i32) -> io::Result<()> {
+    pub fn send_process_group_signal(&self, signal: i32) -> io::Result<()> {
         // since kernel 6.9
         // https://lore.kernel.org/all/20240210-chihuahua-hinzog-3945b6abd44a@brauner/
         cvt(unsafe {
diff --git a/library/std/src/sys/process/unix/pidfd/tests.rs b/library/std/src/sys/process/unix/pidfd/tests.rs
diff --git a/library/std/src/sys/process/unix/unix.rs b/library/std/src/sys/process/unix/unix.rs
@@ -16,7 +16,7 @@ use crate::num::NonZero;
 use crate::process::StdioPipes;
 use crate::sys::cvt;
 #[cfg(target_os = "linux")]
-use crate::sys::pal::linux::pidfd::PidFd;
+use crate::sys::process::PidFd;
 use crate::{fmt, mem, sys};
 
 cfg_select! {
@@ -1279,8 +1279,7 @@ impl ExitStatusError {
 mod linux_child_ext {
     use crate::io::ErrorKind;
     use crate::os::linux::process as os;
-    use crate::sys::FromInner;
-    use crate::sys::pal::linux::pidfd as imp;
+    use crate::sys::{FromInner, process as imp};
     use crate::{io, mem};
 
     #[unstable(feature = "linux_pidfd", issue = "82971")]
diff --git a/library/std/src/sys/sync/condvar/xous.rs b/library/std/src/sys/sync/condvar/xous.rs
@@ -124,11 +124,9 @@ impl Condvar {
     }
 
     pub unsafe fn wait_timeout(&self, mutex: &Mutex, dur: Duration) -> bool {
-        let mut millis = dur.as_millis() as usize;
-        // Ensure we don't wait for 0 ms, which would cause us to wait forever
-        if millis == 0 {
-            millis = 1;
-        }
+        // A value of zero indicates an indefinite wait, so clamp the number of
+        // milliseconds to the representable range and avoid waiting forever.
+        let millis = usize::max(dur.as_millis().try_into().unwrap_or(usize::MAX), 1);
         self.wait_ms(mutex, millis)
     }
 }
diff --git a/src/tools/miri/tests/genmc/fail/atomics/atomic_ptr_invalid_provenance.rs b/src/tools/miri/tests/genmc/fail/atomics/atomic_ptr_invalid_provenance.rs
@@ -4,7 +4,6 @@
 // We have two variants, one where we send such a pointer to GenMC, and one where we make it on the GenMC side.
 
 #![no_main]
-#![feature(box_as_ptr)]
 
 use std::sync::atomic::AtomicPtr;
 use std::sync::atomic::Ordering::*;
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_write_access.rs b/src/tools/miri/tests/native-lib/pass/ptr_write_access.rs
@@ -3,8 +3,6 @@
 //@[trace] compile-flags: -Zmiri-native-lib-enable-tracing
 //@compile-flags: -Zmiri-permissive-provenance
 
-#![feature(box_as_ptr)]
-
 use std::mem::MaybeUninit;
 use std::ptr;
 
diff --git a/src/tools/miri/tests/pass/tree_borrows/cell-inside-box.rs b/src/tools/miri/tests/pass/tree_borrows/cell-inside-box.rs
@@ -1,7 +1,6 @@
 //@revisions: tree tree_implicit_writes
 //@[tree_implicit_writes]compile-flags: -Zmiri-tree-borrows-implicit-writes
 //@compile-flags: -Zmiri-tree-borrows
-#![feature(box_as_ptr)]
 #[path = "../../utils/mod.rs"]
 #[macro_use]
 mod utils;
diff --git a/tests/codegen-llvm/pclmulqdq-target-feature-inlining.rs b/tests/codegen-llvm/pclmulqdq-target-feature-inlining.rs
@@ -0,0 +1,31 @@
+//@ only-x86_64
+//@ compile-flags: -C opt-level=3
+
+//! Regression test for https://github.com/rust-lang/rust/issues/139029
+//!
+//! The pclmulqdq intrinsics should inline into functions with the required target features.
+
+#![crate_type = "lib"]
+
+use std::arch::x86_64 as arch;
+
+// CHECK-LABEL: @reduce128_caller
+// CHECK-NEXT: start
+// CHECK-COUNT-3: load
+// CHECK-NEXT: call <2 x i64> @llvm.x86.pclmulqdq
+// CHECK-NEXT: call <2 x i64> @llvm.x86.pclmulqdq
+#[target_feature(enable = "pclmulqdq", enable = "sse2", enable = "sse4.1")]
+#[no_mangle]
+pub unsafe fn reduce128_caller(
+    a: arch::__m128i,
+    b: arch::__m128i,
+    keys: arch::__m128i,
+) -> arch::__m128i {
+    reduce128(a, b, keys)
+}
+
+unsafe fn reduce128(a: arch::__m128i, b: arch::__m128i, keys: arch::__m128i) -> arch::__m128i {
+    let t1 = arch::_mm_clmulepi64_si128(a, keys, 0x00);
+    let t2 = arch::_mm_clmulepi64_si128(a, keys, 0x11);
+    arch::_mm_xor_si128(arch::_mm_xor_si128(b, t1), t2)
+}

Original file line number	Diff line number	Diff line change
`@@ -773,7 +773,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {`
`773`	`773`	`_ => return interp_ok(false),`
`774`	`774`	`}`
`775`	`775`
`776`		`- trace!("{:?}", self.dump_place(&dest.clone().into()));`
	`776`	`+ trace!("{:?}", self.dump_place(&dest));`
`777`	`777`	`self.return_to_block(ret)?;`
`778`	`778`	`interp_ok(true)`
`779`	`779`	`}`