use rustc-build-sysroot instead of xargo

.github/workflows/ci.yml

@@ -62,15 +62,14 @@ jobs:
             # contains package information of crates installed via `cargo install`.
             ~/.cargo/.crates.toml
             ~/.cargo/.crates2.json
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock', 'cargo-miri/src/version.rs') }}
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: ${{ runner.os }}-cargo
 
-      - name: Install rustup-toolchain-install-master and xargo
+      - name: Install rustup-toolchain-install-master
         if: ${{ steps.cache.outputs.cache-hit == 'false' }}
         shell: bash
         run: |
           cargo install rustup-toolchain-install-master
-          cargo install xargo
 
       - name: Install "master" toolchain
         shell: bash

CONTRIBUTING.md

@@ -38,7 +38,7 @@ for you. If you don't want all of these to happen, you can add individual `.auto
 ## Building and testing Miri
 
 Invoking Miri requires getting a bunch of flags right and setting up a custom
-sysroot with xargo. The `miri` script takes care of that for you. With the
+sysroot. The `miri` script takes care of that for you. With the
 build environment prepared, compiling Miri is just one command away:
 
 ```

README.md

@@ -447,7 +447,7 @@ binaries, and as such worth documenting:
   some compiler flags to prepare the code for interpretation; with `host`, this is not done.
   This environment variable is useful to be sure that the compiled `rlib`s are compatible
   with Miri.
-* `MIRI_CALLED_FROM_XARGO` is set during the Miri-induced `xargo` sysroot build,
+* `MIRI_CALLED_FROM_SETUP` is set during the Miri sysroot build,
   which will re-invoke `cargo-miri` as the `rustc` to use for this build.
 * `MIRI_CALLED_FROM_RUSTDOC` when set to any value tells `cargo-miri` that it is
   running as a child process of `rustdoc`, which invokes it twice for each doc-test

cargo-miri/Cargo.toml

@@ -18,6 +18,7 @@ directories = "3"
 rustc_version = "0.4"
 serde_json = "1.0.40"
 cargo_metadata = "0.15.0"
+rustc-build-sysroot = "0.1"
 
 # A noop dependency that changes in the Rust repository, it's a bit of a hack.
 # See the `src/tools/rustc-workspace-hack/README.md` file in `rust-lang/rust`

cargo-miri/src/main.rs

@@ -6,7 +6,6 @@ mod util;
 mod arg;
 mod phases;
 mod setup;
-mod version;
 
 use std::{env, iter};
 
@@ -22,8 +21,8 @@ fn main() {
     // Dispatch to `cargo-miri` phase. Here is a rough idea of "who calls who".
     //
     // Initially, we are invoked as `cargo-miri miri run/test`. We first run the setup phase:
-    // - We call `xargo`, and set `RUSTC` back to us, together with `MIRI_CALLED_FROM_XARGO`,
-    //   so that xargo's rustc invocations end up in `phase_rustc` with `RustcPhase::Setup`.
+    // - We use `rustc-build-sysroot`, and set `RUSTC` back to us, together with `MIRI_CALLED_FROM_SETUP`,
+    //   so that the sysroot build rustc invocations end up in `phase_rustc` with `RustcPhase::Setup`.
     //   There we then call the Miri driver with `MIRI_BE_RUSTC` to perform the actual build.
     //
     // Then we call `cargo run/test`, exactly forwarding all user flags, plus some configuration so
@@ -52,7 +51,7 @@ fn main() {
     //     the Miri driver for interpretation.
 
     // Dispatch running as part of sysroot compilation.
-    if env::var_os("MIRI_CALLED_FROM_XARGO").is_some() {
+    if env::var_os("MIRI_CALLED_FROM_SETUP").is_some() {
         phase_rustc(args, RustcPhase::Setup);
         return;
     }

cargo-miri/src/phases.rs

@@ -7,6 +7,8 @@ use std::io::BufReader;
 use std::path::PathBuf;
 use std::process::Command;
 
+use rustc_version::VersionMeta;
+
 use crate::{setup::*, util::*};
 
 const CARGO_MIRI_HELP: &str = r#"Runs binary crates and tests in Miri
@@ -90,12 +92,14 @@ pub fn phase_cargo_miri(mut args: impl Iterator<Item = String>) {
     let verbose = num_arg_flag("-v");
 
     // Determine the involved architectures.
-    let host = version_info().host;
+    let rustc_version = VersionMeta::for_command(miri_for_host())
+        .expect("failed to determine underlying rustc version of Miri");
+    let host = &rustc_version.host;
     let target = get_arg_flag_value("--target");
-    let target = target.as_ref().unwrap_or(&host);
+    let target = target.as_ref().unwrap_or(host);
 
     // We always setup.
-    setup(&subcommand, &host, target);
+    setup(&subcommand, target, &rustc_version);
 
     // Invoke actual cargo for the job, but with different flags.
     // We re-use `cargo test` and `cargo run`, which makes target and binary handling very easy but
@@ -204,7 +208,7 @@ pub fn phase_cargo_miri(mut args: impl Iterator<Item = String>) {
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum RustcPhase {
-    /// `rustc` called via `xargo` for sysroot build.
+    /// `rustc` called during sysroot build.
     Setup,
     /// `rustc` called by `cargo` for regular build.
     Build,
@@ -264,7 +268,7 @@ pub fn phase_rustc(mut args: impl Iterator<Item = String>, phase: RustcPhase) {
     let verbose = std::env::var("MIRI_VERBOSE")
         .map_or(0, |verbose| verbose.parse().expect("verbosity flag must be an integer"));
     let target_crate = is_target_crate();
-    // Determine whether this is cargo/xargo invoking rustc to get some infos.
+    // Determine whether this is cargo invoking rustc to get some infos.
     let info_query = get_arg_flag_value("--print").is_some() || has_arg_flag("-vV");
 
     let store_json = |info: CrateRunInfo| {