miri subtree update

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

@@ -53,7 +53,7 @@ jobs:
           #   qemu: true
           - host_target: aarch64-apple-darwin
             os: macos-latest
-          - host_target: i686-pc-windows-msvc
+          - host_target: x86_64-pc-windows-msvc
             os: windows-latest
           - host_target: aarch64-pc-windows-msvc
             os: windows-11-arm

src/tools/miri/cargo-miri/src/phases.rs

@@ -530,10 +530,6 @@ pub fn phase_rustc(args: impl Iterator<Item = String>, phase: RustcPhase) {
     cmd.env("MIRI_BE_RUSTC", if target_crate { "target" } else { "host" });
 
     // Run it.
-    if verbose > 0 {
-        eprintln!("[cargo-miri rustc] target_crate={target_crate} runnable_crate={runnable_crate}");
-    }
-
     debug_cmd("[cargo-miri rustc]", verbose, &cmd);
     exec(cmd);
 }
@@ -582,16 +578,21 @@ pub fn phase_runner(mut binary_args: impl Iterator<Item = String>, phase: Runner
         if name == "CARGO_MAKEFLAGS" {
             continue;
         }
-        if let Some(old_val) = env::var_os(name) {
-            if *old_val == *val {
-                // This one did not actually change, no need to re-set it.
-                // (This keeps the `debug_cmd` below more manageable.)
-                continue;
-            } else if verbose > 0 {
-                eprintln!(
-                    "[cargo-miri runner] Overwriting run-time env var {name:?}={old_val:?} with build-time value {val:?}"
-                );
-            }
+        let old_val = env::var_os(name);
+        if old_val.as_ref() == Some(val) {
+            // This one did not actually change, no need to re-set it.
+            // (This keeps the `debug_cmd` below more manageable.)
+            continue;
+        }
+        if verbose > 0 {
+            eprintln!(
+                "[cargo-miri runner] Carrying over build-time env var {name:?}={val:?}{}",
+                if let Some(old_val) = old_val {
+                    format!(", overwriting run-time value {old_val:?}")
+                } else {
+                    format!("")
+                }
+            );
         }
         cmd.env(name, val);
     }

src/tools/miri/cargo-miri/src/util.rs

@@ -39,7 +39,15 @@ impl CrateRunInfo {
     /// Gather all the information we need.
     pub fn collect(args: impl Iterator<Item = String>, capture_stdin: bool) -> Self {
         let args = args.collect();
-        let env = env::vars_os().collect();
+        let env = env::vars_os()
+            .filter(|(var, _val)| {
+                // We only need to bother with env vars cargo actually sets.
+                // We try to avoid storing anything that may contain secrets.
+                var.to_str().is_some_and(|var| {
+                    var == "OUT_DIR" || (var.starts_with("CARGO_") && !var.ends_with("_TOKEN"))
+                })
+            })
+            .collect();
         let current_dir = env::current_dir().unwrap().into_os_string();
 
         let mut stdin = Vec::new();

src/tools/miri/ci/ci.sh

@@ -150,7 +150,7 @@ case $HOST_TARGET in
   i686-unknown-linux-gnu)
     # Host
     MIR_OPT=1 MANY_SEEDS=64 TEST_BENCH=1 CARGO_MIRI_ENV=1 run_tests
-    # Not officially supported tier 2
+    # Not officially supported tier 2. Also covers "64bit target on 32bit host".
     MANY_SEEDS=16 TEST_TARGET=aarch64-linux-android run_tests
     MANY_SEEDS=16 TEST_TARGET=loongarch64-unknown-linux-gnu run_tests
     # Partially supported targets (no_std, tier 2)
@@ -175,7 +175,7 @@ case $HOST_TARGET in
     MIR_OPT=1 MANY_SEEDS=64 TEST_BENCH=1 CARGO_MIRI_ENV=1 run_tests
     # Custom target JSON file
     TEST_TARGET=tests/x86_64-unknown-kernel.json MIRI_NO_STD=1 MIRIFLAGS="-Zunstable-options" run_tests_minimal no_std
-    # Not officially supported tier 2
+    # Not officially supported tier 2.
     MANY_SEEDS=16 TEST_TARGET=x86_64-pc-solaris run_tests
     MANY_SEEDS=16 TEST_TARGET=mips-unknown-linux-gnu run_tests # a 32bit big-endian target, and also a target without 64bit atomics
     MANY_SEEDS=16 TEST_TARGET=riscv64a23-unknown-linux-gnu run_tests
@@ -187,12 +187,11 @@ case $HOST_TARGET in
     MANY_SEEDS=64 TEST_TARGET=i686-pc-windows-gnu run_tests
     MANY_SEEDS=64 TEST_TARGET=x86_64-pc-windows-msvc CARGO_MIRI_ENV=1 run_tests
     ;;
-  i686-pc-windows-msvc)
+  x86_64-pc-windows-msvc)
     # Host
     MIR_OPT=1 MANY_SEEDS=64 TEST_BENCH=1 run_tests
     # Extra tier 1
-    # We really want to ensure a Linux target works on a Windows host,
-    # and a 64bit target works on a 32bit host.
+    # We really want to ensure a Linux target works on a Windows host.
     TEST_TARGET=x86_64-unknown-linux-gnu run_tests
     ;;
   aarch64-pc-windows-msvc)

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

@@ -162,6 +162,11 @@ impl Command {
         cmd!(sh, "rustup override set miri").run()?;
         // Cleanup.
         cmd!(sh, "cargo clean").run()?;
+        // Call `cargo metadata` on the sources in case that changes the lockfile
+        // (works around <https://github.com/rust-lang/rust-analyzer/issues/23392>).
+        let sysroot = cmd!(sh, "rustc --print sysroot").read()?;
+        let sysroot = sysroot.trim();
+        cmd!(sh, "cargo metadata --format-version 1 --manifest-path {sysroot}/lib/rustlib/rustc-src/rust/compiler/rustc/Cargo.toml").ignore_stdout().run()?;
         Ok(())
     }
 

src/tools/miri/rust-version

@@ -1 +1 @@
-0ed41eb4142dda2df61eb1145a312c1a9d62eb56
+feaadeeaca7db0594da854e7c8c07495341c7439

src/tools/miri/src/concurrency/mod.rs

@@ -1,5 +1,4 @@
 pub mod blocking_io;
-pub mod cpu_affinity;
 pub mod data_race;
 mod data_race_handler;
 pub mod init_once;

src/tools/miri/src/eval.rs

@@ -458,11 +458,13 @@ fn call_main<'tcx>(
     // Call start function.
     match entry_type {
         MiriEntryFnType::Rustc(EntryFnType::Main { .. }) => {
+            let entry_sig = tcx.fn_sig(entry_id).no_bound_vars().unwrap();
+            let main_ret_ty = entry_sig.output();
+            let main_ret_ty = main_ret_ty.no_bound_vars().unwrap();
+
             let start_id = tcx.lang_items().start_fn().unwrap_or_else(|| {
                 tcx.dcx().fatal("could not find start lang item");
             });
-            let main_ret_ty = tcx.fn_sig(entry_id).no_bound_vars().unwrap().output();
-            let main_ret_ty = main_ret_ty.no_bound_vars().unwrap();
             let start_instance = ty::Instance::try_resolve(
                 tcx,
                 ecx.typing_env(),
@@ -484,8 +486,7 @@ fn call_main<'tcx>(
                 &[
                     ImmTy::from_scalar(
                         Scalar::from_pointer(main_ptr, ecx),
-                        // FIXME use a proper fn ptr type
-                        ecx.machine.layouts.const_raw_ptr,
+                        ecx.layout_of(Ty::new_fn_ptr(tcx, entry_sig)).unwrap(),
                     ),
                     argc,
                     argv,

src/tools/miri/src/lib.rs

@@ -137,7 +137,6 @@ pub use crate::clock::{Deadline, Instant, MonotonicClock, TimeoutClock, TimeoutS
 pub use crate::concurrency::blocking_io::{
     BlockingIoInterest, BlockingIoManager, EvalContextExt as _, SourceFileDescription,
 };
-pub use crate::concurrency::cpu_affinity::MAX_CPUS;
 pub use crate::concurrency::data_race::{
     AtomicFenceOrd, AtomicReadOrd, AtomicRwOrd, AtomicWriteOrd, EvalContextExt as _,
 };
@@ -166,6 +165,7 @@ pub use crate::machine::{
 pub use crate::operator::EvalContextExt as _;
 pub use crate::provenance_gc::{EvalContextExt as _, LiveAllocs, VisitProvenance, VisitWith};
 pub use crate::shims::EmulateItemResult;
+pub use crate::shims::cpu_affinity::MAX_CPUS;
 pub use crate::shims::env::{EnvVars, EvalContextExt as _};
 pub use crate::shims::foreign_items::{DynSym, EvalContextExt as _};
 pub use crate::shims::io_error::{EvalContextExt as _, IoError, LibcError};

src/tools/miri/src/machine.rs

@@ -36,14 +36,12 @@ use rustc_target::callconv::FnAbi;
 use rustc_target::spec::{Arch, Os};
 
 use crate::alloc_addresses::EvalContextExt;
-use crate::concurrency::cpu_affinity::{self, CpuAffinityMask};
 use crate::concurrency::data_race::{self, NaReadType, NaWriteType};
 use crate::concurrency::sync::SyncObj;
 use crate::concurrency::{
     AllocDataRaceHandler, GenmcCtx, GenmcEvalContextExt as _, GlobalDataRaceHandler, weak_memory,
 };
 use crate::helpers::is_no_core;
-use crate::shims::readiness::DelayedReadinessUpdates;
 use crate::*;
 
 /// First real-time signal.
@@ -433,15 +431,33 @@ pub struct PrimitiveLayouts<'tcx> {
     pub u128: TyAndLayout<'tcx>,
     pub usize: TyAndLayout<'tcx>,
     pub bool: TyAndLayout<'tcx>,
-    pub mut_raw_ptr: TyAndLayout<'tcx>,   // *mut ()
-    pub const_raw_ptr: TyAndLayout<'tcx>, // *const ()
+    pub unit_ptr_mut: TyAndLayout<'tcx>,   // *mut ()
+    pub unit_ptr_const: TyAndLayout<'tcx>, // *const ()
+    pub void_ptr_mut: TyAndLayout<'tcx>,   // *mut c_void
+    pub void_ptr_const: TyAndLayout<'tcx>, // *const c_void
+    pub fn_ptr: TyAndLayout<'tcx>,         // extern "C" fn()
 }
 
 impl<'tcx> PrimitiveLayouts<'tcx> {
     fn new(layout_cx: LayoutCx<'tcx>) -> Result<Self, &'tcx LayoutError<'tcx>> {
         let tcx = layout_cx.tcx();
-        let mut_raw_ptr = Ty::new_mut_ptr(tcx, tcx.types.unit);
-        let const_raw_ptr = Ty::new_imm_ptr(tcx, tcx.types.unit);
+
+        let unit_ptr_mut = Ty::new_mut_ptr(tcx, tcx.types.unit);
+        let unit_ptr_const = Ty::new_imm_ptr(tcx, tcx.types.unit);
+        // We fall back to `()` if the lang item is missing, so `no_core` works better with Miri.
+        let c_void = match tcx.lang_items().c_void() {
+            Some(c_void) => ty::Instance::mono(tcx, c_void).ty(tcx, layout_cx.typing_env),
+            None => tcx.types.unit,
+        };
+        let void_ptr_mut = Ty::new_mut_ptr(tcx, c_void);
+        let void_ptr_const = Ty::new_imm_ptr(tcx, c_void);
+
+        let sig_kind = ty::FnSigKind::default()
+            .set_abi(ExternAbi::C { unwind: false })
+            .set_safety(rustc_hir::Safety::Safe);
+        let fn_ptr =
+            Ty::new_fn_ptr(tcx, ty::Binder::dummy(tcx.mk_fn_sig([], tcx.types.unit, sig_kind)));
+
         Ok(Self {
             unit: layout_cx.layout_of(tcx.types.unit)?,
             i8: layout_cx.layout_of(tcx.types.i8)?,
@@ -457,8 +473,11 @@ impl<'tcx> PrimitiveLayouts<'tcx> {
             u128: layout_cx.layout_of(tcx.types.u128)?,
             usize: layout_cx.layout_of(tcx.types.usize)?,
             bool: layout_cx.layout_of(tcx.types.bool)?,
-            mut_raw_ptr: layout_cx.layout_of(mut_raw_ptr)?,
-            const_raw_ptr: layout_cx.layout_of(const_raw_ptr)?,
+            unit_ptr_mut: layout_cx.layout_of(unit_ptr_mut)?,
+            unit_ptr_const: layout_cx.layout_of(unit_ptr_const)?,
+            void_ptr_mut: layout_cx.layout_of(void_ptr_mut)?,
+            void_ptr_const: layout_cx.layout_of(void_ptr_const)?,
+            fn_ptr: layout_cx.layout_of(fn_ptr)?,
         })
     }
 
@@ -536,7 +555,7 @@ pub struct MiriMachine<'tcx> {
     pub(crate) dirs: shims::DirTable,
 
     /// Managing file descriptors whose readiness needs to be updated.
-    pub(crate) delayed_readiness_updates: Rc<DelayedReadinessUpdates>,
+    pub(crate) delayed_readiness_updates: Rc<shims::DelayedReadinessUpdates>,
 
     /// This machine's monotone clock.
     pub(crate) monotonic_clock: MonotonicClock,
@@ -551,7 +570,7 @@ pub struct MiriMachine<'tcx> {
     /// This has no effect at all, it is just tracked to produce the correct result
     /// in `sched_getaffinity`
     /// This will be `None` when running `#![no_core]` crates.
-    pub(crate) thread_cpu_affinity: Option<FxHashMap<ThreadId, CpuAffinityMask>>,
+    pub(crate) thread_cpu_affinity: Option<FxHashMap<ThreadId, shims::CpuAffinityMask>>,
 
     /// Precomputed `TyLayout`s for primitive data types that are commonly used inside Miri.
     pub(crate) layouts: PrimitiveLayouts<'tcx>,
@@ -730,9 +749,9 @@ impl<'tcx> MiriMachine<'tcx> {
         let stack_size =
             if tcx.pointer_size().bits() < 32 { page_size * 4 } else { page_size * 16 };
         assert!(
-            usize::try_from(config.num_cpus).unwrap() <= cpu_affinity::MAX_CPUS,
+            usize::try_from(config.num_cpus).unwrap() <= shims::cpu_affinity::MAX_CPUS,
             "miri only supports up to {} CPUs, but {} were configured",
-            cpu_affinity::MAX_CPUS,
+            shims::cpu_affinity::MAX_CPUS,
             config.num_cpus
         );
         let threads = ThreadManager::new(config);
@@ -743,7 +762,7 @@ impl<'tcx> MiriMachine<'tcx> {
                 let mut affinity = FxHashMap::default();
                 affinity.insert(
                     threads.active_thread(),
-                    CpuAffinityMask::new(&layout_cx, config.num_cpus),
+                    shims::CpuAffinityMask::new(&layout_cx, config.num_cpus),
                 );
                 Some(affinity)
             } else {
@@ -769,7 +788,7 @@ impl<'tcx> MiriMachine<'tcx> {
             isolated_op: config.isolated_op,
             validation: config.validation,
             fds: shims::FdTable::init(config.mute_stdout_stderr),
-            delayed_readiness_updates: Rc::new(DelayedReadinessUpdates::default()),
+            delayed_readiness_updates: Rc::new(shims::DelayedReadinessUpdates::default()),
             dirs: Default::default(),
             layouts,
             threads,