user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

stabilize -Clink-self-contained=-linker on x64 linux

Browse source 
This stabilizes a subset of the `-Clink-self-contained` components on x64 linux:
the rust-lld opt-out.

The opt-in is not stabilized, as interactions with other stable flags require
more internal work, but are not needed for stabilizing using rust-lld by default.

Similarly, since we only switch to rust-lld on x64 linux, the opt-out is
only stabilized there. Other targets still require `-Zunstable-options`
to use it.
This commit is contained in:
Rémy Rakic 2025-07-08 09:10:39 +00:00
parent 2e6d82c9c9
commit 3f194a86ee
2 changed files with 40 additions and 21 deletions
Download patch file Download diff file Expand all files Collapse all files

51
compiler/rustc_session/src/config.rs
View file

@ -370,12 +370,34 @@ impl LinkSelfContained {
}
/// To help checking CLI usage while some of the values are unstable: returns whether one of the
/// components was set individually. This would also require the `-Zunstable-options` flag, to
/// be allowed.
fn are_unstable_variants_set(&self) -> bool {
let any_component_set =
!self.enabled_components.is_empty() || !self.disabled_components.is_empty();
self.explicitly_set.is_none() && any_component_set
/// unstable components was set individually, for the given `TargetTuple`. This would also
/// require the `-Zunstable-options` flag, to be allowed.
fn check_unstable_variants(&self, target_tuple: &TargetTuple) -> Result<(), String> {
if self.explicitly_set.is_some() {
return Ok(());
}
// `-C link-self-contained=-linker` is only stable on x64 linux.
let has_minus_linker = self.disabled_components.is_linker_enabled();
if has_minus_linker && target_tuple.tuple() != "x86_64-unknown-linux-gnu" {
return Err(format!(
"`-C link-self-contained=-linker` is unstable on the `{target_tuple}` \
target. The `-Z unstable-options` flag must also be passed to use it on this target",
));
}
// Any `+linker` or other component used is unstable, and that's an error.
let unstable_enabled = self.enabled_components;
let unstable_disabled = self.disabled_components - LinkSelfContainedComponents::LINKER;
if !unstable_enabled.union(unstable_disabled).is_empty() {
return Err(String::from(
"only `-C link-self-contained` values `y`/`yes`/`on`/`n`/`no`/`off`/`-linker` \
are stable, the `-Z unstable-options` flag must also be passed to use \
the unstable values",
));
}
Ok(())
}
/// Returns whether the self-contained linker component was enabled on the CLI, using the
@ -2679,17 +2701,13 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
)
}
// For testing purposes, until we have more feedback about these options: ensure `-Z
// unstable-options` is required when using the unstable `-C link-self-contained` and `-C
// linker-flavor` options.
let target_triple = parse_target_triple(early_dcx, matches);
// Ensure `-Z unstable-options` is required when using the unstable `-C link-self-contained` and
// `-C linker-flavor` options.
if !unstable_options_enabled {
let uses_unstable_self_contained_option =
cg.link_self_contained.are_unstable_variants_set();
if uses_unstable_self_contained_option {
early_dcx.early_fatal(
"only `-C link-self-contained` values `y`/`yes`/`on`/`n`/`no`/`off` are stable, \
the `-Z unstable-options` flag must also be passed to use the unstable values",
);
if let Err(error) = cg.link_self_contained.check_unstable_variants(&target_triple) {
early_dcx.early_fatal(error);
}
if let Some(flavor) = cg.linker_flavor {
@ -2729,7 +2747,6 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
let cg = cg;
let target_triple = parse_target_triple(early_dcx, matches);
let opt_level = parse_opt_level(early_dcx, matches, &cg);
// The `-g` and `-C debuginfo` flags specify the same setting, so we want to be able
// to use them interchangeably. See the note above (regarding `-O` and `-C opt-level`)

10
tests/run-make/rust-lld/rmake.rs
View file

@ -1,5 +1,5 @@
// Test linking using `cc` with `rust-lld`, using the unstable CLI described in MCP 510
// see https://github.com/rust-lang/compiler-team/issues/510 for more info
// Test linking using `cc` with `rust-lld`, using the `-Clinker-features` and
// `-Clink-self-contained` CLI flags.
//@ needs-rust-lld
//@ ignore-s390x lld does not yet support s390x as target
@ -14,12 +14,14 @@ fn main() {
rustc()
.arg("-Clinker-features=+lld")
.arg("-Clink-self-contained=+linker")
.arg("-Zunstable-options")
.arg("-Zunstable-options") // the opt-ins are unstable
.input("main.rs"),
);
// It should not be used when we explicitly opt out of lld.
assert_rustc_doesnt_use_lld(rustc().arg("-Clinker-features=-lld").input("main.rs"));
assert_rustc_doesnt_use_lld(
rustc().arg("-Clinker-features=-lld").arg("-Zunstable-options").input("main.rs"),
);
// While we're here, also check that the last linker feature flag "wins" when passed multiple
// times to rustc.