Employ clang linker flavor for supporting cross-linking automatically

Author: petrochenkov

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -2284,6 +2284,10 @@ fn add_order_independent_options(
     out_filename: &Path,
     tmpdir: &Path,
 ) {
+    if flavor.uses_clang() && sess.target.linker_flavor != sess.host.linker_flavor {
+        cmd.arg(format!("--target={}", sess.target.llvm_target));
+    }
+
     // Take care of the flavors and CLI options requesting the `lld` linker.
     add_lld_args(cmd, sess, flavor, self_contained_components);
 
@@ -3053,29 +3057,4 @@ fn add_lld_args(
     // 2. Implement the "linker flavor" part of this feature by asking `cc` to use some kind of
     // `lld` as the linker.
     cmd.arg("-fuse-ld=lld");
-
-    if !flavor.is_gnu() {
-        // Tell clang to use a non-default LLD flavor.
-        // Gcc doesn't understand the target option, but we currently assume
-        // that gcc is not used for Apple and Wasm targets (#97402).
-        //
-        // Note that we don't want to do that by default on macOS: e.g. passing a
-        // 10.7 target to LLVM works, but not to recent versions of clang/macOS, as
-        // shown in issue #101653 and the discussion in PR #101792.
-        //
-        // It could be required in some cases of cross-compiling with
-        // LLD, but this is generally unspecified, and we don't know
-        // which specific versions of clang, macOS SDK, host and target OS
-        // combinations impact us here.
-        //
-        // So we do a simple first-approximation until we know more of what the
-        // Apple targets require (and which would be handled prior to hitting this
-        // LLD codepath anyway), but the expectation is that until then
-        // this should be manually passed if needed. We specify the target when
-        // targeting a different linker flavor on macOS, and that's also always
-        // the case when targeting WASM.
-        if sess.target.linker_flavor != sess.host.linker_flavor {
-            cmd.arg(format!("--target={}", sess.target.llvm_target));
-        }
-    }
 }

compiler/rustc_target/src/spec/mod.rs

@@ -43,6 +43,7 @@ use rustc_fs_util::try_canonicalize;
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 use rustc_span::symbol::{kw, sym, Symbol};
 use serde_json::Value;
+use std::assert_matches::assert_matches;
 use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::hash::{Hash, Hasher};
@@ -437,6 +438,17 @@ impl LinkerFlavor {
             | LinkerFlavor::Ptx => false,
         }
     }
+
+    pub fn uses_clang(self) -> bool {
+        match self {
+            LinkerFlavor::Gnu(Cc::Clang, _)
+            | LinkerFlavor::Darwin(Cc::Clang, _)
+            | LinkerFlavor::WasmLld(Cc::Clang)
+            | LinkerFlavor::Unix(Cc::Clang)
+            | LinkerFlavor::EmCc => true,
+            _ => false,
+        }
+    }
 }
 
 macro_rules! linker_flavor_cli_impls {
@@ -2185,21 +2197,34 @@ fn add_link_args_iter(
     match flavor {
         LinkerFlavor::Gnu(cc, lld) => {
             assert_eq!(lld, Lld::No);
+            assert_matches!(cc, Cc::No | Cc::Yes);
             insert(LinkerFlavor::Gnu(cc, Lld::Yes));
+            if cc == Cc::Yes {
+                insert(LinkerFlavor::Gnu(Cc::Clang, Lld::No));
+                insert(LinkerFlavor::Gnu(Cc::Clang, Lld::Yes));
+            }
         }
         LinkerFlavor::Darwin(cc, lld) => {
             assert_eq!(lld, Lld::No);
+            assert_matches!(cc, Cc::No | Cc::Yes);
             insert(LinkerFlavor::Darwin(cc, Lld::Yes));
+            if cc == Cc::Yes {
+                insert(LinkerFlavor::Darwin(Cc::Clang, Lld::No));
+                insert(LinkerFlavor::Darwin(Cc::Clang, Lld::Yes));
+            }
         }
         LinkerFlavor::Msvc(lld) => {
             assert_eq!(lld, Lld::No);
             insert(LinkerFlavor::Msvc(Lld::Yes));
         }
-        LinkerFlavor::WasmLld(..)
-        | LinkerFlavor::Unix(..)
-        | LinkerFlavor::EmCc
-        | LinkerFlavor::Bpf
-        | LinkerFlavor::Ptx => {}
+        LinkerFlavor::WasmLld(cc) | LinkerFlavor::Unix(cc) => {
+            assert_matches!(cc, Cc::No | Cc::Yes);
+            if cc == Cc::Yes {
+                insert(LinkerFlavor::Gnu(Cc::Clang, Lld::No));
+                insert(LinkerFlavor::Gnu(Cc::Clang, Lld::Yes));
+            }
+        }
+        LinkerFlavor::EmCc | LinkerFlavor::Bpf | LinkerFlavor::Ptx => {}
     }
 }
 

compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs

@@ -35,15 +35,7 @@ pub fn target() -> Target {
             "--no-entry",
         ],
     );
-    options.add_pre_link_args(
-        LinkerFlavor::WasmLld(Cc::Yes),
-        &[
-            // Make sure clang uses LLD as its linker and is configured appropriately
-            // otherwise
-            "--target=wasm32-unknown-unknown",
-            "-Wl,--no-entry",
-        ],
-    );
+    options.add_pre_link_args(LinkerFlavor::WasmLld(Cc::Yes), &["-Wl,--no-entry"]);
 
     Target {
         llvm_target: "wasm32-unknown-unknown".into(),

compiler/rustc_target/src/spec/targets/wasm32_wasi.rs

@@ -74,13 +74,12 @@
 
 use crate::spec::crt_objects;
 use crate::spec::LinkSelfContainedDefault;
-use crate::spec::{base, Cc, LinkerFlavor, Target};
+use crate::spec::{base, Target};
 
 pub fn target() -> Target {
     let mut options = base::wasm::options();
 
     options.os = "wasi".into();
-    options.add_pre_link_args(LinkerFlavor::WasmLld(Cc::Yes), &["--target=wasm32-wasi"]);
 
     options.pre_link_objects_self_contained = crt_objects::pre_wasi_self_contained();
     options.post_link_objects_self_contained = crt_objects::post_wasi_self_contained();

compiler/rustc_target/src/spec/targets/wasm32_wasi_preview1_threads.rs

@@ -85,12 +85,7 @@ pub fn target() -> Target {
     );
     options.add_pre_link_args(
         LinkerFlavor::WasmLld(Cc::Yes),
-        &[
-            "--target=wasm32-wasi-threads",
-            "-Wl,--import-memory",
-            "-Wl,--export-memory,",
-            "-Wl,--shared-memory",
-        ],
+        &["-Wl,--import-memory", "-Wl,--export-memory,", "-Wl,--shared-memory"],
     );
 
     options.pre_link_objects_self_contained = crt_objects::pre_wasi_self_contained();

compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs

@@ -22,15 +22,7 @@ pub fn target() -> Target {
             "-mwasm64",
         ],
     );
-    options.add_pre_link_args(
-        LinkerFlavor::WasmLld(Cc::Yes),
-        &[
-            // Make sure clang uses LLD as its linker and is configured appropriately
-            // otherwise
-            "--target=wasm64-unknown-unknown",
-            "-Wl,--no-entry",
-        ],
-    );
+    options.add_pre_link_args(LinkerFlavor::WasmLld(Cc::Yes), &["-Wl,--no-entry"]);
 
     // Any engine that implements wasm64 will surely implement the rest of these
     // features since they were all merged into the official spec by the time