rust/0001-Allow-linking-a-prebuilt-optimized-compiler-rt-built.patch
Paul Murphy 920d923779 Update to Rust 1.90
Resolves: RHEL-111873
Related: RHEL-111847
2025-09-30 12:09:33 -05:00

279 lines
14 KiB
Diff

From 4815c3cd733812bec777970ff4b1e73c2fcad1a6 Mon Sep 17 00:00:00 2001
From: Paul Murphy <paumurph@redhat.com>
Date: Tue, 24 Jun 2025 11:07:54 -0500
Subject: [PATCH] Allow linking a prebuilt optimized compiler-rt builtins
library
Extend the <target>.optimized-compiler-builtins bootstrap option to accept a
path to a prebuilt compiler-rt builtins library, and update compiler-builtins
to enable optimized builtins without building compiler-rt builtins.
(cherry picked from commit b382478bba7b8f75c73673c239fa86a29db66223)
---
bootstrap.example.toml | 4 +-
.../compiler-builtins/build.rs | 55 ++++++++++++++++---
src/bootstrap/src/core/build_steps/compile.rs | 44 ++++++++-------
src/bootstrap/src/core/config/config.rs | 10 +++-
src/bootstrap/src/core/config/tests.rs | 4 +-
src/bootstrap/src/core/config/toml/target.rs | 4 +-
6 files changed, 87 insertions(+), 34 deletions(-)
diff --git a/bootstrap.example.toml b/bootstrap.example.toml
index 82041167b444..a11aec1b60e5 100644
--- a/bootstrap.example.toml
+++ b/bootstrap.example.toml
@@ -1038,7 +1038,9 @@
# sources are available.
#
# Setting this to `false` generates slower code, but removes the requirement for a C toolchain in
-# order to run `x check`.
+# order to run `x check`. This may also be given a path to an existing build of the builtins
+# runtime library from LLVM's compiler-rt. This option will override the same option under [build]
+# section.
#optimized-compiler-builtins = build.optimized-compiler-builtins (bool)
# Link the compiler and LLVM against `jemalloc` instead of the default libc allocator.
diff --git a/library/compiler-builtins/compiler-builtins/build.rs b/library/compiler-builtins/compiler-builtins/build.rs
index 8f51c12b535d..b8de1789ebc7 100644
--- a/library/compiler-builtins/compiler-builtins/build.rs
+++ b/library/compiler-builtins/compiler-builtins/build.rs
@@ -547,12 +547,20 @@ pub fn compile(llvm_target: &[&str], target: &Target) {
sources.extend(&[("__emutls_get_address", "emutls.c")]);
}
+ // Optionally, link against a prebuilt llvm compiler-rt containing the builtins
+ // library. Only the builtins library is required. On many platforms, this is
+ // available as a library named libclang_rt.builtins.a.
+ let link_against_prebuilt_rt = env::var_os("LLVM_COMPILER_RT_LIB").is_some();
+
// When compiling the C code we require the user to tell us where the
// source code is, and this is largely done so when we're compiling as
// part of rust-lang/rust we can use the same llvm-project repository as
// rust-lang/rust.
let root = match env::var_os("RUST_COMPILER_RT_ROOT") {
Some(s) => PathBuf::from(s),
+ // If a prebuild libcompiler-rt is provided, set a valid
+ // path to simplify later logic. Nothing should be compiled.
+ None if link_against_prebuilt_rt => PathBuf::new(),
None => {
panic!(
"RUST_COMPILER_RT_ROOT is not set. You may need to run \
@@ -560,7 +568,7 @@ pub fn compile(llvm_target: &[&str], target: &Target) {
);
}
};
- if !root.exists() {
+ if !link_against_prebuilt_rt && !root.exists() {
panic!("RUST_COMPILER_RT_ROOT={} does not exist", root.display());
}
@@ -576,7 +584,7 @@ pub fn compile(llvm_target: &[&str], target: &Target) {
let src_dir = root.join("lib/builtins");
if target.arch == "aarch64" && target.env != "msvc" && target.os != "uefi" {
// See below for why we're building these as separate libraries.
- build_aarch64_out_of_line_atomics_libraries(&src_dir, cfg);
+ build_aarch64_out_of_line_atomics_libraries(&src_dir, cfg, link_against_prebuilt_rt);
// Some run-time CPU feature detection is necessary, as well.
let cpu_model_src = if src_dir.join("cpu_model.c").exists() {
@@ -590,20 +598,45 @@ pub fn compile(llvm_target: &[&str], target: &Target) {
let mut added_sources = HashSet::new();
for (sym, src) in sources.map.iter() {
let src = src_dir.join(src);
- if added_sources.insert(src.clone()) {
+ if !link_against_prebuilt_rt && added_sources.insert(src.clone()) {
cfg.file(&src);
println!("cargo:rerun-if-changed={}", src.display());
}
println!("cargo:rustc-cfg={}=\"optimized-c\"", sym);
}
- cfg.compile("libcompiler-rt.a");
+ if link_against_prebuilt_rt {
+ let rt_builtins_ext = PathBuf::from(env::var_os("LLVM_COMPILER_RT_LIB").unwrap());
+ if !rt_builtins_ext.exists() {
+ panic!(
+ "LLVM_COMPILER_RT_LIB={} does not exist",
+ rt_builtins_ext.display()
+ );
+ }
+ if let Some(dir) = rt_builtins_ext.parent() {
+ println!("cargo::rustc-link-search=native={}", dir.display());
+ }
+ if let Some(lib) = rt_builtins_ext.file_name() {
+ println!(
+ "cargo::rustc-link-lib=static:+verbatim={}",
+ lib.to_str().unwrap()
+ );
+ }
+ } else {
+ cfg.compile("libcompiler-rt.a");
+ }
}
- fn build_aarch64_out_of_line_atomics_libraries(builtins_dir: &Path, cfg: &mut cc::Build) {
+ fn build_aarch64_out_of_line_atomics_libraries(
+ builtins_dir: &Path,
+ cfg: &mut cc::Build,
+ link_against_prebuilt_rt: bool,
+ ) {
let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
let outlined_atomics_file = builtins_dir.join("aarch64").join("lse.S");
- println!("cargo:rerun-if-changed={}", outlined_atomics_file.display());
+ if !link_against_prebuilt_rt {
+ println!("cargo:rerun-if-changed={}", outlined_atomics_file.display());
+ }
cfg.include(&builtins_dir);
@@ -616,6 +649,13 @@ fn build_aarch64_out_of_line_atomics_libraries(builtins_dir: &Path, cfg: &mut cc
for (model_number, model_name) in
&[(1, "relax"), (2, "acq"), (3, "rel"), (4, "acq_rel")]
{
+ let sym = format!("__aarch64_{}{}_{}", instruction_type, size, model_name);
+ println!("cargo:rustc-cfg={}=\"optimized-c\"", sym);
+
+ if link_against_prebuilt_rt {
+ continue;
+ }
+
// The original compiler-rt build system compiles the same
// source file multiple times with different compiler
// options. Here we do something slightly different: we
@@ -639,9 +679,6 @@ fn build_aarch64_out_of_line_atomics_libraries(builtins_dir: &Path, cfg: &mut cc
.unwrap();
drop(file);
cfg.file(path);
-
- let sym = format!("__aarch64_{}{}_{}", instruction_type, size, model_name);
- println!("cargo:rustc-cfg={}=\"optimized-c\"", sym);
}
}
}
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 7a5533346adf..39c9db3d6c35 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -572,25 +572,31 @@ pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, stage: u32, car
// `compiler-builtins` crate is enabled and it's configured to learn where
// `compiler-rt` is located.
let compiler_builtins_c_feature = if builder.config.optimized_compiler_builtins(target) {
- // NOTE: this interacts strangely with `llvm-has-rust-patches`. In that case, we enforce `submodules = false`, so this is a no-op.
- // But, the user could still decide to manually use an in-tree submodule.
- //
- // NOTE: if we're using system llvm, we'll end up building a version of `compiler-rt` that doesn't match the LLVM we're linking to.
- // That's probably ok? At least, the difference wasn't enforced before. There's a comment in
- // the compiler_builtins build script that makes me nervous, though:
- // https://github.com/rust-lang/compiler-builtins/blob/31ee4544dbe47903ce771270d6e3bea8654e9e50/build.rs#L575-L579
- builder.require_submodule(
- "src/llvm-project",
- Some(
- "The `build.optimized-compiler-builtins` config option \
- requires `compiler-rt` sources from LLVM.",
- ),
- );
- let compiler_builtins_root = builder.src.join("src/llvm-project/compiler-rt");
- assert!(compiler_builtins_root.exists());
- // The path to `compiler-rt` is also used by `profiler_builtins` (above),
- // so if you're changing something here please also change that as appropriate.
- cargo.env("RUST_COMPILER_RT_ROOT", &compiler_builtins_root);
+ if let Some(path) = builder.config.optimized_compiler_builtins_path(target) {
+ cargo.env("LLVM_COMPILER_RT_LIB", path);
+ } else {
+ // NOTE: this interacts strangely with `llvm-has-rust-patches`. In that case, we enforce
+ // `submodules = false`, so this is a no-op. But, the user could still decide to
+ // manually use an in-tree submodule.
+ //
+ // NOTE: if we're using system llvm, we'll end up building a version of `compiler-rt`
+ // that doesn't match the LLVM we're linking to. That's probably ok? At least, the
+ // difference wasn't enforced before. There's a comment in the compiler_builtins build
+ // script that makes me nervous, though:
+ // https://github.com/rust-lang/compiler-builtins/blob/31ee4544dbe47903ce771270d6e3bea8654e9e50/build.rs#L575-L579
+ builder.require_submodule(
+ "src/llvm-project",
+ Some(
+ "The `build.optimized-compiler-builtins` config option \
+ requires `compiler-rt` sources from LLVM.",
+ ),
+ );
+ let compiler_builtins_root = builder.src.join("src/llvm-project/compiler-rt");
+ assert!(compiler_builtins_root.exists());
+ // The path to `compiler-rt` is also used by `profiler_builtins` (above),
+ // so if you're changing something here please also change that as appropriate.
+ cargo.env("RUST_COMPILER_RT_ROOT", &compiler_builtins_root);
+ }
" compiler-builtins-c"
} else {
""
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 6055876c4757..588c3489f898 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -1769,10 +1769,18 @@ pub fn rpath_enabled(&self, target: TargetSelection) -> bool {
pub fn optimized_compiler_builtins(&self, target: TargetSelection) -> bool {
self.target_config
.get(&target)
- .and_then(|t| t.optimized_compiler_builtins)
+ .and_then(|t| t.optimized_compiler_builtins.as_ref())
+ .map(StringOrBool::is_string_or_true)
.unwrap_or(self.optimized_compiler_builtins)
}
+ pub fn optimized_compiler_builtins_path(&self, target: TargetSelection) -> Option<&str> {
+ match self.target_config.get(&target)?.optimized_compiler_builtins.as_ref()? {
+ StringOrBool::String(s) => Some(s),
+ StringOrBool::Bool(_) => None,
+ }
+ }
+
pub fn llvm_enabled(&self, target: TargetSelection) -> bool {
self.codegen_backends(target).contains(&CodegenBackendKind::Llvm)
}
diff --git a/src/bootstrap/src/core/config/tests.rs b/src/bootstrap/src/core/config/tests.rs
index 50eba12aba74..c32e4384cf62 100644
--- a/src/bootstrap/src/core/config/tests.rs
+++ b/src/bootstrap/src/core/config/tests.rs
@@ -17,7 +17,7 @@
use crate::core::build_steps::llvm;
use crate::core::build_steps::llvm::LLVM_INVALIDATION_PATHS;
use crate::core::config::toml::TomlConfig;
-use crate::core::config::{LldMode, Target, TargetSelection};
+use crate::core::config::{LldMode, StringOrBool, Target, TargetSelection};
use crate::utils::tests::git::git_test;
pub(crate) fn parse(config: &str) -> Config {
@@ -212,7 +212,7 @@ fn override_toml() {
let darwin = TargetSelection::from_user("aarch64-apple-darwin");
let darwin_values = Target {
runner: Some("apple".into()),
- optimized_compiler_builtins: Some(false),
+ optimized_compiler_builtins: Some(StringOrBool::Bool(false)),
..Default::default()
};
assert_eq!(
diff --git a/src/bootstrap/src/core/config/toml/target.rs b/src/bootstrap/src/core/config/toml/target.rs
index 69afa8af3419..5ddb8c50c146 100644
--- a/src/bootstrap/src/core/config/toml/target.rs
+++ b/src/bootstrap/src/core/config/toml/target.rs
@@ -45,7 +45,7 @@ struct TomlTarget {
no_std: Option<bool> = "no-std",
codegen_backends: Option<Vec<String>> = "codegen-backends",
runner: Option<String> = "runner",
- optimized_compiler_builtins: Option<bool> = "optimized-compiler-builtins",
+ optimized_compiler_builtins: Option<StringOrBool> = "optimized-compiler-builtins",
jemalloc: Option<bool> = "jemalloc",
self_contained: Option<bool> = "self-contained",
}
@@ -78,7 +78,7 @@ pub struct Target {
pub runner: Option<String>,
pub no_std: bool,
pub codegen_backends: Option<Vec<CodegenBackendKind>>,
- pub optimized_compiler_builtins: Option<bool>,
+ pub optimized_compiler_builtins: Option<StringOrBool>,
pub jemalloc: Option<bool>,
pub self_contained: bool,
}
--
2.50.1