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

miri subtree update Subtree update of `miri` to rust-lang/miri@5774cef. Created using https://github.com/rust-lang/josh-sync. r? `@ghost`

Author: bors

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

@@ -73,7 +73,10 @@ jobs:
  sudo bash -c "echo 'https://ports.ubuntu.com/	priority:4' >> /etc/apt/apt-mirrors.txt"
  # Add architecture
  sudo dpkg --add-architecture ${{ matrix.multiarch }}
- sudo apt update
+ # Ubuntu Ports often has outdated mirrors so try a few times to get the apt repo
+ for TRY in $(seq 3); do
+ { sudo apt update && break; } || sleep 30
+ done
  # Install needed packages
  sudo apt install $(echo "libatomic1: zlib1g-dev:" | sed 's/:/:${{ matrix.multiarch }}/g')
  - uses: ./.github/workflows/setup

src/tools/miri/Cargo.lock

@@ -1519,9 +1519,9 @@ dependencies = [
 
 [[package]]
 name = "tikv-jemalloc-sys"
-version = "0.6.0+5.3.0-1-ge13ca993e8ccb9ba9847cc330696e02839f328f7"
+version = "0.6.1+5.3.0-1-ge13ca993e8ccb9ba9847cc330696e02839f328f7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd3c60906412afa9c2b5b5a48ca6a5abe5736aec9eb48ad05037a677e52e4e2d"
+checksum = "cd8aa5b2ab86a2cefa406d889139c162cbb230092f7d1d7cbc1716405d852a3b"
 dependencies = [
  "cc",
  "libc",

src/tools/miri/README.md

@@ -464,11 +464,6 @@ to Miri failing to detect cases of undefined behavior in a program.
  errors and warnings.
 * `-Zmiri-recursive-validation` is a *highly experimental* flag that makes validity checking
  recurse below references.
-* `-Zmiri-retag-fields[=<all|none|scalar>]` controls when Stacked Borrows retagging recurses into
- fields. `all` means it always recurses (the default, and equivalent to `-Zmiri-retag-fields`
- without an explicit value), `none` means it never recurses, `scalar` means it only recurses for
- types where we would also emit `noalias` annotations in the generated LLVM IR (types passed as
- individual scalars or pairs of scalars). Setting this to `none` is **unsound**.
 * `-Zmiri-preemption-rate` configures the probability that at the end of a basic block, the active
  thread will be preempted. The default is `0.01` (i.e., 1%). Setting this to `0` disables
  preemption. Note that even without preemption, the schedule is still non-deterministic:

src/tools/miri/rust-version

@@ -1 +1 @@
-8401398e1f14a24670ee1a3203713dc2f0f8b3a8
+7a72c5459dd58f81b0e1a0e5436d145485889375

src/tools/miri/src/bin/miri.rs

@@ -23,18 +23,18 @@ extern crate rustc_span;
 mod log;
 
 use std::env;
-use std::num::NonZero;
+use std::num::{NonZero, NonZeroI32};
 use std::ops::Range;
 use std::rc::Rc;
 use std::str::FromStr;
-use std::sync::atomic::{AtomicI32, AtomicU32, Ordering};
+use std::sync::atomic::{AtomicU32, Ordering};
 
 use miri::{
  BacktraceStyle, BorrowTrackerMethod, GenmcConfig, GenmcCtx, MiriConfig, MiriEntryFnType,
- ProvenanceMode, RetagFields, TreeBorrowsParams, ValidationMode, run_genmc_mode,
+ ProvenanceMode, TreeBorrowsParams, ValidationMode, run_genmc_mode,
 };
 use rustc_abi::ExternAbi;
-use rustc_data_structures::sync;
+use rustc_data_structures::sync::{self, DynSync};
 use rustc_driver::Compilation;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_hir::{self as hir, Node};
@@ -120,15 +120,47 @@ fn entry_fn(tcx: TyCtxt<'_>) -> (DefId, MiriEntryFnType) {
  }
 }
 
+fn run_many_seeds(
+ many_seeds: ManySeedsConfig,
+ eval_entry_once: impl Fn(u64) -> Result<(), NonZeroI32> + DynSync,
+) -> Result<(), NonZeroI32> {
+ let exit_code =
+ sync::IntoDynSyncSend(AtomicU32::new(rustc_driver::EXIT_SUCCESS.cast_unsigned()));
+ let num_failed = sync::IntoDynSyncSend(AtomicU32::new(0));
+ sync::par_for_each_in(many_seeds.seeds.clone(), |&seed| {
+ if let Err(return_code) = eval_entry_once(seed.into()) {
+ eprintln!("FAILING SEED: {seed}");
+ if !many_seeds.keep_going {
+ // `abort_if_errors` would unwind but would not actually stop miri, since
+ // `par_for_each` waits for the rest of the threads to finish.
+ exit(return_code.get());
+ }
+ // Preserve the "maximum" return code (when interpreted as `u32`), to make
+ // the result order-independent and to make it 0 only if all executions were 0.
+ exit_code.fetch_max(return_code.get().cast_unsigned(), Ordering::Relaxed);
+ num_failed.fetch_add(1, Ordering::Relaxed);
+ }
+ });
+ let num_failed = num_failed.0.into_inner();
+ let exit_code = exit_code.0.into_inner().cast_signed();
+ if num_failed > 0 {
+ eprintln!("{num_failed}/{total} SEEDS FAILED", total = many_seeds.seeds.count());
+ Err(NonZeroI32::new(exit_code).unwrap())
+ } else {
+ assert!(exit_code == 0);
+ Ok(())
+ }
+}
+
 impl rustc_driver::Callbacks for MiriCompilerCalls {
  fn after_analysis<'tcx>(
  &mut self,
  _: &rustc_interface::interface::Compiler,
  tcx: TyCtxt<'tcx>,
  ) -> Compilation {
- if tcx.sess.dcx().has_errors_or_delayed_bugs().is_some() {
-  tcx.dcx().fatal("miri cannot be run on programs that fail compilation");
- }
+ tcx.dcx().abort_if_errors();
+ tcx.dcx().flush_delayed();
+
  if !tcx.crate_types().contains(&CrateType::Executable) {
  tcx.dcx().fatal("miri only makes sense on bin crates");
  }
@@ -161,64 +193,28 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
  optimizations is usually marginal at best.");
  }
 
- // Run in GenMC mode if enabled.
- if config.genmc_config.is_some() {
- // Validate GenMC settings.
- if let Err(err) = GenmcConfig::validate(&mut config, tcx) {
- fatal_error!("Invalid settings: {err}");
- }
-
- // This is the entry point used in GenMC mode.
- // This closure will be called multiple times to explore the concurrent execution space of the program.
- let eval_entry_once = |genmc_ctx: Rc<GenmcCtx>| {
+ let res = if config.genmc_config.is_some() {
+ assert!(self.many_seeds.is_none());
+ run_genmc_mode(tcx, &config, |genmc_ctx: Rc<GenmcCtx>| {
  miri::eval_entry(tcx, entry_def_id, entry_type, &config, Some(genmc_ctx))
- };
- let return_code = run_genmc_mode(&config, eval_entry_once, tcx).unwrap_or_else(|| {
- tcx.dcx().abort_if_errors();
- rustc_driver::EXIT_FAILURE
- });
- exit(return_code);
- };
-
- if let Some(many_seeds) = self.many_seeds.take() {
+ })
+ } else if let Some(many_seeds) = self.many_seeds.take() {
  assert!(config.seed.is_none());
- let exit_code = sync::IntoDynSyncSend(AtomicI32::new(rustc_driver::EXIT_SUCCESS));
- let num_failed = sync::IntoDynSyncSend(AtomicU32::new(0));
- sync::par_for_each_in(many_seeds.seeds.clone(), |seed| {
+ run_many_seeds(many_seeds, |seed| {
  let mut config = config.clone();
- config.seed = Some((*seed).into());
+ config.seed = Some(seed);
  eprintln!("Trying seed: {seed}");
- let return_code = miri::eval_entry(
- tcx,
- entry_def_id,
- entry_type,
- &config,
- /* genmc_ctx */ None,
- )
- .unwrap_or(rustc_driver::EXIT_FAILURE);
- if return_code != rustc_driver::EXIT_SUCCESS {
- eprintln!("FAILING SEED: {seed}");
- if !many_seeds.keep_going {
- // `abort_if_errors` would actually not stop, since `par_for_each` waits for the
- // rest of the to finish, so we just exit immediately.
- exit(return_code);
- }
- exit_code.store(return_code, Ordering::Relaxed);
- num_failed.fetch_add(1, Ordering::Relaxed);
- }
- });
- let num_failed = num_failed.0.into_inner();
- if num_failed > 0 {
- eprintln!("{num_failed}/{total} SEEDS FAILED", total = many_seeds.seeds.count());
- }
- exit(exit_code.0.into_inner());
+ miri::eval_entry(tcx, entry_def_id, entry_type, &config, /* genmc_ctx */ None)
+ })
  } else {
- let return_code = miri::eval_entry(tcx, entry_def_id, entry_type, &config, None)
- .unwrap_or_else(|| {
- tcx.dcx().abort_if_errors();
- rustc_driver::EXIT_FAILURE
- });
- exit(return_code);
+ miri::eval_entry(tcx, entry_def_id, entry_type, &config, None)
+ };
+
+ if let Err(return_code) = res {
+ tcx.dcx().abort_if_errors();
+ exit(return_code.get());
+ } else {
+ exit(rustc_driver::EXIT_SUCCESS);
  }
 
  // Unreachable.
@@ -571,21 +567,17 @@ fn main() {
  } else if arg == "-Zmiri-mute-stdout-stderr" {
  miri_config.mute_stdout_stderr = true;
  } else if arg == "-Zmiri-retag-fields" {
- miri_config.retag_fields = RetagFields::Yes;
+ eprintln!(
+ "warning: `-Zmiri-retag-fields` is a NOP and will be removed in a future version of Miri.\n\
+ Field retagging has been on-by-default for a long time."
+ );
  } else if arg == "-Zmiri-fixed-schedule" {
  miri_config.fixed_scheduling = true;
  } else if arg == "-Zmiri-deterministic-concurrency" {
  miri_config.fixed_scheduling = true;
  miri_config.address_reuse_cross_thread_rate = 0.0;
  miri_config.cmpxchg_weak_failure_rate = 0.0;
  miri_config.weak_memory_emulation = false;
- } else if let Some(retag_fields) = arg.strip_prefix("-Zmiri-retag-fields=") {
- miri_config.retag_fields = match retag_fields {
- "all" => RetagFields::Yes,
- "none" => RetagFields::No,
- "scalar" => RetagFields::OnlyScalar,
- _ => fatal_error!("`-Zmiri-retag-fields` can only be `all`, `none`, or `scalar`"),
- };
  } else if let Some(param) = arg.strip_prefix("-Zmiri-seed=") {
  let seed = param.parse::<u64>().unwrap_or_else(|_| {
  fatal_error!("-Zmiri-seed must be an integer that fits into u64")
@@ -747,6 +739,13 @@ fn main() {
  );
  };
 
+ // Validate GenMC settings.
+ if miri_config.genmc_config.is_some()
+ && let Err(err) = GenmcConfig::validate(&mut miri_config)
+ {
+ fatal_error!("Invalid settings: {err}");
+ }
+
  debug!("rustc arguments: {:?}", rustc_args);
  debug!("crate arguments: {:?}", miri_config.args);
  if !miri_config.native_lib.is_empty() && miri_config.native_lib_enable_tracing {

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

@@ -116,8 +116,6 @@ pub struct GlobalStateInner {
  protected_tags: FxHashMap<BorTag, ProtectorKind>,
  /// The pointer ids to trace
  tracked_pointer_tags: FxHashSet<BorTag>,
- /// Whether to recurse into datatypes when searching for pointers to retag.
- retag_fields: RetagFields,
 }
 
 impl VisitProvenance for GlobalStateInner {
@@ -131,18 +129,6 @@ impl VisitProvenance for GlobalStateInner {
 /// We need interior mutable access to the global state.
 pub type GlobalState = RefCell<GlobalStateInner>;
 
-/// Policy on whether to recurse into fields to retag
-#[derive(Copy, Clone, Debug)]
-pub enum RetagFields {
- /// Don't retag any fields.
- No,
- /// Retag all fields.
- Yes,
- /// Only retag fields of types with Scalar and ScalarPair layout,
- /// to match the LLVM `noalias` we generate.
- OnlyScalar,
-}
-
 /// The flavor of the protector.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum ProtectorKind {
@@ -168,15 +154,13 @@ impl GlobalStateInner {
  pub fn new(
  borrow_tracker_method: BorrowTrackerMethod,
  tracked_pointer_tags: FxHashSet<BorTag>,
- retag_fields: RetagFields,
  ) -> Self {
  GlobalStateInner {
  borrow_tracker_method,
  next_ptr_tag: BorTag::one(),
  root_ptr_tags: FxHashMap::default(),
  protected_tags: FxHashMap::default(),
  tracked_pointer_tags,
- retag_fields,
  }
  }
 
@@ -244,11 +228,7 @@ pub struct TreeBorrowsParams {
 
 impl BorrowTrackerMethod {
  pub fn instantiate_global_state(self, config: &MiriConfig) -> GlobalState {
- RefCell::new(GlobalStateInner::new(
- self,
- config.tracked_pointer_tags.clone(),
- config.retag_fields,
- ))
+ RefCell::new(GlobalStateInner::new(self, config.tracked_pointer_tags.clone()))
  }
 
  pub fn get_tree_borrows_params(self) -> TreeBorrowsParams {

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

@@ -9,7 +9,7 @@ use std::fmt::Write;
 use std::sync::atomic::AtomicBool;
 use std::{cmp, mem};
 
-use rustc_abi::{BackendRepr, Size};
+use rustc_abi::Size;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_middle::mir::{Mutability, RetagKind};
 use rustc_middle::ty::layout::HasTypingEnv;
@@ -887,22 +887,19 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
  place: &PlaceTy<'tcx>,
  ) -> InterpResult<'tcx> {
  let this = self.eval_context_mut();
- let retag_fields = this.machine.borrow_tracker.as_mut().unwrap().get_mut().retag_fields;
  let retag_cause = match kind {
  RetagKind::TwoPhase => unreachable!(), // can only happen in `retag_ptr_value`
  RetagKind::FnEntry => RetagCause::FnEntry,
  RetagKind::Default | RetagKind::Raw => RetagCause::Normal,
  };
- let mut visitor =
- RetagVisitor { ecx: this, kind, retag_cause, retag_fields, in_field: false };
+ let mut visitor = RetagVisitor { ecx: this, kind, retag_cause, in_field: false };
  return visitor.visit_value(place);
 
  // The actual visitor.
  struct RetagVisitor<'ecx, 'tcx> {
  ecx: &'ecx mut MiriInterpCx<'tcx>,
  kind: RetagKind,
  retag_cause: RetagCause,
- retag_fields: RetagFields,
  in_field: bool,
  }
  impl<'ecx, 'tcx> RetagVisitor<'ecx, 'tcx> {
@@ -967,24 +964,10 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
  self.walk_value(place)?;
  }
  _ => {
- // Not a reference/pointer/box. Only recurse if configured appropriately.
- let recurse = match self.retag_fields {
- RetagFields::No => false,
- RetagFields::Yes => true,
- RetagFields::OnlyScalar => {
- // Matching `ArgAbi::new` at the time of writing, only fields of
- // `Scalar` and `ScalarPair` ABI are considered.
- matches!(
- place.layout.backend_repr,
- BackendRepr::Scalar(..) | BackendRepr::ScalarPair(..)
- )
- }
- };
- if recurse {
- let in_field = mem::replace(&mut self.in_field, true); // remember and restore old value
- self.walk_value(place)?;
- self.in_field = in_field;
- }
+ // Not a reference/pointer/box. Recurse.
+ let in_field = mem::replace(&mut self.in_field, true); // remember and restore old value
+ self.walk_value(place)?;
+ self.in_field = in_field;
  }
  }