Avoid copying rustc artifacts to the build compiler sysroot during check

Author: Kobzol

src/bootstrap/src/bin/rustc.rs

@@ -179,6 +179,16 @@ fn main() {
         }
     }
 
+    // Here we pass additional paths that essentially act as a sysroot.
+    // These are used to load rustc crates (e.g. `extern crate rustc_ast;`)
+    // for rustc_private tools, so that we do not have to copy them into the
+    // actual sysroot of the compiler that builds the tool.
+    if let Ok(dirs) = env::var("RUSTC_ADDITIONAL_SYSROOT_PATHS") {
+        for dir in dirs.split(",") {
+            cmd.arg(format!("-L{dir}"));
+        }
+    }
+
     // Force all crates compiled by this compiler to (a) be unstable and (b)
     // allow the `rustc_private` feature to link to other unstable crates
     // also in the sysroot. We also do this for host crates, since those

src/bootstrap/src/core/build_steps/check.rs

@@ -1,5 +1,8 @@
 //! Implementation of compiling the compiler and standard library, in "check"-based modes.
 
+use std::fs;
+use std::path::PathBuf;
+
 use crate::core::build_steps::compile::{
     add_to_sysroot, run_cargo, rustc_cargo, rustc_cargo_env, std_cargo, std_crates_for_run_make,
 };
@@ -9,11 +12,11 @@ use crate::core::build_steps::tool::{
     prepare_tool_cargo,
 };
 use crate::core::builder::{
-    self, Alias, Builder, Kind, RunConfig, ShouldRun, Step, StepMetadata, crate_description,
+    self, Alias, Builder, Cargo, Kind, RunConfig, ShouldRun, Step, StepMetadata, crate_description,
 };
 use crate::core::config::TargetSelection;
 use crate::utils::build_stamp::{self, BuildStamp};
-use crate::{Compiler, Mode, Subcommand};
+use crate::{Compiler, Mode, Subcommand, t};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Std {
@@ -64,7 +67,8 @@ impl Step for Std {
 
         let crates = std_crates_for_run_make(&run);
         run.builder.ensure(Std {
-            build_compiler: prepare_compiler_for_check(run.builder, run.target, Mode::Std),
+            build_compiler: prepare_compiler_for_check(run.builder, run.target, Mode::Std)
+                .build_compiler,
             target: run.target,
             crates,
         });
@@ -145,8 +149,65 @@ impl Step for Std {
     }
 }
 
-/// Checks rustc using `build_compiler` and copies the built
-/// .rmeta files into the sysroot of `build_compiler`.
+/// Represents a proof that rustc was checked.
+/// Contains directories that contain .rmeta files generated by checking rustc for a specific
+/// target.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct RustcRmetaSysroot {
+    host_dir: PathBuf,
+    target_dir: PathBuf,
+}
+
+impl RustcRmetaSysroot {
+    /// Configure the given cargo invocation so that the compiled crate will be able to use
+    /// rustc rmeta artifacts that were previously generated.
+    fn configure_cargo(&self, cargo: &mut Cargo) {
+        cargo.env(
+            "RUSTC_ADDITIONAL_SYSROOT_PATHS",
+            format!("{},{}", self.host_dir.display(), self.target_dir.display()),
+        );
+    }
+}
+
+/// Checks rustc using the given `build_compiler` for the given `target`, and produces
+/// a sysroot in the build directory that stores the generated .rmeta files.
+///
+/// This step exists so that we can separate the generated .rmeta artifacts into a separate
+/// directory. Before, we used to copy them into the sysroot of `build_compiler`, but that
+/// "pollutes" its sysroot, which is problematic especially for external stage0 rustc.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct PrepareRustcRmetaSysroot {
+    build_compiler: Compiler,
+    target: TargetSelection,
+}
+
+impl Step for PrepareRustcRmetaSysroot {
+    type Output = RustcRmetaSysroot;
+
+    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+        run.never()
+    }
+
+    fn run(self, builder: &Builder<'_>) -> Self::Output {
+        // Check rustc
+        let stamp = builder.ensure(Rustc::new(builder, self.build_compiler, self.target));
+
+        // Copy the generated rmeta artifacts to a separate directory
+        let dir = builder
+            .out
+            .join(self.build_compiler.host)
+            .join(format!("stage{}-rustc-check-artifacts", self.build_compiler.stage + 1));
+        let host_dir = dir.join("host");
+        let target_dir = dir.join(self.target);
+        let _ = fs::remove_dir_all(&dir);
+        t!(fs::create_dir_all(&dir));
+        add_to_sysroot(builder, &target_dir, &host_dir, &stamp);
+
+        RustcRmetaSysroot { host_dir, target_dir }
+    }
+}
+
+/// Checks rustc using `build_compiler`.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Rustc {
     /// Compiler that will check this rustc.
@@ -172,7 +233,7 @@ impl Rustc {
 }
 
 impl Step for Rustc {
-    type Output = ();
+    type Output = BuildStamp;
     const ONLY_HOSTS: bool = true;
     const DEFAULT: bool = true;
 
@@ -184,7 +245,8 @@ impl Step for Rustc {
         let crates = run.make_run_crates(Alias::Compiler);
         run.builder.ensure(Rustc {
             target: run.target,
-            build_compiler: prepare_compiler_for_check(run.builder, run.target, Mode::Rustc),
+            build_compiler: prepare_compiler_for_check(run.builder, run.target, Mode::Rustc)
+                .build_compiler,
             crates,
         });
     }
@@ -196,7 +258,7 @@ impl Step for Rustc {
     /// created will also be linked into the sysroot directory.
     ///
     /// If we check a stage 2 compiler, we will have to first build a stage 1 compiler to check it.
-    fn run(self, builder: &Builder<'_>) {
+    fn run(self, builder: &Builder<'_>) -> Self::Output {
         let build_compiler = self.build_compiler;
         let target = self.target;
 
@@ -238,53 +300,62 @@ impl Step for Rustc {
 
         run_cargo(builder, cargo, builder.config.free_args.clone(), &stamp, vec![], true, false);
 
-        let libdir = builder.sysroot_target_libdir(build_compiler, target);
-        let hostdir = builder.sysroot_target_libdir(build_compiler, build_compiler.host);
-        add_to_sysroot(builder, &libdir, &hostdir, &stamp);
+        stamp
     }
 
     fn metadata(&self) -> Option<StepMetadata> {
         Some(StepMetadata::check("rustc", self.target).built_by(self.build_compiler))
     }
 }
 
+/// Represents a compiler that can check something.
+/// It optionally includes .rmeta artifacts from rustc that was already checked using
+/// `build_compiler`.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct CompilerForCheck {
+    build_compiler: Compiler,
+    rustc_rmeta_sysroot: Option<RustcRmetaSysroot>,
+}
+
 /// Prepares a compiler that will check something with the given `mode`.
 fn prepare_compiler_for_check(
     builder: &Builder<'_>,
     target: TargetSelection,
     mode: Mode,
-) -> Compiler {
+) -> CompilerForCheck {
     let host = builder.host_target;
 
-    match mode {
+    let mut rmeta_sysroot = None;
+    let build_compiler = match mode {
         Mode::ToolBootstrap => builder.compiler(0, host),
         Mode::ToolTarget => get_tool_target_compiler(builder, ToolTargetBuildMode::Build(target)),
         Mode::ToolStd => {
             if builder.config.compile_time_deps {
                 // When --compile-time-deps is passed, we can't use any rustc
                 // other than the bootstrap compiler. Luckily build scripts and
                 // proc macros for tools are unlikely to need nightly.
-                return builder.compiler(0, host);
+                builder.compiler(0, host)
+            } else {
+                // These tools require the local standard library to be checked
+                let build_compiler = builder.compiler(builder.top_stage, host);
+
+                // We need to build the host stdlib to check the tool itself.
+                // We need to build the target stdlib so that the tool can link to it.
+                builder.std(build_compiler, host);
+                // We could only check this library in theory, but `check::Std` doesn't copy rmetas
+                // into `build_compiler`'s sysroot to avoid clashes with `.rlibs`, so we build it
+                // instead.
+                builder.std(build_compiler, target);
+                build_compiler
             }
-
-            // These tools require the local standard library to be checked
-            let build_compiler = builder.compiler(builder.top_stage, host);
-
-            // We need to build the host stdlib to check the tool itself.
-            // We need to build the target stdlib so that the tool can link to it.
-            builder.std(build_compiler, host);
-            // We could only check this library in theory, but `check::Std` doesn't copy rmetas
-            // into `build_compiler`'s sysroot to avoid clashes with `.rlibs`, so we build it
-            // instead.
-            builder.std(build_compiler, target);
-            build_compiler
         }
         Mode::ToolRustc | Mode::Codegen => {
             // FIXME: this is a hack, see description of Mode::Rustc below
             let stage = if host == target { builder.top_stage - 1 } else { builder.top_stage };
             // When checking tool stage N, we check it with compiler stage N-1
             let build_compiler = builder.compiler(stage, host);
-            builder.ensure(Rustc::new(builder, build_compiler, target));
+            rmeta_sysroot =
+                Some(builder.ensure(PrepareRustcRmetaSysroot { build_compiler, target }));
             build_compiler
         }
         Mode::Rustc => {
@@ -304,15 +375,17 @@ fn prepare_compiler_for_check(
             // stage 0 stdlib is used to compile build scripts and proc macros.
             builder.compiler(builder.top_stage, host)
         }
-    }
+    };
+    CompilerForCheck { build_compiler, rustc_rmeta_sysroot: rmeta_sysroot }
 }
 
 /// Checks a single codegen backend.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct CodegenBackend {
-    pub build_compiler: Compiler,
-    pub target: TargetSelection,
-    pub backend: &'static str,
+    build_compiler: Compiler,
+    rmeta_sysroot: RustcRmetaSysroot,
+    target: TargetSelection,
+    backend: &'static str,
 }
 
 impl Step for CodegenBackend {
@@ -326,9 +399,17 @@ impl Step for CodegenBackend {
 
     fn make_run(run: RunConfig<'_>) {
         // FIXME: only check the backend(s) that were actually selected in run.paths
-        let build_compiler = prepare_compiler_for_check(run.builder, run.target, Mode::Codegen);
+        let CompilerForCheck { build_compiler, rustc_rmeta_sysroot: rmeta_sysroot } =
+            prepare_compiler_for_check(run.builder, run.target, Mode::Codegen);
+        let rmeta_sysroot =
+            rmeta_sysroot.expect("Rustc rmeta sysroot missing for checking codegen");
         for &backend in &["cranelift", "gcc"] {
-            run.builder.ensure(CodegenBackend { build_compiler, target: run.target, backend });
+            run.builder.ensure(CodegenBackend {
+                build_compiler,
+                rmeta_sysroot: rmeta_sysroot.clone(),
+                target: run.target,
+                backend,
+            });
         }
     }
 
@@ -351,6 +432,7 @@ impl Step for CodegenBackend {
             target,
             builder.kind,
         );
+        self.rmeta_sysroot.configure_cargo(&mut cargo);
 
         cargo
             .arg("--manifest-path")
@@ -388,8 +470,8 @@ macro_rules! tool_check_step {
     ) => {
         #[derive(Debug, Clone, PartialEq, Eq, Hash)]
         pub struct $name {
-            pub build_compiler: Compiler,
-            pub target: TargetSelection,
+            compiler: CompilerForCheck,
+            target: TargetSelection,
         }
 
         impl Step for $name {
@@ -407,31 +489,31 @@ macro_rules! tool_check_step {
                 let builder = run.builder;
                 let mode = $mode(builder);
 
-                let build_compiler = prepare_compiler_for_check(run.builder, target, mode);
+                let compiler = prepare_compiler_for_check(run.builder, target, mode);
 
                 // It doesn't make sense to cross-check bootstrap tools
                 if mode == Mode::ToolBootstrap && target != run.builder.host_target {
                     println!("WARNING: not checking bootstrap tool {} for target {target} as it is a bootstrap (host-only) tool", stringify!($path));
                     return;
                 };
 
-                run.builder.ensure($name { target, build_compiler });
+                run.builder.ensure($name { target, compiler });
             }
 
             fn run(self, builder: &Builder<'_>) {
-                let Self { target, build_compiler } = self;
+                let Self { target, compiler } = self;
                 let allow_features = {
                     let mut _value = "";
                     $( _value = $allow_features; )?
                     _value
                 };
                 let extra_features: &[&str] = &[$($($enable_features),*)?];
                 let mode = $mode(builder);
-                run_tool_check_step(builder, build_compiler, target, $path, mode, allow_features, extra_features);
+                run_tool_check_step(builder, compiler, target, $path, mode, allow_features, extra_features);
             }
 
             fn metadata(&self) -> Option<StepMetadata> {
-                Some(StepMetadata::check(stringify!($name), self.target).built_by(self.build_compiler))
+                Some(StepMetadata::check(stringify!($name), self.target).built_by(self.compiler.build_compiler))
             }
         }
     }
@@ -440,7 +522,7 @@ macro_rules! tool_check_step {
 /// Used by the implementation of `Step::run` in `tool_check_step!`.
 fn run_tool_check_step(
     builder: &Builder<'_>,
-    build_compiler: Compiler,
+    compiler: CompilerForCheck,
     target: TargetSelection,
     path: &str,
     mode: Mode,
@@ -449,6 +531,8 @@ fn run_tool_check_step(
 ) {
     let display_name = path.rsplit('/').next().unwrap();
 
+    let CompilerForCheck { build_compiler, rustc_rmeta_sysroot: rmeta_sysroot } = compiler;
+
     let extra_features = extra_features.iter().map(|f| f.to_string()).collect::<Vec<String>>();
     let mut cargo = prepare_tool_cargo(
         builder,
@@ -465,6 +549,11 @@ fn run_tool_check_step(
         &extra_features,
     );
     cargo.allow_features(allow_features);
+    if mode == Mode::ToolRustc {
+        let rmeta_sysroot =
+            rmeta_sysroot.expect("rustc rmeta sysroot missing for a ToolRustc tool");
+        rmeta_sysroot.configure_cargo(&mut cargo);
+    }
 
     // FIXME: check bootstrap doesn't currently work when multiple targets are checked
     // FIXME: rust-analyzer does not work with --all-targets