undo codegen_* changes

Author: mati865

compiler/rustc_codegen_cranelift/src/toolchain.rs

@@ -4,12 +4,10 @@ use std::path::PathBuf;
 
 use rustc_codegen_ssa::back::link::linker_and_flavor;
 use rustc_session::Session;
-use rustc_target::spec::LinkSelfContainedComponents;
 
 /// Tries to infer the path of a binary for the target toolchain from the linker name.
 pub(crate) fn get_toolchain_binary(sess: &Session, tool: &str) -> PathBuf {
-    let (mut linker, _linker_flavor) =
-        linker_and_flavor(sess, &LinkSelfContainedComponents::empty());
+    let (mut linker, _linker_flavor) = linker_and_flavor(sess);
     let linker_file_name =
         linker.file_name().unwrap().to_str().expect("linker filename should be valid UTF-8");
 

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -685,8 +685,8 @@ fn link_natively(
     codegen_backend: &'static str,
 ) {
     info!("preparing {:?} to {:?}", crate_type, out_filename);
-    let self_contained_components = self_contained_components(sess, crate_type);
-    let (linker_path, flavor) = linker_and_flavor(sess, &self_contained_components);
+    let (linker_path, flavor) = linker_and_flavor(sess);
+    let self_contained_components = self_contained_components(sess, crate_type, &linker_path);
 
     // On AIX, we ship all libraries as .a big_af archive
     // the expected format is lib<name>.a(libname.so) for the actual
@@ -1318,10 +1318,7 @@ pub fn ignored_for_lto(sess: &Session, info: &CrateInfo, cnum: CrateNum) -> bool
 }
 
 /// This functions tries to determine the appropriate linker (and corresponding LinkerFlavor) to use
-pub fn linker_and_flavor(
-    sess: &Session,
-    self_contained_components: &LinkSelfContainedComponents,
-) -> (PathBuf, LinkerFlavor) {
+pub fn linker_and_flavor(sess: &Session) -> (PathBuf, LinkerFlavor) {
     fn infer_from(
         sess: &Session,
         linker: Option<PathBuf>,
@@ -1418,18 +1415,6 @@ pub fn linker_and_flavor(
         return ret;
     }
 
-    // When using a supported target in self-contained linker mode, we want to use rust-lld directly.
-    let self_contained_target = sess.target.os == Os::Windows
-        && sess.target.env == Env::Gnu
-        && sess.target.abi == Abi::Llvm
-        && self_contained_components.is_linker_enabled();
-    if self_contained_target
-        && let Some(ret) =
-            infer_from(sess, None, Some(LinkerFlavor::Gnu(Cc::No, Lld::Yes)), features)
-    {
-        return ret;
-    }
-
     if let Some(ret) = infer_from(
         sess,
         sess.target.linker.as_deref().map(PathBuf::from),
@@ -1776,25 +1761,20 @@ fn link_output_kind(sess: &Session, crate_type: CrateType) -> LinkOutputKind {
     }
 }
 
-/// Returns true if linker is shipped by Rust.
-// There are currently two different solutions for self-contained mode with mingw-w64:
-// using rust-lld directly (`-gnullvm`) or using shipped cc to call the linker (`-gnu`).
-// Eventually, `-gnu` toolchains might be moved to calling the linker directly.
-fn detect_self_contained_mingw(sess: &Session) -> bool {
-    // Passing explicit linker other than `rust-lld` means non-self-contained mode.
-    if let Some(linker) = &sess.opts.cg.linker {
-        return linker == Path::new("rust-lld");
+// Returns true if linker is located within sysroot
+fn detect_self_contained_mingw(sess: &Session, linker: &Path) -> bool {
+    // Assume `-C linker=rust-lld` as self-contained mode
+    if linker == Path::new("rust-lld") {
+        return true;
     }
-
-    // If no explicit linker was given, proceed with implicit one (if present);
-    let linker_with_extension = if let Some(linker) = sess.target.linker.as_deref().map(Path::new) {
+    let linker_with_extension = if cfg!(windows) && linker.extension().is_none() {
         linker.with_extension("exe")
     } else {
-        return false;
+        linker.to_path_buf()
     };
     for dir in env::split_paths(&env::var_os("PATH").unwrap_or_default()) {
         let full_path = dir.join(&linker_with_extension);
-        // If linker doesn't come from sysroot assume non-self-contained mode
+        // If linker comes from sysroot assume self-contained mode
         if full_path.is_file() && !full_path.starts_with(sess.opts.sysroot.path()) {
             return false;
         }
@@ -1805,7 +1785,11 @@ fn detect_self_contained_mingw(sess: &Session) -> bool {
 /// Various toolchain components used during linking are used from rustc distribution
 /// instead of being found somewhere on the host system.
 /// We only provide such support for a very limited number of targets.
-fn self_contained_components(sess: &Session, crate_type: CrateType) -> LinkSelfContainedComponents {
+fn self_contained_components(
+    sess: &Session,
+    crate_type: CrateType,
+    linker: &Path,
+) -> LinkSelfContainedComponents {
     // Turn the backwards compatible bool values for `self_contained` into fully inferred
     // `LinkSelfContainedComponents`.
     let self_contained =
@@ -1834,7 +1818,7 @@ fn self_contained_components(sess: &Session, crate_type: CrateType) -> LinkSelfC
                 LinkSelfContainedDefault::InferredForMingw => {
                     sess.host == sess.target
                         && sess.target.abi != Abi::Uwp
-                        && detect_self_contained_mingw(sess)
+                        && detect_self_contained_mingw(sess, linker)
                 }
             }
         };