Generate extern wrappers for inlined functions

If bindgen finds an inlined function and the
`--generate-extern-functions` options is enabled, then:

- It will generate two new source and header files with external
  functions that wrap the inlined functions.
- Rerun `Bindings::generate` using the new header file to include these
  wrappers in the generated bindings.

The following additional options were added:
- `--extern-function-suffix=<suffix>`: Adds <suffix> to the name of each
  external wrapper function (`__extern` is used by default).
- `--extern-functions-file-name=<name>`: Uses <name> as the file name
  for the header and source files (`extern` is used by default).
- `--extern-function-directory=<dir>`: Creates the source and header
  files inside <dir> (`/tmp/bindgen` is used by default).

The C code serialization is experimental and only supports a very
limited set of C functions.

Fixes rust-lang#1090.

Author: pvdrz

bindgen-cli/options.rs

@@ -353,6 +353,18 @@ struct BindgenCommand {
     /// Derive custom traits on a `union`. The <CUSTOM> value must be of the shape <REGEX>=<DERIVE> where <DERIVE> is a coma-separated list of derive macros.
     #[arg(long, value_name = "CUSTOM")]
     with_derive_custom_union: Vec<String>,
+    /// Generate extern wrappers for inlined functions
+    #[arg(long)]
+    generate_extern_functions: bool,
+    /// Sets the name of the header and source code files that would be created if any extern wrapper functions must be generated due to the presence of inlined functions.
+    #[arg(long, value_name = "FILENAME")]
+    extern_functions_file_name: Option<String>,
+    #[arg(long, value_name = "DIRECTORY")]
+    /// Sets the directory path where any extra files must be created due to the presence of inlined functions.
+    extern_functions_directory: Option<String>,
+    /// Sets the suffix added to the extern wrapper functions generated for inlined functions.
+    #[arg(long, value_name = "SUFFIX")]
+    extern_function_suffix: Option<String>,
     /// Prints the version, and exits
     #[arg(short = 'V', long)]
     version: bool,
@@ -473,6 +485,10 @@ where
         with_derive_custom_struct,
         with_derive_custom_enum,
         with_derive_custom_union,
+        generate_extern_functions,
+        extern_functions_file_name,
+        extern_functions_directory,
+        extern_function_suffix,
         version,
         clang_args,
     } = command;
@@ -978,5 +994,21 @@ where
         }
     }
 
+    if generate_extern_functions {
+        builder = builder.generate_extern_functions(true);
+    }
+
+    if let Some(file_name) = extern_functions_file_name {
+        builder = builder.extern_functions_file_name(file_name);
+    }
+
+    if let Some(directory) = extern_functions_directory {
+        builder = builder.extern_functions_directory(directory);
+    }
+
+    if let Some(suffix) = extern_function_suffix {
+        builder = builder.extern_function_suffix(suffix);
+    }
+
     Ok((builder, output, verbose))
 }

bindgen-tests/tests/expectations/tests/generate-extern-functions.rs

@@ -0,0 +1,11 @@
+// bindgen-flags: --generate-extern-functions
+
+static inline int foo() {
+    return 0;
+}
+static int bar() {
+    return 1;
+}
+inline int baz() {
+    return 2;
+}

bindgen-tests/tests/headers/generate-extern-functions.h

@@ -4002,9 +4002,8 @@ impl CodeGenerator for Function {
 
         // We can't currently do anything with Internal functions so just
         // avoid generating anything for them.
-        match self.linkage() {
-            Linkage::Internal => return None,
-            Linkage::External => {}
+        if matches!(self.linkage(), Linkage::Internal) {
+            return None;
         }
 
         // Pure virtual methods have no actual symbol, so we can't generate
@@ -4114,6 +4113,7 @@ impl CodeGenerator for Function {
             write!(&mut canonical_name, "{}", times_seen).unwrap();
         }
 
+        let mut has_link_name_attr = false;
         let link_name = mangled_name.unwrap_or(name);
         if !is_dynamic_function &&
             !utils::names_will_be_identical_after_mangling(
@@ -4123,6 +4123,7 @@ impl CodeGenerator for Function {
             )
         {
             attributes.push(attributes::link_name(link_name));
+            has_link_name_attr = true;
         }
 
         // Unfortunately this can't piggyback on the `attributes` list because
@@ -4133,6 +4134,20 @@ impl CodeGenerator for Function {
                 quote! { #[link(wasm_import_module = #name)] }
             });
 
+        if ctx.options().generate_extern_functions.is_second_run() {
+            if let Some(name) = canonical_name.strip_suffix(
+                ctx.options()
+                    .extern_function_suffix
+                    .as_deref()
+                    .unwrap_or(crate::DEFAULT_EXTERN_FUNCTION_SUFFIX),
+            ) {
+                if !has_link_name_attr {
+                    attributes.push(attributes::link_name(&canonical_name));
+                }
+                canonical_name = name.to_owned();
+            }
+        }
+
         let ident = ctx.rust_ident(canonical_name);
         let tokens = quote! {
             #wasm_link_attribute

bindgen/codegen/mod.rs

@@ -16,6 +16,7 @@ use super::int::IntKind;
 use super::item::{IsOpaque, Item, ItemAncestors, ItemSet};
 use super::item_kind::ItemKind;
 use super::module::{Module, ModuleKind};
+use super::serialize::CItem;
 use super::template::{TemplateInstantiation, TemplateParameters};
 use super::traversal::{self, Edge, ItemTraversal};
 use super::ty::{FloatKind, Type, TypeKind};
@@ -477,6 +478,9 @@ pub struct BindgenContext {
 
     /// The set of warnings raised during binding generation.
     warnings: Vec<String>,
+
+    /// C items that need to be serialized to an extra header file.
+    pub(crate) c_items: Vec<CItem>,
 }
 
 /// A traversal of allowlisted items.
@@ -593,6 +597,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
             has_type_param_in_array: None,
             has_float: None,
             warnings: Vec::new(),
+            c_items: Vec::new(),
         }
     }
 

bindgen/ir/context.rs

@@ -8,6 +8,7 @@ use super::traversal::{EdgeKind, Trace, Tracer};
 use super::ty::TypeKind;
 use crate::callbacks::{ItemInfo, ItemKind};
 use crate::clang::{self, Attribute};
+use crate::ir::serialize::CItem;
 use crate::parse::{ClangSubItemParser, ParseError, ParseResult};
 use clang_sys::{self, CXCallingConv};
 use proc_macro2;
@@ -679,9 +680,12 @@ impl ClangSubItemParser for Function {
                 .definition()
                 .map_or(false, |x| x.is_inlined_function())
         {
-            if !context.options().generate_inline_functions {
+            if !(context.options().generate_inline_functions ||
+                context.options().generate_extern_functions.is_true())
+            {
                 return Err(ParseError::Continue);
             }
+
             if cursor.is_deleted_function() {
                 return Err(ParseError::Continue);
             }
@@ -728,6 +732,16 @@ impl ClangSubItemParser for Function {
 
         let function =
             Self::new(name, mangled_name, sig, comment, kind, linkage);
+
+        if matches!(linkage, Linkage::Internal) &&
+            context.options().generate_extern_functions.is_true()
+        {
+            match CItem::from_function(&function, context) {
+                Ok(c_item) => context.c_items.push(c_item),
+                Err(err) => warn!("Serialization failed: {:?}", err),
+            }
+        }
+
         Ok(ParseResult::New(function, Some(cursor)))
     }
 }

bindgen/ir/function.rs

@@ -18,6 +18,7 @@ pub mod item_kind;
 pub mod layout;
 pub mod module;
 pub mod objc;
+pub(crate) mod serialize;
 pub mod template;
 pub mod traversal;
 pub mod ty;