Auto merge of #150283 - Urgau:remap-debuginfo-absolute, r=<try>

Remap both absolute and relative paths when building `rustc` and `std`

try-job: dist-x86_64-linux

Author: rust-bors[bot]

src/bootstrap/src/bin/rustc.rs

@@ -168,8 +168,11 @@ fn main() {
         }
     }
 
-    if let Ok(map) = env::var("RUSTC_DEBUGINFO_MAP") {
-        cmd.arg("--remap-path-prefix").arg(&map);
+    // The remap flags for the compiler and standard library sources.
+    if let Ok(maps) = env::var("RUSTC_DEBUGINFO_MAP") {
+        for map in maps.split('\t') {
+            cmd.arg("--remap-path-prefix").arg(map);
+        }
     }
     // The remap flags for Cargo registry sources need to be passed after the remapping for the
     // Rust source code directory, to handle cases when $CARGO_HOME is inside the source directory.

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

@@ -2257,6 +2257,10 @@ Please disable assertions with `rust.debug-assertions = false`.
             cmd.arg("--with-std-debug-assertions");
         }
 
+        if builder.config.rust_remap_debuginfo {
+            cmd.arg("--with-std-remap-debuginfo");
+        }
+
         let mut llvm_components_passed = false;
         let mut copts_passed = false;
         if builder.config.llvm_enabled(test_compiler.host) {

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

@@ -1025,15 +1025,26 @@ impl Builder<'_> {
                 if let Some(ref map_to) =
                     self.build.debuginfo_map_to(GitRepo::Rustc, 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)
                 {
-                    // When building compiler sources, we want to apply the compiler remap scheme.
-                    cargo.env("RUSTC_DEBUGINFO_MAP", format!("compiler/={map_to}/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);
+
+                    // When building compiler sources, we want to apply the compiler remap scheme.
+                    let map = [
+                        // Cargo use relative paths for workspace members, so let's remap those.
+                        format!("compiler/={map_to}/compiler"),
+                        // rustc creates absolute paths (in part bc of the `rust-src` unremap
+                        // and for working directory) so let's remap the build directory as well.
+                        format!("{}={map_to}", self.build.src.display()),
+                    ]
+                    .join("\t");
+                    cargo.env("RUSTC_DEBUGINFO_MAP", map);
                 }
             }
             Mode::Std
@@ -1044,7 +1055,16 @@ impl Builder<'_> {
                 if let Some(ref map_to) =
                     self.build.debuginfo_map_to(GitRepo::Rustc, RemapScheme::NonCompiler)
                 {
-                    cargo.env("RUSTC_DEBUGINFO_MAP", format!("library/={map_to}/library"));
+                    // When building the standard library sources, we want to apply the std remap scheme.
+                    let map = [
+                        // Cargo use relative paths for workspace members, so let's remap those.
+                        format!("library/={map_to}/library"),
+                        // rustc creates absolute paths (in part bc of the `rust-src` unremap
+                        // and for working directory) so let's remap the build directory as well.
+                        format!("{}={map_to}", self.build.src.display()),
+                    ]
+                    .join("\t");
+                    cargo.env("RUSTC_DEBUGINFO_MAP", map);
                 }
             }
         }

src/doc/rustc-dev-guide/src/tests/directives.md

@@ -189,6 +189,10 @@ settings:
   assertions.
 - `needs-std-debug-assertions` — ignores if std was not built with debug
   assertions.
+- `ignore-std-remap-debuginfo` — ignores if std was built with remapping of
+  it's sources.
+- `needs-std-remap-debugino` — ignores if std was not built with remapping of
+  it's sources.
 - `ignore-rustc-debug-assertions` — ignores if rustc was built with debug
   assertions.
 - `needs-rustc-debug-assertions` — ignores if rustc was not built with debug

src/tools/compiletest/src/common.rs

@@ -438,6 +438,11 @@ pub struct Config {
     /// FIXME: make it clearer that this refers to the staged `std`, not stage 0 `std`.
     pub with_std_debug_assertions: bool,
 
+    /// Whether *staged* `std` was built with remapping of debuginfo.
+    ///
+    /// FIXME: make it clearer that this refers to the staged `std`, not stage 0 `std`.
+    pub with_std_remap_debuginfo: bool,
+
     /// Only run tests that match these filters (using `libtest` "test name contains" filter logic).
     ///
     /// FIXME(#139660): the current hand-rolled test executor intentionally mimics the `libtest`

src/tools/compiletest/src/directives/cfg.rs

@@ -202,6 +202,11 @@ pub(crate) fn prepare_conditions(config: &Config) -> PreparedConditions {
         config.with_std_debug_assertions,
         "when std is built with debug assertions",
     );
+    builder.cond(
+        "std-remap-debuginfo",
+        config.with_std_remap_debuginfo,
+        "when std is built with remapping of debuginfo",
+    );
 
     for &debugger in Debugger::STR_VARIANTS {
         builder.cond(

src/tools/compiletest/src/directives/directive_names.rs

@@ -184,6 +184,7 @@ pub(crate) const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "needs-sanitizer-support",
     "needs-sanitizer-thread",
     "needs-std-debug-assertions",
+    "needs-std-remap-debuginfo",
     "needs-subprocess",
     "needs-symlink",
     "needs-target-has-atomic",

src/tools/compiletest/src/directives/needs.rs

@@ -181,6 +181,11 @@ pub(super) fn handle_needs(
             condition: config.with_std_debug_assertions,
             ignore_reason: "ignored if std wasn't built with debug assertions",
         },
+        Need {
+            name: "needs-std-remap-debuginfo",
+            condition: config.with_std_remap_debuginfo,
+            ignore_reason: "ignored if std wasn't built with remapping of debuginfo",
+        },
         Need {
             name: "needs-target-std",
             condition: build_helper::targets::target_supports_std(&config.target),

src/tools/compiletest/src/directives/tests.rs

@@ -117,6 +117,7 @@ struct ConfigBuilder {
     profiler_runtime: bool,
     rustc_debug_assertions: bool,
     std_debug_assertions: bool,
+    std_remap_debuginfo: bool,
 }
 
 impl ConfigBuilder {
@@ -185,6 +186,11 @@ impl ConfigBuilder {
         self
     }
 
+    fn std_remap_debuginfo(&mut self, is_enabled: bool) -> &mut Self {
+        self.std_remap_debuginfo = is_enabled;
+        self
+    }
+
     fn build(&mut self) -> Config {
         let args = &[
             "compiletest",
@@ -246,6 +252,9 @@ impl ConfigBuilder {
         if self.std_debug_assertions {
             args.push("--with-std-debug-assertions".to_owned());
         }
+        if self.std_remap_debuginfo {
+            args.push("--with-std-remap-debuginfo".to_owned());
+        }
 
         args.push("--rustc-path".to_string());
         args.push(std::env::var("TEST_RUSTC").expect("must be configured by bootstrap"));
@@ -400,6 +409,19 @@ fn std_debug_assertions() {
     assert!(check_ignore(&config, "//@ ignore-std-debug-assertions"));
 }
 
+#[test]
+fn std_remap_debuginfo() {
+    let config: Config = cfg().std_remap_debuginfo(false).build();
+
+    assert!(check_ignore(&config, "//@ needs-std-remap-debuginfo"));
+    assert!(!check_ignore(&config, "//@ ignore-std-remap-debuginfo"));
+
+    let config: Config = cfg().std_remap_debuginfo(true).build();
+
+    assert!(!check_ignore(&config, "//@ needs-std-remap-debuginfo"));
+    assert!(check_ignore(&config, "//@ ignore-std-remap-debuginfo"));
+}
+
 #[test]
 fn stage() {
     let config: Config = cfg().stage(1).stage_id("stage1-x86_64-unknown-linux-gnu").build();

src/tools/compiletest/src/lib.rs

@@ -106,6 +106,7 @@ fn parse_config(args: Vec<String>) -> Config {
         .optflag("", "has-enzyme", "run tests that require enzyme")
         .optflag("", "with-rustc-debug-assertions", "whether rustc was built with debug assertions")
         .optflag("", "with-std-debug-assertions", "whether std was built with debug assertions")
+        .optflag("", "with-std-remap-debuginfo", "whether std was built with remapping")
         .optmulti(
             "",
             "skip",
@@ -295,6 +296,7 @@ fn parse_config(args: Vec<String>) -> Config {
     let run_ignored = matches.opt_present("ignored");
     let with_rustc_debug_assertions = matches.opt_present("with-rustc-debug-assertions");
     let with_std_debug_assertions = matches.opt_present("with-std-debug-assertions");
+    let with_std_remap_debuginfo = matches.opt_present("with-std-remap-debuginfo");
     let mode = matches.opt_str("mode").unwrap().parse().expect("invalid mode");
     let has_enzyme = matches.opt_present("has-enzyme");
     let filters = if mode == TestMode::RunMake {
@@ -402,6 +404,7 @@ fn parse_config(args: Vec<String>) -> Config {
         run_ignored,
         with_rustc_debug_assertions,
         with_std_debug_assertions,
+        with_std_remap_debuginfo,
         filters,
         skip: matches.opt_strs("skip"),
         filter_exact: matches.opt_present("exact"),