Auto merge of #156118 - RalfJung:miri, r=RalfJung

miri subtree update

Subtree update of `miri` to rust-lang/miri@0853747.

Created using https://github.com/rust-lang/josh-sync.

r? @ghost

Author: bors

src/tools/miri/.github/workflows/ci.yml

@@ -58,7 +58,7 @@ jobs:
     env:
       HOST_TARGET: ${{ matrix.host_target }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: install multiarch
         if: ${{ matrix.multiarch != '' }}
         run: |
@@ -105,7 +105,7 @@ jobs:
     name: style checks
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: ./.github/workflows/setup
 
       - name: rustfmt
@@ -121,7 +121,7 @@ jobs:
     name: bootstrap build
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       # Deliberately skipping `./.github/workflows/setup` as we do our own setup
       - name: Add cache for cargo
         id: cache
@@ -156,7 +156,7 @@ jobs:
     name: coverage report
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: ./.github/workflows/setup
       - name: coverage
         run: ./miri test --coverage
@@ -191,7 +191,7 @@ jobs:
         pull-requests: write
     if: ${{ github.event_name == 'schedule' }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 256 # get a bit more of the history
       - name: install josh-sync
@@ -205,7 +205,7 @@ jobs:
       - name: Install rustup-toolchain-install-master
         run: cargo install -f rustup-toolchain-install-master
       # Create a token for the next step so it can create a PR that actually runs CI.
-      - uses: actions/create-github-app-token@v2
+      - uses: actions/create-github-app-token@v3
         id: app-token
         with:
           app-id: ${{ vars.APP_CLIENT_ID }}

src/tools/miri/.github/workflows/sysroots.yml

@@ -13,7 +13,7 @@ jobs:
     name: Build the sysroots
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Build the sysroots
         run: |
           rustup toolchain install nightly
@@ -25,7 +25,7 @@ jobs:
       - name: Upload build errors
         # We don't want to skip this step on failure
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: failures
           path: failures.tar.gz
@@ -38,7 +38,7 @@ jobs:
     steps:
       # Download our build error logs
       - name: Download build errors
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
         with:
           name: failures
       # Send a Zulip notification

src/tools/miri/rust-version

@@ -1 +1 @@
-9836b06b55f5389f605ee7766eeecd9f17a86cb5
+44860d3e9ef700cac0b4a61d924f41f46bf1b447

src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs

@@ -1,4 +1,5 @@
 use rustc_abi::Size;
+use rustc_hir::find_attr;
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty::layout::HasTypingEnv;
 use rustc_middle::ty::{self, Ty};
@@ -137,16 +138,23 @@ impl<'tcx> NewPermission {
         let ty_is_freeze = pointee.is_freeze(*cx.tcx, cx.typing_env());
         let is_protected = mode == RetagMode::FnEntry;
 
-        // Check if the implicit writes check has been enabled for this function using the `-Zmiri-tree-borrows-implicit-writes` flag
-        let implicit_writes = cx
-            .machine
-            .borrow_tracker
-            .as_ref()
-            .unwrap()
-            .borrow()
-            .borrow_tracker_method
-            .get_tree_borrows_params()
-            .implicit_writes;
+        // Check if the implicit writes feature is globally enabled, using the
+        // `-Zmiri-tree-borrows-implicit-writes` flag, and not locally disabled using the
+        // `#[rustc_no_writable]` attribute. For performance reasons, only performs the lookup if
+        // is_protected is true as implicit writes are only performed for protected references.
+        let implicit_writes_enabled = is_protected && {
+            let implicit_writes = cx
+                .machine
+                .borrow_tracker
+                .as_ref()
+                .unwrap()
+                .borrow()
+                .borrow_tracker_method
+                .get_tree_borrows_params()
+                .implicit_writes;
+            let def_id = cx.frame().instance().def_id();
+            implicit_writes && !find_attr!(cx.tcx, def_id, RustcNoWritable)
+        };
 
         if matches!(ref_mutability, Some(Mutability::Mut) | None if !ty_is_unpin) {
             // Mutable reference / Box to pinning type: retagging is a NOP.
@@ -179,7 +187,7 @@ impl<'tcx> NewPermission {
                     },
                 // Mutable references
                 Some(Mutability::Mut) => {
-                    if is_protected && implicit_writes && !matches!(part, Outside) {
+                    if implicit_writes_enabled && !matches!(part, Outside) {
                         // We cannot use `Unique` for the outside part.
                         Permission::new_unique()
                     } else if is_protected || frozen {
@@ -191,8 +199,8 @@ impl<'tcx> NewPermission {
                     }
                 }
                 // Boxes
-                None =>
-                    if is_protected && implicit_writes && !matches!(part, Outside) {
+                None => {
+                    if implicit_writes_enabled && !matches!(part, Outside) {
                         // Boxes are treated the same as mutable references.
                         Permission::new_unique()
                     } else if is_protected || frozen {
@@ -201,7 +209,8 @@ impl<'tcx> NewPermission {
                         Permission::new_reserved_frz()
                     } else {
                         Permission::new_reserved_im()
-                    },
+                    }
+                }
             }
         };
 
@@ -477,15 +486,15 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         mode: RetagMode,
     ) -> InterpResult<'tcx, Option<ImmTy<'tcx>>> {
         let this = self.eval_context_mut();
-        let new_perm = match ty.kind() {
+        let new_perm = match *ty.kind() {
             _ if ty.is_box_global(*this.tcx) => {
                 // The `None` marks this as a Box.
                 NewPermission::new(ty.builtin_deref(true).unwrap(), None, mode, this)
             }
-            &ty::Ref(_, pointee, mutability) =>
+            ty::Ref(_, pointee, mutability) =>
                 NewPermission::new(pointee, Some(mutability), mode, this),
 
-            &ty::RawPtr(..) => {
+            ty::RawPtr(..) => {
                 assert!(mode == RetagMode::Raw);
                 // We don't give new tags to raw pointers.
                 None

src/tools/miri/src/concurrency/blocking_io.rs

@@ -219,7 +219,7 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
         let this = self.eval_context_mut();
         this.machine.blocking_io.register(
             source_fd,
-            InterestReceiver::UnblockThread(this.machine.threads.active_thread()),
+            InterestReceiver::UnblockThread(this.active_thread()),
             interests,
         );
         this.block_thread(BlockReason::IO, timeout, callback);

src/tools/miri/src/concurrency/thread.rs

@@ -90,7 +90,7 @@ impl From<ThreadId> for u64 {
 }
 
 /// Keeps track of what the thread is blocked on.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum BlockReason {
     /// The thread tried to join the specified thread and is blocked until that
     /// thread terminates.
@@ -151,8 +151,8 @@ impl<'tcx> ThreadState<'tcx> {
         matches!(self, ThreadState::Terminated)
     }
 
-    fn is_blocked_on(&self, reason: BlockReason) -> bool {
-        matches!(*self, ThreadState::Blocked { reason: actual_reason, .. } if actual_reason == reason)
+    fn is_blocked_on(&self, reason: &BlockReason) -> bool {
+        matches!(self, ThreadState::Blocked { reason: actual_reason, .. } if actual_reason == reason)
     }
 }
 
@@ -421,9 +421,14 @@ pub enum TimeoutAnchor {
     Absolute,
 }
 
-/// An error signaling that the requested thread doesn't exist.
+/// An error signaling that the requested thread doesn't exist or has terminated.
 #[derive(Debug, Copy, Clone)]
-pub struct ThreadNotFound;
+pub enum ThreadLookupError {
+    /// No thread with this ID exists.
+    InvalidId,
+    /// The thread exists but has already terminated.
+    Terminated(ThreadId),
+}
 
 /// A set of threads.
 #[derive(Debug)]
@@ -489,13 +494,21 @@ impl<'tcx> ThreadManager<'tcx> {
         }
     }
 
-    pub fn thread_id_try_from(&self, id: impl TryInto<u32>) -> Result<ThreadId, ThreadNotFound> {
+    /// Returns the `ThreadId` for the given raw thread id.
+    /// Returns `Err(ThreadNotFound::InvalidId)` if the id is out of range, or
+    /// `Err(ThreadNotFound::Terminated(id))` if the thread exists but has terminated.
+    pub fn thread_id_try_from(&self, id: impl TryInto<u32>) -> Result<ThreadId, ThreadLookupError> {
         if let Ok(id) = id.try_into()
             && usize::try_from(id).is_ok_and(|id| id < self.threads.len())
         {
-            Ok(ThreadId(id))
+            let thread_id = ThreadId(id);
+            if self.threads[thread_id].state.is_terminated() {
+                Err(ThreadLookupError::Terminated(thread_id))
+            } else {
+                Ok(thread_id)
+            }
         } else {
-            Err(ThreadNotFound)
+            Err(ThreadLookupError::InvalidId)
         }
     }
 
@@ -696,7 +709,7 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
                 // If a thread is blocked on GenMC, we have to implicitly unblock it when it gets scheduled again.
                 if this.machine.threads.threads[next_thread_id]
                     .state
-                    .is_blocked_on(BlockReason::Genmc)
+                    .is_blocked_on(&BlockReason::Genmc)
                 {
                     info!(
                         "GenMC: scheduling blocked thread {next_thread_id:?}, so we unblock it now."
@@ -798,7 +811,7 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
         } else if thread_manager
             .threads
             .iter()
-            .any(|thread| thread.state.is_blocked_on(BlockReason::IO))
+            .any(|thread| thread.state.is_blocked_on(&BlockReason::IO))
         {
             // At least one thread is blocked on host I/O but doesn't
             // have a timeout set. Hence, we sleep indefinitely in the
@@ -884,7 +897,7 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     #[inline]
-    fn thread_id_try_from(&self, id: impl TryInto<u32>) -> Result<ThreadId, ThreadNotFound> {
+    fn thread_id_try_from(&self, id: impl TryInto<u32>) -> Result<ThreadId, ThreadLookupError> {
         self.eval_context_ref().machine.threads.thread_id_try_from(id)
     }
 
@@ -1059,11 +1072,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let threads = &this.machine.threads.threads;
         let joining_threads = threads
             .iter_enumerated()
-            .filter(|(_, thread)| thread.state.is_blocked_on(unblock_reason))
+            .filter(|(_, thread)| thread.state.is_blocked_on(&unblock_reason))
             .map(|(id, _)| id)
             .collect::<Vec<_>>();
         for thread in joining_threads {
-            this.unblock_thread(thread, unblock_reason)?;
+            this.unblock_thread(thread, unblock_reason.clone())?;
         }
 
         interp_ok(())
@@ -1231,9 +1244,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         // Sanity check `join_status`.
         assert!(
-            threads
-                .iter()
-                .all(|thread| { !thread.state.is_blocked_on(BlockReason::Join(joined_thread_id)) }),
+            threads.iter().all(|thread| {
+                !thread.state.is_blocked_on(&BlockReason::Join(joined_thread_id))
+            }),
             "this thread already has threads waiting for its termination"
         );
 

src/tools/miri/src/shims/env.rs

@@ -1,3 +1,4 @@
+use std::assert_matches;
 use std::ffi::{OsStr, OsString};
 
 use rustc_data_structures::fx::FxHashMap;
@@ -108,23 +109,22 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         if this.machine.communicate() { std::process::id() } else { 1000 }
     }
 
-    /// Get an "OS" thread ID for the current thread.
-    fn get_current_tid(&self) -> u32 {
+    /// Get an "OS" thread ID for any thread.
+    fn get_tid(&self, thread: ThreadId) -> u32 {
         let this = self.eval_context_ref();
-        self.get_tid(this.machine.threads.active_thread())
+        assert!(this.target_os_is_unix());
+        // On Linux, the main thread has PID == TID so we uphold this. For simplicity we do it
+        // everywhere. That also ensures this ID is different from what is returned by
+        // `pthread_self`.
+        this.get_pid().strict_add(thread.to_u32())
     }
 
-    /// Get an "OS" thread ID for any thread.
-    fn get_tid(&self, thread: ThreadId) -> u32 {
+    /// Convert TID back to a `ThreadId`, or `None` if it is invalid or the thread has terminated.
+    fn get_thread_id_from_linux_tid(&self, tid: u32) -> Option<ThreadId> {
         let this = self.eval_context_ref();
-        let index = thread.to_u32();
-        let target_os = &this.tcx.sess.target.os;
-        if matches!(target_os, Os::Linux | Os::Android) {
-            // On Linux, the main thread has PID == TID so we uphold this.
-            this.get_pid().strict_add(index)
-        } else {
-            // Other platforms do not display any relationship between PID and TID.
-            index
-        }
+        assert_matches!(this.tcx.sess.target.os, Os::Linux | Os::Android);
+        // TID = PID + thread_index => index = TID - PID.
+        let id = tid.checked_sub(this.get_pid())?;
+        this.machine.threads.thread_id_try_from(id).ok()
     }
 }

src/tools/miri/src/shims/foreign_items.rs

@@ -459,7 +459,13 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 )?;
 
                 let thread = this.read_target_usize(thread_id)?;
-                if let Ok(thread) = this.thread_id_try_from(thread) {
+                // Joining a terminated thread is valid.
+                use crate::concurrency::thread::ThreadLookupError;
+                let thread = match this.thread_id_try_from(thread) {
+                    Ok(id) | Err(ThreadLookupError::Terminated(id)) => Some(id),
+                    Err(ThreadLookupError::InvalidId) => None,
+                };
+                if let Some(thread) = thread {
                     this.join_thread_exclusive(
                         thread,
                         /* success_retval */ Scalar::from_bool(true),

src/tools/miri/src/shims/io_error.rs

@@ -251,6 +251,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn io_error_to_errnum(&self, err: std::io::Error) -> InterpResult<'tcx, Scalar> {
         let this = self.eval_context_ref();
         let target = &this.tcx.sess.target;
+
         if target.families.iter().any(|f| f == "unix") {
             for &(name, kind) in UNIX_IO_ERROR_TABLE {
                 if err.kind() == kind {

src/tools/miri/src/shims/unix/env.rs

@@ -269,7 +269,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         // For most platforms the return type is an `i32`, but some are unsigned. The TID
         // will always be positive so we don't need to differentiate.
-        interp_ok(Scalar::from_u32(this.get_current_tid()))
+        interp_ok(Scalar::from_u32(this.get_tid(this.active_thread())))
     }
 
     /// `fields_size`, if present, says how large each field of the struct is.
@@ -323,7 +323,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     /// allows querying the ID for arbitrary threads, identified by their pthread_t.
     ///
     /// API documentation: <https://www.manpagez.com/man/3/pthread_threadid_np/>.
-    fn apple_pthread_threadip_np(
+    fn apple_pthread_threadid_np(
         &mut self,
         thread_op: &OpTy<'tcx>,
         tid_op: &OpTy<'tcx>,
@@ -349,6 +349,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             thread
         };
 
+        // This returns an `int`, not a `pthread_t`, so we treat it like we treat `gettid` on Linux.
         let tid = this.get_tid(thread);
         let tid_dest = this.deref_pointer_as(tid_op, this.machine.layouts.u64)?;
         this.write_int(tid, &tid_dest)?;