Miri subtree update

Cargo.lock

@@ -3426,9 +3426,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-build-sysroot"
-version = "0.4.7"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab1dbbd1bdf65fdac44c885f6cca147ba179108ce284b60a08ccc04b1f1dbac0"
+checksum = "fa3ca63cc537c1cb69e4c2c0afc5fda2ccd36ac84c97d5a4ae05e69b1c834afb"
 dependencies = [
  "anyhow",
  "rustc_version",

src/tools/miri/.gitignore

@@ -5,6 +5,7 @@ tex/*/out
 *.out
 *.rs.bk
 .vscode
+.helix
 *.mm_profdata
 perf.data
 perf.data.old

src/tools/miri/cargo-miri/Cargo.lock

@@ -178,9 +178,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-build-sysroot"
-version = "0.4.7"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab1dbbd1bdf65fdac44c885f6cca147ba179108ce284b60a08ccc04b1f1dbac0"
+checksum = "fa3ca63cc537c1cb69e4c2c0afc5fda2ccd36ac84c97d5a4ae05e69b1c834afb"
 dependencies = [
  "anyhow",
  "rustc_version",

src/tools/miri/cargo-miri/Cargo.toml

@@ -18,7 +18,7 @@ directories = "5"
 rustc_version = "0.4"
 serde_json = "1.0.40"
 cargo_metadata = "0.18.0"
-rustc-build-sysroot = "0.4.6"
+rustc-build-sysroot = "0.5.2"
 
 # Enable some feature flags that dev-dependencies need but dependencies
 # do not. This makes `./miri install` after `./miri build` faster.

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

@@ -2,11 +2,10 @@
 
 use std::env;
 use std::ffi::OsStr;
-use std::fmt::Write;
 use std::path::PathBuf;
 use std::process::{self, Command};
 
-use rustc_build_sysroot::{BuildMode, SysrootBuilder, SysrootConfig};
+use rustc_build_sysroot::{BuildMode, SysrootBuilder, SysrootConfig, SysrootStatus};
 use rustc_version::VersionMeta;
 
 use crate::util::*;
@@ -24,6 +23,7 @@ pub fn setup(
  let only_setup = matches!(subcommand, MiriCommand::Setup);
  let ask_user = !only_setup;
  let print_sysroot = only_setup && has_arg_flag("--print-sysroot"); // whether we just print the sysroot path
+ let show_setup = only_setup && !print_sysroot;
  if !only_setup {
  if let Some(sysroot) = std::env::var_os("MIRI_SYSROOT") {
  // Skip setup step if MIRI_SYSROOT is explicitly set, *unless* we are `cargo miri setup`.
@@ -115,18 +115,16 @@ pub fn setup(
  // `config.toml`.
  command.env("RUSTC_WRAPPER", "");
 
- if only_setup && !print_sysroot {
+ if show_setup {
  // Forward output. Even make it verbose, if requested.
+ command.stdout(process::Stdio::inherit());
+ command.stderr(process::Stdio::inherit());
  for _ in 0..verbose {
  command.arg("-v");
  }
  if quiet {
  command.arg("--quiet");
  }
- } else {
- // Suppress output.
- command.stdout(process::Stdio::null());
- command.stderr(process::Stdio::null());
  }
 
  command
@@ -137,49 +135,52 @@ pub fn setup(
  // not apply `RUSTFLAGS` to the sysroot either.
  let rustflags = &["-Cdebug-assertions=off", "-Coverflow-checks=on"];
 
- // Do the build.
- if print_sysroot || quiet {
- // Be silent.
- } else {
- let mut msg = String::new();
- write!(msg, "Preparing a sysroot for Miri (target: {target})").unwrap();
- if verbose > 0 {
- write!(msg, " in {}", sysroot_dir.display()).unwrap();
- }
- write!(msg, "...").unwrap();
- if only_setup {
- // We want to be explicit.
- eprintln!("{msg}");
- } else {
- // We want to be quiet, but still let the user know that something is happening.
- eprint!("{msg} ");
+ let mut after_build_output = String::new(); // what should be printed when the build is done.
+ let notify = || {
+ if !quiet {
+ eprint!("Preparing a sysroot for Miri (target: {target})");
+ if verbose > 0 {
+ eprint!(" in {}", sysroot_dir.display());
+ }
+ if show_setup {
+ // Cargo will print things, so we need to finish this line.
+ eprintln!("...");
+ after_build_output = format!(
+ "A sysroot for Miri is now available in `{}`.\n",
+ sysroot_dir.display()
+ );
+ } else {
+ // Keep all output on a single line.
+ eprint!("... ");
+ after_build_output = format!("done\n");
+ }
  }
- }
- SysrootBuilder::new(&sysroot_dir, target)
+ };
+
+ // Do the build.
+ let status = SysrootBuilder::new(&sysroot_dir, target)
  .build_mode(BuildMode::Check)
  .rustc_version(rustc_version.clone())
  .sysroot_config(sysroot_config)
  .rustflags(rustflags)
  .cargo(cargo_cmd)
- .build_from_source(&rust_src)
- .unwrap_or_else(|err| {
- if print_sysroot {
- show_error!("failed to build sysroot")
- } else if only_setup {
- show_error!("failed to build sysroot: {err:?}")
- } else {
- show_error!(
- "failed to build sysroot; run `cargo miri setup` to see the error details"
- )
- }
- });
- if print_sysroot || quiet {
- // Be silent.
- } else if only_setup {
- eprintln!("A sysroot for Miri is now available in `{}`.", sysroot_dir.display());
- } else {
- eprintln!("done");
+ .when_build_required(notify)
+ .build_from_source(&rust_src);
+ match status {
+ Ok(SysrootStatus::AlreadyCached) =>
+ if !quiet && show_setup {
+ eprintln!(
+ "A sysroot for Miri is already available in `{}`.",
+ sysroot_dir.display()
+ );
+ },
+ Ok(SysrootStatus::SysrootBuilt) => {
+ // Print what `notify` prepared.
+ eprint!("{after_build_output}");
+ }
+ Err(err) => show_error!("failed to build sysroot: {err:?}"),
  }
+
  if print_sysroot {
  // Print just the sysroot and nothing else to stdout; this way we do not need any escaping.
  println!("{}", sysroot_dir.display());

src/tools/miri/ci/ci.sh

@@ -144,16 +144,16 @@ case $HOST_TARGET in
  TEST_TARGET=arm-unknown-linux-gnueabi run_tests
  TEST_TARGET=s390x-unknown-linux-gnu run_tests # big-endian architecture of choice
  # Partially supported targets (tier 2)
- VERY_BASIC="integer vec string btreemap" # common things we test on all of them (if they have std), requires no target-specific shims
- BASIC="$VERY_BASIC hello hashmap alloc align" # ensures we have the shims for stdout and basic data structures
- TEST_TARGET=x86_64-unknown-freebsd run_tests_minimal $BASIC panic/panic concurrency/simple atomic threadname libc-mem libc-misc libc-random libc-time fs env num_cpus
- TEST_TARGET=i686-unknown-freebsd run_tests_minimal $BASIC panic/panic concurrency/simple atomic threadname libc-mem libc-misc libc-random libc-time fs env num_cpus
- TEST_TARGET=x86_64-unknown-illumos run_tests_minimal $VERY_BASIC hello panic/panic concurrency/simple pthread-sync libc-mem libc-misc libc-random
- TEST_TARGET=x86_64-pc-solaris run_tests_minimal $VERY_BASIC hello panic/panic concurrency/simple pthread-sync libc-mem libc-misc libc-random
- TEST_TARGET=aarch64-linux-android run_tests_minimal $VERY_BASIC hello panic/panic
- TEST_TARGET=wasm32-wasi run_tests_minimal $VERY_BASIC wasm
- TEST_TARGET=wasm32-unknown-unknown run_tests_minimal $VERY_BASIC wasm
- TEST_TARGET=thumbv7em-none-eabihf run_tests_minimal no_std
+ BASIC="empty_main integer vec string btreemap hello hashmap heap_alloc align" # ensures we have the basics: stdout/stderr, system allocator, randomness (for HashMap initialization)
+ UNIX="panic/panic panic/unwind concurrency/simple atomic libc-mem libc-misc libc-random env num_cpus" # the things that are very similar across all Unixes, and hence easily supported there
+ TEST_TARGET=x86_64-unknown-freebsd run_tests_minimal $BASIC $UNIX threadname libc-time fs
+ TEST_TARGET=i686-unknown-freebsd run_tests_minimal $BASIC $UNIX threadname libc-time fs
+ TEST_TARGET=x86_64-unknown-illumos run_tests_minimal $BASIC $UNIX pthread-sync
+ TEST_TARGET=x86_64-pc-solaris  run_tests_minimal $BASIC $UNIX pthread-sync
+ TEST_TARGET=aarch64-linux-android run_tests_minimal $BASIC $UNIX
+ TEST_TARGET=wasm32-wasip2 run_tests_minimal empty_main wasm heap_alloc libc-mem
+ TEST_TARGET=wasm32-unknown-unknown run_tests_minimal empty_main wasm
+ TEST_TARGET=thumbv7em-none-eabihf  run_tests_minimal no_std
  # Custom target JSON file
  TEST_TARGET=tests/avr.json MIRI_NO_STD=1 run_tests_minimal no_std
  ;;

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

@@ -0,0 +1,136 @@
+use std::env;
+use std::iter;
+
+use anyhow::{bail, Result};
+
+pub struct Args {
+ args: iter::Peekable<env::Args>,
+ /// Set to `true` once we saw a `--`.
+ terminated: bool,
+}
+
+impl Args {
+ pub fn new() -> Self {
+ let mut args = Args { args: env::args().peekable(), terminated: false };
+ args.args.next().unwrap(); // skip program name
+ args
+ }
+
+ /// Get the next argument without any interpretation.
+ pub fn next_raw(&mut self) -> Option<String> {
+ self.args.next()
+ }
+
+ /// Consume a `-$f` flag if present.
+ pub fn get_short_flag(&mut self, flag: char) -> Result<bool> {
+ if self.terminated {
+ return Ok(false);
+ }
+ if let Some(next) = self.args.peek() {
+ if let Some(next) = next.strip_prefix("-") {
+ if let Some(next) = next.strip_prefix(flag) {
+ if next.is_empty() {
+ self.args.next().unwrap(); // consume this argument
+ return Ok(true);
+ } else {
+ bail!("`-{flag}` followed by value");
+ }
+ }
+ }
+ }
+ Ok(false)
+ }
+
+ /// Consume a `--$name` flag if present.
+ pub fn get_long_flag(&mut self, name: &str) -> Result<bool> {
+ if self.terminated {
+ return Ok(false);
+ }
+ if let Some(next) = self.args.peek() {
+ if let Some(next) = next.strip_prefix("--") {
+ if next == name {
+ self.args.next().unwrap(); // consume this argument
+ return Ok(true);
+ }
+ }
+ }
+ Ok(false)
+ }
+
+ /// Consume a `--$name val` or `--$name=val` option if present.
+ pub fn get_long_opt(&mut self, name: &str) -> Result<Option<String>> {
+ assert!(!name.is_empty());
+ if self.terminated {
+ return Ok(None);
+ }
+ let Some(next) = self.args.peek() else { return Ok(None) };
+ let Some(next) = next.strip_prefix("--") else { return Ok(None) };
+ let Some(next) = next.strip_prefix(name) else { return Ok(None) };
+ // Starts with `--flag`.
+ Ok(if let Some(val) = next.strip_prefix("=") {
+ // `--flag=val` form
+ let val = val.into();
+ self.args.next().unwrap(); // consume this argument
+ Some(val)
+ } else if next.is_empty() {
+ // `--flag val` form
+ self.args.next().unwrap(); // consume this argument
+ let Some(val) = self.args.next() else { bail!("`--{name}` not followed by value") };
+ Some(val)
+ } else {
+ // Some unrelated flag, like `--flag-more` or so.
+ None
+ })
+ }
+
+ /// Consume a `--$name=val` or `--$name` option if present; the latter
+ /// produces a default value. (`--$name val` is *not* accepted for this form
+ /// of argument, it understands `val` already as the next argument!)
+ pub fn get_long_opt_with_default(
+ &mut self,
+ name: &str,
+ default: &str,
+ ) -> Result<Option<String>> {
+ assert!(!name.is_empty());
+ if self.terminated {
+ return Ok(None);
+ }
+ let Some(next) = self.args.peek() else { return Ok(None) };
+ let Some(next) = next.strip_prefix("--") else { return Ok(None) };
+ let Some(next) = next.strip_prefix(name) else { return Ok(None) };
+ // Starts with `--flag`.
+ Ok(if let Some(val) = next.strip_prefix("=") {
+ // `--flag=val` form
+ let val = val.into();
+ self.args.next().unwrap(); // consume this argument
+ Some(val)
+ } else if next.is_empty() {
+ // `--flag` form
+ self.args.next().unwrap(); // consume this argument
+ Some(default.into())
+ } else {
+ // Some unrelated flag, like `--flag-more` or so.
+ None
+ })
+ }
+
+ /// Returns the next free argument or uninterpreted flag, or `None` if there are no more
+ /// arguments left. `--` is returned as well, but it is interpreted in the sense that no more
+ /// flags will be parsed after this.
+ pub fn get_other(&mut self) -> Option<String> {
+ if self.terminated {
+ return self.args.next();
+ }
+ let next = self.args.next()?;
+ if next == "--" {
+ self.terminated = true; // don't parse any more flags
+ // This is where our parser is special, we do yield the `--`.
+ }
+ Some(next)
+ }
+
+ /// Return the rest of the aguments entirely unparsed.
+ pub fn remainder(self) -> Vec<String> {
+ self.args.collect()
+ }
+}