implement linker-flavor enrichments for MCP

Author: lqd

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -9,15 +9,15 @@ use rustc_hir::def_id::CrateNum;
 use rustc_metadata::fs::{emit_metadata, METADATA_FILENAME};
 use rustc_middle::middle::dependency_format::Linkage;
 use rustc_middle::middle::exported_symbols::SymbolExportKind;
-use rustc_session::config::{self, CFGuard, CrateType, DebugInfo, LdImpl, Strip};
+use rustc_session::config::{self, CFGuard, CrateType, DebugInfo, LdImpl, LinkerFlavorCli, Strip};
 use rustc_session::config::{OutputFilenames, OutputType, PrintRequest, SplitDwarfKind};
 use rustc_session::cstore::DllImport;
 use rustc_session::output::{check_file_is_writeable, invalid_output_for_target, out_filename};
 use rustc_session::search_paths::PathKind;
 use rustc_session::utils::NativeLibKind;
 /// For all the linkers we support, and information they might
 /// need out of the shared crate context before we get rid of it.
-use rustc_session::{filesearch, Session};
+use rustc_session::{config::InstrumentCoverage, filesearch, Session};
 use rustc_span::symbol::Symbol;
 use rustc_span::DebuggerVisualizerFile;
 use rustc_target::spec::crt_objects::{CrtObjects, CrtObjectsFallback};
@@ -2016,7 +2016,7 @@ fn add_order_independent_options(
     out_filename: &Path,
     tmpdir: &Path,
 ) {
-    add_gcc_ld_path(cmd, sess, flavor);
+    handle_cli_linker_flavors(cmd, sess, flavor, crt_objects_fallback);
 
     add_apple_sdk(cmd, sess, flavor);
 
@@ -2694,29 +2694,113 @@ fn get_apple_sdk_root(sdk_name: &str) -> Result<String, String> {
     }
 }
 
-fn add_gcc_ld_path(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavor) {
-    if let Some(ld_impl) = sess.opts.unstable_opts.gcc_ld {
-        if let LinkerFlavor::Gcc = flavor {
-            match ld_impl {
-                LdImpl::Lld => {
-                    let tools_path = sess.get_tools_search_paths(false);
-                    let gcc_ld_dir = tools_path
-                        .into_iter()
-                        .map(|p| p.join("gcc-ld"))
-                        .find(|p| {
-                            p.join(if sess.host.is_like_windows { "ld.exe" } else { "ld" }).exists()
-                        })
-                        .unwrap_or_else(|| sess.fatal("rust-lld (as ld) not found"));
-                    cmd.arg({
-                        let mut arg = OsString::from("-B");
-                        arg.push(gcc_ld_dir);
-                        arg
-                    });
-                    cmd.arg(format!("-Wl,-rustc-lld-flavor={}", sess.target.lld_flavor.as_str()));
-                }
+/// This takes care of the various possible enrichments to the linking that can be requested on the
+/// CLI (and emitting errors and warnings when applicable):
+/// - shortcuts to `-fuse-ld` with the `gcc` flavor
+/// - the unstable `-Zgcc-ld=lld` flag to use `rust-lld`, stabilized as the following item
+fn handle_cli_linker_flavors(
+    cmd: &mut dyn Linker,
+    sess: &Session,
+    flavor: LinkerFlavor,
+    crt_objects_fallback: bool,
+) {
+    let unstable_gcc_lld = sess.opts.unstable_opts.gcc_ld == Some(LdImpl::Lld);
+    if unstable_gcc_lld {
+        // Sanity check: ensure `gcc` is the currently selected flavor.
+        if LinkerFlavor::Gcc != flavor {
+            sess.fatal("`-Zgcc-ld` is used even though the linker flavor is not `gcc`");
+        }
+    }
+
+    let cg = &sess.opts.cg;
+
+    // The `-C linker-flavor` CLI flag can optionally enrich linker-flavors. Check whether that's
+    // applicable, and emit errors if sanity checks fail. There's currently only one enrichment:
+    // adding an argument to the `cc` invocation to use the `use_ld` given linker.
+    let use_ld = match &cg.linker_flavor {
+        Some(LinkerFlavorCli::Gcc { use_ld }) => {
+            // Ensure `gcc` is the currently selected flavor. Error out cleanly, as `-Zgcc-ld` does
+            // if that happens, but this should be unreachable.
+            if LinkerFlavor::Gcc != flavor {
+                sess.fatal(
+                    "`-Clinker-flavor=gcc:*` flag is used even though the \
+                    linker flavor is not `gcc`",
+                );
+            }
+
+            use_ld
+        }
+
+        // Note: exhaustive match arm here, to avoid fallthroughs if new linker-flavor enrichments
+        // are added in the future.
+        Some(LinkerFlavorCli::WellKnown(_)) | None => {
+            if unstable_gcc_lld {
+                "lld"
+            } else {
+                // We're not in a situation needing enrichments.
+                return;
             }
+        }
+    };
+
+    // From now on in this function, we handle the `gcc` linker-flavor enrichment.
+
+    // Except for `lld`, the given linker executable will be passed straight to `-fuse-ld`.
+    if use_ld == "lld" {
+        // Start by checking if we're in the context of a known issue that users might hit when
+        // using `lld`:
+        //
+        // 1. when requesting self-contained CRT linking (or on a target that does it
+        // automatically), and coverage/profile generation: point at #79555 "Coverage is not
+        // generated when using rust-lld as linker"
+        let instrument_coverage = cg.instrument_coverage.is_some()
+            && cg.instrument_coverage != Some(InstrumentCoverage::Off);
+        let generate_profile = cg.profile_generate.enabled();
+        if crt_objects_fallback && (instrument_coverage || generate_profile) {
+            sess.warn(
+                "Using `lld`, self-contained linking, and coverage or profile generation has known \
+                issues. See issue #79555 for more details, at \
+                https://github.com/rust-lang/rust/issues/79555",
+            );
+        }
+
+        // 2. Maybe point at https://github.com/flamegraph-rs/flamegraph/pull/157 or the
+        // corresponding rust/LLVM issue when/if it's tracked, depending on whether we use the
+        // workaround argument `--no-rosegment` by default when invoking `lld`.
+        //
+        // 3. If in the future, other linker flavors and targets are eligible to a `rust-lld`
+        // enrichment, maybe also point at target-specific issues like:
+        // - MSVC + ThinLTO blocker https://github.com/rust-lang/rust/issues/81408
+        // - the "lld on MSVC" tracking issue https://github.com/rust-lang/rust/issues/71520
+        //   containing a list of blocking issues
+
+        // Now, handle `rust-lld`. If the `-Zgcc-ld=lld` flag was provided, we use `rust-lld`, the
+        // rustup-distributed version of `lld` (when applicable, i.e. not in distro-builds) by:
+        // - checking the `lld-wrapper`s exist in the sysroot
+        // - adding their folder as a search path, or requesting to use a wrapper directly
+        if unstable_gcc_lld {
+            // A `gcc-ld` folder (containing the `lld-wrapper`s that will run `rust-lld`) is present in
+            // the sysroot's target-specific tool binaries folder.
+            let tools_path = sess.get_tools_search_paths(false);
+            let gcc_ld_dir = tools_path
+                .into_iter()
+                .map(|p| p.join("gcc-ld"))
+                .find(|p| p.join(if sess.host.is_like_windows { "ld.exe" } else { "ld" }).exists())
+                .unwrap_or_else(|| sess.fatal("rust-lld (as ld) not found"));
+
+            cmd.arg({
+                let mut arg = OsString::from("-B");
+                arg.push(gcc_ld_dir);
+                arg
+            });
+            cmd.arg(format!("-Wl,-rustc-lld-flavor={}", sess.target.lld_flavor.as_str()));
         } else {
-            sess.fatal("option `-Z gcc-ld` is used even though linker flavor is not gcc");
+            // We were asked to use `lld` but not `rust-lld`.
+            cmd.arg("-fuse-ld=lld");
         }
+    } else {
+        // Otherwise, we were just asked to use a linker executable, and it's expected that `cc`
+        // will find it on the $PATH.
+        cmd.arg(format!("-fuse-ld={}", use_ld));
     }
 }

compiler/rustc_session/src/options.rs

@@ -1618,7 +1618,7 @@ pub enum WasiExecModel {
     Reactor,
 }
 
-#[derive(Clone, Copy, Hash)]
+#[derive(Clone, Copy, Hash, PartialEq)]
 pub enum LdImpl {
     Lld,
 }