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

Remove usage of compiler_for from the compile::Rustc step

Browse source
This commit is contained in:
Jakub Beránek 2025-08-13 07:34:59 +02:00
parent d8a51f58b3
commit 36dfed6435
No known key found for this signature in database
GPG key ID: 909CD0D26483516B
1 changed files with 43 additions and 51 deletions
Download patch file Download diff file Expand all files Collapse all files

94
src/bootstrap/src/core/build_steps/compile.rs
View file

@ -666,6 +666,14 @@ pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, cargo: &mut Car
cargo.rustdocflag("-Zcrate-attr=warn(rust_2018_idioms)");
}
/// Link all libstd rlibs/dylibs into a sysroot of `target_compiler`.
///
/// Links those artifacts generated by `compiler` to the `stage` compiler's
/// sysroot for the specified `host` and `target`.
///
/// Note that this assumes that `compiler` has already generated the libstd
/// libraries for `target`, and this method will find them in the relevant
/// output directory.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct StdLink {
pub compiler: Compiler,
@ -952,14 +960,8 @@ impl Rustc {
}
impl Step for Rustc {
/// We return the stage of the "actual" compiler (not the uplifted one).
///
/// By "actual" we refer to the uplifting logic where we may not compile the requested stage;
/// instead, we uplift it from the previous stages. Which can lead to bootstrap failures in
/// specific situations where we request stage X from other steps. However we may end up
/// uplifting it from stage Y, causing the other stage to fail when attempting to link with
/// stage X which was never actually built.
type Output = u32;
type Output = ();
const IS_HOST: bool = true;
const DEFAULT: bool = false;
@ -998,7 +1000,7 @@ impl Step for Rustc {
/// This will build the compiler for a particular stage of the build using
/// the `build_compiler` targeting the `target` architecture. The artifacts
/// created will also be linked into the sysroot directory.
fn run(self, builder: &Builder<'_>) -> u32 {
fn run(self, builder: &Builder<'_>) {
let build_compiler = self.build_compiler;
let target = self.target;
@ -1014,7 +1016,7 @@ impl Step for Rustc {
&sysroot,
builder.config.ci_rustc_dev_contents(),
);
return build_compiler.stage;
return;
}
// Build a standard library for `target` using the `build_compiler`.
@ -1028,31 +1030,33 @@ impl Step for Rustc {
builder.info("WARNING: Use `--keep-stage-std` if you want to rebuild the compiler when it changes");
builder.ensure(RustcLink::from_rustc(self, build_compiler));
return build_compiler.stage;
return;
}
let compiler_to_use =
builder.compiler_for(build_compiler.stage, build_compiler.host, target);
if compiler_to_use != build_compiler {
builder.ensure(Rustc::new(compiler_to_use, target));
let msg = if compiler_to_use.host == target {
format!(
"Uplifting rustc (stage{} -> stage{})",
compiler_to_use.stage,
build_compiler.stage + 1
)
// The stage of the compiler that we're building
let stage = build_compiler.stage + 1;
// If we are building a stage3+ compiler, and full bootstrap is disabled, and we have a
// previous rustc available, we will uplift a compiler from a previous stage.
if build_compiler.stage >= 2
&& !builder.config.full_bootstrap
&& (target == builder.host_target || builder.hosts.contains(&target))
{
// If we're cross-compiling, the earliest rustc that we could have is stage 2.
// If we're not cross-compiling, then we should have rustc stage 1.
let stage_to_uplift = if target == builder.host_target { 1 } else { 2 };
let rustc_to_uplift = builder.compiler(stage_to_uplift, target);
let msg = if rustc_to_uplift.host == target {
format!("Uplifting rustc (stage{} -> stage{stage})", rustc_to_uplift.stage,)
} else {
format!(
"Uplifting rustc (stage{}:{} -> stage{}:{})",
compiler_to_use.stage,
compiler_to_use.host,
build_compiler.stage + 1,
target
"Uplifting rustc (stage{}:{} -> stage{stage}:{target})",
rustc_to_uplift.stage, rustc_to_uplift.host,
)
};
builder.info(&msg);
builder.ensure(RustcLink::from_rustc(self, compiler_to_use));
return compiler_to_use.stage;
builder.ensure(RustcLink::from_rustc(self, rustc_to_uplift));
return;
}
// Build a standard library for the current host target using the `build_compiler`.
@ -1129,8 +1133,6 @@ impl Step for Rustc {
self,
builder.compiler(build_compiler.stage, builder.config.host_target),
));
build_compiler.stage
}
fn metadata(&self) -> Option<StepMetadata> {
@ -1910,12 +1912,18 @@ impl Step for Sysroot {
}
}
/// Prepare a compiler sysroot.
///
/// The sysroot may contain various things useful for running the compiler, like linkers and
/// linker wrappers (LLD, LLVM bitcode linker, etc.).
///
/// This will assemble a compiler in `build/$target/stage$stage`.
#[derive(Debug, PartialOrd, Ord, Clone, PartialEq, Eq, Hash)]
pub struct Assemble {
/// The compiler which we will produce in this step. Assemble itself will
/// take care of ensuring that the necessary prerequisites to do so exist,
/// that is, this target can be a stage2 compiler and Assemble will build
/// previous stages for you.
/// that is, this can be e.g. a stage2 compiler and Assemble will build
/// the previous stages for you.
pub target_compiler: Compiler,
}
@ -1933,11 +1941,6 @@ impl Step for Assemble {
});
}
/// Prepare a new compiler from the artifacts in `stage`
///
/// This will assemble a compiler in `build/$host/stage$stage`. The compiler
/// must have been previously produced by the `stage - 1` builder.build
/// compiler.
fn run(self, builder: &Builder<'_>) -> Compiler {
let target_compiler = self.target_compiler;
@ -2066,7 +2069,7 @@ impl Step for Assemble {
target_compiler.stage - 1,
builder.config.host_target,
);
let mut build_compiler =
let build_compiler =
builder.compiler(target_compiler.stage - 1, builder.config.host_target);
// Build enzyme
@ -2090,24 +2093,13 @@ impl Step for Assemble {
}
// Build the libraries for this compiler to link to (i.e., the libraries
// it uses at runtime). NOTE: Crates the target compiler compiles don't
// link to these. (FIXME: Is that correct? It seems to be correct most
// of the time but I think we do link to these for stage2/bin compilers
// when not performing a full bootstrap).
// it uses at runtime).
debug!(
?build_compiler,
"target_compiler.host" = ?target_compiler.host,
"building compiler libraries to link to"
);
let actual_stage = builder.ensure(Rustc::new(build_compiler, target_compiler.host));
// Current build_compiler.stage might be uplifted instead of being built; so update it
// to not fail while linking the artifacts.
debug!(
"(old) build_compiler.stage" = build_compiler.stage,
"(adjusted) build_compiler.stage" = actual_stage,
"temporarily adjusting `build_compiler.stage` to account for uplifted libraries"
);
build_compiler.stage = actual_stage;
builder.ensure(Rustc::new(build_compiler, target_compiler.host));
let stage = target_compiler.stage;
let host = target_compiler.host;