Let LLVM mangle the link name of static wrappers

Author: pvdrz

bindgen-tests/tests/expectations/tests/generated/wrap_static_fns.c

@@ -1,16 +1,8 @@
-int foo__extern(void) asm("foo__extern");
 int foo__extern(void) { return foo(); }
-int bar__extern(void) asm("bar__extern");
 int bar__extern(void) { return bar(); }
-int takes_ptr__extern(int *arg) asm("takes_ptr__extern");
 int takes_ptr__extern(int *arg) { return takes_ptr(arg); }
-int takes_fn_ptr__extern(int (*f) (int)) asm("takes_fn_ptr__extern");
 int takes_fn_ptr__extern(int (*f) (int)) { return takes_fn_ptr(f); }
-int takes_fn__extern(int (f) (int)) asm("takes_fn__extern");
 int takes_fn__extern(int (f) (int)) { return takes_fn(f); }
-int takes_alias__extern(func f) asm("takes_alias__extern");
 int takes_alias__extern(func f) { return takes_alias(f); }
-int takes_qualified__extern(const int *const *arg) asm("takes_qualified__extern");
 int takes_qualified__extern(const int *const *arg) { return takes_qualified(arg); }
-enum foo takes_enum__extern(const enum foo f) asm("takes_enum__extern");
 enum foo takes_enum__extern(const enum foo f) { return takes_enum(f); }

bindgen-tests/tests/expectations/tests/wrap-static-fns.rs

@@ -7,7 +7,7 @@ use quote::TokenStreamExt;
 
 pub(crate) mod attributes {
     use proc_macro2::{Ident, Span, TokenStream};
-    use std::str::FromStr;
+    use std::{borrow::Cow, str::FromStr};
 
     pub(crate) fn repr(which: &str) -> TokenStream {
         let which = Ident::new(which, Span::call_site());
@@ -62,10 +62,15 @@ pub(crate) mod attributes {
         }
     }
 
-    pub(crate) fn link_name(name: &str) -> TokenStream {
+    pub(crate) fn link_name<const MANGLE: bool>(name: &str) -> TokenStream {
         // LLVM mangles the name by default but it's already mangled.
         // Prefixing the name with \u{1} should tell LLVM to not mangle it.
-        let name = format!("\u{1}{}", name);
+        let name: Cow<'_, str> = if MANGLE {
+            name.into()
+        } else {
+            format!("\u{1}{}", name).into()
+        };
+
         quote! {
             #[link_name = #name]
         }
@@ -151,8 +156,8 @@ pub(crate) mod ast_ty {
                 }
             }
             None => {
-                if ctx.options().use_core &&
-                    ctx.options().rust_features.core_ffi_c_void
+                if ctx.options().use_core
+                    && ctx.options().rust_features.core_ffi_c_void
                 {
                     quote! { ::core::ffi::c_void }
                 } else {
@@ -172,8 +177,8 @@ pub(crate) mod ast_ty {
                 }
             }
             None => {
-                if ctx.options().use_core &&
-                    ctx.options().rust_features().core_ffi_c
+                if ctx.options().use_core
+                    && ctx.options().rust_features().core_ffi_c
                 {
                     quote! {
                         ::core::ffi::#ident

bindgen/codegen/helpers.rs

@@ -751,7 +751,7 @@ impl CodeGenerator for Var {
                 link_name,
                 None,
             ) {
-                attrs.push(attributes::link_name(link_name));
+                attrs.push(attributes::link_name::<false>(link_name));
             }
 
             let maybe_mut = if self.is_const() {
@@ -4155,7 +4155,7 @@ impl CodeGenerator for Function {
                 Some(abi),
             )
         {
-            attributes.push(attributes::link_name(link_name));
+            attributes.push(attributes::link_name::<false>(link_name));
             has_link_name_attr = true;
         }
 
@@ -4169,7 +4169,7 @@ impl CodeGenerator for Function {
 
         if is_internal && ctx.options().wrap_static_fns && !has_link_name_attr {
             let name = canonical_name.clone() + ctx.wrap_static_fns_suffix();
-            attributes.push(attributes::link_name(&name));
+            attributes.push(attributes::link_name::<true>(&name));
         }
 
         let ident = ctx.rust_ident(canonical_name);

bindgen/codegen/mod.rs

@@ -105,12 +105,6 @@ impl<'a> CSerialize<'a> for Function {
         // The function's return type
         let ret_ty = signature.return_type();
 
-        // Write `ret_ty wrap_name(args) asm("wrap_name");`
-        ret_ty.serialize(ctx, (), stack, writer)?;
-        write!(writer, " {}(", wrap_name)?;
-        serialize_args(&args, ctx, writer)?;
-        writeln!(writer, ") asm(\"{}\");", wrap_name)?;
-
         // Write `ret_ty wrap_name(args) { return name(arg_names)' }`
         ret_ty.serialize(ctx, (), stack, writer)?;
         write!(writer, " {}(", wrap_name)?;