Auto merge of #126801 - Oneirical:seek-and-testroy, r=<try>

Migrate `remap-path-prefix`, `debug-assertions` and `emit-stack-sizes` `run-make` tests to rmake

Part of #121876 and the associated [Google Summer of Code project](https://blog.rust-lang.org/2024/05/01/gsoc-2024-selected-projects.html).

Needs OSX/MSVC try jobs.

try-job: aarch64-apple
try-job: x86_64-msvc

Cargo.lock

@@ -3401,6 +3401,7 @@ name = "run_make_support"
 version = "0.2.0"
 dependencies = [
  "ar",
+ "bstr",
  "gimli 0.28.1",
  "object 0.34.0",
  "regex",

src/tools/run-make-support/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.2.0"
 edition = "2021"
 
 [dependencies]
+bstr = "1.6.0"
 object = "0.34.0"
 similar = "2.5.0"
 wasmparser = "0.118.2"

src/tools/run-make-support/src/lib.rs

@@ -21,6 +21,7 @@ use std::io;
 use std::panic;
 use std::path::{Path, PathBuf};
 
+pub use bstr;
 pub use gimli;
 pub use object;
 pub use regex;

src/tools/run-make-support/src/rustc.rs

@@ -106,6 +106,17 @@ impl Rustc {
         self
     }
 
+    /// Remap source path prefixes in all output.
+    pub fn remap_path_prefix<P: AsRef<Path>>(&mut self, from: P, to: P) -> &mut Self {
+        let from = from.as_ref().to_string_lossy();
+        let to = to.as_ref().to_string_lossy();
+
+        self.cmd.arg("--remap-path-prefix");
+        self.cmd.arg(format!("{from}={to}"));
+
+        self
+    }
+
     /// Specify path to the input file.
     pub fn input<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
         self.cmd.arg(path.as_ref());

src/tools/tidy/src/allowed_run_make_makefiles.txt

@@ -18,7 +18,6 @@ run-make/cross-lang-lto-clang/Makefile
 run-make/cross-lang-lto-pgo-smoketest/Makefile
 run-make/cross-lang-lto-upstream-rlibs/Makefile
 run-make/cross-lang-lto/Makefile
-run-make/debug-assertions/Makefile
 run-make/dep-info-doesnt-run-much/Makefile
 run-make/dep-info-spaces/Makefile
 run-make/dep-info/Makefile
@@ -27,7 +26,6 @@ run-make/dump-mono-stats/Makefile
 run-make/dylib-chain/Makefile
 run-make/emit-path-unhashed/Makefile
 run-make/emit-shared-files/Makefile
-run-make/emit-stack-sizes/Makefile
 run-make/emit-to-stdout/Makefile
 run-make/env-dep-info/Makefile
 run-make/export-executable-symbols/Makefile
@@ -148,7 +146,6 @@ run-make/raw-dylib-link-ordinal/Makefile
 run-make/raw-dylib-stdcall-ordinal/Makefile
 run-make/redundant-libs/Makefile
 run-make/remap-path-prefix-dwarf/Makefile
-run-make/remap-path-prefix/Makefile
 run-make/reproducible-build-2/Makefile
 run-make/reproducible-build/Makefile
 run-make/return-non-c-like-enum-from-c/Makefile

tests/run-make/debug-assertions/debug.rs

@@ -1,15 +1,13 @@
+#![allow(internal_features)]
 #![feature(rustc_attrs)]
 #![deny(warnings)]
 
-use std::env;
 use std::thread;
 
 fn main() {
-    let should_fail = env::args().nth(1) == Some("bad".to_string());
-
-    assert_eq!(thread::spawn(debug_assert_eq).join().is_err(), should_fail);
-    assert_eq!(thread::spawn(debug_assert).join().is_err(), should_fail);
-    assert_eq!(thread::spawn(overflow).join().is_err(), should_fail);
+    assert!(thread::spawn(debug_assert_eq).join().is_ok());
+    assert!(thread::spawn(debug_assert).join().is_ok());
+    assert!(thread::spawn(overflow).join().is_ok());
 }
 
 fn debug_assert_eq() {

tests/run-make/debug-assertions/rmake.rs

@@ -0,0 +1,37 @@
+// debug.rs contains some "debug assertion" statements which
+// should only be enabled in either non-optimized builds or when
+// `-C debug-assertions` is set to yes. These debug assertions
+// are guaranteed to fail, so this test checks that the run command
+// fails where debug assertions should be activated, and succeeds where
+// debug assertions should be disabled.
+// See https://github.com/rust-lang/rust/pull/22980
+
+//@ ignore-cross-compile
+//@ needs-unwind
+
+use run_make_support::{run, run_fail, rustc};
+
+fn main() {
+    rustc().input("debug.rs").arg("-Cdebug-assertions=no").run();
+    run("debug");
+    rustc().input("debug.rs").opt_level("0").run();
+    run_fail("debug");
+    rustc().input("debug.rs").opt_level("1").run();
+    run("debug");
+    rustc().input("debug.rs").opt_level("2").run();
+    run("debug");
+    rustc().input("debug.rs").opt_level("3").run();
+    run("debug");
+    rustc().input("debug.rs").opt_level("s").run();
+    run("debug");
+    rustc().input("debug.rs").opt_level("z").run();
+    run("debug");
+    rustc().input("debug.rs").opt().run();
+    run("debug");
+    rustc().input("debug.rs").run();
+    run_fail("debug");
+    rustc().input("debug.rs").opt().arg("-Cdebug-assertions=yes").run();
+    run_fail("debug");
+    rustc().input("debug.rs").opt_level("1").arg("-Cdebug-assertions=yes").run();
+    run_fail("debug");
+}

tests/run-make/emit-stack-sizes/rmake.rs

@@ -0,0 +1,23 @@
+// Running rustc with the -Z emit-stack-sizes
+// flag enables diagnostics to seek stack overflows
+// at compile time. This test compiles a rust file
+// with this flag, then checks that the output object
+// file contains the section "stack_sizes", where
+// this diagnostics information should be located.
+// See https://github.com/rust-lang/rust/pull/51946
+
+//@ ignore-windows
+//@ ignore-apple
+// Reason: this feature only works when the output object format is ELF.
+// This won't be the case on Windows/OSX - for example, OSX produces a Mach-O binary.
+
+use run_make_support::{llvm_readobj, rustc};
+
+fn main() {
+    rustc().opt_level("3").arg("-Zemit-stack-sizes").emit("obj").input("foo.rs").run();
+    llvm_readobj()
+        .arg("--section-headers")
+        .input("foo.o")
+        .run()
+        .assert_stdout_contains(".stack_sizes");
+}

tests/run-make/remap-path-prefix/rmake.rs

@@ -0,0 +1,89 @@
+// Generating metadata alongside remap-path-prefix would fail to actually remap the path
+// in the metadata. After this was fixed in #85344, this test checks that "auxiliary" is being
+// successfully remapped to "/the/aux" in the rmeta files.
+// See https://github.com/rust-lang/rust/pull/85344
+
+// FIXME(Oneirical): check if works without ignore-windows
+
+use run_make_support::bstr::ByteSlice;
+use run_make_support::{bstr, fs_wrapper, is_darwin, rustc};
+
+fn main() {
+    let mut out_simple = rustc();
+    let mut out_object = rustc();
+    let mut out_macro = rustc();
+    let mut out_diagobj = rustc();
+    out_simple
+        .remap_path_prefix("auxiliary", "/the/aux")
+        .crate_type("lib")
+        .emit("metadata")
+        .input("auxiliary/lib.rs");
+    out_object
+        .remap_path_prefix("auxiliary", "/the/aux")
+        .crate_type("lib")
+        .emit("metadata")
+        .input("auxiliary/lib.rs");
+    out_macro
+        .remap_path_prefix("auxiliary", "/the/aux")
+        .crate_type("lib")
+        .emit("metadata")
+        .input("auxiliary/lib.rs");
+    out_diagobj
+        .remap_path_prefix("auxiliary", "/the/aux")
+        .crate_type("lib")
+        .emit("metadata")
+        .input("auxiliary/lib.rs");
+
+    out_simple.run();
+    rmeta_contains("/the/aux/lib.rs");
+    rmeta_not_contains("auxiliary");
+
+    out_object.arg("-Zremap-path-scope=object");
+    out_macro.arg("-Zremap-path-scope=macro");
+    out_diagobj.arg("-Zremap-path-scope=diagnostics,object");
+    if is_darwin() {
+        out_object.arg("-Csplit-debuginfo=off");
+        out_macro.arg("-Csplit-debuginfo=off");
+        out_diagobj.arg("-Csplit-debuginfo=off");
+    }
+
+    out_object.run();
+    rmeta_contains("/the/aux/lib.rs");
+    rmeta_not_contains("auxiliary");
+    out_macro.run();
+    rmeta_contains("/the/aux/lib.rs");
+    rmeta_not_contains("auxiliary");
+    out_diagobj.run();
+    rmeta_contains("/the/aux/lib.rs");
+    rmeta_not_contains("auxiliary");
+}
+
+//FIXME(Oneirical): These could be generalized into run_make_support
+// helper functions.
+fn rmeta_contains(expected: &str) {
+    // Normalize to account for path differences in Windows.
+    if !bstr::BString::from(fs_wrapper::read("liblib.rmeta"))
+        .replace(b"\\", b"/")
+        .contains_str(expected)
+    {
+        eprintln!("=== FILE CONTENTS (LOSSY) ===");
+        eprintln!("{}", String::from_utf8_lossy(&fs_wrapper::read("liblib.rmeta")));
+        eprintln!("=== SPECIFIED TEXT ===");
+        eprintln!("{}", expected);
+        panic!("specified text was not found in file");
+    }
+}
+
+fn rmeta_not_contains(expected: &str) {
+    // Normalize to account for path differences in Windows.
+    if bstr::BString::from(fs_wrapper::read("liblib.rmeta"))
+        .replace(b"\\", b"/")
+        .contains_str(expected)
+    {
+        eprintln!("=== FILE CONTENTS (LOSSY) ===");
+        eprintln!("{}", String::from_utf8_lossy(&fs_wrapper::read("liblib.rmeta")));
+        eprintln!("=== SPECIFIED TEXT ===");
+        eprintln!("{}", expected);
+        panic!("specified text was not found in file");
+    }
+}