Rollup merge of rust-lang#126427 - Oneirical:oktobertest, r=jieyouxu

Rewrite `intrinsic-unreachable`, `sepcomp-cci-copies`, `sepcomp-inlining` and `sepcomp-separate` `run-make` tests to rmake.rs

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

Author: GuillaumeGomez

Cargo.lock

@@ -3476,6 +3476,7 @@ dependencies = [
  "object 0.34.0",
  "regex",
  "similar",
+ "walkdir",
  "wasmparser",
 ]
 

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

@@ -9,3 +9,4 @@ similar = "2.5.0"
 wasmparser = "0.118.2"
 regex = "1.8" # 1.8 to avoid memchr 2.6.0, as 2.5.0 is pinned in the workspace
 gimli = "0.28.1"
+walkdir = "2.5.0"

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

@@ -1,7 +1,7 @@
 use std::fs;
 use std::path::Path;
 
-/// A wrapper around [`std::fs::remove_file`] which includes the file path in the panic message..
+/// A wrapper around [`std::fs::remove_file`] which includes the file path in the panic message.
 #[track_caller]
 pub fn remove_file<P: AsRef<Path>>(path: P) {
     fs::remove_file(path.as_ref())
@@ -18,21 +18,28 @@ pub fn copy<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) {
     ));
 }
 
-/// A wrapper around [`std::fs::File::create`] which includes the file path in the panic message..
+/// A wrapper around [`std::fs::File::create`] which includes the file path in the panic message.
 #[track_caller]
 pub fn create_file<P: AsRef<Path>>(path: P) {
     fs::File::create(path.as_ref())
         .expect(&format!("the file in path \"{}\" could not be created", path.as_ref().display()));
 }
 
-/// A wrapper around [`std::fs::read`] which includes the file path in the panic message..
+/// A wrapper around [`std::fs::File::open`] which includes the file path in the panic message.
+#[track_caller]
+pub fn open_file<P: AsRef<Path>>(path: P) -> fs::File {
+    fs::File::open(path.as_ref())
+        .expect(&format!("the file in path \"{}\" could not be opened", path.as_ref().display()))
+}
+
+/// A wrapper around [`std::fs::read`] which includes the file path in the panic message.
 #[track_caller]
 pub fn read<P: AsRef<Path>>(path: P) -> Vec<u8> {
     fs::read(path.as_ref())
         .expect(&format!("the file in path \"{}\" could not be read", path.as_ref().display()))
 }
 
-/// A wrapper around [`std::fs::read_to_string`] which includes the file path in the panic message..
+/// A wrapper around [`std::fs::read_to_string`] which includes the file path in the panic message.
 #[track_caller]
 pub fn read_to_string<P: AsRef<Path>>(path: P) -> String {
     fs::read_to_string(path.as_ref()).expect(&format!(
@@ -41,14 +48,14 @@ pub fn read_to_string<P: AsRef<Path>>(path: P) -> String {
     ))
 }
 
-/// A wrapper around [`std::fs::read_dir`] which includes the file path in the panic message..
+/// A wrapper around [`std::fs::read_dir`] which includes the file path in the panic message.
 #[track_caller]
 pub fn read_dir<P: AsRef<Path>>(path: P) -> fs::ReadDir {
     fs::read_dir(path.as_ref())
         .expect(&format!("the directory in path \"{}\" could not be read", path.as_ref().display()))
 }
 
-/// A wrapper around [`std::fs::write`] which includes the file path in the panic message..
+/// A wrapper around [`std::fs::write`] which includes the file path in the panic message.
 #[track_caller]
 pub fn write<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) {
     fs::write(path.as_ref(), contents.as_ref()).expect(&format!(
@@ -57,7 +64,7 @@ pub fn write<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) {
     ));
 }
 
-/// A wrapper around [`std::fs::remove_dir_all`] which includes the file path in the panic message..
+/// A wrapper around [`std::fs::remove_dir_all`] which includes the file path in the panic message.
 #[track_caller]
 pub fn remove_dir_all<P: AsRef<Path>>(path: P) {
     fs::remove_dir_all(path.as_ref()).expect(&format!(
@@ -66,7 +73,7 @@ pub fn remove_dir_all<P: AsRef<Path>>(path: P) {
     ));
 }
 
-/// A wrapper around [`std::fs::create_dir`] which includes the file path in the panic message..
+/// A wrapper around [`std::fs::create_dir`] which includes the file path in the panic message.
 #[track_caller]
 pub fn create_dir<P: AsRef<Path>>(path: P) {
     fs::create_dir(path.as_ref()).expect(&format!(
@@ -75,7 +82,7 @@ pub fn create_dir<P: AsRef<Path>>(path: P) {
     ));
 }
 
-/// A wrapper around [`std::fs::create_dir_all`] which includes the file path in the panic message..
+/// A wrapper around [`std::fs::create_dir_all`] which includes the file path in the panic message.
 #[track_caller]
 pub fn create_dir_all<P: AsRef<Path>>(path: P) {
     fs::create_dir_all(path.as_ref()).expect(&format!(
@@ -84,7 +91,7 @@ pub fn create_dir_all<P: AsRef<Path>>(path: P) {
     ));
 }
 
-/// A wrapper around [`std::fs::metadata`] which includes the file path in the panic message..
+/// A wrapper around [`std::fs::metadata`] which includes the file path in the panic message.
 #[track_caller]
 pub fn metadata<P: AsRef<Path>>(path: P) -> fs::Metadata {
     fs::metadata(path.as_ref()).expect(&format!(

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

@@ -24,6 +24,7 @@ use std::path::{Path, PathBuf};
 pub use gimli;
 pub use object;
 pub use regex;
+pub use walkdir;
 pub use wasmparser;
 
 pub use cc::{cc, extra_c_flags, extra_cxx_flags, Cc};
@@ -277,6 +278,39 @@ pub fn uname() -> String {
     output.stdout_utf8()
 }
 
+/// Search for all files in the current working directory with the extension `ext`,
+/// read their contents and count the
+/// number of regex matches with a given expression (re).
+#[track_caller]
+pub fn count_regex_matches_in_files_with_extension(re: &regex::Regex, ext: &str) -> usize {
+    use std::io::BufRead;
+    use walkdir::{DirEntry, WalkDir};
+
+    let walker = WalkDir::new(cwd()).into_iter();
+
+    fn is_hidden(entry: &DirEntry) -> bool {
+        entry.file_name().to_str().map(|s| s.starts_with(".")).unwrap_or(false)
+    }
+
+    let mut count = 0;
+
+    for entry in walker.filter_entry(|e| !is_hidden(e)) {
+        let entry = entry.expect("failed to get DirEntry");
+        if !entry.path().is_file() {
+            continue;
+        }
+
+        if !entry.path().extension().is_some_and(|e| e == ext) {
+            continue;
+        }
+
+        let content = fs_wrapper::read(entry.path());
+        count += content.lines().filter(|line| re.is_match(&line.as_ref().unwrap())).count();
+    }
+
+    count
+}
+
 fn handle_failed_output(cmd: &Command, output: CompletedProcess, caller_line_number: u32) -> ! {
     if output.status().success() {
         eprintln!("command unexpectedly succeeded at line {caller_line_number}");

src/tools/tidy/src/allowed_run_make_makefiles.txt

@@ -64,7 +64,6 @@ run-make/incr-add-rust-src-component/Makefile
 run-make/incr-foreign-head-span/Makefile
 run-make/inline-always-many-cgu/Makefile
 run-make/interdependent-c-libraries/Makefile
-run-make/intrinsic-unreachable/Makefile
 run-make/invalid-library/Makefile
 run-make/invalid-so/Makefile
 run-make/issue-107094/Makefile
@@ -187,9 +186,6 @@ run-make/sanitizer-dylib-link/Makefile
 run-make/sanitizer-staticlib-link/Makefile
 run-make/separate-link-fail/Makefile
 run-make/separate-link/Makefile
-run-make/sepcomp-cci-copies/Makefile
-run-make/sepcomp-inlining/Makefile
-run-make/sepcomp-separate/Makefile
 run-make/share-generics-dylib/Makefile
 run-make/silly-file-names/Makefile
 run-make/simd-ffi/Makefile

tests/run-make/intrinsic-unreachable/Makefile

@@ -0,0 +1,22 @@
+// intrinsics::unreachable tells the compiler that a certain point in the code
+// is not reachable by any means, which enables some useful optimizations.
+// In this test, exit-unreachable contains this instruction and exit-ret does not,
+// which means the emitted artifacts should be shorter in length.
+// See https://github.com/rust-lang/rust/pull/16970
+
+//@ needs-asm-support
+//@ ignore-windows
+// Reason: Because of Windows exception handling, the code is not necessarily any shorter.
+
+use run_make_support::{fs_wrapper, rustc};
+use std::io::{BufRead, BufReader};
+
+fn main() {
+    rustc().opt().emit("asm").input("exit-ret.rs").run();
+    rustc().opt().emit("asm").input("exit-unreachable.rs").run();
+    let unreachable_file = fs_wrapper::open_file("exit-unreachable.s");
+    let ret_file = fs_wrapper::open_file("exit-ret.s");
+    assert!(
+        BufReader::new(unreachable_file).lines().count() < BufReader::new(ret_file).lines().count()
+    );
+}

tests/run-make/intrinsic-unreachable/rmake.rs

@@ -0,0 +1,14 @@
+// Check that cross-crate inlined items are inlined in all compilation units
+// that refer to them, and not in any other compilation units.
+// Note that we have to pass `-C codegen-units=6` because up to two CGUs may be
+// created for each source module (see `rustc_const_eval::monomorphize::partitioning`).
+// See https://github.com/rust-lang/rust/pull/16367
+
+use run_make_support::{count_regex_matches_in_files_with_extension, regex, rustc};
+
+fn main() {
+    rustc().input("cci_lib.rs").run();
+    rustc().input("foo.rs").emit("llvm-ir").codegen_units(6).arg("-Zinline-in-all-cgus").run();
+    let re = regex::Regex::new(r#"define\ .*cci_fn"#).unwrap();
+    assert_eq!(count_regex_matches_in_files_with_extension(&re, "ll"), 2);
+}

tests/run-make/sepcomp-cci-copies/Makefile

@@ -0,0 +1,20 @@
+// Test that #[inline] functions still get inlined across compilation unit
+// boundaries. Compilation should produce three IR files, but only the two
+// compilation units that have a usage of the #[inline] function should
+// contain a definition. Also, the non-#[inline] function should be defined
+// in only one compilation unit.
+// See https://github.com/rust-lang/rust/pull/16367
+
+use run_make_support::{count_regex_matches_in_files_with_extension, regex, rustc};
+
+fn main() {
+    rustc().input("foo.rs").emit("llvm-ir").codegen_units(3).arg("-Zinline-in-all-cgus").run();
+    let re = regex::Regex::new(r#"define\ i32\ .*inlined"#).unwrap();
+    assert_eq!(count_regex_matches_in_files_with_extension(&re, "ll"), 0);
+    let re = regex::Regex::new(r#"define\ internal\ .*inlined"#).unwrap();
+    assert_eq!(count_regex_matches_in_files_with_extension(&re, "ll"), 2);
+    let re = regex::Regex::new(r#"define\ hidden\ i32\ .*normal"#).unwrap();
+    assert_eq!(count_regex_matches_in_files_with_extension(&re, "ll"), 1);
+    let re = regex::Regex::new(r#"declare\ hidden\ i32\ .*normal"#).unwrap();
+    assert_eq!(count_regex_matches_in_files_with_extension(&re, "ll"), 2);
+}

tests/run-make/sepcomp-cci-copies/rmake.rs

@@ -0,0 +1,12 @@
+// Test that separate compilation actually puts code into separate compilation
+// units.  `foo.rs` defines `magic_fn` in three different modules, which should
+// wind up in three different compilation units.
+// See https://github.com/rust-lang/rust/pull/16367
+
+use run_make_support::{count_regex_matches_in_files_with_extension, regex, rustc};
+
+fn main() {
+    rustc().input("foo.rs").emit("llvm-ir").codegen_units(3).run();
+    let re = regex::Regex::new(r#"define\ .*magic_fn"#).unwrap();
+    assert_eq!(count_regex_matches_in_files_with_extension(&re, "ll"), 3);
+}