Generalize LLD usage in rustdoc

Author: Kobzol

src/bootstrap/bin/rustdoc.rs

@@ -53,10 +53,30 @@ fn main() {
         arg.push(&linker);
         cmd.arg(arg);
     }
-    if let Ok(no_threads) = env::var("RUSTDOC_LLD_NO_THREADS") {
-        cmd.arg("-Clink-arg=-fuse-ld=lld");
-        cmd.arg(format!("-Clink-arg=-Wl,{no_threads}"));
+
+    if let Ok(lld) = env::var("RUSTDOC_HOST_LLD") {
+        match lld.as_str() {
+            "external" => {
+                cmd.arg("-Clink-args=-fuse-ld=lld");
+                cmd.arg(format!(
+                    "-Clink-arg=-Wl,{}",
+                    env::var("RUSTC_LLD_NO_THREADS")
+                        .expect("RUSTC_LLD_NO_THREADS env. var missing")
+                ));
+            }
+            "self-contained" => {
+                let mut arg = std::ffi::OsString::from("-Clink-arg=-B");
+                arg.push(
+                    env::var_os("RUSTDOC_LLD_ROOT").expect("RUSTDOC_LLD_ROOT env. var missing"),
+                );
+                cmd.arg(arg);
+
+                cmd.arg("-Clink-args=-fuse-ld=lld");
+            }
+            _ => panic!("Unknown host lld value {lld}"),
+        }
     }
+
     // Cargo doesn't pass RUSTDOCFLAGS to proc_macros:
     // https://github.com/rust-lang/cargo/issues/4423
     // Thus, if we are on stage 0, we explicitly set `--cfg=bootstrap`.

src/bootstrap/lib.rs

@@ -1306,29 +1306,35 @@ impl Build {
             };
         }
 
-        // For tests we want to use only a single thread.
+        // For tests, we want to disable multi-threading.
         // 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",
-            };
+            let flag = self.lld_single_thread_flag(target);
             flags.push(format!("-Clink-arg=-Wl,{flag}"));
         }
 
         flags
     }
 
+    /// Returns the LLD flag to disable multi-threading based on the given target
+    /// and lld version.
+    fn lld_single_thread_flag(&self, target: TargetSelection) -> &'static str {
+        let new_flags = if let LldMode::External = self.config.lld_mode {
+            util::is_lld_newer_than_10()
+        } else {
+            true
+        };
+
+        match (new_flags, target.contains("windows")) {
+            (true, true) => "/threads:1",
+            (true, false) => "--threads=1",
+            (false, true) => "/no-threads",
+            (false, false) => "--no-threads",
+        }
+    }
+
     /// Returns if this target should statically link the C runtime, if specified
     fn crt_static(&self, target: TargetSelection) -> Option<bool> {
         if target.contains("pc-windows-msvc") {

src/bootstrap/test.rs

@@ -18,7 +18,7 @@ use crate::builder::{Builder, Compiler, Kind, RunConfig, ShouldRun, Step};
 use crate::cache::Interned;
 use crate::cache::INTERNER;
 use crate::compile;
-use crate::config::TargetSelection;
+use crate::config::{LldMode, TargetSelection};
 use crate::dist;
 use crate::doc::DocumentationFormat;
 use crate::flags::Subcommand;
@@ -856,12 +856,22 @@ 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_lld_direct_linker(self.compiler.host) {
+            match builder.config.lld_mode {
+                LldMode::External => {
+                    cmd.env("RUSTDOC_HOST_LLD", "external");
+                    cmd.env(
+                        "RUSTDOC_LLD_NO_THREADS",
+                        builder.lld_single_thread_flag(self.compiler.host),
+                    );
+                }
+                LldMode::SelfContained => {
+                    cmd.env("RUSTDOC_HOST_LLD", "self-contained");
+                    cmd.env("RUSTDOC_HOST_LLD_ROOT", builder.initial_lld_root());
+                }
+                LldMode::Unused => {}
+            }
+        }
         builder.run_delaying_failure(&mut cmd);
     }
 }