Rollup merge of #156739 - RalfJung:miri, r=RalfJung

miri subtree update

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

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

r? @ghost

Author: JonathanBrouwer

src/tools/miri/miri-script/src/commands.rs

@@ -114,8 +114,8 @@ impl Command {
             Command::Check { features, flags } => Self::check(features, flags),
             Command::Test { bless, target, coverage, features, flags } =>
                 Self::test(bless, target, coverage, features, flags),
-            Command::Run { dep, quiet, target, edition, features, flags } =>
-                Self::run(dep, quiet, target, edition, features, flags),
+            Command::Run { dep, native, quiet, target, edition, features, flags } =>
+                Self::run(dep, native, quiet, target, edition, features, flags),
             Command::Doc { features, flags } => Self::doc(features, flags),
             Command::Fmt { flags } => Self::fmt(flags),
             Command::Clippy { features, flags } => Self::clippy(features, flags),
@@ -465,15 +465,18 @@ impl Command {
 
     fn run(
         dep: bool,
+        native: bool,
         quiet: bool,
         target: Option<String>,
         edition: Option<String>,
         features: Vec<String>,
         flags: Vec<String>,
     ) -> Result<()> {
         let mut e = MiriEnv::new()?;
+        let run_via_ui_test = dep || native;
 
         // Preparation: get a sysroot, and get the miri binary.
+        // We do this even for native run as it also builds Miri itself.
         let miri_sysroot =
             e.build_miri_sysroot(/* quiet */ quiet, target.as_deref(), &features)?;
         let miri_bin = e
@@ -484,44 +487,45 @@ impl Command {
         // (because `flags` may contain `--`).
         let mut early_flags = Vec::<OsString>::new();
 
-        // In `dep` mode, the target is already passed via `MIRI_TEST_TARGET`
-        if !dep {
+        // In ui_test mode, the target is already passed via `MIRI_TEST_TARGET`
+        if !run_via_ui_test {
             if let Some(target) = &target {
                 early_flags.push("--target".into());
                 early_flags.push(target.into());
             }
         }
         early_flags.push("--edition".into());
         early_flags.push(edition.as_deref().unwrap_or("2021").into());
-        early_flags.push("--sysroot".into());
-        early_flags.push(miri_sysroot.into());
+        if !native {
+            early_flags.push("--sysroot".into());
+            early_flags.push(miri_sysroot.into());
+        }
 
         // Compute flags.
         let miri_flags = e.sh.var("MIRIFLAGS").unwrap_or_default();
         let miri_flags = flagsplit(&miri_flags);
-        let quiet_flag = if quiet { Some("--quiet") } else { None };
 
         // Run Miri.
         // The basic command that executes the Miri driver.
-        let mut cmd = if dep {
+        let mut cmd = if run_via_ui_test {
             // We invoke the test suite as that has all the logic for running with dependencies.
-            e.cargo_cmd(".", "test", &features)
+            let mut cmd = e
+                .cargo_cmd(".", "test", &features)
                 .args(&["--test", "ui"])
-                .args(quiet_flag)
+                // This does not show anything useful so we always hide it.
+                .arg("--quiet")
                 .arg("--")
-                .args(&["--miri-run-dep-mode"])
+                .env("MIRI_RUN_MODE", if native { "native" } else { "1" });
+            if let Some(target) = &target {
+                cmd = cmd.env("MIRI_TEST_TARGET", target);
+            }
+            cmd
         } else {
             cmd!(e.sh, "{miri_bin}")
         };
         cmd.set_quiet(quiet);
         // Add Miri flags
-        let mut cmd = cmd.args(&miri_flags).args(&early_flags).args(&flags);
-        // For `--dep` we also need to set the target in the env var.
-        if dep {
-            if let Some(target) = &target {
-                cmd = cmd.env("MIRI_TEST_TARGET", target);
-            }
-        }
+        let cmd = cmd.args(&miri_flags).args(&early_flags).args(&flags);
         // Finally, run the thing.
         Ok(cmd.run()?)
     }

src/tools/miri/miri-script/src/main.rs

@@ -78,6 +78,10 @@ pub enum Command {
         /// Build the program with the dependencies declared in `tests/deps/Cargo.toml`.
         #[arg(long)]
         dep: bool,
+        /// Compile and run the program natively instead of via Miri. Implies `--dep`.
+        /// All flags are passed to rustc; there is currently no way to pass flags to the program.
+        #[arg(long)]
+        native: bool,
         /// Hide build progress.
         #[arg(long, short)]
         quiet: bool,

src/tools/miri/rust-version

@@ -1 +1 @@
-63b1dfc0e00fd6f8ad7cd8817fc712e7d9b7be59
+281c97c3240a9abd984ca0c6a2cd7389115e80d5

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

@@ -456,7 +456,7 @@ struct DisplayFmtWrapper {
 /// will show each permission line as
 /// ```text
 /// 0.. 1.. 2.. 3.. 4.. 5
-/// [Act|Res|Frz|Dis|___]
+/// [Unq|Res|Frz|Dis|___]
 /// ```
 struct DisplayFmtPermission {
     /// Text that starts the permission block.
@@ -467,7 +467,7 @@ struct DisplayFmtPermission {
     close: S,
     /// Text to show when a permission is not initialized.
     /// Should have the same width as a `Permission`'s `.short_name()`, i.e.
-    /// 3 if using the `Res/Act/Frz/Dis` notation.
+    /// 3 if using the `Res/Unq/Frz/Dis` notation.
     uninit: S,
     /// Text to separate the `start` and `end` values of a range.
     range_sep: S,
@@ -525,7 +525,7 @@ struct DisplayFmtPadding {
 /// ```
 /// will show states as
 /// ```text
-///  Act
+///  Unq
 /// ?Res
 /// ____
 /// ```
@@ -549,8 +549,8 @@ struct DisplayFmt {
 }
 impl DisplayFmt {
     /// Print the permission with the format
-    /// ` Res`/` Re*`/` Act`/` Frz`/` Dis` for accessed locations
-    /// and `?Res`/`?Re*`/`?Act`/`?Frz`/`?Dis` for unaccessed locations.
+    /// ` Res`/` Re*`/` Unq`/` Frz`/` Dis` for accessed locations
+    /// and `?Res`/`?Re*`/`?Unq`/`?Frz`/`?Dis` for unaccessed locations.
     fn print_perm(&self, perm: Option<LocationState>) -> String {
         if let Some(perm) = perm {
             format!(
@@ -801,7 +801,7 @@ impl DisplayRepr {
         ) {
             let mut line = String::new();
             // Format the permissions on each range.
-            // Looks like `| Act| Res| Res| Act|`.
+            // Looks like `| Unq| Res| Res| Unq|`.
             line.push_str(fmt.perm.open);
             for (i, (perm, &pad)) in tree.rperm.iter().zip(padding.iter()).enumerate() {
                 if i > 0 {

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

@@ -462,7 +462,7 @@ pub mod diagnostics {
                 ReservedFrz { conflicted: false } => "Res ",
                 ReservedFrz { conflicted: true } => "ResC",
                 ReservedIM => "ReIM",
-                Unique => "Act ",
+                Unique => "Unq ",
                 Frozen => "Frz ",
                 Disabled => "Dis ",
             }

src/tools/miri/src/clock.rs

@@ -1,5 +1,7 @@
 use std::cell::Cell;
-use std::time::{Duration, Instant as StdInstant};
+use std::time::{Duration, Instant as StdInstant, SystemTime};
+
+use crate::MiriMachine;
 
 /// When using a virtual clock, this defines how many nanoseconds we pretend are passing for each
 /// basic block.
@@ -8,6 +10,7 @@ use std::time::{Duration, Instant as StdInstant};
 /// (See `tests/pass/shims/time-with-isolation*.rs`.)
 const NANOSECONDS_PER_BASIC_BLOCK: u128 = 5000;
 
+/// An instant (a fixed moment in time) in Miri's monotone clock.
 #[derive(Debug)]
 pub struct Instant {
     kind: InstantKind,
@@ -129,3 +132,79 @@ impl MonotonicClock {
         }
     }
 }
+
+/// A deadline for some event to occur.
+#[derive(Debug)]
+pub enum Deadline {
+    Monotonic(Instant),
+    RealTime(SystemTime),
+}
+
+impl From<Instant> for Deadline {
+    fn from(value: Instant) -> Self {
+        Deadline::Monotonic(value)
+    }
+}
+
+impl Deadline {
+    /// Will try to add `duration`, but if that overflows it may add less.
+    fn add_lossy(&self, duration: Duration) -> Self {
+        match self {
+            Deadline::Monotonic(i) => Deadline::Monotonic(i.add_lossy(duration)),
+            Deadline::RealTime(s) => {
+                // If this overflows, try adding just 1h and assume that will not overflow.
+                Deadline::RealTime(
+                    s.checked_add(duration)
+                        .unwrap_or_else(|| s.checked_add(Duration::from_secs(3600)).unwrap()),
+                )
+            }
+        }
+    }
+}
+
+/// The clock to use for the timeout you are asking for.
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum TimeoutClock {
+    /// The timeout is measured using the monotone clock.
+    Monotonic,
+    /// The timeout is measured using the host's system clock.
+    RealTime,
+}
+
+/// Whether the timeout is relative or absolute.
+#[derive(Debug, Copy, Clone)]
+pub enum TimeoutStyle {
+    /// The given duration is interpreted relative to "now" for the selected clock.
+    Relative,
+    /// The given duration is interpreted as an "absolute" time, i.e., relative to the epoch of the
+    /// selected clock.
+    Absolute,
+}
+
+impl MiriMachine<'_> {
+    /// Computes the deadline for a given timeout configuration and duration.
+    pub fn timeout(
+        &self,
+        clock: TimeoutClock,
+        style: TimeoutStyle,
+        duration: Duration,
+    ) -> Deadline {
+        // First let's figure out what "zero" means for the given clock and style.
+        let zero = match clock {
+            TimeoutClock::RealTime => {
+                assert!(self.communicate(), "cannot have `RealTime` timeout with isolation");
+                Deadline::RealTime(match style {
+                    TimeoutStyle::Absolute => SystemTime::UNIX_EPOCH,
+                    TimeoutStyle::Relative => SystemTime::now(),
+                })
+            }
+            TimeoutClock::Monotonic =>
+                Deadline::Monotonic(match style {
+                    TimeoutStyle::Absolute => self.monotonic_clock.epoch(),
+                    TimeoutStyle::Relative => self.monotonic_clock.now(),
+                }),
+        };
+        // Then add the given duration relative to that "zero".
+        zero.add_lossy(duration)
+    }
+}

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

@@ -355,7 +355,7 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
         &mut self,
         source_fd: FileDescriptionRef<dyn SourceFileDescription>,
         interest: BlockingIoInterest,
-        timeout: Option<(TimeoutClock, TimeoutAnchor, Duration)>,
+        deadline: Option<Deadline>,
         callback: DynUnblockCallback<'tcx>,
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
@@ -370,7 +370,7 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
         } else {
             // The I/O readiness is currently not fulfilled. We block the thread
             // until the readiness is fulfilled and execute the callback then.
-            this.block_thread(BlockReason::IO, timeout, callback);
+            this.block_thread(BlockReason::IO, deadline, callback);
             interp_ok(())
         }
     }

src/tools/miri/src/concurrency/sync.rs

@@ -5,7 +5,6 @@ use std::collections::hash_map::Entry;
 use std::default::Default;
 use std::ops::Not;
 use std::rc::Rc;
-use std::time::Duration;
 use std::{fmt, iter};
 
 use rustc_abi::Size;
@@ -684,7 +683,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         &mut self,
         condvar_ref: CondvarRef,
         mutex_ref: MutexRef,
-        timeout: Option<(TimeoutClock, TimeoutAnchor, Duration)>,
+        deadline: Option<Deadline>,
         retval_succ: Scalar,
         retval_timeout: Scalar,
         dest: MPlaceTy<'tcx>,
@@ -706,7 +705,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         condvar_ref.0.borrow_mut().waiters.push_back(thread);
         this.block_thread(
             BlockReason::Condvar,
-            timeout,
+            deadline,
             callback!(
                 @capture<'tcx> {
                     condvar_ref: CondvarRef,
@@ -763,7 +762,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         &mut self,
         futex_ref: FutexRef,
         bitset: u32,
-        timeout: Option<(TimeoutClock, TimeoutAnchor, Duration)>,
+        deadline: Option<Deadline>,
         callback: DynUnblockCallback<'tcx>,
     ) {
         let this = self.eval_context_mut();
@@ -776,7 +775,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         this.block_thread(
             BlockReason::Futex,
-            timeout,
+            deadline,
             callback!(
                 @capture<'tcx> {
                     futex_ref: FutexRef,