Build llvm-bitcode-linker as a HostRustc tool

This tool can be built with any compiler that can produce code for the host target of the compiler for which the linker should be installed. This change saves one rebuild of the tool in stage 2 build.

Author: Kobzol

src/bootstrap/src/core/build_steps/compile.rs

@@ -2024,20 +2024,20 @@ impl Step for Assemble {
             }
         }
 
-        let maybe_install_llvm_bitcode_linker = |compiler| {
+        // Build llvm-bitcode-linker if it is enabled and install it into the sysroot of `compiler`
+        let maybe_install_llvm_bitcode_linker = |compiler: Compiler| {
             if builder.config.llvm_bitcode_linker_enabled {
                 trace!("llvm-bitcode-linker enabled, installing");
                 let llvm_bitcode_linker =
                     builder.ensure(crate::core::build_steps::tool::LlvmBitcodeLinker {
-                        compiler,
-                        target: target_compiler.host,
+                        target: compiler.host,
                     });
 
                 // Copy the llvm-bitcode-linker to the self-contained binary directory
                 let bindir_self_contained = builder
                     .sysroot(compiler)
                     .join(format!("lib/rustlib/{}/bin/self-contained", compiler.host));
-                let tool_exe = exe("llvm-bitcode-linker", target_compiler.host);
+                let tool_exe = exe("llvm-bitcode-linker", compiler.host);
 
                 t!(fs::create_dir_all(&bindir_self_contained));
                 builder.copy_link(

src/bootstrap/src/core/build_steps/dist.rs

@@ -1555,7 +1555,7 @@ impl Step for Extended {
             compiler: builder.compiler(stage, target),
             backend: "cranelift".to_string(),
         });
-        add_component!("llvm-bitcode-linker" => LlvmBitcodeLinker {compiler, target});
+        add_component!("llvm-bitcode-linker" => LlvmBitcodeLinker {target});
 
         let etc = builder.src.join("src/etc/installer");
 
@@ -2323,7 +2323,6 @@ impl Step for LlvmTools {
 
 #[derive(Debug, PartialOrd, Ord, Clone, Hash, PartialEq, Eq)]
 pub struct LlvmBitcodeLinker {
-    pub compiler: Compiler,
     pub target: TargetSelection,
 }
 
@@ -2338,23 +2337,12 @@ impl Step for LlvmBitcodeLinker {
     }
 
     fn make_run(run: RunConfig<'_>) {
-        run.builder.ensure(LlvmBitcodeLinker {
-            compiler: run.builder.compiler_for(
-                run.builder.top_stage,
-                run.builder.config.build,
-                run.target,
-            ),
-            target: run.target,
-        });
+        run.builder.ensure(LlvmBitcodeLinker { target: run.target });
     }
 
     fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
-        let compiler = self.compiler;
         let target = self.target;
-
-        builder.ensure(compile::Rustc::new(compiler, target));
-
-        let llbc_linker = builder.ensure(tool::LlvmBitcodeLinker { compiler, target });
+        let llbc_linker = builder.ensure(tool::LlvmBitcodeLinker { target });
 
         let self_contained_bin_dir = format!("lib/rustlib/{}/bin/self-contained", target.triple);
 

src/bootstrap/src/core/build_steps/install.rs

@@ -287,7 +287,7 @@ install!((self, builder, _config),
         }
     };
     LlvmBitcodeLinker, alias = "llvm-bitcode-linker", Self::should_build(_config), only_hosts: true, {
-        if let Some(tarball) = builder.ensure(dist::LlvmBitcodeLinker { compiler: self.compiler, target: self.target }) {
+        if let Some(tarball) = builder.ensure(dist::LlvmBitcodeLinker { target: self.target }) {
             install_sh(builder, "llvm-bitcode-linker", self.compiler.stage, Some(self.target), &tarball);
         } else {
             builder.info(

src/bootstrap/src/core/build_steps/tool.rs

@@ -983,9 +983,11 @@ impl Step for RustAnalyzerProcMacroSrv {
     }
 }
 
+/// Compile the `llvm-bitcode-linker` tool for `target`.
+/// It is a compiler host tool used to link specific targets using LLVM.
+/// It is used by `rustc` at runtime.
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct LlvmBitcodeLinker {
-    pub compiler: Compiler,
     pub target: TargetSelection,
 }
 
@@ -1001,19 +1003,18 @@ impl Step for LlvmBitcodeLinker {
     }
 
     fn make_run(run: RunConfig<'_>) {
-        run.builder.ensure(LlvmBitcodeLinker {
-            compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build),
-            target: run.target,
-        });
+        run.builder.ensure(LlvmBitcodeLinker { target: run.target });
     }
 
     #[cfg_attr(
         feature = "tracing",
         instrument(level = "debug", name = "LlvmBitcodeLinker::run", skip_all)
     )]
     fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
+        let compiler = builder.compiler_for_target(self.target);
+
         builder.ensure(ToolBuild {
-            compiler: self.compiler,
+            compiler,
             target: self.target,
             tool: "llvm-bitcode-linker",
             mode: Mode::ToolRustc,

src/bootstrap/src/core/builder/mod.rs

@@ -15,6 +15,7 @@ use tracing::instrument;
 
 pub use self::cargo::{Cargo, cargo_profile_var};
 pub use crate::Compiler;
+use crate::core::build_steps::compile::Std;
 use crate::core::build_steps::{
     check, clean, clippy, compile, dist, doc, gcc, install, llvm, run, setup, test, tool, vendor,
 };
@@ -1314,6 +1315,20 @@ impl<'a> Builder<'a> {
         resolved_compiler
     }
 
+    /// Return the lowest stage compiler that can compile code for the given `target`.
+    pub fn compiler_for_target(&self, target: TargetSelection) -> Compiler {
+        // If we're not cross-compiling, we can always use the stage0 compiler
+        if self.config.build == target {
+            self.compiler(0, target)
+        } else {
+            // Otherwise, we have to build a stage 1 compiler that can compile code for `target`.
+            let compiler = self.compiler(1, self.config.build);
+            // FIXME(kobzol): get rid of this nonsense and create something like `RustcWithStdForTarget`
+            self.ensure(Std::new(compiler, target));
+            compiler
+        }
+    }
+
     pub fn sysroot(&self, compiler: Compiler) -> PathBuf {
         self.ensure(compile::Sysroot::new(compiler))
     }