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

Create a typed wrapper for codegen backends

Browse source 
To avoid representing them just with strings.
This commit is contained in:
Jakub Beránek 2025-07-31 19:39:59 +02:00
parent 32e7a4b92b
commit 32f4876bf1
No known key found for this signature in database
GPG key ID: 909CD0D26483516B
13 changed files with 143 additions and 79 deletions
Download patch file Download diff file Expand all files Collapse all files

19
src/bootstrap/src/core/build_steps/check.rs
View file

@ -13,7 +13,7 @@ use crate::core::builder::{
};
use crate::core::config::TargetSelection;
use crate::utils::build_stamp::{self, BuildStamp};
use crate::{Compiler, Mode, Subcommand};
use crate::{CodegenBackendKind, Compiler, Mode, Subcommand};
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Std {
@ -312,7 +312,7 @@ fn prepare_compiler_for_check(
pub struct CodegenBackend {
pub build_compiler: Compiler,
pub target: TargetSelection,
pub backend: &'static str,
pub backend: CodegenBackendKind,
}
impl Step for CodegenBackend {
@ -327,14 +327,14 @@ impl Step for CodegenBackend {
fn make_run(run: RunConfig<'_>) {
// FIXME: only check the backend(s) that were actually selected in run.paths
let build_compiler = prepare_compiler_for_check(run.builder, run.target, Mode::Codegen);
for &backend in &["cranelift", "gcc"] {
for backend in [CodegenBackendKind::Cranelift, CodegenBackendKind::Gcc] {
run.builder.ensure(CodegenBackend { build_compiler, target: run.target, backend });
}
}
fn run(self, builder: &Builder<'_>) {
// FIXME: remove once https://github.com/rust-lang/rust/issues/112393 is resolved
if builder.build.config.vendor && self.backend == "gcc" {
if builder.build.config.vendor && self.backend.is_gcc() {
println!("Skipping checking of `rustc_codegen_gcc` with vendoring enabled.");
return;
}
@ -354,19 +354,22 @@ impl Step for CodegenBackend {
cargo
.arg("--manifest-path")
.arg(builder.src.join(format!("compiler/rustc_codegen_{backend}/Cargo.toml")));
.arg(builder.src.join(format!("compiler/{}/Cargo.toml", backend.crate_name())));
rustc_cargo_env(builder, &mut cargo, target);
let _guard = builder.msg_check(format!("rustc_codegen_{backend}"), target, None);
let _guard = builder.msg_check(backend.crate_name(), target, None);
let stamp = build_stamp::codegen_backend_stamp(builder, build_compiler, target, backend)
let stamp = build_stamp::codegen_backend_stamp(builder, build_compiler, target, &backend)
.with_prefix("check");
run_cargo(builder, cargo, builder.config.free_args.clone(), &stamp, vec![], true, false);
}
fn metadata(&self) -> Option<StepMetadata> {
Some(StepMetadata::check(self.backend, self.target).built_by(self.build_compiler))
Some(
StepMetadata::check(&self.backend.crate_name(), self.target)
.built_by(self.build_compiler),
)
}
}

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

@ -33,7 +33,10 @@ use crate::utils::exec::command;
use crate::utils::helpers::{
exe, get_clang_cl_resource_dir, is_debug_info, is_dylib, symlink_dir, t, up_to_date,
};
use crate::{CLang, Compiler, DependencyType, FileType, GitRepo, LLVM_TOOLS, Mode, debug, trace};
use crate::{
CLang, CodegenBackendKind, Compiler, DependencyType, FileType, GitRepo, LLVM_TOOLS, Mode,
debug, trace,
};
/// Build a standard library for the given `target` using the given `compiler`.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@ -1330,7 +1333,7 @@ pub fn rustc_cargo_env(builder: &Builder<'_>, cargo: &mut Cargo, target: TargetS
}
if let Some(backend) = builder.config.default_codegen_backend(target) {
cargo.env("CFG_DEFAULT_CODEGEN_BACKEND", backend);
cargo.env("CFG_DEFAULT_CODEGEN_BACKEND", backend.name());
}
let libdir_relative = builder.config.libdir_relative().unwrap_or_else(|| Path::new("lib"));
@ -1543,7 +1546,7 @@ impl Step for RustcLink {
pub struct CodegenBackend {
pub target: TargetSelection,
pub compiler: Compiler,
pub backend: String,
pub backend: CodegenBackendKind,
}
fn needs_codegen_config(run: &RunConfig<'_>) -> bool {
@ -1568,7 +1571,7 @@ fn is_codegen_cfg_needed(path: &TaskPath, run: &RunConfig<'_>) -> bool {
if path.contains(CODEGEN_BACKEND_PREFIX) {
let mut needs_codegen_backend_config = true;
for backend in run.builder.config.codegen_backends(run.target) {
if path.ends_with(&(CODEGEN_BACKEND_PREFIX.to_owned() + backend)) {
if path.ends_with(&(CODEGEN_BACKEND_PREFIX.to_owned() + backend.name())) {
needs_codegen_backend_config = false;
}
}
@ -1602,7 +1605,7 @@ impl Step for CodegenBackend {
}
for backend in run.builder.config.codegen_backends(run.target) {
if backend == "llvm" {
if backend.is_llvm() {
continue; // Already built as part of rustc
}
@ -1663,20 +1666,21 @@ impl Step for CodegenBackend {
);
cargo
.arg("--manifest-path")
.arg(builder.src.join(format!("compiler/rustc_codegen_{backend}/Cargo.toml")));
.arg(builder.src.join(format!("compiler/{}/Cargo.toml", backend.crate_name())));
rustc_cargo_env(builder, &mut cargo, target);
// Ideally, we'd have a separate step for the individual codegen backends,
// like we have in tests (test::CodegenGCC) but that would require a lot of restructuring.
// If the logic gets more complicated, it should probably be done.
if backend == "gcc" {
if backend.is_gcc() {
let gcc = builder.ensure(Gcc { target });
add_cg_gcc_cargo_flags(&mut cargo, &gcc);
}
let tmp_stamp = BuildStamp::new(&out_dir).with_prefix("tmp");
let _guard = builder.msg_build(compiler, format_args!("codegen backend {backend}"), target);
let _guard =
builder.msg_build(compiler, format_args!("codegen backend {}", backend.name()), target);
let files = run_cargo(builder, cargo, vec![], &tmp_stamp, vec![], false, false);
if builder.config.dry_run() {
return;
@ -1731,7 +1735,7 @@ fn copy_codegen_backends_to_sysroot(
}
for backend in builder.config.codegen_backends(target) {
if backend == "llvm" {
if backend.is_llvm() {
continue; // Already built as part of rustc
}
@ -2161,7 +2165,7 @@ impl Step for Assemble {
let _codegen_backend_span =
span!(tracing::Level::DEBUG, "building requested codegen backends").entered();
for backend in builder.config.codegen_backends(target_compiler.host) {
if backend == "llvm" {
if backend.is_llvm() {
debug!("llvm codegen backend is already built as part of rustc");
continue; // Already built as part of rustc
}

30
src/bootstrap/src/core/build_steps/dist.rs
View file

@ -32,7 +32,7 @@ use crate::utils::helpers::{
exe, is_dylib, move_file, t, target_supports_cranelift_backend, timeit,
};
use crate::utils::tarball::{GeneratedTarball, OverlayKind, Tarball};
use crate::{Compiler, DependencyType, FileType, LLVM_TOOLS, Mode, trace};
use crate::{CodegenBackendKind, Compiler, DependencyType, FileType, LLVM_TOOLS, Mode, trace};
pub fn pkgname(builder: &Builder<'_>, component: &str) -> String {
format!("{}-{}", component, builder.rust_package_vers())
@ -1372,10 +1372,10 @@ impl Step for Miri {
}
}
#[derive(Debug, PartialOrd, Ord, Clone, Hash, PartialEq, Eq)]
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub struct CodegenBackend {
pub compiler: Compiler,
pub backend: String,
pub backend: CodegenBackendKind,
}
impl Step for CodegenBackend {
@ -1389,7 +1389,7 @@ impl Step for CodegenBackend {
fn make_run(run: RunConfig<'_>) {
for backend in run.builder.config.codegen_backends(run.target) {
if backend == "llvm" {
if backend.is_llvm() {
continue; // Already built as part of rustc
}
@ -1412,12 +1412,11 @@ impl Step for CodegenBackend {
return None;
}
if !builder.config.codegen_backends(self.compiler.host).contains(&self.backend.to_string())
{
if !builder.config.codegen_backends(self.compiler.host).contains(&self.backend) {
return None;
}
if self.backend == "cranelift" && !target_supports_cranelift_backend(self.compiler.host) {
if self.backend.is_cranelift() && !target_supports_cranelift_backend(self.compiler.host) {
builder.info("target not supported by rustc_codegen_cranelift. skipping");
return None;
}
@ -1425,15 +1424,18 @@ impl Step for CodegenBackend {
let compiler = self.compiler;
let backend = self.backend;
let mut tarball =
Tarball::new(builder, &format!("rustc-codegen-{backend}"), &compiler.host.triple);
if backend == "cranelift" {
let mut tarball = Tarball::new(
builder,
&format!("rustc-codegen-{}", backend.name()),
&compiler.host.triple,
);
if backend.is_cranelift() {
tarball.set_overlay(OverlayKind::RustcCodegenCranelift);
} else {
panic!("Unknown backend rustc_codegen_{backend}");
panic!("Unknown codegen backend {}", backend.name());
}
tarball.is_preview(true);
tarball.add_legal_and_readme_to(format!("share/doc/rustc_codegen_{backend}"));
tarball.add_legal_and_readme_to(format!("share/doc/{}", backend.crate_name()));
let src = builder.sysroot(compiler);
let backends_src = builder.sysroot_codegen_backends(compiler);
@ -1445,7 +1447,7 @@ impl Step for CodegenBackend {
// Don't use custom libdir here because ^lib/ will be resolved again with installer
let backends_dst = PathBuf::from("lib").join(backends_rel);
let backend_name = format!("rustc_codegen_{backend}");
let backend_name = backend.crate_name();
let mut found_backend = false;
for backend in fs::read_dir(&backends_src).unwrap() {
let file_name = backend.unwrap().file_name();
@ -1575,7 +1577,7 @@ impl Step for Extended {
add_component!("analysis" => Analysis { compiler, target });
add_component!("rustc-codegen-cranelift" => CodegenBackend {
compiler: builder.compiler(stage, target),
backend: "cranelift".to_string(),
backend: CodegenBackendKind::Cranelift,
});
add_component!("llvm-bitcode-linker" => LlvmBitcodeLinker {
build_compiler: compiler,

4
src/bootstrap/src/core/build_steps/install.rs
View file

@ -12,7 +12,7 @@ use crate::core::config::{Config, TargetSelection};
use crate::utils::exec::command;
use crate::utils::helpers::t;
use crate::utils::tarball::GeneratedTarball;
use crate::{Compiler, Kind};
use crate::{CodegenBackendKind, Compiler, Kind};
#[cfg(target_os = "illumos")]
const SHELL: &str = "bash";
@ -276,7 +276,7 @@ install!((self, builder, _config),
RustcCodegenCranelift, alias = "rustc-codegen-cranelift", Self::should_build(_config), only_hosts: true, {
if let Some(tarball) = builder.ensure(dist::CodegenBackend {
compiler: self.compiler,
backend: "cranelift".to_string(),
backend: CodegenBackendKind::Cranelift,
}) {
install_sh(builder, "rustc-codegen-cranelift", self.compiler.stage, Some(self.target), &tarball);
} else {

10
src/bootstrap/src/core/build_steps/test.rs
View file

@ -33,7 +33,7 @@ use crate::utils::helpers::{
linker_flags, t, target_supports_cranelift_backend, up_to_date,
};
use crate::utils::render_tests::{add_flags_and_try_run_tests, try_run_tests};
use crate::{CLang, DocTests, GitRepo, Mode, PathSet, debug, envify};
use crate::{CLang, CodegenBackendKind, DocTests, GitRepo, Mode, PathSet, debug, envify};
const ADB_TEST_DIR: &str = "/data/local/tmp/work";
@ -1786,7 +1786,9 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
cmd.arg("--llvm-filecheck").arg(builder.llvm_filecheck(builder.config.host_target));
if let Some(codegen_backend) = builder.config.default_codegen_backend(compiler.host) {
cmd.arg("--codegen-backend").arg(&codegen_backend);
// Tells compiletest which codegen backend is used by default by the compiler.
// It is used to e.g. ignore tests that don't support that codegen backend.
cmd.arg("--codegen-backend").arg(codegen_backend.name());
}
if builder.build.config.llvm_enzyme {
@ -3406,7 +3408,7 @@ impl Step for CodegenCranelift {
return;
}
if !builder.config.codegen_backends(run.target).contains(&"cranelift".to_owned()) {
if !builder.config.codegen_backends(run.target).contains(&CodegenBackendKind::Cranelift) {
builder.info("cranelift not in rust.codegen-backends. skipping");
return;
}
@ -3533,7 +3535,7 @@ impl Step for CodegenGCC {
return;
}
if !builder.config.codegen_backends(run.target).contains(&"gcc".to_owned()) {
if !builder.config.codegen_backends(run.target).contains(&CodegenBackendKind::Gcc) {
builder.info("gcc not in rust.codegen-backends. skipping");
return;
}

2
src/bootstrap/src/core/builder/cargo.rs
View file

@ -1286,7 +1286,7 @@ impl Builder<'_> {
if let Some(limit) = limit
&& (build_compiler_stage == 0
|| self.config.default_codegen_backend(target).unwrap_or_default() == "llvm")
|| self.config.default_codegen_backend(target).unwrap_or_default().is_llvm())
{
rustflags.arg(&format!("-Cllvm-args=-import-instr-limit={limit}"));
}

16
src/bootstrap/src/core/builder/mod.rs
View file

@ -141,7 +141,7 @@ pub trait Step: 'static + Clone + Debug + PartialEq + Eq + Hash {
#[allow(unused)]
#[derive(Debug, PartialEq, Eq)]
pub struct StepMetadata {
name: &'static str,
name: String,
kind: Kind,
target: TargetSelection,
built_by: Option<Compiler>,
@ -151,28 +151,28 @@ pub struct StepMetadata {
}
impl StepMetadata {
pub fn build(name: &'static str, target: TargetSelection) -> Self {
pub fn build(name: &str, target: TargetSelection) -> Self {
Self::new(name, target, Kind::Build)
}
pub fn check(name: &'static str, target: TargetSelection) -> Self {
pub fn check(name: &str, target: TargetSelection) -> Self {
Self::new(name, target, Kind::Check)
}
pub fn doc(name: &'static str, target: TargetSelection) -> Self {
pub fn doc(name: &str, target: TargetSelection) -> Self {
Self::new(name, target, Kind::Doc)
}
pub fn dist(name: &'static str, target: TargetSelection) -> Self {
pub fn dist(name: &str, target: TargetSelection) -> Self {
Self::new(name, target, Kind::Dist)
}
pub fn test(name: &'static str, target: TargetSelection) -> Self {
pub fn test(name: &str, target: TargetSelection) -> Self {
Self::new(name, target, Kind::Test)
}
fn new(name: &'static str, target: TargetSelection, kind: Kind) -> Self {
Self { name, kind, target, built_by: None, stage: None, metadata: None }
fn new(name: &str, target: TargetSelection, kind: Kind) -> Self {
Self { name: name.to_string(), kind, target, built_by: None, stage: None, metadata: None }
}
pub fn built_by(mut self, compiler: Compiler) -> Self {

24
src/bootstrap/src/core/builder/tests.rs
View file

@ -1309,8 +1309,8 @@ mod snapshot {
.path("compiler")
.render_steps(), @r"
[check] rustc 0 <host> -> rustc 1 <host>
[check] rustc 0 <host> -> cranelift 1 <host>
[check] rustc 0 <host> -> gcc 1 <host>
[check] rustc 0 <host> -> rustc_codegen_cranelift 1 <host>
[check] rustc 0 <host> -> rustc_codegen_gcc 1 <host>
");
}
@ -1341,8 +1341,8 @@ mod snapshot {
.stage(1)
.render_steps(), @r"
[check] rustc 0 <host> -> rustc 1 <host>
[check] rustc 0 <host> -> cranelift 1 <host>
[check] rustc 0 <host> -> gcc 1 <host>
[check] rustc 0 <host> -> rustc_codegen_cranelift 1 <host>
[check] rustc 0 <host> -> rustc_codegen_gcc 1 <host>
");
}
@ -1358,8 +1358,8 @@ mod snapshot {
[build] rustc 0 <host> -> rustc 1 <host>
[build] rustc 1 <host> -> std 1 <host>
[check] rustc 1 <host> -> rustc 2 <host>
[check] rustc 1 <host> -> cranelift 2 <host>
[check] rustc 1 <host> -> gcc 2 <host>
[check] rustc 1 <host> -> rustc_codegen_cranelift 2 <host>
[check] rustc 1 <host> -> rustc_codegen_gcc 2 <host>
");
}
@ -1377,8 +1377,8 @@ mod snapshot {
[build] rustc 1 <host> -> std 1 <target1>
[check] rustc 1 <host> -> rustc 2 <target1>
[check] rustc 1 <host> -> Rustdoc 2 <target1>
[check] rustc 1 <host> -> cranelift 2 <target1>
[check] rustc 1 <host> -> gcc 2 <target1>
[check] rustc 1 <host> -> rustc_codegen_cranelift 2 <target1>
[check] rustc 1 <host> -> rustc_codegen_gcc 2 <target1>
[check] rustc 1 <host> -> Clippy 2 <target1>
[check] rustc 1 <host> -> Miri 2 <target1>
[check] rustc 1 <host> -> CargoMiri 2 <target1>
@ -1472,8 +1472,8 @@ mod snapshot {
.args(&args)
.render_steps(), @r"
[check] rustc 0 <host> -> rustc 1 <host>
[check] rustc 0 <host> -> cranelift 1 <host>
[check] rustc 0 <host> -> gcc 1 <host>
[check] rustc 0 <host> -> rustc_codegen_cranelift 1 <host>
[check] rustc 0 <host> -> rustc_codegen_gcc 1 <host>
");
}
@ -1557,8 +1557,8 @@ mod snapshot {
.path("rustc_codegen_cranelift")
.render_steps(), @r"
[check] rustc 0 <host> -> rustc 1 <host>
[check] rustc 0 <host> -> cranelift 1 <host>
[check] rustc 0 <host> -> gcc 1 <host>
[check] rustc 0 <host> -> rustc_codegen_cranelift 1 <host>
[check] rustc 0 <host> -> rustc_codegen_gcc 1 <host>
");
}

12
src/bootstrap/src/core/config/config.rs
View file

@ -51,7 +51,7 @@ use crate::core::download::{
use crate::utils::channel;
use crate::utils::exec::{ExecutionContext, command};
use crate::utils::helpers::{exe, get_host_target};
use crate::{GitInfo, OnceLock, TargetSelection, check_ci_llvm, helpers, t};
use crate::{CodegenBackendKind, GitInfo, OnceLock, TargetSelection, check_ci_llvm, helpers, t};
/// Each path in this list is considered "allowed" in the `download-rustc="if-unchanged"` logic.
/// This means they can be modified and changes to these paths should never trigger a compiler build
@ -208,7 +208,7 @@ pub struct Config {
pub rustc_default_linker: Option<String>,
pub rust_optimize_tests: bool,
pub rust_dist_src: bool,
pub rust_codegen_backends: Vec<String>,
pub rust_codegen_backends: Vec<CodegenBackendKind>,
pub rust_verify_llvm_ir: bool,
pub rust_thin_lto_import_instr_limit: Option<u32>,
pub rust_randomize_layout: bool,
@ -350,7 +350,7 @@ impl Config {
channel: "dev".to_string(),
codegen_tests: true,
rust_dist_src: true,
rust_codegen_backends: vec!["llvm".to_owned()],
rust_codegen_backends: vec![CodegenBackendKind::Llvm],
deny_warnings: true,
bindir: "bin".into(),
dist_include_mingw_linker: true,
@ -1747,7 +1747,7 @@ impl Config {
.unwrap_or(self.profiler)
}
pub fn codegen_backends(&self, target: TargetSelection) -> &[String] {
pub fn codegen_backends(&self, target: TargetSelection) -> &[CodegenBackendKind] {
self.target_config
.get(&target)
.and_then(|cfg| cfg.codegen_backends.as_deref())
@ -1758,7 +1758,7 @@ impl Config {
self.target_config.get(&target).and_then(|cfg| cfg.jemalloc).unwrap_or(self.jemalloc)
}
pub fn default_codegen_backend(&self, target: TargetSelection) -> Option<String> {
pub fn default_codegen_backend(&self, target: TargetSelection) -> Option<CodegenBackendKind> {
self.codegen_backends(target).first().cloned()
}
@ -1774,7 +1774,7 @@ impl Config {
}
pub fn llvm_enabled(&self, target: TargetSelection) -> bool {
self.codegen_backends(target).contains(&"llvm".to_owned())
self.codegen_backends(target).contains(&CodegenBackendKind::Llvm)
}
pub fn llvm_libunwind(&self, target: TargetSelection) -> LlvmLibunwind {

27
src/bootstrap/src/core/config/toml/rust.rs
View file

@ -11,7 +11,9 @@ use crate::core::config::{
DebuginfoLevel, Merge, ReplaceOpt, RustcLto, StringOrBool, set, threads_from_config,
};
use crate::flags::Warnings;
use crate::{BTreeSet, Config, HashSet, PathBuf, TargetSelection, define_config, exit};
use crate::{
BTreeSet, CodegenBackendKind, Config, HashSet, PathBuf, TargetSelection, define_config, exit,
};
define_config! {
/// TOML representation of how the Rust build is configured.
@ -389,9 +391,13 @@ pub fn check_incompatible_options_for_ci_rustc(
Ok(())
}
pub(crate) const VALID_CODEGEN_BACKENDS: &[&str] = &["llvm", "cranelift", "gcc"];
pub(crate) const BUILTIN_CODEGEN_BACKENDS: &[&str] = &["llvm", "cranelift", "gcc"];
pub(crate) fn validate_codegen_backends(backends: Vec<String>, section: &str) -> Vec<String> {
pub(crate) fn parse_codegen_backends(
backends: Vec<String>,
section: &str,
) -> Vec<CodegenBackendKind> {
let mut found_backends = vec![];
for backend in &backends {
if let Some(stripped) = backend.strip_prefix(CODEGEN_BACKEND_PREFIX) {
panic!(
@ -400,14 +406,21 @@ pub(crate) fn validate_codegen_backends(backends: Vec<String>, section: &str) ->
Please, use '{stripped}' instead."
)
}
if !VALID_CODEGEN_BACKENDS.contains(&backend.as_str()) {
if !BUILTIN_CODEGEN_BACKENDS.contains(&backend.as_str()) {
println!(
"HELP: '{backend}' for '{section}.codegen-backends' might fail. \
List of known good values: {VALID_CODEGEN_BACKENDS:?}"
List of known codegen backends: {BUILTIN_CODEGEN_BACKENDS:?}"
);
}
let backend = match backend.as_str() {
"llvm" => CodegenBackendKind::Llvm,
"cranelift" => CodegenBackendKind::Cranelift,
"gcc" => CodegenBackendKind::Gcc,
backend => CodegenBackendKind::Custom(backend.to_string()),
};
found_backends.push(backend);
}
backends
found_backends
}
#[cfg(not(test))]
@ -609,7 +622,7 @@ impl Config {
llvm_libunwind.map(|v| v.parse().expect("failed to parse rust.llvm-libunwind"));
set(
&mut self.rust_codegen_backends,
codegen_backends.map(|backends| validate_codegen_backends(backends, "rust")),
codegen_backends.map(|backends| parse_codegen_backends(backends, "rust")),
);
self.rust_codegen_units = codegen_units.map(threads_from_config);

8
src/bootstrap/src/core/config/toml/target.rs
View file

@ -16,9 +16,9 @@ use std::collections::HashMap;
use serde::{Deserialize, Deserializer};
use crate::core::config::toml::rust::validate_codegen_backends;
use crate::core::config::toml::rust::parse_codegen_backends;
use crate::core::config::{LlvmLibunwind, Merge, ReplaceOpt, SplitDebuginfo, StringOrBool};
use crate::{Config, HashSet, PathBuf, TargetSelection, define_config, exit};
use crate::{CodegenBackendKind, Config, HashSet, PathBuf, TargetSelection, define_config, exit};
define_config! {
/// TOML representation of how each build target is configured.
@ -76,7 +76,7 @@ pub struct Target {
pub qemu_rootfs: Option<PathBuf>,
pub runner: Option<String>,
pub no_std: bool,
pub codegen_backends: Option<Vec<String>>,
pub codegen_backends: Option<Vec<CodegenBackendKind>>,
pub optimized_compiler_builtins: Option<bool>,
pub jemalloc: Option<bool>,
}
@ -144,7 +144,7 @@ impl Config {
target.jemalloc = cfg.jemalloc;
if let Some(backends) = cfg.codegen_backends {
target.codegen_backends =
Some(validate_codegen_backends(backends, &format!("target.{triple}")))
Some(parse_codegen_backends(backends, &format!("target.{triple}")))
}
target.split_debuginfo = cfg.split_debuginfo.as_ref().map(|v| {

40
src/bootstrap/src/lib.rs
View file

@ -123,6 +123,46 @@ impl PartialEq for Compiler {
}
}
/// Represents a codegen backend.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum CodegenBackendKind {
#[default]
Llvm,
Cranelift,
Gcc,
Custom(String),
}
impl CodegenBackendKind {
/// Name of the codegen backend, as identified in the `compiler` directory
/// (`rustc_codegen_<name>`).
pub fn name(&self) -> &str {
match self {
CodegenBackendKind::Llvm => "llvm",
CodegenBackendKind::Cranelift => "cranelift",
CodegenBackendKind::Gcc => "gcc",
CodegenBackendKind::Custom(name) => name,
}
}
/// Name of the codegen backend's crate, e.g. `rustc_codegen_cranelift`.
pub fn crate_name(&self) -> String {
format!("rustc_codegen_{}", self.name())
}
pub fn is_llvm(&self) -> bool {
matches!(self, Self::Llvm)
}
pub fn is_cranelift(&self) -> bool {
matches!(self, Self::Cranelift)
}
pub fn is_gcc(&self) -> bool {
matches!(self, Self::Gcc)
}
}
#[derive(PartialEq, Eq, Copy, Clone, Debug)]
pub enum DocTests {
/// Run normal tests and doc tests (default).

6
src/bootstrap/src/utils/build_stamp.rs
View file

@ -10,7 +10,7 @@ use sha2::digest::Digest;
use crate::core::builder::Builder;
use crate::core::config::TargetSelection;
use crate::utils::helpers::{hex_encode, mtime};
use crate::{Compiler, Mode, helpers, t};
use crate::{CodegenBackendKind, Compiler, Mode, helpers, t};
#[cfg(test)]
mod tests;
@ -129,10 +129,10 @@ pub fn codegen_backend_stamp(
builder: &Builder<'_>,
compiler: Compiler,
target: TargetSelection,
backend: &str,
backend: &CodegenBackendKind,
) -> BuildStamp {
BuildStamp::new(&builder.cargo_out(compiler, Mode::Codegen, target))
.with_prefix(&format!("librustc_codegen_{backend}"))
.with_prefix(&format!("lib{}", backend.crate_name()))
}
/// Cargo's output path for the standard library in a given stage, compiled