From 928f0256cfc35307aa8db2684859b8861aaac61c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= Date: Wed, 1 Oct 2025 14:54:21 +0200 Subject: [PATCH 01/10] wip gnullvm self-contained --- .../src/spec/base/windows_gnullvm.rs | 15 ++++-- .../spec/targets/x86_64_pc_windows_gnullvm.rs | 1 + src/bootstrap/src/core/build_steps/compile.rs | 2 +- src/bootstrap/src/core/build_steps/dist.rs | 48 ++++++++++++++++++- src/bootstrap/src/core/builder/cargo.rs | 2 + .../src/core/config/target_selection.rs | 4 ++ 6 files changed, 64 insertions(+), 8 deletions(-) diff --git a/compiler/rustc_target/src/spec/base/windows_gnullvm.rs b/compiler/rustc_target/src/spec/base/windows_gnullvm.rs index f24ad781e2b81..5ed4c70d77bf5 100644 --- a/compiler/rustc_target/src/spec/base/windows_gnullvm.rs +++ b/compiler/rustc_target/src/spec/base/windows_gnullvm.rs @@ -1,7 +1,9 @@ use std::borrow::Cow; +use crate::spec::crt_objects::pre_mingw_self_contained; use crate::spec::{ - BinaryFormat, Cc, DebuginfoKind, LinkerFlavor, Lld, SplitDebuginfo, TargetOptions, cvs, + BinaryFormat, Cc, DebuginfoKind, LinkSelfContainedDefault, LinkerFlavor, Lld, SplitDebuginfo, + TargetOptions, add_link_args, cvs, }; pub(crate) fn opts() -> TargetOptions { @@ -14,10 +16,11 @@ pub(crate) fn opts() -> TargetOptions { &["-nolibc", "--unwindlib=none"], ); // Order of `late_link_args*` does not matter with LLD. - let late_link_args = TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-lmingw32", "-lmingwex", "-lmsvcrt", "-lkernel32", "-luser32"], - ); + let mingw_libs = &["-lmingw32", "-lmingwex", "-lmsvcrt", "-lkernel32", "-luser32"]; + + let mut late_link_args = + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), mingw_libs); + add_link_args(&mut late_link_args, LinkerFlavor::Gnu(Cc::Yes, Lld::No), mingw_libs); TargetOptions { os: "windows".into(), @@ -35,6 +38,8 @@ pub(crate) fn opts() -> TargetOptions { binary_format: BinaryFormat::Coff, allows_weak_linkage: false, pre_link_args, + pre_link_objects_self_contained: pre_mingw_self_contained(), + link_self_contained: LinkSelfContainedDefault::InferredForMingw, late_link_args, abi_return_struct_as_int: true, emit_debug_gdb_scripts: false, diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs index 28c9e6251255c..938f1e49f1ef7 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs @@ -6,6 +6,7 @@ pub(crate) fn target() -> Target { base.features = "+cx16,+sse3,+sahf".into(); base.plt_by_default = false; base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.add_pre_link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), &["-m", "i386pep"]); base.max_atomic_width = Some(128); base.linker = Some("x86_64-w64-mingw32-clang".into()); diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs index 6857a40ada81b..a6704a5675a12 100644 --- a/src/bootstrap/src/core/build_steps/compile.rs +++ b/src/bootstrap/src/core/build_steps/compile.rs @@ -448,7 +448,7 @@ fn copy_self_contained_objects( DependencyType::TargetSelfContained, ); } - } else if target.is_windows_gnu() { + } else if target.is_windows_gnu() || target.is_windows_gnullvm() { for obj in ["crt2.o", "dllcrt2.o"].iter() { let src = compiler_file(builder, &builder.cc(target), target, CLang::C, obj); let dst = libdir_self_contained.join(obj); diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs index 411d42962644d..b86e1e3c37b4b 100644 --- a/src/bootstrap/src/core/build_steps/dist.rs +++ b/src/bootstrap/src/core/build_steps/dist.rs @@ -344,6 +344,44 @@ fn runtime_dll_dist(rust_root: &Path, target: TargetSelection, builder: &Builder } } +fn make_win_llvm_dist(plat_root: &Path, target: TargetSelection, builder: &Builder<'_>) { + if builder.config.dry_run() { + return; + } + + let (_, lib_path) = get_cc_search_dirs(target, builder); + + // Libraries necessary to link the windows-gnu toolchains. + // System libraries will be preferred if they are available (see #67429). + let target_libs = [ + // MinGW libs + "libunwind.a", + "libunwind.dll.a", + "libmingw32.a", + "libmingwex.a", + "libmsvcrt.a", + // Windows import libs, remove them once std transitions to raw-dylib + "libkernel32.a", + "libuser32.a", + "libntdll.a", + "libuserenv.a", + "libws2_32.a", + "libdbghelp.a", + ]; + + //Find mingw artifacts we want to bundle + let target_libs = find_files(&target_libs, &lib_path); + + //Copy platform libs to platform-specific lib directory + let plat_target_lib_self_contained_dir = + plat_root.join("lib/rustlib").join(target).join("lib/self-contained"); + fs::create_dir_all(&plat_target_lib_self_contained_dir) + .expect("creating plat_target_lib_self_contained_dir failed"); + for src in target_libs { + builder.copy_link_to_folder(&src, &plat_target_lib_self_contained_dir); + } +} + fn get_cc_search_dirs( target: TargetSelection, builder: &Builder<'_>, @@ -394,14 +432,20 @@ impl Step for Mingw { fn run(self, builder: &Builder<'_>) -> Option { let target = self.target; - if !target.ends_with("pc-windows-gnu") || !builder.config.dist_include_mingw_linker { + if !target.contains("pc-windows-gnu") || !builder.config.dist_include_mingw_linker { return None; } let mut tarball = Tarball::new(builder, "rust-mingw", &target.triple); tarball.set_product_name("Rust MinGW"); - make_win_dist(tarball.image_dir(), target, builder); + if target.ends_with("pc-windows-gnu") { + make_win_dist(tarball.image_dir(), target, builder); + } else if target.ends_with("pc-windows-gnullvm") { + make_win_llvm_dist(tarball.image_dir(), target, builder); + } else { + unreachable!(); + } Some(tarball.generate()) } diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs index c2029f97391d4..c8cb2a2f2ac26 100644 --- a/src/bootstrap/src/core/builder/cargo.rs +++ b/src/bootstrap/src/core/builder/cargo.rs @@ -646,6 +646,8 @@ impl Builder<'_> { if let Mode::Rustc | Mode::ToolRustcPrivate | Mode::ToolBootstrap | Mode::ToolTarget = mode { rustflags.arg("--cfg=windows_raw_dylib"); + } else if mode == Mode::Std && target.ends_with("gnullvm") { + rustflags.arg("--cfg=windows_raw_dylib"); } if use_new_symbol_mangling { diff --git a/src/bootstrap/src/core/config/target_selection.rs b/src/bootstrap/src/core/config/target_selection.rs index 40b63a7f9c752..47f6d6f386dfb 100644 --- a/src/bootstrap/src/core/config/target_selection.rs +++ b/src/bootstrap/src/core/config/target_selection.rs @@ -86,6 +86,10 @@ impl TargetSelection { self.ends_with("windows-gnu") } + pub fn is_windows_gnullvm(&self) -> bool { + self.ends_with("windows-gnullvm") + } + pub fn is_cygwin(&self) -> bool { self.is_windows() && // ref. https://cygwin.com/pipermail/cygwin/2022-February/250802.html From 9c62baeca4c989ec0605795de1a55b05a96baefa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= Date: Fri, 3 Oct 2025 23:11:58 +0200 Subject: [PATCH 02/10] Slightly refactor mingw detection --- compiler/rustc_codegen_ssa/src/back/link.rs | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs index ce496c7137913..1b8243cf286e8 100644 --- a/compiler/rustc_codegen_ssa/src/back/link.rs +++ b/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); - 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.a(libname.so) for the actual @@ -1764,7 +1764,13 @@ fn link_output_kind(sess: &Session, crate_type: CrateType) -> LinkOutputKind { } // Returns true if linker is located within sysroot -fn detect_self_contained_mingw(sess: &Session, linker: &Path) -> bool { +fn detect_self_contained_mingw(sess: &Session) -> bool { + let linker = if let Some(linker) = &sess.target.linker { + Path::new(linker.as_ref()) + } else { + return false; + }; + // Assume `-C linker=rust-lld` as self-contained mode if linker == Path::new("rust-lld") { return true; @@ -1776,7 +1782,7 @@ fn detect_self_contained_mingw(sess: &Session, linker: &Path) -> bool { }; for dir in env::split_paths(&env::var_os("PATH").unwrap_or_default()) { let full_path = dir.join(&linker_with_extension); - // If linker comes from sysroot assume self-contained mode + // If linker doesn't come from sysroot assume non-self-contained mode if full_path.is_file() && !full_path.starts_with(sess.opts.sysroot.path()) { return false; } @@ -1787,11 +1793,7 @@ fn detect_self_contained_mingw(sess: &Session, linker: &Path) -> 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, - linker: &Path, -) -> LinkSelfContainedComponents { +fn self_contained_components(sess: &Session, crate_type: CrateType) -> LinkSelfContainedComponents { // Turn the backwards compatible bool values for `self_contained` into fully inferred // `LinkSelfContainedComponents`. let self_contained = @@ -1820,7 +1822,7 @@ fn self_contained_components( LinkSelfContainedDefault::InferredForMingw => { sess.host == sess.target && sess.target.vendor != "uwp" - && detect_self_contained_mingw(sess, linker) + && detect_self_contained_mingw(sess) } } }; From acd3e2c9f59a02fac2448ec50b44ff840bb637b8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= Date: Thu, 9 Oct 2025 18:23:23 +0200 Subject: [PATCH 03/10] Use self-contained with windows-gnullvm --- compiler/rustc_codegen_ssa/src/back/link.rs | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs index 1b8243cf286e8..7d160cabe0881 100644 --- a/compiler/rustc_codegen_ssa/src/back/link.rs +++ b/compiler/rustc_codegen_ssa/src/back/link.rs @@ -686,7 +686,8 @@ fn link_natively( ) { 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); + let (linker_path, flavor) = + linker_and_flavor(sess, self_contained_components.is_linker_enabled()); // On AIX, we ship all libraries as .a big_af archive // the expected format is lib.a(libname.so) for the actual @@ -1318,7 +1319,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) -> (PathBuf, LinkerFlavor) { +pub fn linker_and_flavor(sess: &Session, self_contained: bool) -> (PathBuf, LinkerFlavor) { fn infer_from( sess: &Session, linker: Option, @@ -1417,6 +1418,15 @@ pub fn linker_and_flavor(sess: &Session) -> (PathBuf, LinkerFlavor) { return ret; } + // FIXME: do it better + if sess.target.os == "windows" + && sess.target.env == "gnu" + && sess.target.abi == "llvm" + && self_contained + { + return (PathBuf::from("rust-lld.exe"), LinkerFlavor::Gnu(Cc::No, Lld::Yes)); + } + if let Some(ret) = infer_from( sess, sess.target.linker.as_deref().map(PathBuf::from), From 5bdd64a5937eae4afbec6eec0caa20642b5b6d50 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= Date: Thu, 9 Oct 2025 19:39:18 +0200 Subject: [PATCH 04/10] Fix -C linker=rust-lld --- compiler/rustc_codegen_ssa/src/back/link.rs | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs index 7d160cabe0881..d453d40397d65 100644 --- a/compiler/rustc_codegen_ssa/src/back/link.rs +++ b/compiler/rustc_codegen_ssa/src/back/link.rs @@ -1775,8 +1775,16 @@ fn link_output_kind(sess: &Session, crate_type: CrateType) -> LinkOutputKind { // Returns true if linker is located within sysroot fn detect_self_contained_mingw(sess: &Session) -> bool { - let linker = if let Some(linker) = &sess.target.linker { - Path::new(linker.as_ref()) + // FIXME: this sort of duplicates `infer_from()` inside `linker_and_flavor()` + let path_buf = sess + .opts + .cg + .linker + .as_ref() + .map(|l| l.as_path()) + .or_else(|| sess.target.linker.as_ref().map(|linker| Path::new(linker.as_ref()))); + let linker = if let Some(linker) = path_buf { + linker } else { return false; }; From 91aa2f222e6df5b4270bca79e0476fa80ef616a2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= Date: Thu, 9 Oct 2025 20:55:58 +0200 Subject: [PATCH 05/10] workaround for cranelift --- compiler/rustc_codegen_cranelift/src/toolchain.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/rustc_codegen_cranelift/src/toolchain.rs b/compiler/rustc_codegen_cranelift/src/toolchain.rs index b6b465e1f4e0a..ecaf82ca16259 100644 --- a/compiler/rustc_codegen_cranelift/src/toolchain.rs +++ b/compiler/rustc_codegen_cranelift/src/toolchain.rs @@ -7,7 +7,7 @@ use rustc_session::Session; /// 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); + let (mut linker, _linker_flavor) = linker_and_flavor(sess, false); let linker_file_name = linker.file_name().unwrap().to_str().expect("linker filename should be valid UTF-8"); From ecd017983594f27abee9ef31624405520d34b5be Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= Date: Tue, 28 Oct 2025 15:05:35 +0100 Subject: [PATCH 06/10] Revert unnecessary change --- src/bootstrap/src/core/builder/cargo.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs index c8cb2a2f2ac26..c2029f97391d4 100644 --- a/src/bootstrap/src/core/builder/cargo.rs +++ b/src/bootstrap/src/core/builder/cargo.rs @@ -646,8 +646,6 @@ impl Builder<'_> { if let Mode::Rustc | Mode::ToolRustcPrivate | Mode::ToolBootstrap | Mode::ToolTarget = mode { rustflags.arg("--cfg=windows_raw_dylib"); - } else if mode == Mode::Std && target.ends_with("gnullvm") { - rustflags.arg("--cfg=windows_raw_dylib"); } if use_new_symbol_mangling { From 85c30da5817157419540e2f5c1d5440c342cdae5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= Date: Tue, 28 Oct 2025 19:48:11 +0100 Subject: [PATCH 07/10] Fix comment --- src/bootstrap/src/core/build_steps/dist.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs index b86e1e3c37b4b..a8e6033c6e58d 100644 --- a/src/bootstrap/src/core/build_steps/dist.rs +++ b/src/bootstrap/src/core/build_steps/dist.rs @@ -351,7 +351,7 @@ fn make_win_llvm_dist(plat_root: &Path, target: TargetSelection, builder: &Build let (_, lib_path) = get_cc_search_dirs(target, builder); - // Libraries necessary to link the windows-gnu toolchains. + // Libraries necessary to link the windows-gnullvm toolchains. // System libraries will be preferred if they are available (see #67429). let target_libs = [ // MinGW libs From 133b91b252f540ee13b34a8d18aed7842111e4d8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= Date: Tue, 28 Oct 2025 19:54:09 +0100 Subject: [PATCH 08/10] Update manifest --- src/tools/build-manifest/src/main.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs index 9bae8b241a941..4ffd17ae52189 100644 --- a/src/tools/build-manifest/src/main.rs +++ b/src/tools/build-manifest/src/main.rs @@ -476,7 +476,7 @@ impl Builder { } // so is rust-mingw if it's available for the target PkgType::RustMingw => { - if host.ends_with("pc-windows-gnu") { + if host.contains("pc-windows-gnu") { components.push(host_component(pkg)); } } From f6fbe04bde81114279ed2425cb81215ab2d1a5f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= Date: Thu, 30 Oct 2025 18:17:10 +0100 Subject: [PATCH 09/10] refactor --- compiler/rustc_codegen_ssa/src/back/link.rs | 49 +++++++++++---------- 1 file changed, 26 insertions(+), 23 deletions(-) diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs index d453d40397d65..a0177c4001dde 100644 --- a/compiler/rustc_codegen_ssa/src/back/link.rs +++ b/compiler/rustc_codegen_ssa/src/back/link.rs @@ -1418,13 +1418,16 @@ pub fn linker_and_flavor(sess: &Session, self_contained: bool) -> (PathBuf, Link return ret; } - // FIXME: do it better - if sess.target.os == "windows" + // When using a supported target in self-contained mode, we want to use rust-lld directly. + let self_contained_target = sess.target.os == "windows" && sess.target.env == "gnu" && sess.target.abi == "llvm" - && self_contained + && self_contained; + if self_contained_target + && let Some(ret) = + infer_from(sess, None, Some(LinkerFlavor::Gnu(Cc::No, Lld::Yes)), features) { - return (PathBuf::from("rust-lld.exe"), LinkerFlavor::Gnu(Cc::No, Lld::Yes)); + return ret; } if let Some(ret) = infer_from( @@ -1773,30 +1776,30 @@ fn link_output_kind(sess: &Session, crate_type: CrateType) -> LinkOutputKind { } } -// Returns true if linker is located within sysroot +/// 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 { - // FIXME: this sort of duplicates `infer_from()` inside `linker_and_flavor()` - let path_buf = sess - .opts - .cg - .linker - .as_ref() - .map(|l| l.as_path()) - .or_else(|| sess.target.linker.as_ref().map(|linker| Path::new(linker.as_ref()))); - let linker = if let Some(linker) = path_buf { - linker - } else { - return false; - }; + // Passing custom linker means non-self-contained mode. + if sess.opts.cg.linker.is_some() { + // Unless running on `-windows-gnu-llvm` and using `-C linker=rust-lld`. + if sess.target.abi == "llvm" { + return sess + .opts + .cg + .linker + .as_ref() + .is_some_and(|linker| linker == Path::new("rust-lld")); + } - // Assume `-C linker=rust-lld` as self-contained mode - if linker == Path::new("rust-lld") { - return true; + return false; } - let linker_with_extension = if cfg!(windows) && linker.extension().is_none() { + + let linker_with_extension = if let Some(linker) = sess.target.linker.as_deref().map(Path::new) { linker.with_extension("exe") } else { - linker.to_path_buf() + return false; }; for dir in env::split_paths(&env::var_os("PATH").unwrap_or_default()) { let full_path = dir.join(&linker_with_extension); From 9f92112593c6ffb699656324f296b13694424e30 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Miku=C5=82a?= Date: Mon, 10 Nov 2025 21:01:33 +0100 Subject: [PATCH 10/10] address review feedback --- compiler/rustc_codegen_cranelift/src/toolchain.rs | 4 +++- compiler/rustc_codegen_ssa/src/back/link.rs | 12 +++++++----- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/compiler/rustc_codegen_cranelift/src/toolchain.rs b/compiler/rustc_codegen_cranelift/src/toolchain.rs index ecaf82ca16259..bd8a5e725b342 100644 --- a/compiler/rustc_codegen_cranelift/src/toolchain.rs +++ b/compiler/rustc_codegen_cranelift/src/toolchain.rs @@ -4,10 +4,12 @@ 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, false); + let (mut linker, _linker_flavor) = + linker_and_flavor(sess, &LinkSelfContainedComponents::empty()); let linker_file_name = linker.file_name().unwrap().to_str().expect("linker filename should be valid UTF-8"); diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs index a0177c4001dde..ba26ca0e8bda8 100644 --- a/compiler/rustc_codegen_ssa/src/back/link.rs +++ b/compiler/rustc_codegen_ssa/src/back/link.rs @@ -686,8 +686,7 @@ fn link_natively( ) { 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.is_linker_enabled()); + let (linker_path, flavor) = linker_and_flavor(sess, &self_contained_components); // On AIX, we ship all libraries as .a big_af archive // the expected format is lib.a(libname.so) for the actual @@ -1319,7 +1318,10 @@ 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: bool) -> (PathBuf, LinkerFlavor) { +pub fn linker_and_flavor( + sess: &Session, + self_contained_components: &LinkSelfContainedComponents, +) -> (PathBuf, LinkerFlavor) { fn infer_from( sess: &Session, linker: Option, @@ -1418,11 +1420,11 @@ pub fn linker_and_flavor(sess: &Session, self_contained: bool) -> (PathBuf, Link return ret; } - // When using a supported target in self-contained mode, we want to use rust-lld directly. + // When using a supported target in self-contained linker mode, we want to use rust-lld directly. let self_contained_target = sess.target.os == "windows" && sess.target.env == "gnu" && sess.target.abi == "llvm" - && self_contained; + && 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)