use std::env;
use std::ffi::OsString;
use std::fs::{self, File};
-use std::io::{self, BufRead, BufReader, BufWriter, Write};
use std::iter::TakeWhile;
+use std::io::{self, BufRead, BufReader, BufWriter, Read, Write};
use std::ops::Not;
use std::path::{Path, PathBuf};
use std::process::Command;
Setup,
}
-/// The inforamtion Miri needs to run a crate. Stored as JSON when the crate is "compiled".
+/// The information to run a crate with the given environment.
#[derive(Serialize, Deserialize)]
-struct CrateRunInfo {
+struct CrateRunEnv {
/// The command-line arguments.
args: Vec<String>,
/// The environment.
env: Vec<(OsString, OsString)>,
/// The current working directory.
current_dir: OsString,
+ /// The contents passed via standard input.
+ stdin: Vec<u8>,
}
-impl CrateRunInfo {
+impl CrateRunEnv {
/// Gather all the information we need.
- fn collect(args: env::Args) -> Self {
+ fn collect(args: env::Args, capture_stdin: bool) -> Self {
let args = args.collect();
let env = env::vars_os().collect();
let current_dir = env::current_dir().unwrap().into_os_string();
- CrateRunInfo { args, env, current_dir }
+
+ let mut stdin = Vec::new();
+ if capture_stdin {
+ std::io::stdin().lock().read_to_end(&mut stdin).expect("cannot read stdin");
+ }
+
+ CrateRunEnv { args, env, current_dir, stdin }
}
+}
+/// The information Miri needs to run a crate. Stored as JSON when the crate is "compiled".
+#[derive(Serialize, Deserialize)]
+enum CrateRunInfo {
+ /// Run it with the given environment.
+ RunWith(CrateRunEnv),
+ /// Skip it as Miri does not support interpreting such kind of crates.
+ SkipProcMacroTest,
+}
+
+impl CrateRunInfo {
fn store(&self, filename: &Path) {
let file = File::create(filename)
.unwrap_or_else(|_| show_error(format!("cannot create `{}`", filename.display())));
println!(
"miri {} ({} {})",
env!("CARGO_PKG_VERSION"),
- env!("VERGEN_SHA_SHORT"),
- env!("VERGEN_COMMIT_DATE")
+ env!("VERGEN_GIT_SHA_SHORT"),
+ env!("VERGEN_GIT_COMMIT_DATE")
);
}
args.any(|val| val == name)
}
+/// Yields all values of command line flag `name`.
struct ArgFlagValueIter<'a> {
args: TakeWhile<env::Args, fn(&String) -> bool>,
name: &'a str,
ArgFlagValueIter::new(name).next()
}
+fn forward_patched_extern_arg(args: &mut impl Iterator<Item = String>, cmd: &mut Command) {
+ cmd.arg("--extern"); // always forward flag, but adjust filename:
+ let path = args.next().expect("`--extern` should be followed by a filename");
+ if let Some(lib) = path.strip_suffix(".rlib") {
+ // If this is an rlib, make it an rmeta.
+ cmd.arg(format!("{}.rmeta", lib));
+ } else {
+ // Some other extern file (e.g. a `.so`). Forward unchanged.
+ cmd.arg(path);
+ }
+}
+
+fn forward_miri_sysroot(cmd: &mut Command) {
+ let sysroot =
+ env::var_os("MIRI_SYSROOT").expect("the wrapper should have set MIRI_SYSROOT");
+ cmd.arg("--sysroot");
+ cmd.arg(sysroot);
+}
+
/// Returns the path to the `miri` binary
fn find_miri() -> PathBuf {
if let Some(path) = env::var_os("MIRI") {
}
}
+/// Execute the command and pipe `input` into its stdin.
+/// If it fails, fail this process with the same exit code.
+/// Otherwise, continue.
+fn exec_with_pipe(mut cmd: Command, input: &[u8]) {
+ cmd.stdin(std::process::Stdio::piped());
+ let mut child = cmd.spawn().expect("failed to spawn process");
+ {
+ let stdin = child.stdin.as_mut().expect("failed to open stdin");
+ stdin.write_all(input).expect("failed to write out test source");
+ }
+ let exit_status = child.wait().expect("failed to run command");
+ if exit_status.success().not() {
+ std::process::exit(exit_status.code().unwrap_or(-1))
+ }
+}
+
fn xargo_version() -> Option<(u32, u32, u32)> {
let out = xargo_check().arg("--version").output().ok()?;
if !out.status.success() {
// for target crates.
// We set ourselves (`cargo-miri`) instead of Miri directly to be able to patch the flags
// for `libpanic_abort` (usually this is done by bootstrap but we have to do it ourselves).
- // The `MIRI_BE_RUSTC` will mean we dispatch to `phase_setup_rustc`.
+ // The `MIRI_CALLED_FROM_XARGO` will mean we dispatch to `phase_setup_rustc`.
let cargo_miri_path = std::env::current_exe().expect("current executable path invalid");
if env::var_os("RUSTC_STAGE").is_some() {
command.env("RUSTC_REAL", &cargo_miri_path);
} else {
command.env("RUSTC", &cargo_miri_path);
}
- command.env("MIRI_BE_RUSTC", "1");
+ command.env("MIRI_CALLED_FROM_XARGO", "1");
// Make sure there are no other wrappers or flags getting in our way
// (Cc https://github.com/rust-lang/miri/issues/1421).
// This is consistent with normal `cargo build` that does not apply `RUSTFLAGS`
}
}
-fn phase_setup_rustc(args: env::Args) {
- // Mostly we just forward everything.
- // `MIRI_BE_RUST` is already set.
- let mut cmd = miri();
- cmd.args(args);
-
- // Patch the panic runtime for `libpanic_abort` (mirroring what bootstrap usually does).
- if get_arg_flag_value("--crate-name").as_deref() == Some("panic_abort") {
- cmd.arg("-C").arg("panic=abort");
- }
-
- // Run it!
- exec(cmd);
-}
-
fn phase_cargo_miri(mut args: env::Args) {
// Check for version and help flags even when invoked as `cargo-miri`.
if has_arg_flag("--help") || has_arg_flag("-h") {
// This is needed to make the `CARGO_TARGET_*_RUNNER` env var do something,
// and it later helps us detect which crates are proc-macro/build-script
// (host crates) and which crates are needed for the program itself.
- let target = if let Some(target) = get_arg_flag_value("--target") {
+ let host = version_info().host;
+ let target = get_arg_flag_value("--target");
+ let target = if let Some(ref target) = target {
target
} else {
// No target given. Pick default and tell cargo about it.
- let host = version_info().host;
cmd.arg("--target");
cmd.arg(&host);
- host
+ &host
};
- // Forward all further arguments. We do some processing here because we want to
- // detect people still using the old way of passing flags to Miri
- // (`cargo miri -- -Zmiri-foo`).
- while let Some(arg) = args.next() {
- cmd.arg(&arg);
- if arg == "--" {
- // Check if the next argument starts with `-Zmiri`. If yes, we assume
- // this is an old-style invocation.
- if let Some(next_arg) = args.next() {
- if next_arg.starts_with("-Zmiri") || next_arg == "--" {
- eprintln!(
- "WARNING: it seems like you are setting Miri's flags in `cargo miri` the old way,\n\
- i.e., by passing them after the first `--`. This style is deprecated; please set\n\
- the MIRIFLAGS environment variable instead. `cargo miri run/test` now interprets\n\
- arguments the exact same way as `cargo run/test`."
- );
- // Old-style invocation. Turn these into MIRIFLAGS, if there are any.
- if next_arg != "--" {
- let mut miriflags = env::var("MIRIFLAGS").unwrap_or_default();
- miriflags.push(' ');
- miriflags.push_str(&next_arg);
- while let Some(further_arg) = args.next() {
- if further_arg == "--" {
- // End of the Miri flags!
- break;
- }
- miriflags.push(' ');
- miriflags.push_str(&further_arg);
- }
- env::set_var("MIRIFLAGS", miriflags);
- }
- // Pass the remaining flags to cargo.
- cmd.args(args);
- break;
- }
- // Not a Miri argument after all, make sure we pass it to cargo.
- cmd.arg(next_arg);
- }
- }
- }
+ // Forward all further arguments to cargo.
+ cmd.args(args);
// Set `RUSTC_WRAPPER` to ourselves. Cargo will prepend that binary to its usual invocation,
// i.e., the first argument is `rustc` -- which is what we use in `main` to distinguish
}
cmd.env("RUSTC_WRAPPER", &cargo_miri_path);
- // Set the runner for the current target to us as well, so we can interpret the binaries.
- let runner_env_name = format!("CARGO_TARGET_{}_RUNNER", target.to_uppercase().replace('-', "_"));
- cmd.env(&runner_env_name, &cargo_miri_path);
-
- // Set rustdoc to us as well, so we can make it do nothing (see issue #584).
+ let runner_env_name = |triple: &str| {
+ format!("CARGO_TARGET_{}_RUNNER", triple.to_uppercase().replace('-', "_"))
+ };
+ let host_runner_env_name = runner_env_name(&host);
+ let target_runner_env_name = runner_env_name(target);
+ // Set the target runner to us, so we can interpret the binaries.
+ cmd.env(&target_runner_env_name, &cargo_miri_path);
+ // Unit tests of `proc-macro` crates are run on the host, so we set the host runner to
+ // us in order to skip them.
+ cmd.env(&host_runner_env_name, &cargo_miri_path);
+
+ // Set rustdoc to us as well, so we can run doctests.
cmd.env("RUSTDOC", &cargo_miri_path);
// Run cargo.
if verbose {
eprintln!("[cargo-miri miri] RUSTC_WRAPPER={:?}", cargo_miri_path);
- eprintln!("[cargo-miri miri] {}={:?}", runner_env_name, cargo_miri_path);
+ eprintln!("[cargo-miri miri] {}={:?}", target_runner_env_name, cargo_miri_path);
+ if *target != host {
+ eprintln!("[cargo-miri miri] {}={:?}", host_runner_env_name, cargo_miri_path);
+ }
eprintln!("[cargo-miri miri] RUSTDOC={:?}", cargo_miri_path);
eprintln!("[cargo-miri miri] {:?}", cmd);
cmd.env("MIRI_VERBOSE", ""); // This makes the other phases verbose.
exec(cmd)
}
-fn phase_cargo_rustc(args: env::Args) {
+#[derive(Debug, Copy, Clone, PartialEq)]
+enum RustcPhase {
+ /// `rustc` called via `xargo` for sysroot build.
+ Setup,
+ /// `rustc` called by `cargo` for regular build.
+ Build,
+ /// `rustc` called by `rustdoc` for doctest.
+ Rustdoc,
+}
+
+fn phase_rustc(mut args: env::Args, phase: RustcPhase) {
/// Determines if we are being invoked (as rustc) to build a crate for
/// the "target" architecture, in contrast to the "host" architecture.
/// Host crates are for build scripts and proc macros and still need to
}
fn out_filename(prefix: &str, suffix: &str) -> PathBuf {
- let mut path = PathBuf::from(get_arg_flag_value("--out-dir").unwrap());
- path.push(format!(
- "{}{}{}{}",
- prefix,
- get_arg_flag_value("--crate-name").unwrap(),
- // This is technically a `-C` flag but the prefix seems unique enough...
- // (and cargo passes this before the filename so it should be unique)
- get_arg_flag_value("extra-filename").unwrap_or(String::new()),
- suffix,
- ));
- path
+ if let Some(out_dir) = get_arg_flag_value("--out-dir") {
+ let mut path = PathBuf::from(out_dir);
+ path.push(format!(
+ "{}{}{}{}",
+ prefix,
+ get_arg_flag_value("--crate-name").unwrap(),
+ // This is technically a `-C` flag but the prefix seems unique enough...
+ // (and cargo passes this before the filename so it should be unique)
+ get_arg_flag_value("extra-filename").unwrap_or(String::new()),
+ suffix,
+ ));
+ path
+ } else {
+ let out_file = get_arg_flag_value("-o").unwrap();
+ PathBuf::from(out_file)
+ }
}
let verbose = std::env::var_os("MIRI_VERBOSE").is_some();
let target_crate = is_target_crate();
- let print = get_arg_flag_value("--print").is_some(); // whether this is cargo passing `--print` to get some infos
+ let print = get_arg_flag_value("--print").is_some() || has_arg_flag("-vV"); // whether this is cargo/xargo invoking rustc to get some infos
- // rlib and cdylib are just skipped, we cannot interpret them and do not need them
- // for the rest of the build either.
- match get_arg_flag_value("--crate-type").as_deref() {
- Some("rlib") | Some("cdylib") => {
- if verbose {
- eprint!("[cargo-miri rustc] (rlib/cdylib skipped)");
- }
- return;
+ let store_json = |info: CrateRunInfo| {
+ // Create a stub .d file to stop Cargo from "rebuilding" the crate:
+ // https://github.com/rust-lang/miri/issues/1724#issuecomment-787115693
+ // As we store a JSON file instead of building the crate here, an empty file is fine.
+ let dep_info_name = out_filename("", ".d");
+ if verbose {
+ eprintln!("[cargo-miri rustc] writing stub dep-info to `{}`", dep_info_name.display());
}
- _ => {},
- }
+ File::create(dep_info_name).expect("failed to create fake .d file");
- if !print && target_crate && is_runnable_crate() {
- // This is the binary or test crate that we want to interpret under Miri.
- // But we cannot run it here, as cargo invoked us as a compiler -- our stdin and stdout are not
- // like we want them.
- // Instead of compiling, we write JSON into the output file with all the relevant command-line flags
- // and environment variables; this is used when cargo calls us again in the CARGO_TARGET_RUNNER phase.
- let info = CrateRunInfo::collect(args);
let filename = out_filename("", "");
if verbose {
eprintln!("[cargo-miri rustc] writing run info to `{}`", filename.display());
}
-
info.store(&filename);
// For Windows, do the same thing again with `.exe` appended to the filename.
// (Need to do this here as cargo moves that "binary" to a different place before running it.)
info.store(&out_filename("", ".exe"));
+ };
+
+ let runnable_crate = !print && is_runnable_crate();
+
+ if runnable_crate && target_crate {
+ assert!(phase != RustcPhase::Setup, "there should be no interpretation during sysroot build");
+ let inside_rustdoc = phase == RustcPhase::Rustdoc;
+ // This is the binary or test crate that we want to interpret under Miri.
+ // But we cannot run it here, as cargo invoked us as a compiler -- our stdin and stdout are not
+ // like we want them.
+ // Instead of compiling, we write JSON into the output file with all the relevant command-line flags
+ // and environment variables; this is used when cargo calls us again in the CARGO_TARGET_RUNNER phase.
+ let env = CrateRunEnv::collect(args, inside_rustdoc);
+
+ // Rustdoc expects us to exit with an error code if the test is marked as `compile_fail`,
+ // just creating the JSON file is not enough: we need to detect syntax errors,
+ // so we need to run Miri with `MIRI_BE_RUSTC` for a check-only build.
+ if inside_rustdoc {
+ let mut cmd = miri();
+
+ // Ensure --emit argument for a check-only build is present.
+ // We cannot use the usual helpers since we need to check specifically in `env.args`.
+ if let Some(i) = env.args.iter().position(|arg| arg.starts_with("--emit=")) {
+ // For `no_run` tests, rustdoc passes a `--emit` flag; make sure it has the right shape.
+ assert_eq!(env.args[i], "--emit=metadata");
+ } else {
+ // For all other kinds of tests, we can just add our flag.
+ cmd.arg("--emit=metadata");
+ }
+ cmd.args(&env.args);
+ cmd.env("MIRI_BE_RUSTC", "target");
+
+ if verbose {
+ eprintln!("[cargo-miri rustc] captured input:\n{}", std::str::from_utf8(&env.stdin).unwrap());
+ eprintln!("[cargo-miri rustc] {:?}", cmd);
+ }
+
+ exec_with_pipe(cmd, &env.stdin);
+ }
+
+ store_json(CrateRunInfo::RunWith(env));
+
+ return;
+ }
+
+ if runnable_crate && ArgFlagValueIter::new("--extern").any(|krate| krate == "proc_macro") {
+ // This is a "runnable" `proc-macro` crate (unit tests). We do not support
+ // interpreting that under Miri now, so we write a JSON file to (display a
+ // helpful message and) skip it in the runner phase.
+ store_json(CrateRunInfo::SkipProcMacroTest);
return;
}
if !print && target_crate {
// Forward arguments, but remove "link" from "--emit" to make this a check-only build.
let emit_flag = "--emit";
- for arg in args {
+ while let Some(arg) = args.next() {
if arg.starts_with(emit_flag) {
// Patch this argument. First, extract its value.
let val = &arg[emit_flag.len()..];
}
}
cmd.arg(format!("{}={}", emit_flag, val.join(",")));
+ } else if arg == "--extern" {
+ // Patch `--extern` filenames, since Cargo sometimes passes stub `.rlib` files:
+ // https://github.com/rust-lang/miri/issues/1705
+ forward_patched_extern_arg(&mut args, &mut cmd);
} else {
cmd.arg(arg);
}
}
- // Use our custom sysroot.
- let sysroot =
- env::var_os("MIRI_SYSROOT").expect("the wrapper should have set MIRI_SYSROOT");
- cmd.arg("--sysroot");
- cmd.arg(sysroot);
+ // Use our custom sysroot (but not if that is what we are currently building).
+ if phase != RustcPhase::Setup {
+ forward_miri_sysroot(&mut cmd);
+ }
+
+ // During setup, patch the panic runtime for `libpanic_abort` (mirroring what bootstrap usually does).
+ if phase == RustcPhase::Setup && get_arg_flag_value("--crate-name").as_deref() == Some("panic_abort") {
+ cmd.arg("-C").arg("panic=abort");
+ }
} else {
// For host crates or when we are printing, just forward everything.
cmd.args(args);
// We want to compile, not interpret. We still use Miri to make sure the compiler version etc
// are the exact same as what is used for interpretation.
- cmd.env("MIRI_BE_RUSTC", "1");
+ // MIRI_DEFAULT_ARGS should not be used to build host crates, hence setting "target" or "host"
+ // as the value here to help Miri differentiate them.
+ cmd.env("MIRI_BE_RUSTC", if target_crate { "target" } else { "host" });
// Run it.
if verbose {
exec(cmd);
// Create a stub .rlib file if "link" was requested by cargo.
+ // This is necessary to prevent cargo from doing rebuilds all the time.
if emit_link_hack {
// Some platforms prepend "lib", some do not... let's just create both files.
- let filename = out_filename("lib", ".rlib");
- File::create(filename).expect("failed to create rlib file");
- let filename = out_filename("", ".rlib");
- File::create(filename).expect("failed to create rlib file");
+ File::create(out_filename("lib", ".rlib")).expect("failed to create fake .rlib file");
+ File::create(out_filename("", ".rlib")).expect("failed to create fake .rlib file");
+ // Just in case this is a cdylib or staticlib, also create those fake files.
+ File::create(out_filename("lib", ".so")).expect("failed to create fake .so file");
+ File::create(out_filename("lib", ".a")).expect("failed to create fake .a file");
+ File::create(out_filename("lib", ".dylib")).expect("failed to create fake .dylib file");
+ File::create(out_filename("", ".dll")).expect("failed to create fake .dll file");
+ File::create(out_filename("", ".lib")).expect("failed to create fake .lib file");
}
}
-fn phase_cargo_runner(binary: &Path, binary_args: env::Args) {
+#[derive(Debug, Copy, Clone, PartialEq)]
+enum RunnerPhase {
+ /// `cargo` is running a binary
+ Cargo,
+ /// `rustdoc` is running a binary
+ Rustdoc,
+}
+
+fn phase_runner(binary: &Path, binary_args: env::Args, phase: RunnerPhase) {
let verbose = std::env::var_os("MIRI_VERBOSE").is_some();
let file = File::open(&binary)
.unwrap_or_else(|_| show_error(format!("file {:?} not found or `cargo-miri` invoked incorrectly; please only invoke this binary through `cargo miri`", binary)));
let file = BufReader::new(file);
- let info: CrateRunInfo = serde_json::from_reader(file)
+
+ let info = serde_json::from_reader(file)
.unwrap_or_else(|_| show_error(format!("file {:?} contains outdated or invalid JSON; try `cargo clean`", binary)));
+ let info = match info {
+ CrateRunInfo::RunWith(info) => info,
+ CrateRunInfo::SkipProcMacroTest => {
+ eprintln!("Running unit tests of `proc-macro` crates is not currently supported by Miri.");
+ return;
+ }
+ };
+
+ let mut cmd = miri();
- // Set missing env vars. Looks like `build.rs` vars are still set at run-time, but
- // `CARGO_BIN_EXE_*` are not. This means we can give the run-time environment precedence,
- // to rather do too little than too much.
+ // Set missing env vars. We prefer build-time env vars over run-time ones; see
+ // <https://github.com/rust-lang/miri/issues/1661> for the kind of issue that fixes.
for (name, val) in info.env {
- if env::var_os(&name).is_none() {
- env::set_var(name, val);
+ if verbose {
+ if let Some(old_val) = env::var_os(&name) {
+ if old_val != val {
+ eprintln!("[cargo-miri runner] Overwriting run-time env var {:?}={:?} with build-time value {:?}", name, old_val, val);
+ }
+ }
}
+ cmd.env(name, val);
}
- let mut cmd = miri();
// Forward rustc arguments.
// We need to patch "--extern" filenames because we forced a check-only
// build without cargo knowing about that: replace `.rlib` suffix by
// but when we run here, cargo does not interpret the JSON any more. `--json`
// then also nees to be dropped.
let mut args = info.args.into_iter();
- let extern_flag = "--extern";
let error_format_flag = "--error-format";
let json_flag = "--json";
while let Some(arg) = args.next() {
- if arg == extern_flag {
- cmd.arg(extern_flag); // always forward flag, but adjust filename
- // `--extern` is always passed as a separate argument by cargo.
- let next_arg = args.next().expect("`--extern` should be followed by a filename");
- if let Some(next_lib) = next_arg.strip_suffix(".rlib") {
- // If this is an rlib, make it an rmeta.
- cmd.arg(format!("{}.rmeta", next_lib));
- } else {
- // Some other extern file (e.g., a `.so`). Forward unchanged.
- cmd.arg(next_arg);
- }
+ if arg == "--extern" {
+ forward_patched_extern_arg(&mut args, &mut cmd);
} else if arg.starts_with(error_format_flag) {
let suffix = &arg[error_format_flag.len()..];
assert!(suffix.starts_with('='));
cmd.arg(arg);
}
}
- // Set sysroot.
- let sysroot =
- env::var_os("MIRI_SYSROOT").expect("the wrapper should have set MIRI_SYSROOT");
- cmd.arg("--sysroot");
- cmd.arg(sysroot);
+ // Set sysroot (if we are inside rustdoc, we already did that in `phase_cargo_rustdoc`).
+ if phase != RunnerPhase::Rustdoc {
+ forward_miri_sysroot(&mut cmd);
+ }
// Respect `MIRIFLAGS`.
if let Ok(a) = env::var("MIRIFLAGS") {
// This code is taken from `RUSTFLAGS` handling in cargo.
if verbose {
eprintln!("[cargo-miri runner] {:?}", cmd);
}
+
+ match phase {
+ RunnerPhase::Rustdoc => {
+ exec_with_pipe(cmd, &info.stdin)
+ }
+ RunnerPhase::Cargo => {
+ exec(cmd)
+ }
+ }
+}
+
+fn phase_rustdoc(fst_arg: &str, mut args: env::Args) {
+ let verbose = std::env::var_os("MIRI_VERBOSE").is_some();
+
+ // phase_cargo_miri sets the RUSTDOC env var to ourselves, so we can't use that here;
+ // just default to a straight-forward invocation for now:
+ let mut cmd = Command::new("rustdoc");
+
+ // Because of the way the main function is structured, we have to take the first argument spearately
+ // from the rest; to simplify the following argument patching loop, we'll just skip that one.
+ // This is fine for now, because cargo will never pass --extern arguments in the first position,
+ // but we should defensively assert that this will work.
+ let extern_flag = "--extern";
+ assert!(fst_arg != extern_flag);
+ cmd.arg(fst_arg);
+
+ let runtool_flag = "--runtool";
+ // `crossmode` records if *any* argument matches `runtool_flag`; here we check the first one.
+ let mut crossmode = fst_arg == runtool_flag;
+ while let Some(arg) = args.next() {
+ if arg == extern_flag {
+ // Patch --extern arguments to use *.rmeta files, since phase_cargo_rustc only creates stub *.rlib files.
+ forward_patched_extern_arg(&mut args, &mut cmd);
+ } else if arg == runtool_flag {
+ // An existing --runtool flag indicates cargo is running in cross-target mode, which we don't support.
+ // Note that this is only passed when cargo is run with the unstable -Zdoctest-xcompile flag;
+ // otherwise, we won't be called as rustdoc at all.
+ crossmode = true;
+ break;
+ } else {
+ cmd.arg(arg);
+ }
+ }
+
+ if crossmode {
+ show_error(format!("cross-interpreting doc-tests is not currently supported by Miri."));
+ }
+
+ // For each doc-test, rustdoc starts two child processes: first the test is compiled,
+ // then the produced executable is invoked. We want to reroute both of these to cargo-miri,
+ // such that the first time we'll enter phase_cargo_rustc, and phase_cargo_runner second.
+ //
+ // rustdoc invokes the test-builder by forwarding most of its own arguments, which makes
+ // it difficult to determine when phase_cargo_rustc should run instead of phase_cargo_rustdoc.
+ // Furthermore, the test code is passed via stdin, rather than a temporary file, so we need
+ // to let phase_cargo_rustc know to expect that. We'll use this environment variable as a flag:
+ cmd.env("MIRI_CALLED_FROM_RUSTDOC", "1");
+
+ // The `--test-builder` and `--runtool` arguments are unstable rustdoc features,
+ // which are disabled by default. We first need to enable them explicitly:
+ cmd.arg("-Z").arg("unstable-options");
+
+ // rustdoc needs to know the right sysroot.
+ forward_miri_sysroot(&mut cmd);
+
+ // Make rustdoc call us back.
+ let cargo_miri_path = std::env::current_exe().expect("current executable path invalid");
+ cmd.arg("--test-builder").arg(&cargo_miri_path); // invoked by forwarding most arguments
+ cmd.arg("--runtool").arg(&cargo_miri_path); // invoked with just a single path argument
+
+ if verbose {
+ eprintln!("[cargo-miri rustdoc] {:?}", cmd);
+ }
+
exec(cmd)
}
args.next().unwrap();
// Dispatch running as part of sysroot compilation.
- if env::var_os("MIRI_BE_RUSTC").is_some() {
- phase_setup_rustc(args);
+ if env::var_os("MIRI_CALLED_FROM_XARGO").is_some() {
+ phase_rustc(args, RustcPhase::Setup);
+ return;
+ }
+
+ // The way rustdoc invokes rustc is indistuingishable from the way cargo invokes rustdoc by the
+ // arguments alone. `phase_cargo_rustdoc` sets this environment variable to let us disambiguate.
+ if env::var_os("MIRI_CALLED_FROM_RUSTDOC").is_some() {
+ // ...however, we then also see this variable when rustdoc invokes us as the testrunner!
+ // The runner is invoked as `$runtool ($runtool-arg)* output_file`;
+ // since we don't specify any runtool-args, and rustdoc supplies multiple arguments to
+ // the test-builder unconditionally, we can just check the number of remaining arguments:
+ if args.len() == 1 {
+ let arg = args.next().unwrap();
+ let binary = Path::new(&arg);
+ if binary.exists() {
+ phase_runner(binary, args, RunnerPhase::Rustdoc);
+ } else {
+ show_error(format!("`cargo-miri` called with non-existing path argument `{}` in rustdoc mode; please invoke this binary through `cargo miri`", arg));
+ }
+ } else {
+ phase_rustc(args, RustcPhase::Rustdoc);
+ }
+
return;
}
// On top of that, we are also called as RUSTDOC, but that is just a stub currently.
match args.next().as_deref() {
Some("miri") => phase_cargo_miri(args),
- Some("rustc") => phase_cargo_rustc(args),
+ Some("rustc") => phase_rustc(args, RustcPhase::Build),
Some(arg) => {
- // We have to distinguish the "runner" and "rustfmt" cases.
+ // We have to distinguish the "runner" and "rustdoc" cases.
// As runner, the first argument is the binary (a file that should exist, with an absolute path);
- // as rustfmt, the first argument is a flag (`--something`).
+ // as rustdoc, the first argument is a flag (`--something`).
let binary = Path::new(arg);
if binary.exists() {
assert!(!arg.starts_with("--")); // not a flag
- phase_cargo_runner(binary, args);
+ phase_runner(binary, args, RunnerPhase::Cargo);
} else if arg.starts_with("--") {
- // We are rustdoc.
- eprintln!("Running doctests is not currently supported by Miri.")
+ phase_rustdoc(arg, args);
} else {
show_error(format!("`cargo-miri` called with unexpected first argument `{}`; please only invoke this binary through `cargo miri`", arg));
}
projects / rust.git / blobdiff