Auto merge of #128356 - Oneirical:real-estate-reaLTOr, r=jieyouxu

Migrate `cross-lang-lto-clang` and `cross-lang-lto-pgo-smoketest` `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).

This has the same problem outlined by #126180, where the tests do not actually run as no test-running CI enviroment has `RUSTBUILD_FORCE_CLANG_BASED_TESTS` set.

However, I still find it interesting to turn the Makefiles into the rmake format until the Clang issue is fixed.

This should technically be tested on MSVC... if MSVC actually ran Clang tests.

try-job: x86_64-gnu-debug

src/tools/run-make-support/src/external_deps/clang.rs

@@ -1,7 +1,7 @@
 use std::path::Path;
 
 use crate::command::Command;
-use crate::{bin_name, env_var};
+use crate::{bin_name, cwd, env_var};
 
 /// Construct a new `clang` invocation. `clang` is not always available for all targets.
 #[track_caller]
@@ -23,7 +23,8 @@ impl Clang {
     #[track_caller]
     pub fn new() -> Self {
         let clang = env_var("CLANG");
-        let cmd = Command::new(clang);
+        let mut cmd = Command::new(clang);
+        cmd.arg("-L").arg(cwd());
         Self { cmd }
     }
 

src/tools/run-make-support/src/external_deps/llvm.rs

@@ -246,6 +246,12 @@ impl LlvmObjdump {
         self.cmd.arg(path.as_ref());
         self
     }
+
+    /// Disassemble all executable sections found in the input files.
+    pub fn disassemble(&mut self) -> &mut Self {
+        self.cmd.arg("-d");
+        self
+    }
 }
 
 impl LlvmAr {

src/tools/tidy/src/allowed_run_make_makefiles.txt

@@ -1,8 +1,6 @@
 run-make/branch-protection-check-IBT/Makefile
 run-make/cat-and-grep-sanity-check/Makefile
 run-make/cdylib-dylib-linkage/Makefile
-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/dep-info-doesnt-run-much/Makefile
 run-make/dep-info-spaces/Makefile

tests/run-make/cross-lang-lto-clang/Makefile

@@ -1,25 +0,0 @@
-# needs-force-clang-based-tests
-
-# This test makes sure that cross-language inlining actually works by checking
-# the generated machine code.
-
-include ../tools.mk
-
-all: cpp-executable rust-executable
-
-cpp-executable:
-	$(RUSTC) -Clinker-plugin-lto=on -o $(TMPDIR)/librustlib-xlto.a -Copt-level=2 -Ccodegen-units=1 ./rustlib.rs
-	$(CLANG) -flto=thin -fuse-ld=lld -L $(TMPDIR) -lrustlib-xlto -o $(TMPDIR)/cmain ./cmain.c -O3
-	# Make sure we don't find a call instruction to the function we expect to
-	# always be inlined.
-	"$(LLVM_BIN_DIR)"/llvm-objdump -d $(TMPDIR)/cmain | $(CGREP) -v -e "call.*rust_always_inlined"
-	# As a sanity check, make sure we do find a call instruction to a
-	# non-inlined function
-	"$(LLVM_BIN_DIR)"/llvm-objdump -d $(TMPDIR)/cmain | $(CGREP) -e "call.*rust_never_inlined"
-
-rust-executable:
-	$(CLANG) ./clib.c -flto=thin -c -o $(TMPDIR)/clib.o -O2
-	(cd $(TMPDIR); $(AR) crus ./libxyz.a ./clib.o)
-	$(RUSTC) -Clinker-plugin-lto=on -L$(TMPDIR) -Copt-level=2 -Clinker=$(CLANG) -Clink-arg=-fuse-ld=lld ./main.rs -o $(TMPDIR)/rsmain
-	"$(LLVM_BIN_DIR)"/llvm-objdump -d $(TMPDIR)/rsmain | $(CGREP) -e "call.*c_never_inlined"
-	"$(LLVM_BIN_DIR)"/llvm-objdump -d $(TMPDIR)/rsmain | $(CGREP) -v -e "call.*c_always_inlined"

tests/run-make/cross-lang-lto-clang/rmake.rs

@@ -0,0 +1,62 @@
+// This test checks that cross-language inlining actually works by checking
+// the generated machine code.
+// See https://github.com/rust-lang/rust/pull/57514
+
+//@ needs-force-clang-based-tests
+// NOTE(#126180): This test only runs on `x86_64-gnu-debug`, because that CI job sets
+// RUSTBUILD_FORCE_CLANG_BASED_TESTS and only runs tests which contain "clang" in their
+// name.
+
+use run_make_support::{clang, env_var, llvm_ar, llvm_objdump, rustc, static_lib_name};
+
+fn main() {
+    rustc()
+        .linker_plugin_lto("on")
+        .output(static_lib_name("rustlib-xlto"))
+        .opt_level("2")
+        .codegen_units(1)
+        .input("rustlib.rs")
+        .run();
+    clang()
+        .lto("thin")
+        .use_ld("lld")
+        .arg("-lrustlib-xlto")
+        .out_exe("cmain")
+        .input("cmain.c")
+        .arg("-O3")
+        .run();
+    // Make sure we don't find a call instruction to the function we expect to
+    // always be inlined.
+    llvm_objdump()
+        .disassemble()
+        .input("cmain")
+        .run()
+        .assert_stdout_not_contains_regex("call.*rust_always_inlined");
+    // As a sanity check, make sure we do find a call instruction to a
+    // non-inlined function
+    llvm_objdump()
+        .disassemble()
+        .input("cmain")
+        .run()
+        .assert_stdout_contains_regex("call.*rust_never_inlined");
+    clang().input("clib.c").lto("thin").arg("-c").out_exe("clib.o").arg("-O2").run();
+    llvm_ar().obj_to_ar().output_input(static_lib_name("xyz"), "clib.o").run();
+    rustc()
+        .linker_plugin_lto("on")
+        .opt_level("2")
+        .linker(&env_var("CLANG"))
+        .link_arg("-fuse-ld=lld")
+        .input("main.rs")
+        .output("rsmain")
+        .run();
+    llvm_objdump()
+        .disassemble()
+        .input("rsmain")
+        .run()
+        .assert_stdout_not_contains_regex("call.*c_always_inlined");
+    llvm_objdump()
+        .disassemble()
+        .input("rsmain")
+        .run()
+        .assert_stdout_contains_regex("call.*c_never_inlined");
+}

tests/run-make/cross-lang-lto-pgo-smoketest-clang/rmake.rs

@@ -0,0 +1,120 @@
+// This test makes sure that cross-language inlining can be used in conjunction
+// with profile-guided optimization. The test only tests that the whole workflow
+// can be executed without anything crashing. It does not test whether PGO or
+// xLTO have any specific effect on the generated code.
+// See https://github.com/rust-lang/rust/pull/61036
+
+//@ needs-force-clang-based-tests
+// NOTE(#126180): This test would only run on `x86_64-gnu-debug`, because that CI job sets
+// RUSTBUILD_FORCE_CLANG_BASED_TESTS and only runs tests which contain "clang" in their
+// name.
+
+//@ needs-profiler-support
+// FIXME(Oneirical): Except that due to the reliance on llvm-profdata, this test
+// never runs, because `x86_64-gnu-debug` does not have the `profiler_builtins` crate.
+
+//FIXME(Oneirical): There was a strange workaround for MSVC on this test
+// which added -C panic=abort to every RUSTC call. It was justified as follows:
+
+// "LLVM doesn't support instrumenting binaries that use SEH:
+// https://bugs.llvm.org/show_bug.cgi?id=41279
+// Things work fine with -Cpanic=abort though."
+
+// This isn't very pertinent, however, as the test does not get run on any
+// MSVC platforms.
+
+use run_make_support::{
+    clang, env_var, has_extension, has_prefix, llvm_ar, llvm_profdata, rfs, run, rustc,
+    shallow_find_files, static_lib_name,
+};
+
+fn main() {
+    rustc()
+        .linker_plugin_lto("on")
+        .output(static_lib_name("rustlib-xlto"))
+        .opt_level("3")
+        .codegen_units(1)
+        .input("rustlib.rs")
+        .arg("-Cprofile-generate=cpp-profdata")
+        .run();
+    clang()
+        .lto("thin")
+        .arg("-fprofile-generate=cpp-profdata")
+        .use_ld("lld")
+        .arg("-lrustlib-xlto")
+        .out_exe("cmain")
+        .input("cmain.c")
+        .arg("-O3")
+        .run();
+    run("cmain");
+    // Postprocess the profiling data so it can be used by the compiler
+    let profraw_files = shallow_find_files("cpp-profdata", |path| {
+        has_prefix(path, "default") && has_extension(path, "profraw")
+    });
+    let profraw_file = profraw_files.get(0).unwrap();
+    llvm_profdata().merge().output("cpp-profdata/merged.profdata").input(profraw_file).run();
+    rustc()
+        .linker_plugin_lto("on")
+        .profile_use("cpp-profdata/merged.profdata")
+        .output(static_lib_name("rustlib-xlto"))
+        .opt_level("3")
+        .codegen_units(1)
+        .input("rustlib.rs")
+        .run();
+    clang()
+        .lto("thin")
+        .arg("-fprofile-use=cpp-profdata/merged.profdata")
+        .use_ld("lld")
+        .arg("-lrustlib-xlto")
+        .out_exe("cmain")
+        .input("cmain.c")
+        .arg("-O3")
+        .run();
+
+    clang()
+        .input("clib.c")
+        .arg("-fprofile-generate=rs-profdata")
+        .lto("thin")
+        .arg("-c")
+        .out_exe("clib.o")
+        .arg("-O3")
+        .run();
+    llvm_ar().obj_to_ar().output_input(static_lib_name("xyz"), "clib.o").run();
+    rustc()
+        .linker_plugin_lto("on")
+        .opt_level("3")
+        .codegen_units(1)
+        .arg("-Cprofile-generate=rs-profdata")
+        .linker(&env_var("CLANG"))
+        .link_arg("-fuse-ld=lld")
+        .input("main.rs")
+        .output("rsmain")
+        .run();
+    run("rsmain");
+    // Postprocess the profiling data so it can be used by the compiler
+    let profraw_files = shallow_find_files("rs-profdata", |path| {
+        has_prefix(path, "default") && has_extension(path, "profraw")
+    });
+    let profraw_file = profraw_files.get(0).unwrap();
+    llvm_profdata().merge().output("rs-profdata/merged.profdata").input(profraw_file).run();
+    clang()
+        .input("clib.c")
+        .arg("-fprofile-use=rs-profdata/merged.profdata")
+        .arg("-c")
+        .lto("thin")
+        .out_exe("clib.o")
+        .arg("-O3")
+        .run();
+    rfs::remove_file(static_lib_name("xyz"));
+    llvm_ar().obj_to_ar().output_input(static_lib_name("xyz"), "clib.o").run();
+    rustc()
+        .linker_plugin_lto("on")
+        .opt_level("3")
+        .codegen_units(1)
+        .arg("-Cprofile-use=rs-profdata/merged.profdata")
+        .linker(&env_var("CLANG"))
+        .link_arg("-fuse-ld=lld")
+        .input("main.rs")
+        .output("rsmain")
+        .run();
+}

tests/run-make/cross-lang-lto-pgo-smoketest/Makefile

@@ -1,90 +0,0 @@
-# needs-force-clang-based-tests
-
-# FIXME(#126180): This test doesn't actually run anywhere, because the only
-# CI job that sets RUSTBUILD_FORCE_CLANG_BASED_TESTS runs very few tests.
-
-# This test makes sure that cross-language inlining can be used in conjunction
-# with profile-guided optimization. The test only tests that the whole workflow
-# can be executed without anything crashing. It does not test whether PGO or
-# xLTO have any specific effect on the generated code.
-
-include ../tools.mk
-
-COMMON_FLAGS=-Copt-level=3 -Ccodegen-units=1
-
-# LLVM doesn't support instrumenting binaries that use SEH:
-# https://bugs.llvm.org/show_bug.cgi?id=41279
-#
-# Things work fine with -Cpanic=abort though.
-ifdef IS_MSVC
-COMMON_FLAGS+= -Cpanic=abort
-endif
-
-all: cpp-executable rust-executable
-
-cpp-executable:
-	$(RUSTC) -Clinker-plugin-lto=on \
-	         -Cprofile-generate="$(TMPDIR)"/cpp-profdata \
-	         -o "$(TMPDIR)"/librustlib-xlto.a \
-	         $(COMMON_FLAGS) \
-	         ./rustlib.rs
-	$(CLANG) -flto=thin \
-	         -fprofile-generate="$(TMPDIR)"/cpp-profdata \
-	         -fuse-ld=lld \
-	         -L "$(TMPDIR)" \
-	         -lrustlib-xlto \
-	         -o "$(TMPDIR)"/cmain \
-	         -O3 \
-	         ./cmain.c
-	$(TMPDIR)/cmain
-	# Postprocess the profiling data so it can be used by the compiler
-	"$(LLVM_BIN_DIR)"/llvm-profdata merge \
-		-o "$(TMPDIR)"/cpp-profdata/merged.profdata \
-		"$(TMPDIR)"/cpp-profdata/default_*.profraw
-	$(RUSTC) -Clinker-plugin-lto=on \
-	         -Cprofile-use="$(TMPDIR)"/cpp-profdata/merged.profdata \
-	         -o "$(TMPDIR)"/librustlib-xlto.a \
-	         $(COMMON_FLAGS) \
-	         ./rustlib.rs
-	$(CLANG) -flto=thin \
-	         -fprofile-use="$(TMPDIR)"/cpp-profdata/merged.profdata \
-	         -fuse-ld=lld \
-	         -L "$(TMPDIR)" \
-	         -lrustlib-xlto \
-	         -o "$(TMPDIR)"/cmain \
-	         -O3 \
-	         ./cmain.c
-
-rust-executable:
-	exit
-	$(CLANG) ./clib.c -fprofile-generate="$(TMPDIR)"/rs-profdata -flto=thin -c -o $(TMPDIR)/clib.o -O3
-	(cd $(TMPDIR); $(AR) crus ./libxyz.a ./clib.o)
-	$(RUSTC) -Clinker-plugin-lto=on \
-	         -Cprofile-generate="$(TMPDIR)"/rs-profdata \
-	         -L$(TMPDIR) \
-	         $(COMMON_FLAGS) \
-	         -Clinker=$(CLANG) \
-	         -Clink-arg=-fuse-ld=lld \
-	         -o $(TMPDIR)/rsmain \
-	         ./main.rs
-	$(TMPDIR)/rsmain
-	# Postprocess the profiling data so it can be used by the compiler
-	"$(LLVM_BIN_DIR)"/llvm-profdata merge \
-		-o "$(TMPDIR)"/rs-profdata/merged.profdata \
-		"$(TMPDIR)"/rs-profdata/default_*.profraw
-	$(CLANG) ./clib.c \
-	         -fprofile-use="$(TMPDIR)"/rs-profdata/merged.profdata \
-	         -flto=thin \
-	         -c \
-	         -o $(TMPDIR)/clib.o \
-	         -O3
-	rm "$(TMPDIR)"/libxyz.a
-	(cd $(TMPDIR); $(AR) crus ./libxyz.a ./clib.o)
-	$(RUSTC) -Clinker-plugin-lto=on \
-	         -Cprofile-use="$(TMPDIR)"/rs-profdata/merged.profdata \
-	         -L$(TMPDIR) \
-	         $(COMMON_FLAGS) \
-	         -Clinker=$(CLANG) \
-	         -Clink-arg=-fuse-ld=lld \
-	         -o $(TMPDIR)/rsmain \
-	         ./main.rs

tests/run-make/cross-lang-lto-riscv-abi/rmake.rs

@@ -3,8 +3,11 @@
 //@ needs-force-clang-based-tests
 //@ needs-llvm-components riscv
 
-// FIXME(#126180): This test doesn't actually run anywhere, because the only
-// CI job that sets RUSTBUILD_FORCE_CLANG_BASED_TESTS runs very few tests.
+//@ needs-force-clang-based-tests
+// FIXME(#126180): This test can only run on `x86_64-gnu-debug`, because that CI job sets
+// RUSTBUILD_FORCE_CLANG_BASED_TESTS and only runs tests which contain "clang" in their
+// name.
+// However, this test does not run at all as its name does not contain "clang".
 
 use std::path::PathBuf;
 use std::process::{Command, Output};

tests/run-make/wasm-override-linker/rmake.rs

@@ -2,6 +2,10 @@
 // $ RUSTBUILD_FORCE_CLANG_BASED_TESTS=1 ./x.py test tests/run-make/wasm-override-linker/
 
 //@ needs-force-clang-based-tests
+// FIXME(#126180): This test can only run on `x86_64-gnu-debug`, because that CI job sets
+// RUSTBUILD_FORCE_CLANG_BASED_TESTS and only runs tests which contain "clang" in their
+// name.
+// However, this test does not run at all as its name does not contain "clang".
 
 use run_make_support::{env_var, rustc, target};