bootstrap: move debug-prefix-map C flags to LLVM CMake build

The `-fdebug-prefix-map` flags in `cc_unhandled_cflags` served three
kinds of consumers.

* The cc-rs-driven C/C++ builds inside cargo:
  They now inherit the same remap pairs from cargo trim-paths
  so passing the flag through `CFLAGS` there is redundant.
* The CMake-driven LLVM build:
  This is the one we need the remaps.
* The remaining callers
  (`compiler_file` probing, cc detection, test fixtures):
  They never produce distributed artifacts.

Author: weihanglo

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

@@ -37,8 +37,7 @@ use crate::utils::helpers::{
     self, exe, get_clang_cl_resource_dir, is_debug_info, is_dylib, symlink_dir, t, up_to_date,
 };
 use crate::{
-    CLang, CodegenBackendKind, Compiler, DependencyType, FileType, GitRepo, LLVM_TOOLS, Mode,
-    debug, trace,
+    CLang, CodegenBackendKind, Compiler, DependencyType, FileType, LLVM_TOOLS, Mode, debug, trace,
 };
 
 /// Build a standard library for the given `target` using the given `build_compiler`.
@@ -1898,7 +1897,7 @@ pub fn compiler_file(
     }
     let mut cmd = command(compiler);
     cmd.args(builder.cc_handled_cflags(target, c));
-    cmd.args(builder.cc_unhandled_cflags(target, GitRepo::Rustc, c));
+    cmd.args(builder.cc_unhandled_cflags(target, c));
     cmd.arg(format!("-print-file-name={file}"));
     let out = cmd.run_capture_stdout(builder).stdout();
     PathBuf::from(out.trim())

src/bootstrap/src/core/build_steps/llvm.rs

@@ -26,7 +26,7 @@ use crate::utils::exec::command;
 use crate::utils::helpers::{
     self, exe, get_clang_cl_resource_dir, libdir, t, unhashed_basename, up_to_date,
 };
-use crate::{CLang, GitRepo, trace};
+use crate::{CLang, trace};
 
 /// Result of building or downloading LLVM artifacts.
 #[derive(Clone)]
@@ -663,6 +663,27 @@ fn check_llvm_version(builder: &Builder<'_>, llvm_config: &Path) {
     panic!("\n\nbad LLVM version: {version}, need >=21\n\n")
 }
 
+/// C/C++ debug info remap flags for LLVM build.
+///
+/// The remap is observable when LLVM is compiled with debug info,
+/// for example, with `llvm.release-debuginfo = true`.
+fn debuginfo_map_cflags(builder: &Builder<'_>, target: TargetSelection) -> Vec<String> {
+    if !builder.config.rust_remap_debuginfo {
+        return Vec::new();
+    }
+
+    let mut flags = Vec::new();
+    let map = format!("{}=/rustc/llvm", builder.src.display());
+    let cc = builder.cc_tool(target);
+    if cc.is_like_clang() || cc.is_like_gnu() {
+        flags.push(format!("-fdebug-prefix-map={map}"));
+    } else if cc.is_like_clang_cl() {
+        flags.push("-Xclang".into());
+        flags.push(format!("-fdebug-prefix-map={map}"));
+    }
+    flags
+}
+
 fn configure_cmake(
     builder: &Builder<'_>,
     target: TargetSelection,
@@ -827,7 +848,8 @@ fn configure_cmake(
     for flag in builder
         .cc_handled_cflags(target, CLang::C)
         .into_iter()
-        .chain(builder.cc_unhandled_cflags(target, GitRepo::Llvm, CLang::C))
+        .chain(builder.cc_unhandled_cflags(target, CLang::C))
+        .chain(debuginfo_map_cflags(builder, target))
         .filter(|flag| !suppressed_compiler_flag_prefixes.iter().any(|p| flag.starts_with(p)))
     {
         cflags.push(" ");
@@ -848,7 +870,8 @@ fn configure_cmake(
     for flag in builder
         .cc_handled_cflags(target, CLang::Cxx)
         .into_iter()
-        .chain(builder.cc_unhandled_cflags(target, GitRepo::Llvm, CLang::Cxx))
+        .chain(builder.cc_unhandled_cflags(target, CLang::Cxx))
+        .chain(debuginfo_map_cflags(builder, target))
         .filter(|flag| {
             !suppressed_compiler_flag_prefixes
                 .iter()

src/bootstrap/src/core/build_steps/test.rs

@@ -45,7 +45,7 @@ use crate::utils::helpers::{
     up_to_date,
 };
 use crate::utils::render_tests::{add_flags_and_try_run_tests, try_run_tests};
-use crate::{CLang, CodegenBackendKind, GitRepo, Mode, TestTarget, envify};
+use crate::{CLang, CodegenBackendKind, Mode, TestTarget, envify};
 
 mod compiletest;
 pub mod failed_tests;
@@ -2781,9 +2781,9 @@ Please disable assertions with `rust.debug-assertions = false`.
         // requires that a C++ compiler was configured which isn't always the case.
         if !builder.config.dry_run() && mode == CompiletestMode::RunMake {
             let mut cflags = builder.cc_handled_cflags(target, CLang::C);
-            cflags.extend(builder.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::C));
+            cflags.extend(builder.cc_unhandled_cflags(target, CLang::C));
             let mut cxxflags = builder.cc_handled_cflags(target, CLang::Cxx);
-            cxxflags.extend(builder.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::Cxx));
+            cxxflags.extend(builder.cc_unhandled_cflags(target, CLang::Cxx));
             cmd.arg("--cc")
                 .arg(builder.cc(target))
                 .arg("--cxx")

src/bootstrap/src/core/builder/cargo.rs

@@ -11,9 +11,7 @@ use crate::core::config::{CompressDebuginfo, Config, DryRun, SplitDebuginfo, Tar
 use crate::utils::build_stamp;
 use crate::utils::exec::{BootstrapCommand, command};
 use crate::utils::helpers::{self, LldThreads, check_cfg_arg, linker_flags, t};
-use crate::{
-    CLang, Compiler, EXTRA_CHECK_CFGS, GitRepo, Mode, RemapScheme, prepare_behaviour_dump_dir,
-};
+use crate::{CLang, Compiler, EXTRA_CHECK_CFGS, Mode, RemapScheme, prepare_behaviour_dump_dir};
 
 /// Represents flag values in `String` form with a `\x1f` delimiter to pass to the compiler later.
 ///
@@ -431,8 +429,7 @@ impl Cargo {
 
             // Extend `CXXFLAGS_$TARGET` with our extra flags.
             let env = format!("CFLAGS_{triple_underscored}");
-            let mut cflags =
-                builder.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::C).join(" ");
+            let mut cflags = builder.cc_unhandled_cflags(target, CLang::C).join(" ");
             if let Ok(var) = std::env::var(&env) {
                 cflags.push(' ');
                 cflags.push_str(&var);
@@ -452,8 +449,7 @@ impl Cargo {
 
                 // Extend `CXXFLAGS_$TARGET` with our extra flags.
                 let env = format!("CXXFLAGS_{triple_underscored}");
-                let mut cxxflags =
-                    builder.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::Cxx).join(" ");
+                let mut cxxflags = builder.cc_unhandled_cflags(target, CLang::Cxx).join(" ");
                 if let Ok(var) = std::env::var(&env) {
                     cxxflags.push(' ');
                     cxxflags.push_str(&var);
@@ -1116,16 +1112,12 @@ impl Builder<'_> {
 
         match mode {
             Mode::Rustc | Mode::Codegen => {
-                if let Some(ref map_to) =
-                    self.build.debuginfo_map_to(GitRepo::Rustc, RemapScheme::NonCompiler)
-                {
+                if let Some(ref map_to) = self.build.debuginfo_map_to(RemapScheme::NonCompiler) {
                     // Tell the compiler which prefix was used for remapping the standard library
                     cargo.env("CFG_VIRTUAL_RUST_SOURCE_BASE_DIR", map_to);
                 }
 
-                if let Some(ref map_to) =
-                    self.build.debuginfo_map_to(GitRepo::Rustc, RemapScheme::Compiler)
-                {
+                if let Some(ref map_to) = self.build.debuginfo_map_to(RemapScheme::Compiler) {
                     // Tell the compiler which prefix was used for remapping the compiler it-self
                     cargo.env("CFG_VIRTUAL_RUSTC_DEV_SOURCE_BASE_DIR", map_to);
 
@@ -1137,9 +1129,7 @@ impl Builder<'_> {
             | Mode::ToolRustcPrivate
             | Mode::ToolStd
             | Mode::ToolTarget => {
-                if let Some(ref map_to) =
-                    self.build.debuginfo_map_to(GitRepo::Rustc, RemapScheme::NonCompiler)
-                {
+                if let Some(ref map_to) = self.build.debuginfo_map_to(RemapScheme::NonCompiler) {
                     trim_paths(&mut cargo, map_to);
                 }
             }

src/bootstrap/src/lib.rs

@@ -186,11 +186,6 @@ impl TestTarget {
     }
 }
 
-pub enum GitRepo {
-    Rustc,
-    Llvm,
-}
-
 /// Global configuration for the build system.
 ///
 /// This structure transitively contains all configuration for the build system.
@@ -1167,34 +1162,29 @@ impl Build {
         })
     }
 
-    fn debuginfo_map_to(&self, which: GitRepo, remap_scheme: RemapScheme) -> Option<String> {
+    fn debuginfo_map_to(&self, remap_scheme: RemapScheme) -> Option<String> {
         if !self.config.rust_remap_debuginfo {
             return None;
         }
 
-        match which {
-            GitRepo::Rustc => {
-                let sha = self.rust_sha().unwrap_or(&self.version);
-
-                match remap_scheme {
-                    RemapScheme::Compiler => {
-                        // For compiler sources, remap via `/rustc-dev/{sha}` to allow
-                        // distinguishing between compiler sources vs library sources, since
-                        // `rustc-dev` dist component places them under
-                        // `$sysroot/lib/rustlib/rustc-src/rust` as opposed to `rust-src`'s
-                        // `$sysroot/lib/rustlib/src/rust`.
-                        //
-                        // Keep this scheme in sync with `rustc_metadata::rmeta::decoder`'s
-                        // `try_to_translate_virtual_to_real`.
-                        Some(format!("/rustc-dev/{sha}"))
-                    }
-                    RemapScheme::NonCompiler => {
-                        // For non-compiler sources, use `/rustc/{sha}` remapping scheme.
-                        Some(format!("/rustc/{sha}"))
-                    }
-                }
+        let sha = self.rust_sha().unwrap_or(&self.version);
+
+        match remap_scheme {
+            RemapScheme::Compiler => {
+                // For compiler sources, remap via `/rustc-dev/{sha}` to allow
+                // distinguishing between compiler sources vs library sources, since
+                // `rustc-dev` dist component places them under
+                // `$sysroot/lib/rustlib/rustc-src/rust` as opposed to `rust-src`'s
+                // `$sysroot/lib/rustlib/src/rust`.
+                //
+                // Keep this scheme in sync with `rustc_metadata::rmeta::decoder`'s
+                // `try_to_translate_virtual_to_real`.
+                Some(format!("/rustc-dev/{sha}"))
+            }
+            RemapScheme::NonCompiler => {
+                // For non-compiler sources, use `/rustc/{sha}` remapping scheme.
+                Some(format!("/rustc/{sha}"))
             }
-            GitRepo::Llvm => Some(String::from("/rustc/llvm")),
         }
     }
 
@@ -1237,12 +1227,7 @@ impl Build {
     }
 
     /// Returns extra C flags that `cc-rs` doesn't handle.
-    fn cc_unhandled_cflags(
-        &self,
-        target: TargetSelection,
-        which: GitRepo,
-        c: CLang,
-    ) -> Vec<String> {
+    fn cc_unhandled_cflags(&self, target: TargetSelection, c: CLang) -> Vec<String> {
         let mut base = Vec::new();
 
         // If we're compiling C++ on macOS then we add a flag indicating that
@@ -1259,16 +1244,6 @@ impl Build {
             base.push("-fno-omit-frame-pointer".into());
         }
 
-        if let Some(map_to) = self.debuginfo_map_to(which, RemapScheme::NonCompiler) {
-            let map = format!("{}={}", self.src.display(), map_to);
-            let cc = self.cc_tool(target);
-            if cc.is_like_clang() || cc.is_like_gnu() {
-                base.push(format!("-fdebug-prefix-map={map}"));
-            } else if cc.is_like_clang_cl() {
-                base.push("-Xclang".into());
-                base.push(format!("-fdebug-prefix-map={map}"));
-            }
-        }
         base
     }
 

src/bootstrap/src/utils/cc_detect.rs

@@ -27,7 +27,7 @@ use std::path::{Path, PathBuf};
 
 use crate::core::config::{CompressDebuginfo, Subcommand, TargetSelection};
 use crate::utils::exec::{BootstrapCommand, command};
-use crate::{Build, CLang, GitRepo};
+use crate::{Build, CLang};
 
 /// Creates and configures a new [`cc::Build`] instance for the given target.
 fn new_cc_build(build: &Build, target: TargetSelection) -> cc::Build {
@@ -124,7 +124,7 @@ pub fn fill_target_compiler(build: &mut Build, target: TargetSelection) {
 
     build.cc.insert(target, compiler.clone());
     let mut cflags = build.cc_handled_cflags(target, CLang::C);
-    cflags.extend(build.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::C));
+    cflags.extend(build.cc_unhandled_cflags(target, CLang::C));
 
     // If we use llvm-libunwind, we will need a C++ compiler as well for all targets
     // We'll need one anyways if the target triple is also a host triple
@@ -151,7 +151,7 @@ pub fn fill_target_compiler(build: &mut Build, target: TargetSelection) {
     build.do_if_verbose(|| println!("CFLAGS_{} = {cflags:?}", target.triple));
     if let Ok(cxx) = build.cxx(target) {
         let mut cxxflags = build.cc_handled_cflags(target, CLang::Cxx);
-        cxxflags.extend(build.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::Cxx));
+        cxxflags.extend(build.cc_unhandled_cflags(target, CLang::Cxx));
         build.do_if_verbose(|| println!("CXX_{} = {cxx:?}", target.triple));
         build.do_if_verbose(|| println!("CXXFLAGS_{} = {cxxflags:?}", target.triple));
     }