Rename jemalloc bootstrap options to override-allocator

Author: Zoxc

INSTALL.md

@@ -96,7 +96,7 @@ See [the rustc-dev-guide for more info][sysllvm].
       --set llvm.libzstd=true \
       --set llvm.ninja=false \
       --set rust.debug-assertions=false \
-      --set rust.jemalloc \
+      --set rust.override-allocator \
       --set rust.bootstrap-override-lld=true \
       --set rust.lto=thin \
       --set rust.codegen-units=1

bootstrap.example.toml

@@ -848,7 +848,7 @@
 # Link the compiler and LLVM against `jemalloc` instead of the default libc allocator.
 # This option is only tested on Linux and OSX. It can also be configured per-target in the
 # [target.<tuple>] section.
-#rust.jemalloc = false
+#rust.override-allocator = false
 
 # Run tests in various test suites with the "nll compare mode" in addition to
 # running the tests in normal mode. Largely only used on CI and during local
@@ -1121,8 +1121,8 @@
 #optimized-compiler-builtins = build.optimized-compiler-builtins (bool or path)
 
 # Link the compiler and LLVM against `jemalloc` instead of the default libc allocator.
-# This overrides the global `rust.jemalloc` option. See that option for more info.
-#jemalloc = rust.jemalloc (bool)
+# This overrides the global `rust.override-allocator` option. See that option for more info.
+#override-allocator = rust.override-allocator (bool)
 
 # The linker configuration that will *override* the default linker used for Linux
 # targets in the built compiler.

compiler/rustc/Cargo.toml

@@ -35,7 +35,7 @@ features = ['override_allocator_on_supported_platforms']
 [features]
 # tidy-alphabetical-start
 check_only = ['rustc_driver_impl/check_only']
-jemalloc = ['dep:tikv-jemalloc-sys']
+override_allocator = ['dep:tikv-jemalloc-sys']
 llvm = ['rustc_driver_impl/llvm']
 llvm_enzyme = ['rustc_driver_impl/llvm_enzyme']
 llvm_offload = ['rustc_driver_impl/llvm_offload']

compiler/rustc/src/main.rs

@@ -37,7 +37,7 @@ use std::process::ExitCode;
 // to compare their performance, see
 // https://github.com/rust-lang/rust/commit/b90cfc887c31c3e7a9e6d462e2464db1fe506175#diff-43914724af6e464c1da2171e4a9b6c7e607d5bc1203fa95c0ab85be4122605ef
 // for an example of how to do so.
-#[cfg(feature = "jemalloc")]
+#[cfg(feature = "override_allocator")]
 use tikv_jemalloc_sys as _;
 
 fn main() -> ExitCode {

src/bootstrap/src/core/build_steps/compile.rs

@@ -1411,7 +1411,9 @@ pub fn rustc_cargo_env(builder: &Builder<'_>, cargo: &mut Cargo, target: TargetS
     }
 
     // See also the "JEMALLOC_SYS_WITH_LG_PAGE" setting in the tool build step.
-    if builder.config.jemalloc(target) && env::var_os("JEMALLOC_SYS_WITH_LG_PAGE").is_none() {
+    if builder.config.override_allocator(target)
+        && env::var_os("JEMALLOC_SYS_WITH_LG_PAGE").is_none()
+    {
         // Build jemalloc on AArch64 with support for page sizes up to 64K
         // See: https://github.com/rust-lang/rust/pull/135081
         if target.starts_with("aarch64") {

src/bootstrap/src/core/build_steps/tool.rs

@@ -229,7 +229,9 @@ pub fn prepare_tool_cargo(
     cargo.env("LZMA_API_STATIC", "1");
 
     // See also the "JEMALLOC_SYS_WITH_LG_PAGE" setting in the compile build step.
-    if builder.config.jemalloc(target) && env::var_os("JEMALLOC_SYS_WITH_LG_PAGE").is_none() {
+    if builder.config.override_allocator(target)
+        && env::var_os("JEMALLOC_SYS_WITH_LG_PAGE").is_none()
+    {
         // Build jemalloc on AArch64 with support for page sizes up to 64K
         // See: https://github.com/rust-lang/rust/pull/135081
         if target.starts_with("aarch64") {
@@ -752,8 +754,8 @@ impl Step for Rustdoc {
         // to build rustdoc.
         //
         let mut extra_features = Vec::new();
-        if builder.config.jemalloc(target) {
-            extra_features.push("jemalloc".to_string());
+        if builder.config.override_allocator(target) {
+            extra_features.push("override_allocator".to_string());
         }
 
         let compilers = RustcPrivateCompilers::from_target_compiler(builder, target_compiler);
@@ -1576,8 +1578,8 @@ tool_rustc_extended!(Clippy {
     stable: true,
     add_bins_to_sysroot: ["clippy-driver"],
     add_features: |builder, target, features| {
-        if builder.config.jemalloc(target) {
-            features.push("jemalloc".to_string());
+        if builder.config.override_allocator(target) {
+            features.push("override_allocator".to_string());
         }
     }
 });
@@ -1587,8 +1589,8 @@ tool_rustc_extended!(Miri {
     stable: false,
     add_bins_to_sysroot: ["miri"],
     add_features: |builder, target, features| {
-        if builder.config.jemalloc(target) {
-            features.push("jemalloc".to_string());
+        if builder.config.override_allocator(target) {
+            features.push("override_allocator".to_string());
         }
     },
     // Always compile also tests when building miri. Otherwise feature unification can cause rebuilds between building and testing miri.

src/bootstrap/src/core/config/config.rs

@@ -242,7 +242,7 @@ pub struct Config {
     pub hosts: Vec<TargetSelection>,
     pub targets: Vec<TargetSelection>,
     pub local_rebuild: bool,
-    pub jemalloc: bool,
+    pub override_allocator: bool,
     pub control_flow_guard: bool,
     pub ehcont_guard: bool,
 
@@ -570,7 +570,7 @@ impl Config {
             thin_lto_import_instr_limit: rust_thin_lto_import_instr_limit,
             parallel_frontend_threads: rust_parallel_frontend_threads,
             remap_debuginfo: rust_remap_debuginfo,
-            jemalloc: rust_jemalloc,
+            override_allocator: rust_override_allocator,
             test_compare_mode: rust_test_compare_mode,
             llvm_libunwind: rust_llvm_libunwind,
             control_flow_guard: rust_control_flow_guard,
@@ -900,7 +900,7 @@ impl Config {
                     codegen_backends: target_codegen_backends,
                     runner: target_runner,
                     optimized_compiler_builtins: target_optimized_compiler_builtins,
-                    jemalloc: target_jemalloc,
+                    override_allocator: target_override_allocator,
                 } = cfg;
 
                 let mut target = Target::from_triple(&triple);
@@ -976,7 +976,7 @@ impl Config {
                 target.rpath = target_rpath;
                 target.rustflags = target_rustflags.unwrap_or_default();
                 target.optimized_compiler_builtins = target_optimized_compiler_builtins;
-                target.jemalloc = target_jemalloc;
+                target.override_allocator = target_override_allocator;
                 if let Some(backends) = target_codegen_backends {
                     target.codegen_backends =
                         Some(parse_codegen_backends(backends, &format!("target.{triple}")))
@@ -1365,7 +1365,7 @@ impl Config {
             initial_rustdoc,
             initial_rustfmt,
             initial_sysroot,
-            jemalloc: rust_jemalloc.unwrap_or(false),
+            override_allocator: rust_override_allocator.unwrap_or(false),
             jobs: Some(threads_from_config(flags_jobs.or(build_jobs).unwrap_or(0))),
             json_output: flags_json_output,
             keep_stage: flags_keep_stage,
@@ -1858,8 +1858,11 @@ impl Config {
         self.enabled_codegen_backends(target).first().unwrap()
     }
 
-    pub fn jemalloc(&self, target: TargetSelection) -> bool {
-        self.target_config.get(&target).and_then(|cfg| cfg.jemalloc).unwrap_or(self.jemalloc)
+    pub fn override_allocator(&self, target: TargetSelection) -> bool {
+        self.target_config
+            .get(&target)
+            .and_then(|cfg| cfg.override_allocator)
+            .unwrap_or(self.override_allocator)
     }
 
     pub fn rpath_enabled(&self, target: TargetSelection) -> bool {

src/bootstrap/src/core/config/toml/rust.rs

@@ -55,7 +55,7 @@ define_config! {
         verify_llvm_ir: Option<bool> = "verify-llvm-ir",
         thin_lto_import_instr_limit: Option<u32> = "thin-lto-import-instr-limit",
         remap_debuginfo: Option<bool> = "remap-debuginfo",
-        jemalloc: Option<bool> = "jemalloc",
+        override_allocator: Option<bool> = "override-allocator",
         test_compare_mode: Option<bool> = "test-compare-mode",
         llvm_libunwind: Option<String> = "llvm-libunwind",
         control_flow_guard: Option<bool> = "control-flow-guard",
@@ -325,7 +325,7 @@ pub fn check_incompatible_options_for_ci_rustc(
         llvm_bitcode_linker,
         stack_protector,
         strip,
-        jemalloc,
+        override_allocator,
         rpath,
         channel,
         default_linker,
@@ -394,7 +394,7 @@ pub fn check_incompatible_options_for_ci_rustc(
     err!(current_rust_config.strip, strip, "rust");
     err!(current_rust_config.llvm_tools, llvm_tools, "rust");
     err!(current_rust_config.llvm_bitcode_linker, llvm_bitcode_linker, "rust");
-    err!(current_rust_config.jemalloc, jemalloc, "rust");
+    err!(current_rust_config.override_allocator, override_allocator, "rust");
     err!(current_rust_config.default_linker, default_linker, "rust");
     err!(current_rust_config.stack_protector, stack_protector, "rust");
     err!(current_rust_config.std_features, std_features, "rust");

src/bootstrap/src/core/config/toml/target.rs

@@ -47,7 +47,7 @@ define_config! {
         codegen_backends: Option<Vec<String>> = "codegen-backends",
         runner: Option<String> = "runner",
         optimized_compiler_builtins: Option<CompilerBuiltins> = "optimized-compiler-builtins",
-        jemalloc: Option<bool> = "jemalloc",
+        override_allocator: Option<bool> = "override-allocator",
     }
 }
 
@@ -81,7 +81,7 @@ pub struct Target {
     pub no_std: bool,
     pub codegen_backends: Option<Vec<CodegenBackendKind>>,
     pub optimized_compiler_builtins: Option<CompilerBuiltins>,
-    pub jemalloc: Option<bool>,
+    pub override_allocator: Option<bool>,
 }
 
 impl Target {

src/bootstrap/src/lib.rs

@@ -863,8 +863,8 @@ impl Build {
             crates.is_empty() || possible_features_by_crates.contains(feature)
         };
         let mut features = vec![];
-        if self.config.jemalloc(target) && check("jemalloc") {
-            features.push("jemalloc");
+        if self.config.override_allocator(target) && check("override_allocator") {
+            features.push("override_allocator");
         }
         if (self.config.llvm_enabled(target) || kind == Kind::Check) && check("llvm") {
             features.push("llvm");