tests: port extern-fn-reachable to rmake.rs

Co-authored-by: binarycat <binarycat@envs.net>

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/extern-fn-reachable/Makefile
 run-make/jobserver-error/Makefile
 run-make/split-debuginfo/Makefile
 run-make/symbol-mangling-hashed/Makefile

tests/run-make/extern-fn-reachable/Makefile

@@ -1,19 +1,34 @@
 #![crate_type = "dylib"]
 #![allow(dead_code)]
 
+// `pub` extern fn here is a Rust nameres visibility concept, and should not affect symbol
+// visibility in the dylib.
 #[no_mangle]
 pub extern "C" fn fun1() {}
+
+// (Lack of) `pub` for the extern fn here is a Rust nameres visibility concept, and should not
+// affect symbol visibility in the dylib.
 #[no_mangle]
 extern "C" fn fun2() {}
 
+// Modules are a Rust nameres concept, and should not affect symbol visibility in the dylib if the
+// extern fn is nested inside a module.
 mod foo {
     #[no_mangle]
     pub extern "C" fn fun3() {}
 }
+
+// Similarly, the Rust visibility of the containing module is a Rust nameres concept, and should not
+// affect symbol visibility in the dylib.
 pub mod bar {
     #[no_mangle]
     pub extern "C" fn fun4() {}
 }
 
+// Non-extern `#[no_mangle]` fn should induce a symbol visible in the dylib.
 #[no_mangle]
 pub fn fun5() {}
+
+// The Rust visibility of the fn should not affect is symbol visibility in the dylib.
+#[no_mangle]
+fn fun6() {}

tests/run-make/extern-fn-reachable/dylib.rs

@@ -0,0 +1,55 @@
+//! Smoke test to check that that symbols of `extern "C"` functions and `#[no_mangle]` rust
+//! functions:
+//!
+//! 1. Are externally visible in the dylib produced.
+//! 2. That the symbol visibility is orthogonal to the Rust nameres visibility of the functions
+//!    involved.
+
+//@ ignore-cross-compile
+
+use run_make_support::object::{self, Object, ObjectSection, ObjectSymbol};
+use run_make_support::{dynamic_lib_name, is_darwin, is_msvc, path, rfs, rustc};
+
+fn main() {
+    let dylib = dynamic_lib_name("dylib");
+    rustc().input("dylib.rs").output(&dylib).arg("-Cprefer-dynamic").run();
+    let mut fun1_count = 0; // #[no_mangle] pub extern "C" fn fun1() {}
+    let mut fun2_count = 0; // #[no_mangle] extern "C" fn fun2() {}
+    let mut fun3_count = 0; // mod foo { #[no_mangle] pub extern "C" fn fun3() {} }
+    let mut fun4_count = 0; // pub mod bar { #[no_mangle] pub extern "C" fn fun4() {} }
+    let mut fun5_count = 0; // #[no_mangle] pub fn fun5() {}
+    let mut fun6_count = 0; // #[no_mangle] fn fun6() {}
+
+    let p = if is_msvc() { path(dylib) } else { path(dylib) };
+    let blob = rfs::read(&p);
+    let file = object::File::parse(&*blob).unwrap();
+
+    for export in file.exports().unwrap() {
+        let sym_name = export.name();
+        let sym_name = String::from_utf8_lossy(sym_name);
+        match sym_name.as_ref() {
+            "fun1" => fun1_count += 1,
+            "fun2" => fun2_count += 1,
+            "fun3" => fun3_count += 1,
+            "fun4" => fun4_count += 1,
+            "fun5" => fun5_count += 1,
+            "fun6" => fun6_count += 1,
+            // Mach-O states that all exported symbols should have an underscore as prefix. At the
+            // same time dlsym will implicitly add it, so outside of compilers, linkers and people
+            // writing assembly, nobody needs to be aware of this.
+            "_fun1" if is_darwin() => fun1_count += 1,
+            "_fun2" if is_darwin() => fun2_count += 1,
+            "_fun3" if is_darwin() => fun3_count += 1,
+            "_fun4" if is_darwin() => fun4_count += 1,
+            "_fun5" if is_darwin() => fun5_count += 1,
+            "_fun6" if is_darwin() => fun6_count += 1,
+            _ => {}
+        }
+    }
+    assert_eq!(fun1_count, 1);
+    assert_eq!(fun2_count, 1);
+    assert_eq!(fun3_count, 1);
+    assert_eq!(fun4_count, 1);
+    assert_eq!(fun5_count, 1);
+    assert_eq!(fun6_count, 1);
+}