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

@@ -565,6 +565,21 @@ where
             Arg::new("wrap-unsafe-ops")
                 .long("wrap-unsafe-ops")
                 .help("Wrap unsafe operations in unsafe blocks."),
+            Arg::new("generate-extern-functions")
+                .long("generate-extern-functions")
+                .help("Generate extern wrappers for inlined functions"),
+            Arg::new("extern-functions-file-name")
+                .long("extern-functions-file-name")
+                .help("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.")
+                .takes_value(true),
+            Arg::new("extern-functions-directory")
+                .long("extern-functions-directory")
+                .help("Sets the directory path where any extra files must be created due to the presence of inlined functions.")
+                .takes_value(true),
+            Arg::new("extern-function-suffix")
+                .long("extern-function-suffix")
+                .help("Sets the suffix added to the extern wrapper functions generated for inlined functions.")
+                .takes_value(true),
             Arg::new("V")
                 .long("version")
                 .help("Prints the version, and exits"),
@@ -1092,5 +1107,21 @@ where
         builder = builder.wrap_unsafe_ops(true);
     }
 
+    if matches.is_present("generate-extern-functions") {
+        builder = builder.generate_extern_functions(true);
+    }
+
+    if let Some(file_name) = matches.value_of("extern-functions-file-name") {
+        builder = builder.extern_functions_file_name(file_name);
+    }
+
+    if let Some(directory) = matches.value_of("extern-functions-directory") {
+        builder = builder.extern_functions_directory(directory);
+    }
+
+    if let Some(suffix) = matches.value_of("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

@@ -4006,9 +4006,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
@@ -4118,6 +4117,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(
@@ -4127,6 +4127,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
@@ -4137,6 +4138,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};
@@ -462,6 +463,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.
@@ -577,6 +581,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

@@ -7,6 +7,7 @@ use super::item::Item;
 use super::traversal::{EdgeKind, Trace, Tracer};
 use super::ty::TypeKind;
 use crate::clang::{self, Attribute};
+use crate::ir::serialize::CItem;
 use crate::parse::{
     ClangItemParser, ClangSubItemParser, ParseError, ParseResult,
 };
@@ -680,9 +681,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);
             }
@@ -727,6 +731,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;