Merging upstream version 1.66.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 85 insertions, 94 deletions

diff --git a/compiler/rustc_codegen_cranelift/build_system/tests.rs b/compiler/rustc_codegen_cranelift/build_system/tests.rs
index e21397cec..a414b60f4 100644
--- a/compiler/rustc_codegen_cranelift/build_system/tests.rs
+++ b/compiler/rustc_codegen_cranelift/build_system/tests.rs
@@ -1,7 +1,8 @@
 use super::build_sysroot;
 use super::config;
+use super::prepare;
 use super::rustc_info::get_wrapper_file_name;
-use super::utils::{spawn_and_wait, spawn_and_wait_with_input};
+use super::utils::{cargo_command, hyperfine_command, spawn_and_wait, spawn_and_wait_with_input};
 use build_system::SysrootKind;
 use std::env;
 use std::ffi::OsStr;
@@ -217,103 +218,95 @@ const BASE_SYSROOT_SUITE: &[TestCase] = &[
 
 const EXTENDED_SYSROOT_SUITE: &[TestCase] = &[
     TestCase::new("test.rust-random/rand", &|runner| {
-        runner.in_dir(["rand"], |runner| {
-            runner.run_cargo(["clean"]);
+        runner.in_dir(prepare::RAND.source_dir(), |runner| {
+            runner.run_cargo("clean", []);
 
             if runner.host_triple == runner.target_triple {
                 eprintln!("[TEST] rust-random/rand");
-                runner.run_cargo(["test", "--workspace"]);
+                runner.run_cargo("test", ["--workspace"]);
             } else {
                 eprintln!("[AOT] rust-random/rand");
-                runner.run_cargo([
-                    "build",
-                    "--workspace",
-                    "--target",
-                    &runner.target_triple,
-                    "--tests",
-                ]);
+                runner.run_cargo("build", ["--workspace", "--tests"]);
             }
         });
     }),
     TestCase::new("bench.simple-raytracer", &|runner| {
-        runner.in_dir(["simple-raytracer"], |runner| {
-            let run_runs = env::var("RUN_RUNS").unwrap_or("10".to_string());
+        runner.in_dir(prepare::SIMPLE_RAYTRACER.source_dir(), |runner| {
+            let run_runs = env::var("RUN_RUNS").unwrap_or("10".to_string()).parse().unwrap();
 
             if runner.host_triple == runner.target_triple {
                 eprintln!("[BENCH COMPILE] ebobby/simple-raytracer");
-                let mut bench_compile = Command::new("hyperfine");
-                bench_compile.arg("--runs");
-                bench_compile.arg(&run_runs);
-                bench_compile.arg("--warmup");
-                bench_compile.arg("1");
-                bench_compile.arg("--prepare");
-                bench_compile.arg(format!("{:?}", runner.cargo_command(["clean"])));
-
-                if cfg!(windows) {
-                    bench_compile.arg("cmd /C \"set RUSTFLAGS= && cargo build\"");
-                } else {
-                    bench_compile.arg("RUSTFLAGS='' cargo build");
-                }
+                let prepare = runner.cargo_command("clean", []);
+
+                let llvm_build_cmd = cargo_command("cargo", "build", None, Path::new("."));
+
+                let cargo_clif = runner
+                    .root_dir
+                    .clone()
+                    .join("build")
+                    .join(get_wrapper_file_name("cargo-clif", "bin"));
+                let clif_build_cmd = cargo_command(cargo_clif, "build", None, Path::new("."));
+
+                let bench_compile =
+                    hyperfine_command(1, run_runs, Some(prepare), llvm_build_cmd, clif_build_cmd);
 
-                bench_compile.arg(format!("{:?}", runner.cargo_command(["build"])));
                 spawn_and_wait(bench_compile);
 
                 eprintln!("[BENCH RUN] ebobby/simple-raytracer");
                 fs::copy(PathBuf::from("./target/debug/main"), PathBuf::from("raytracer_cg_clif"))
                     .unwrap();
 
-                let mut bench_run = Command::new("hyperfine");
-                bench_run.arg("--runs");
-                bench_run.arg(&run_runs);
-                bench_run.arg(PathBuf::from("./raytracer_cg_llvm"));
-                bench_run.arg(PathBuf::from("./raytracer_cg_clif"));
+                let bench_run = hyperfine_command(
+                    0,
+                    run_runs,
+                    None,
+                    Command::new("./raytracer_cg_llvm"),
+                    Command::new("./raytracer_cg_clif"),
+                );
                 spawn_and_wait(bench_run);
             } else {
-                runner.run_cargo(["clean"]);
+                runner.run_cargo("clean", []);
                 eprintln!("[BENCH COMPILE] ebobby/simple-raytracer (skipped)");
                 eprintln!("[COMPILE] ebobby/simple-raytracer");
-                runner.run_cargo(["build", "--target", &runner.target_triple]);
+                runner.run_cargo("build", []);
                 eprintln!("[BENCH RUN] ebobby/simple-raytracer (skipped)");
             }
         });
     }),
     TestCase::new("test.libcore", &|runner| {
-        runner.in_dir(["build_sysroot", "sysroot_src", "library", "core", "tests"], |runner| {
-            runner.run_cargo(["clean"]);
-
-            if runner.host_triple == runner.target_triple {
-                runner.run_cargo(["test"]);
-            } else {
-                eprintln!("Cross-Compiling: Not running tests");
-                runner.run_cargo(["build", "--target", &runner.target_triple, "--tests"]);
-            }
-        });
+        runner.in_dir(
+            std::env::current_dir()
+                .unwrap()
+                .join("build_sysroot")
+                .join("sysroot_src")
+                .join("library")
+                .join("core")
+                .join("tests"),
+            |runner| {
+                runner.run_cargo("clean", []);
+
+                if runner.host_triple == runner.target_triple {
+                    runner.run_cargo("test", []);
+                } else {
+                    eprintln!("Cross-Compiling: Not running tests");
+                    runner.run_cargo("build", ["--tests"]);
+                }
+            },
+        );
     }),
     TestCase::new("test.regex-shootout-regex-dna", &|runner| {
-        runner.in_dir(["regex"], |runner| {
-            runner.run_cargo(["clean"]);
+        runner.in_dir(prepare::REGEX.source_dir(), |runner| {
+            runner.run_cargo("clean", []);
 
             // newer aho_corasick versions throw a deprecation warning
             let lint_rust_flags = format!("{} --cap-lints warn", runner.rust_flags);
 
-            let mut build_cmd = runner.cargo_command([
-                "build",
-                "--example",
-                "shootout-regex-dna",
-                "--target",
-                &runner.target_triple,
-            ]);
+            let mut build_cmd = runner.cargo_command("build", ["--example", "shootout-regex-dna"]);
             build_cmd.env("RUSTFLAGS", lint_rust_flags.clone());
             spawn_and_wait(build_cmd);
 
             if runner.host_triple == runner.target_triple {
-                let mut run_cmd = runner.cargo_command([
-                    "run",
-                    "--example",
-                    "shootout-regex-dna",
-                    "--target",
-                    &runner.target_triple,
-                ]);
+                let mut run_cmd = runner.cargo_command("run", ["--example", "shootout-regex-dna"]);
                 run_cmd.env("RUSTFLAGS", lint_rust_flags);
 
                 let input =
@@ -353,41 +346,43 @@ const EXTENDED_SYSROOT_SUITE: &[TestCase] = &[
         });
     }),
     TestCase::new("test.regex", &|runner| {
-        runner.in_dir(["regex"], |runner| {
-            runner.run_cargo(["clean"]);
+        runner.in_dir(prepare::REGEX.source_dir(), |runner| {
+            runner.run_cargo("clean", []);
 
             // newer aho_corasick versions throw a deprecation warning
             let lint_rust_flags = format!("{} --cap-lints warn", runner.rust_flags);
 
             if runner.host_triple == runner.target_triple {
-                let mut run_cmd = runner.cargo_command([
+                let mut run_cmd = runner.cargo_command(
                     "test",
-                    "--tests",
-                    "--",
-                    "--exclude-should-panic",
-                    "--test-threads",
-                    "1",
-                    "-Zunstable-options",
-                    "-q",
-                ]);
+                    [
+                        "--tests",
+                        "--",
+                        "--exclude-should-panic",
+                        "--test-threads",
+                        "1",
+                        "-Zunstable-options",
+                        "-q",
+                    ],
+                );
                 run_cmd.env("RUSTFLAGS", lint_rust_flags);
                 spawn_and_wait(run_cmd);
             } else {
                 eprintln!("Cross-Compiling: Not running tests");
                 let mut build_cmd =
-                    runner.cargo_command(["build", "--tests", "--target", &runner.target_triple]);
+                    runner.cargo_command("build", ["--tests", "--target", &runner.target_triple]);
                 build_cmd.env("RUSTFLAGS", lint_rust_flags.clone());
                 spawn_and_wait(build_cmd);
             }
         });
     }),
     TestCase::new("test.portable-simd", &|runner| {
-        runner.in_dir(["portable-simd"], |runner| {
-            runner.run_cargo(["clean"]);
-            runner.run_cargo(["build", "--all-targets", "--target", &runner.target_triple]);
+        runner.in_dir(prepare::PORTABLE_SIMD.source_dir(), |runner| {
+            runner.run_cargo("clean", []);
+            runner.run_cargo("build", ["--all-targets", "--target", &runner.target_triple]);
 
             if runner.host_triple == runner.target_triple {
-                runner.run_cargo(["test", "-q"]);
+                runner.run_cargo("test", ["-q"]);
             }
         });
     }),
@@ -397,7 +392,7 @@ pub(crate) fn run_tests(
     channel: &str,
     sysroot_kind: SysrootKind,
     target_dir: &Path,
-    cg_clif_build_dir: &Path,
+    cg_clif_dylib: &Path,
     host_triple: &str,
     target_triple: &str,
 ) {
@@ -408,7 +403,7 @@ pub(crate) fn run_tests(
             channel,
             SysrootKind::None,
             &target_dir,
-            cg_clif_build_dir,
+            cg_clif_dylib,
             &host_triple,
             &target_triple,
         );
@@ -427,7 +422,7 @@ pub(crate) fn run_tests(
             channel,
             sysroot_kind,
             &target_dir,
-            cg_clif_build_dir,
+            cg_clif_dylib,
             &host_triple,
             &target_triple,
         );
@@ -521,16 +516,8 @@ impl TestRunner {
         }
     }
 
-    fn in_dir<'a, I, F>(&self, dir: I, callback: F)
-    where
-        I: IntoIterator<Item = &'a str>,
-        F: FnOnce(&TestRunner),
-    {
+    fn in_dir(&self, new: impl AsRef<Path>, callback: impl FnOnce(&TestRunner)) {
         let current = env::current_dir().unwrap();
-        let mut new = current.clone();
-        for d in dir {
-            new.push(d);
-        }
 
         env::set_current_dir(new).unwrap();
         callback(self);
@@ -595,25 +582,29 @@ impl TestRunner {
         spawn_and_wait(cmd);
     }
 
-    fn cargo_command<I, S>(&self, args: I) -> Command
+    fn cargo_command<'a, I>(&self, subcommand: &str, args: I) -> Command
     where
-        I: IntoIterator<Item = S>,
-        S: AsRef<OsStr>,
+        I: IntoIterator<Item = &'a str>,
     {
         let mut cargo_clif = self.root_dir.clone();
         cargo_clif.push("build");
         cargo_clif.push(get_wrapper_file_name("cargo-clif", "bin"));
 
-        let mut cmd = Command::new(cargo_clif);
+        let mut cmd = cargo_command(
+            cargo_clif,
+            subcommand,
+            if subcommand == "clean" { None } else { Some(&self.target_triple) },
+            Path::new("."),
+        );
         cmd.args(args);
         cmd.env("RUSTFLAGS", &self.rust_flags);
         cmd
     }
 
-    fn run_cargo<'a, I>(&self, args: I)
+    fn run_cargo<'a, I>(&self, subcommand: &str, args: I)
     where
         I: IntoIterator<Item = &'a str>,
     {
-        spawn_and_wait(self.cargo_command(args));
+        spawn_and_wait(self.cargo_command(subcommand, args));
     }
 }