tests: port symbol-mangling-hashed to rmake.rs

- Use `object` based test logic instead of processing `nm`
  human-readable textual output.
- Try to expand test coverage to not be limited to only linux + x86_64.

Co-authored-by: binarycat <[email protected]>

Author: jieyouxu

src/tools/tidy/src/allowed_run_make_makefiles.txt

@@ -1,5 +1,4 @@
 run-make/cat-and-grep-sanity-check/Makefile
 run-make/jobserver-error/Makefile
 run-make/split-debuginfo/Makefile
-run-make/symbol-mangling-hashed/Makefile
 run-make/translation/Makefile

tests/run-make/symbol-mangling-hashed/Makefile

@@ -0,0 +1,123 @@
+// ignore-tidy-linelength
+//! Basic smoke test for the unstable option `-C symbol_mangling_version=hashed` which aims to
+//! replace full symbol mangling names based on hash digests to shorten symbol name lengths in
+//! dylibs for space savings.
+//!
+//! # References
+//!
+//! - MCP #705: Provide option to shorten symbol names by replacing them with a digest:
+//!   <https://github.com/rust-lang/compiler-team/issues/705>.
+//! - Implementation PR: <https://github.com/rust-lang/rust/pull/118636>.
+//! - PE format: <https://learn.microsoft.com/en-us/windows/win32/debug/pe-format>.
+
+//@ ignore-cross-compile
+
+#![deny(warnings)]
+
+use run_make_support::symbols::exported_dynamic_symbol_names;
+use run_make_support::{bin_name, cwd, dynamic_lib_name, is_darwin, object, rfs, rustc};
+
+fn main() {
+    rustc()
+        .input("a_dylib.rs")
+        .prefer_dynamic()
+        .arg("-Zunstable-options")
+        .symbol_mangling_version("hashed")
+        .metadata("foo")
+        .run();
+
+    rustc()
+        .input("a_rlib.rs")
+        .prefer_dynamic()
+        .arg("-Zunstable-options")
+        .symbol_mangling_version("hashed")
+        .metadata("bar")
+        .run();
+
+    rustc().input("b_dylib.rs").library_search_path(cwd()).prefer_dynamic().run();
+    rustc().input("b_bin.rs").library_search_path(cwd()).prefer_dynamic().run();
+
+    // Check hashed symbol name
+
+    {
+        let dylib_filename = dynamic_lib_name("a_dylib");
+        println!("checking dylib `{dylib_filename}`");
+
+        let dylib_blob = rfs::read(&dylib_filename);
+        let dylib_file = object::File::parse(&*dylib_blob)
+            .unwrap_or_else(|e| panic!("failed to parse `{dylib_filename}`: {e}"));
+
+        let dynamic_symbols = exported_dynamic_symbol_names(&dylib_file);
+
+        if dynamic_symbols.iter().filter(|sym| sym.contains("hello")).count() != 0 {
+            eprintln!("exported dynamic symbols: {:#?}", dynamic_symbols);
+            panic!("expected no occurrence of `hello`");
+        }
+
+        let expected_prefix = if is_darwin() { "__RNxC7a_dylib" } else { "_RNxC7a_dylib" };
+        if dynamic_symbols.iter().filter(|sym| sym.starts_with(expected_prefix)).count() != 2 {
+            eprintln!("exported dynamic symbols: {:#?}", dynamic_symbols);
+            panic!("expected two dynamic symbols starting with `{expected_prefix}`");
+        }
+    }
+
+    {
+        let so_filename = dynamic_lib_name("b_dylib");
+        println!("checking so `{so_filename}`");
+
+        let so_blob = rfs::read(&so_filename);
+        let so_file = object::File::parse(&*so_blob)
+            .unwrap_or_else(|e| panic!("failed to parse `{so_filename}`: {e}"));
+
+        let dynamic_symbols = exported_dynamic_symbol_names(&so_file);
+
+        if dynamic_symbols
+            .iter()
+            .filter(|sym| sym.contains("b_dylib") && sym.contains("hello"))
+            .count()
+            != 1
+        {
+            eprintln!("exported dynamic symbols: {:#?}", dynamic_symbols);
+            panic!("expected one occurrence of mangled `hello`");
+        }
+
+        let expected_rlib_prefix = if is_darwin() { "__RNxC6a_rlib" } else { "_RNxC6a_rlib" };
+        if dynamic_symbols.iter().filter(|sym| sym.starts_with(expected_rlib_prefix)).count() != 2 {
+            eprintln!("exported dynamic symbols: {:#?}", dynamic_symbols);
+            panic!("expected two exported symbols starting with `{expected_rlib_prefix}`");
+        }
+
+        let expected_dylib_prefix = if is_darwin() { "__RNxC7a_dylib" } else { "_RNxC7a_dylib" };
+        if dynamic_symbols.iter().any(|sym| sym.starts_with("_RNxC7a_dylib")) {
+            eprintln!("exported dynamic symbols: {:#?}", dynamic_symbols);
+            panic!("did not expect any symbols starting with `{expected_dylib_prefix}`");
+        }
+    }
+
+    {
+        let bin_filename = bin_name("b_bin");
+        println!("checking bin `{bin_filename}`");
+
+        let bin_blob = rfs::read(&bin_filename);
+        let bin_file = object::File::parse(&*bin_blob)
+            .unwrap_or_else(|e| panic!("failed to parse `{bin_filename}`: {e}"));
+
+        let dynamic_symbols = exported_dynamic_symbol_names(&bin_file);
+
+        let expected_rlib_prefix = if is_darwin() { "__RNxC6a_rlib" } else { "_RNxC6a_rlib" };
+        let expected_dylib_prefix = if is_darwin() { "__RNxC7a_dylib" } else { "_RNxC7a_dylib" };
+        if dynamic_symbols.iter().any(|sym| {
+            sym.starts_with(expected_rlib_prefix)
+                || sym.starts_with(expected_dylib_prefix)
+                || (sym.contains("b_dylib") && sym.contains("hello"))
+        }) {
+            eprintln!("dynamic symbols: {:#?}", dynamic_symbols);
+            panic!(
+                "did not expect any symbols to: \
+                (1) start with `{expected_rlib_prefix}` or \
+                (2) start with `{expected_dylib_prefix}` or \
+                (3) to be of the form `*b_dylib*hello*`"
+            );
+        }
+    }
+}