test that weak linkage is respected

Author: folkertdev

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -561,6 +561,13 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
     // a declaration, with a definition provided in global assembly.
     if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NAKED) {
         codegen_fn_attrs.inline = InlineAttr::Never;
+
+        // linkage must always be some flavor of external because the actual symbol is defined in
+        // assembly, and the function is just a declaration, not a definition. This conversion
+        // gives the naked function the semantics of a weakly-linked function.
+        if codegen_fn_attrs.linkage == Some(Linkage::WeakAny) {
+            codegen_fn_attrs.linkage = Some(Linkage::ExternalWeak);
+        }
     }
 
     codegen_fn_attrs.optimize = attrs.iter().fold(OptimizeAttr::None, |ia, attr| {

tests/run-make/naked-symbol-visibility/a_rust_dylib.rs

@@ -1,4 +1,4 @@
-#![feature(naked_functions, asm_const)]
+#![feature(naked_functions, asm_const, linkage)]
 #![crate_type = "dylib"]
 
 use std::arch::asm;
@@ -35,6 +35,16 @@ pub extern "C" fn public_vanilla_generic_function_from_rust_dylib<T: TraitWithCo
     T::COUNT
 }
 
+#[linkage = "weak"]
+extern "C" fn vanilla_weak_linkage() -> u32 {
+    42
+}
+
+#[linkage = "external"]
+extern "C" fn vanilla_external_linkage() -> u32 {
+    42
+}
+
 #[naked]
 extern "C" fn private_naked_rust_function_from_rust_dylib() -> u32 {
     unsafe { asm!("mov rax, 42", "ret", options(noreturn)) }
@@ -50,3 +60,15 @@ pub extern "C" fn public_naked_rust_function_from_rust_dylib() -> u32 {
 pub extern "C" fn public_naked_generic_function_from_rust_dylib<T: TraitWithConst>() -> u32 {
     unsafe { asm!("mov rax, {}", "ret", const T::COUNT, options(noreturn)) }
 }
+
+#[naked]
+#[linkage = "weak"]
+extern "C" fn naked_weak_linkage() -> u32 {
+    unsafe { asm!("mov rax, 42", "ret", options(noreturn)) }
+}
+
+#[naked]
+#[linkage = "external"]
+extern "C" fn naked_external_linkage() -> u32 {
+    unsafe { asm!("mov rax, 42", "ret", options(noreturn)) }
+}

tests/run-make/naked-symbol-visibility/rmake.rs

@@ -7,31 +7,57 @@ fn main() {
 
     // check vanilla symbols
     not_dynamic_symbol(&rdylib_name, "private_vanilla_rust_function_from_rust_dylib");
-    dynamic_symbol(&rdylib_name, "public_vanilla_rust_function_from_rust_dylib");
+    global_function(&rdylib_name, "public_vanilla_rust_function_from_rust_dylib");
     not_dynamic_symbol(&rdylib_name, "public_vanilla_generic_function_from_rust_dylib");
 
+    weak_function(&rdylib_name, "vanilla_weak_linkage");
+    global_function(&rdylib_name, "vanilla_external_linkage");
+
     // naked should mirror vanilla
     not_dynamic_symbol(&rdylib_name, "private_naked_rust_function_from_rust_dylib");
-    dynamic_symbol(&rdylib_name, "public_naked_rust_function_from_rust_dylib");
+    global_function(&rdylib_name, "public_naked_rust_function_from_rust_dylib");
     not_dynamic_symbol(&rdylib_name, "public_naked_generic_function_from_rust_dylib");
 
+    weak_function(&rdylib_name, "naked_weak_linkage");
+    global_function(&rdylib_name, "naked_external_linkage");
+
     // share generics should expose the generic functions
     rustc().arg("-Zshare-generics=yes").input("a_rust_dylib.rs").run();
-    dynamic_symbol(&rdylib_name, "public_vanilla_generic_function_from_rust_dylib");
-    dynamic_symbol(&rdylib_name, "public_naked_generic_function_from_rust_dylib");
+    global_function(&rdylib_name, "public_vanilla_generic_function_from_rust_dylib");
+    global_function(&rdylib_name, "public_naked_generic_function_from_rust_dylib");
 }
 
 #[track_caller]
-fn dynamic_symbol(path: &str, symbol_name: &str) {
-    assert_eq!(find_dynamic_symbol(path, symbol_name), 1)
+fn global_function(path: &str, symbol_name: &str) {
+    let lines = find_dynamic_symbol(path, symbol_name);
+    let [line] = lines.as_slice() else {
+        panic!("symbol {symbol_name} occurs {} times", lines.len())
+    };
+
+    assert!(line.contains("FUNC"), "`{symbol_name}` is not a function");
+    assert!(line.contains("GLOBAL"), "`{symbol_name}` is not marked as global");
+}
+
+#[track_caller]
+fn weak_function(path: &str, symbol_name: &str) {
+    let lines = find_dynamic_symbol(path, symbol_name);
+    let [line] = lines.as_slice() else {
+        panic!("symbol {symbol_name} occurs {} times", lines.len())
+    };
+
+    assert!(line.contains("FUNC"), "`{symbol_name}` is not a function");
+    assert!(line.contains("WEAK"), "`{symbol_name}` is not marked as weak");
 }
 
 #[track_caller]
 fn not_dynamic_symbol(path: &str, symbol_name: &str) {
-    assert_eq!(find_dynamic_symbol(path, symbol_name), 0)
+    assert_eq!(find_dynamic_symbol(path, symbol_name).len(), 0)
 }
 
-fn find_dynamic_symbol(path: &str, symbol_name: &str) -> usize {
+fn find_dynamic_symbol<'a>(path: &str, symbol_name: &str) -> Vec<String> {
     let out = llvm_readobj().arg("--dyn-symbols").input(path).run().stdout_utf8();
-    out.lines().filter(|&line| !line.contains("__imp_") && line.contains(symbol_name)).count()
+    out.lines()
+        .filter(|&line| !line.contains("__imp_") && line.contains(symbol_name))
+        .map(|line| line.to_string())
+        .collect()
 }