Auto merge of #126957 - Oneirical:artestic-inspiration, r=jieyouxu,ko…

…bzol

Migrate `pgo-gen`, `pgo-use` and `profile` `run-make` tests to rmake.rs

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

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

src/tools/tidy/src/allowed_run_make_makefiles.txt

@@ -109,13 +109,10 @@ run-make/pass-non-c-like-enum-to-c/Makefile
 run-make/pdb-buildinfo-cl-cmd/Makefile
 run-make/pgo-gen-lto/Makefile
 run-make/pgo-gen-no-imp-symbols/Makefile
-run-make/pgo-gen/Makefile
 run-make/pgo-indirect-call-promotion/Makefile
-run-make/pgo-use/Makefile
 run-make/pointer-auth-link-with-c/Makefile
 run-make/print-calling-conventions/Makefile
 run-make/print-target-list/Makefile
-run-make/profile/Makefile
 run-make/prune-link-args/Makefile
 run-make/raw-dylib-alt-calling-convention/Makefile
 run-make/raw-dylib-c/Makefile

tests/run-make/pgo-gen/rmake.rs

@@ -0,0 +1,18 @@
+// -C profile-generate, when used with rustc, is supposed to output
+// profile files (.profraw) after running a binary to analyze how the compiler
+// optimizes code. This test checks that these files are generated.
+// See https://github.com/rust-lang/rust/pull/48346
+
+//@ needs-profiler-support
+//@ ignore-cross-compile
+
+use run_make_support::{cwd, has_extension, has_prefix, run, rustc, shallow_find_files};
+
+fn main() {
+    rustc().arg("-g").profile_generate(cwd()).input("test.rs").run();
+    run("test");
+    let profraw_files = shallow_find_files(cwd(), |path| {
+        has_prefix(path, "default") && has_extension(path, "profraw")
+    });
+    assert!(!profraw_files.is_empty(), "no .profraw file generated");
+}

tests/run-make/pgo-use/rmake.rs

@@ -0,0 +1,55 @@
+// This test makes sure that PGO profiling data leads to cold functions being
+// marked as `cold` and hot functions with `inlinehint`.
+// The test program contains an `if` where actual execution only ever takes the
+// `else` branch. Accordingly, we expect the function that is never called to
+// be marked as cold.
+// See https://github.com/rust-lang/rust/pull/60262
+
+//@ needs-profiler-support
+//@ ignore-cross-compile
+
+use run_make_support::{
+    cwd, fs_wrapper, has_extension, has_prefix, llvm_filecheck, llvm_profdata, run_with_args,
+    rustc, shallow_find_files,
+};
+
+fn main() {
+    // Compile the test program with instrumentation
+    // Disable the pre-inlining pass (i.e. a pass that does some inlining before
+    // it adds the profiling instrumentation). Disabling this pass leads to
+    // rather predictable IR which we need for this test to be stable.
+    rustc()
+        .opt_level("2")
+        .codegen_units(1)
+        .arg("-Cllvm-args=-disable-preinline")
+        .profile_generate(cwd())
+        .input("main.rs")
+        .run();
+    // Run it in order to generate some profiling data
+    run_with_args("main", &["some-argument"]);
+    // Postprocess the profiling data so it can be used by the compiler
+    let profraw_files = shallow_find_files(cwd(), |path| {
+        has_prefix(path, "default") && has_extension(path, "profraw")
+    });
+    let profraw_file = profraw_files.get(0).unwrap();
+    llvm_profdata().merge().output("merged.profdata").input(profraw_file).run();
+    // Compile the test program again, making use of the profiling data
+    rustc()
+        .opt_level("2")
+        .codegen_units(1)
+        .arg("-Cllvm-args=-disable-preinline")
+        .profile_use("merged.profdata")
+        .emit("llvm-ir")
+        .input("main.rs")
+        .run();
+    // Check that the generate IR contains some things that we expect.
+    // We feed the file into LLVM FileCheck tool *with its lines reversed* so that we see the
+    // line with the function name before the line with the function attributes.
+    // FileCheck only supports checking that something matches on the next line,
+    // but not if something matches on the previous line.
+    let ir = fs_wrapper::read_to_string("main.ll");
+    let lines: Vec<_> = ir.lines().rev().collect();
+    let mut reversed_ir = lines.join("\n");
+    reversed_ir.push('\n');
+    llvm_filecheck().patterns("filecheck-patterns.txt").stdin(reversed_ir.as_bytes()).run();
+}

tests/run-make/profile/rmake.rs

@@ -0,0 +1,22 @@
+// This test revolves around the rustc flag -Z profile, which should
+// generate a .gcno file (initial profiling information) as well
+// as a .gcda file (branch counters). The path where these are emitted
+// should also be configurable with -Z profile-emit. This test checks
+// that the files are produced, and then that the latter flag is respected.
+// See https://github.com/rust-lang/rust/pull/42433
+
+//@ ignore-cross-compile
+//@ needs-profiler-support
+
+use run_make_support::{run, rustc};
+use std::path::Path;
+
+fn main() {
+    rustc().arg("-g").arg("-Zprofile").input("test.rs").run();
+    run("test");
+    assert!(Path::new("test.gcno").exists(), "no .gcno file");
+    assert!(Path::new("test.gcda").exists(), "no .gcda file");
+    rustc().arg("-g").arg("-Zprofile").arg("-Zprofile-emit=abc/abc.gcda").input("test.rs").run();
+    run("test");
+    assert!(Path::new("abc/abc.gcda").exists(), "gcda file not emitted to defined path");
+}