Generalize usage of LLD in bootstrap

Allow choosing between self-contained and externally provided LLD.

Author: Kobzol

src/bootstrap/bin/rustc.rs

@@ -115,8 +115,23 @@ fn main() {
         if let Ok(host_linker) = env::var("RUSTC_HOST_LINKER") {
             cmd.arg(format!("-Clinker={host_linker}"));
         }
-        if env::var_os("RUSTC_HOST_FUSE_LD_LLD").is_some() {
-            cmd.arg("-Clink-args=-fuse-ld=lld");
+        if let Ok(lld) = env::var("RUSTC_HOST_LLD") {
+            match lld.as_str() {
+                "external" => {
+                    cmd.arg("-Clink-args=-fuse-ld=lld");
+                }
+                "self-contained" => {
+                    let mut arg = std::ffi::OsString::from("-Clink-arg=-B");
+                    arg.push(
+                        env::var_os("RUSTC_HOST_LLD_ROOT")
+                            .expect("RUSTC_HOST_LLD_ROOT env. var missing"),
+                    );
+                    cmd.arg(arg);
+
+                    cmd.arg("-Clink-args=-fuse-ld=lld");
+                }
+                _ => panic!("Unknown host lld value {lld}"),
+            }
         }
 
         if let Ok(s) = env::var("RUSTC_HOST_CRT_STATIC") {

src/bootstrap/builder.rs

@@ -13,7 +13,7 @@ use std::process::Command;
 use std::time::{Duration, Instant};
 
 use crate::cache::{Cache, Interned, INTERNER};
-use crate::config::{DryRun, SplitDebuginfo, TargetSelection};
+use crate::config::{DryRun, LldMode, SplitDebuginfo, TargetSelection};
 use crate::doc;
 use crate::flags::{Color, Subcommand};
 use crate::install;
@@ -1654,20 +1654,28 @@ impl<'a> Builder<'a> {
         if let Some(host_linker) = self.linker(compiler.host) {
             cargo.env("RUSTC_HOST_LINKER", host_linker);
         }
-        if self.is_fuse_ld_lld(compiler.host) {
-            cargo.env("RUSTC_HOST_FUSE_LD_LLD", "1");
+
+        if !self.is_lld_direct_linker(compiler.host) {
+            match self.config.lld_mode {
+                LldMode::External => {
+                    cargo.env("RUSTC_HOST_LLD", "external");
+                }
+                LldMode::SelfContained => {
+                    cargo.env("RUSTC_HOST_LLD", "self-contained");
+                    cargo.env("RUSTC_HOST_LLD_ROOT", self.initial_lld_root());
+                }
+                LldMode::Unused => {}
+            }
         }
 
         if let Some(target_linker) = self.linker(target) {
             let target = crate::envify(&target.triple);
             cargo.env(&format!("CARGO_TARGET_{target}_LINKER"), target_linker);
         }
-        if self.is_fuse_ld_lld(target) {
-            rustflags.arg("-Clink-args=-fuse-ld=lld");
-        }
-        self.lld_flags(target).for_each(|flag| {
+        for flag in self.lld_flags(target, false) {
+            rustflags.arg(&flag);
             rustdocflags.arg(&flag);
-        });
+        }
 
         if !(["build", "check", "clippy", "fix", "rustc"].contains(&cmd)) && want_rustdoc {
             cargo.env("RUSTDOC_LIBDIR", self.rustc_libdir(compiler));

src/bootstrap/compile.rs

@@ -839,7 +839,7 @@ impl Step for Rustc {
         // is already on by default in MSVC optimized builds, which is interpreted as --icf=all:
         // https://github.com/llvm/llvm-project/blob/3329cec2f79185bafd678f310fafadba2a8c76d2/lld/COFF/Driver.cpp#L1746
         // https://github.com/rust-lang/rust/blob/f22819bcce4abaff7d1246a56eec493418f9f4ee/compiler/rustc_codegen_ssa/src/back/linker.rs#L827
-        if builder.config.use_lld && !compiler.host.is_msvc() {
+        if builder.config.lld_mode.is_used() && !compiler.host.is_msvc() {
             cargo.rustflag("-Clink-args=-Wl,--icf=all");
         }
 

src/bootstrap/config.rs

@@ -102,6 +102,17 @@ impl Display for DebuginfoLevel {
     }
 }
 
+/// LLD in bootstrap works like this:
+/// - Self-contained lld: use `rust-lld` from the compiler's sysroot
+/// - External: use an external `lld` binary
+///
+/// It is configured depending on the target:
+/// 1) Everything except MSVC
+/// - Self-contained: -Clinker-flavor=gnu-lld-cc -Clink-self-contained=+linker
+/// - External: -Clinker-favor=gnu-lld-cc
+/// 2) MSVC
+/// - Self-contained: -Clinker=<path to rust-lld>
+/// - External: -Clinker=lld
 #[derive(Default, Clone)]
 pub enum LldMode {
     /// Do not use LLD
@@ -115,6 +126,15 @@ pub enum LldMode {
     External,
 }
 
+impl LldMode {
+    pub fn is_used(&self) -> bool {
+        match self {
+            LldMode::SelfContained | LldMode::External => true,
+            LldMode::Unused => false,
+        }
+    }
+}
+
 /// Global configuration for the entire build and/or bootstrap.
 ///
 /// This structure is parsed from `config.toml`, and some of the fields are inferred from `git` or build-time parameters.
@@ -207,7 +227,7 @@ pub struct Config {
     pub llvm_from_ci: bool,
     pub llvm_build_config: HashMap<String, String>,
 
-    pub use_lld: bool,
+    pub lld_mode: LldMode,
     pub lld_enabled: bool,
     pub llvm_tools_enabled: bool,
 
@@ -1476,13 +1496,7 @@ impl Config {
             if let Some(true) = rust.incremental {
                 config.incremental = true;
             }
-            set(
-                &mut config.use_lld,
-                match rust.lld_mode {
-                    None | Some(LldMode::Unused) => None,
-                    _ => Some(true),
-                },
-            );
+            set(&mut config.lld_mode, rust.lld_mode);
             set(&mut config.lld_enabled, rust.lld);
             set(&mut config.llvm_tools_enabled, rust.llvm_tools);
             config.rustc_parallel = rust.parallel_compiler.unwrap_or(false);

src/bootstrap/config/tests.rs

@@ -1,4 +1,4 @@
-use crate::config::TomlConfig;
+use crate::config::{LldMode, TomlConfig};
 
 use super::{Config, Flags};
 use clap::CommandFactory;
@@ -199,8 +199,9 @@ fn invalid_rust_optimize() {
 
 #[test]
 fn rust_lld() {
-    assert!(!parse("").use_lld);
-    assert!(parse("rust.use-lld = \"self-contained\"").use_lld);
-    assert!(parse("rust.use-lld = \"lld\"").use_lld);
-    assert!(parse("rust.use-lld = true").use_lld);
+    assert!(matches!(parse("").lld_mode, LldMode::Unused));
+    assert!(matches!(parse("rust.use-lld = \"self-contained\"").lld_mode, LldMode::SelfContained));
+    assert!(matches!(parse("rust.use-lld = \"lld\"").lld_mode, LldMode::External));
+    assert!(matches!(parse("rust.use-lld = true").lld_mode, LldMode::External));
+    assert!(matches!(parse("rust.use-lld = false").lld_mode, LldMode::Unused));
 }

src/bootstrap/lib.rs

@@ -34,7 +34,7 @@ use filetime::FileTime;
 use once_cell::sync::OnceCell;
 
 use crate::builder::Kind;
-use crate::config::{LlvmLibunwind, TargetSelection};
+use crate::config::{LldMode, LlvmLibunwind, TargetSelection};
 use crate::util::{
     dir_is_empty, exe, libdir, mtime, output, run, run_suppressed, symlink_dir, try_run_suppressed,
 };
@@ -1250,6 +1250,7 @@ impl Build {
         if self.config.dry_run() {
             return Some(PathBuf::new());
         }
+
         if let Some(linker) = self.config.target_config.get(&target).and_then(|c| c.linker.clone())
         {
             Some(linker)
@@ -1260,32 +1261,72 @@ impl Build {
         } else if target != self.config.build && util::use_host_linker(target) && !target.is_msvc()
         {
             Some(self.cc(target))
-        } else if self.config.use_lld && !self.is_fuse_ld_lld(target) && self.build == target {
-            Some(self.initial_lld.clone())
+        } else if self.config.lld_mode.is_used()
+            && self.is_lld_direct_linker(target)
+            && self.build == target
+        {
+            match self.config.lld_mode {
+                LldMode::SelfContained => Some(self.initial_lld.clone()),
+                LldMode::External => Some("lld".into()),
+                LldMode::Unused => None,
+            }
         } else {
             None
         }
     }
 
-    // LLD is used through `-fuse-ld=lld` rather than directly.
+    // Is LLD configured directly through `-Clinker`?
     // Only MSVC targets use LLD directly at the moment.
-    fn is_fuse_ld_lld(&self, target: TargetSelection) -> bool {
-        self.config.use_lld && !target.is_msvc()
+    fn is_lld_direct_linker(&self, target: TargetSelection) -> bool {
+        target.is_msvc()
     }
 
-    fn lld_flags(&self, target: TargetSelection) -> impl Iterator<Item = String> {
-        let mut options = [None, None];
+    // Returns the gcc-ld directory of the snapshot compiler's rust-lld.
+    fn initial_lld_root(&self) -> PathBuf {
+        let mut rust_lld_path = self.initial_lld.clone();
+        rust_lld_path.pop();
+        rust_lld_path.join("gcc-ld")
+    }
 
-        if self.config.use_lld {
-            if self.is_fuse_ld_lld(target) {
-                options[0] = Some("-Clink-arg=-fuse-ld=lld".to_string());
-            }
+    fn lld_flags(&self, target: TargetSelection, test: bool) -> Vec<String> {
+        let mut flags = vec![];
+
+        if !self.is_lld_direct_linker(target) {
+            match self.config.lld_mode {
+                LldMode::SelfContained => {
+                    // FIXME: replace with MCP510 (-Clinker-flavor + -Clink-self-contained)
+                    // once gcc-ld is available in stage0-sysroot.
+                    flags.push("-Clink-arg=-fuse-ld=lld".to_string());
+                    flags.push(format!("-Clink-arg=-B{}", self.initial_lld_root().display()));
+                }
+                LldMode::External => {
+                    flags.push("-Clink-arg=-fuse-ld=lld".to_string());
+                }
+                LldMode::Unused => {}
+            };
+        }
 
-            let no_threads = util::lld_flag_no_threads(target.contains("windows"));
-            options[1] = Some(format!("-Clink-arg=-Wl,{no_threads}"));
+        // For tests we want to use only a single thread.
+        // If we use an external LLD, we don't know if it's new enough to support the required
+        // threads flag. Therefore we invoke it to find it out.
+        // The self-contained lld should always be new enough.
+        if test {
+            let new_flags = if let LldMode::External = self.config.lld_mode {
+                util::is_lld_newer_than_10()
+            } else {
+                true
+            };
+
+            let flag = match (new_flags, target.contains("windows")) {
+                (true, true) => "/threads:1",
+                (true, false) => "--threads=1",
+                (false, true) => "/no-threads",
+                (false, false) => "--no-threads",
+            };
+            flags.push(format!("-Clink-arg=-Wl,{flag}"));
         }
 
-        IntoIterator::into_iter(options).flatten()
+        flags
     }
 
     /// Returns if this target should statically link the C runtime, if specified

src/bootstrap/test.rs

@@ -856,12 +856,12 @@ impl Step for RustdocTheme {
         if let Some(linker) = builder.linker(self.compiler.host) {
             cmd.env("RUSTDOC_LINKER", linker);
         }
-        if builder.is_fuse_ld_lld(self.compiler.host) {
-            cmd.env(
-                "RUSTDOC_LLD_NO_THREADS",
-                util::lld_flag_no_threads(self.compiler.host.contains("windows")),
-            );
-        }
+        // if builder.is_fuse_ld_lld(self.compiler.host) {
+        //     cmd.env(
+        //         "RUSTDOC_LLD_NO_THREADS",
+        //         util::lld_flag_no_threads(self.compiler.host.contains("windows")),
+        //     );
+        // }
         builder.run_delaying_failure(&mut cmd);
     }
 }
@@ -1637,14 +1637,14 @@ note: if you're sure you want to do this, please open an issue as to why. In the
 
         let mut hostflags = flags.clone();
         hostflags.push(format!("-Lnative={}", builder.test_helpers_out(compiler.host).display()));
-        hostflags.extend(builder.lld_flags(compiler.host));
+        hostflags.extend(builder.lld_flags(compiler.host, true));
         for flag in hostflags {
             cmd.arg("--host-rustcflags").arg(flag);
         }
 
         let mut targetflags = flags;
         targetflags.push(format!("-Lnative={}", builder.test_helpers_out(target).display()));
-        targetflags.extend(builder.lld_flags(target));
+        targetflags.extend(builder.lld_flags(target, true));
         for flag in targetflags {
             cmd.arg("--target-rustcflags").arg(flag);
         }

src/bootstrap/util.rs

@@ -479,17 +479,17 @@ pub fn get_clang_cl_resource_dir(clang_cl_path: &str) -> PathBuf {
     clang_rt_dir.to_path_buf()
 }
 
-pub fn lld_flag_no_threads(is_windows: bool) -> &'static str {
-    static LLD_NO_THREADS: OnceCell<(&'static str, &'static str)> = OnceCell::new();
-    let (windows, other) = LLD_NO_THREADS.get_or_init(|| {
+/// Finds out if a global `lld` binary is a newer version than version 10.
+pub fn is_lld_newer_than_10() -> bool {
+    static LLD_NO_THREADS: OnceCell<bool> = OnceCell::new();
+    *LLD_NO_THREADS.get_or_init(|| {
         let out = output(Command::new("lld").arg("-flavor").arg("ld").arg("--version"));
         let newer = match (out.find(char::is_numeric), out.find('.')) {
             (Some(b), Some(e)) => out.as_str()[b..e].parse::<i32>().ok().unwrap_or(14) > 10,
             _ => true,
         };
-        if newer { ("/threads:1", "--threads=1") } else { ("/no-threads", "--no-threads") }
-    });
-    if is_windows { windows } else { other }
+        newer
+    })
 }
 
 pub fn dir_is_empty(dir: &Path) -> bool {