Simplify LLVM bitcode linker in bootstrap

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))
     }