[WIP] reexport the static inline functions and TLS variables with C/CPP wrapper

src/clang.rs

@@ -1527,6 +1527,18 @@ pub fn type_to_str(x: CXTypeKind) -> String {
     unsafe { cxstring_into_string(clang_getTypeKindSpelling(x)) }
 }
 
+/// Convert a linkage kind to a static string.
+pub fn linkage_to_str(x: CXLinkageKind) -> &'static str {
+     match x {
+        CXLinkage_Invalid => "invalid",
+        CXLinkage_NoLinkage => "non-extern",
+        CXLinkage_Internal => "internal",
+        CXLinkage_UniqueExternal => "unique-external",
+        CXLinkage_External =>"external",
+        _ => unreachable!(),
+    }
+}
+
 /// Dump the Clang AST to stdout for debugging purposes.
 pub fn ast_dump(c: &Cursor, depth: isize) -> CXChildVisitResult {
     fn print_indent<S: AsRef<str>>(depth: isize, s: S) {
@@ -1546,6 +1558,10 @@ pub fn ast_dump(c: &Cursor, depth: isize) -> CXChildVisitResult {
             depth,
             format!(" {}spelling = \"{}\"", prefix, c.spelling()),
         );
+        print_indent(
+            depth,
+            format!(" {}linkage = {}", prefix, linkage_to_str(c.linkage())),
+        );
         print_indent(depth, format!(" {}location = {}", prefix, c.location()));
         print_indent(
             depth,

src/codegen/mod.rs

@@ -107,6 +107,9 @@ struct CodegenResult<'a> {
     /// Whether a bitfield allocation unit has been seen at least once.
     saw_bitfield_unit: bool,
 
+    /// Whether a static inlined function have been seen at least once.
+    saw_static_inlined_function: bool,
+
     items_seen: HashSet<ItemId>,
     /// The set of generated function/var names, needed because in C/C++ is
     /// legal to do something like:
@@ -142,6 +145,7 @@ impl<'a> CodegenResult<'a> {
             saw_objc: false,
             saw_block: false,
             saw_bitfield_unit: false,
+            saw_static_inlined_function: false,
             codegen_id: codegen_id,
             items_seen: Default::default(),
             functions_seen: Default::default(),
@@ -170,6 +174,10 @@ impl<'a> CodegenResult<'a> {
         self.saw_bitfield_unit = true;
     }
 
+    fn saw_static_inlined_function(&mut self) {
+        self.saw_static_inlined_function = true;
+    }
+
     fn seen<Id: Into<ItemId>>(&self, item: Id) -> bool {
         self.items_seen.contains(&item.into())
     }
@@ -217,6 +225,7 @@ impl<'a> CodegenResult<'a> {
         self.saw_block |= new.saw_block;
         self.saw_bitfield_unit |= new.saw_bitfield_unit;
         self.saw_bindgen_union |= new.saw_bindgen_union;
+        self.saw_static_inlined_function |= new.saw_static_inlined_function;
 
         new.items
     }
@@ -412,6 +421,9 @@ impl CodeGenerator for Module {
                 if result.saw_bitfield_unit {
                     utils::prepend_bitfield_unit_type(&mut *result);
                 }
+                if result.saw_static_inlined_function {
+                    utils::prepend_c_include(ctx, &mut *result);
+                }
             }
         };
 
@@ -3315,12 +3327,16 @@ impl CodeGenerator for Function {
         debug!("<Function as CodeGenerator>::codegen: item = {:?}", item);
         debug_assert!(item.is_enabled_for_codegen(ctx));
 
-        // We can't currently do anything with Internal functions so just
+        // We can't currently do anything with Internal non-inlined functions so just
         // avoid generating anything for them.
-        match self.linkage() {
-            Linkage::Internal => return,
-            Linkage::External => {}
-        }
+        let is_static_inlined_function = match self.linkage() {
+            Linkage::Internal if self.kind() == FunctionKind::Function && self.is_inlined() => {
+                result.saw_static_inlined_function();
+                true
+            },
+            Linkage::External => { false }
+            _ => { return }
+        };
 
         // Pure virtual methods have no actual symbol, so we can't generate
         // something meaningful for them.
@@ -3381,13 +3397,31 @@ impl CodeGenerator for Function {
             write!(&mut canonical_name, "{}", times_seen).unwrap();
         }
 
-        if let Some(mangled) = mangled_name {
+        let cfunc_name = if let Some(mangled) = mangled_name {
             if canonical_name != mangled {
                 attributes.push(attributes::link_name(mangled));
+                Some(mangled.to_owned())
+            } else {
+                None
             }
         } else if name != canonical_name {
             attributes.push(attributes::link_name(name));
-        }
+            Some(name.to_owned())
+        } else {
+            None
+        }.unwrap_or_else(|| {
+            if is_static_inlined_function {
+                let mut cfunc_name = format!("_{}", canonical_name);
+                let times_seen = result.overload_number(&cfunc_name);
+                if times_seen > 0 {
+                    write!(&mut cfunc_name, "{}", times_seen).unwrap();
+                }
+                attributes.push(attributes::link_name(&cfunc_name));
+                cfunc_name
+            } else {
+                canonical_name.to_owned()
+            }
+        });
 
         let abi = match signature.abi() {
             Abi::ThisCall if !ctx.options().rust_features().thiscall_abi => {
@@ -3409,12 +3443,41 @@ impl CodeGenerator for Function {
             abi => abi,
         };
 
-        let ident = ctx.rust_ident(canonical_name);
+        let ident = ctx.rust_ident(&canonical_name);
         let tokens = quote!( extern #abi {
             #(#attributes)*
             pub fn #ident ( #( #args ),* ) #ret;
         });
         result.push(tokens);
+        if is_static_inlined_function {
+            let cfunc_name = proc_macro2::TokenStream::from_str(&cfunc_name).unwrap();
+            let ret_ty = ctx.resolve_item(signature.return_type());
+            let ret_stmt = if let TypeKind::Void = *ret_ty.kind().expect_type().kind() {
+                None
+            } else {
+                Some(quote!{ return })
+            };
+            let ret_ty_name = proc_macro2::TokenStream::from_str(ret_ty.name(ctx).get().as_str()).unwrap();
+            let arg_decl = signature.argument_types().iter().map(|&(ref name, ty)| {
+                let arg_ty = ctx.resolve_item(ty).kind().expect_type().name().unwrap();
+                let arg_name = name.as_ref().map(|s| s.as_str()).unwrap();
+
+                proc_macro2::TokenStream::from_str(&format!("{} {}", arg_ty, arg_name)).unwrap()
+            });
+            let args = signature.argument_types().iter().map(|&(ref name, _)| {
+                let arg_name = name.as_ref().map(|s| s.as_str()).unwrap();
+
+                proc_macro2::TokenStream::from_str(arg_name).unwrap()
+            });
+            let macro_name = proc_macro2::TokenStream::from_str(if ctx.options().is_cpp() { "cpp" } else { "c" }).unwrap();
+
+            let tokens = quote!( #macro_name ! {
+                #ret_ty_name #cfunc_name ( #( #arg_decl ),* ) {
+                    #ret_stmt #ident ( #( #args ),* );
+                }
+            });
+            result.push(tokens);
+        }
     }
 }
 
@@ -3576,6 +3639,7 @@ mod utils {
     use ir::ty::TypeKind;
     use proc_macro2;
     use std::mem;
+    use std::path::Path;
     use std::str::FromStr;
 
     pub fn prepend_bitfield_unit_type(result: &mut Vec<proc_macro2::TokenStream>) {
@@ -3587,6 +3651,19 @@ mod utils {
         result.extend(old_items);
     }
 
+    pub fn prepend_c_include(
+        ctx: &BindgenContext,
+        result: &mut Vec<proc_macro2::TokenStream>,
+    ) {
+        if let Some(ref header_file) = ctx.options().input_header() {
+            let macro_name = proc_macro2::TokenStream::from_str(if ctx.options().is_cpp() { "cpp" } else { "c" }).unwrap();
+            let include = proc_macro2::TokenStream::from_str("#include").unwrap();
+            let header_file = Path::new(header_file).file_name().unwrap().to_str().unwrap();
+
+            result.insert(0, quote!( #macro_name ! { #include #header_file }))
+        }
+    }
+
     pub fn prepend_objc_header(
         ctx: &BindgenContext,
         result: &mut Vec<proc_macro2::TokenStream>,

src/ir/function.rs

@@ -92,6 +92,9 @@ pub struct Function {
 
     /// The linkage of the function.
     linkage: Linkage,
+
+    /// The function is inlined.
+    inlined: bool,
 }
 
 impl Function {
@@ -102,7 +105,8 @@ impl Function {
         signature: TypeId,
         comment: Option<String>,
         kind: FunctionKind,
-        linkage: Linkage
+        linkage: Linkage,
+        inlined: bool,
     ) -> Self {
         Function {
             name,
@@ -111,6 +115,7 @@ impl Function {
             comment,
             kind,
             linkage,
+            inlined,
         }
     }
 
@@ -139,6 +144,10 @@ impl Function {
         self.linkage
     }
 
+    /// Whether this function is inline.
+    pub fn is_inlined(&self) -> bool {
+        self.inlined
+    }
 }
 
 impl DotAttributes for Function {
@@ -546,6 +555,7 @@ impl ClangSubItemParser for Function {
         {
             return Err(ParseError::Continue);
         }
+        let inlined = cursor.is_inlined_function();
 
         let linkage = cursor.linkage();
         let linkage = match linkage {
@@ -578,7 +588,7 @@ impl ClangSubItemParser for Function {
         let mangled_name = cursor_mangling(context, &cursor);
         let comment = cursor.raw_comment();
 
-        let function = Self::new(name, mangled_name, sig, comment, kind, linkage);
+        let function = Self::new(name, mangled_name, sig, comment, kind, linkage, inlined);
         Ok(ParseResult::New(function, Some(cursor)))
     }
 }

src/lib.rs

@@ -102,6 +102,12 @@ fn args_are_cpp(clang_args: &[String]) -> bool {
         .any(|w| w[0] == "-xc++" || w[1] == "-xc++" || w == &["-x", "c++"]);
 }
 
+fn header_is_cpp(name_file: &str) -> bool {
+    name_file.ends_with(".hpp") || name_file.ends_with(".hxx")
+        || name_file.ends_with(".hh")
+        || name_file.ends_with(".h++")
+}
+
 bitflags! {
     /// A type used to indicate which kind of items we have to generate.
     pub struct CodegenConfig: u32 {
@@ -1222,12 +1228,6 @@ impl Builder {
     /// issues. The resulting file will be named something like `__bindgen.i` or
     /// `__bindgen.ii`
     pub fn dump_preprocessed_input(&self) -> io::Result<()> {
-        fn check_is_cpp(name_file: &str) -> bool {
-            name_file.ends_with(".hpp") || name_file.ends_with(".hxx")
-                || name_file.ends_with(".hh")
-                || name_file.ends_with(".h++")
-        }
-
         let clang = clang_sys::support::Clang::find(None, &[]).ok_or_else(|| {
             io::Error::new(io::ErrorKind::Other, "Cannot find clang executable")
         })?;
@@ -1241,7 +1241,7 @@ impl Builder {
 
         // For each input header, add `#include "$header"`.
         for header in &self.input_headers {
-            is_cpp |= check_is_cpp(header);
+            is_cpp |= header_is_cpp(header);
 
             wrapper_contents.push_str("#include \"");
             wrapper_contents.push_str(header);
@@ -1251,7 +1251,7 @@ impl Builder {
         // For each input header content, add a prefix line of `#line 0 "$name"`
         // followed by the contents.
         for &(ref name, ref contents) in &self.input_header_contents {
-            is_cpp |= check_is_cpp(name);
+            is_cpp |= header_is_cpp(name);
 
             wrapper_contents.push_str("#line 0 \"");
             wrapper_contents.push_str(name);
@@ -1580,6 +1580,17 @@ impl BindgenOptions {
     pub fn rust_features(&self) -> RustFeatures {
         self.rust_features
     }
+
+    /// Get the input header file.
+    pub fn input_header(&self) -> Option<&str> {
+        self.input_header.as_ref().map(|s| s.as_str())
+    }
+
+    /// Whether the header is c++ mode.
+    pub fn is_cpp(&self) -> bool {
+        args_are_cpp(&self.clang_args) ||
+            self.input_header.as_ref().map(|filename| header_is_cpp(filename)).unwrap_or(false)
+    }
 }
 
 impl Default for BindgenOptions {

tests/expectations/tests/generate-inline.rs

@@ -1,9 +1,13 @@
 /* automatically generated by rust-bindgen */
 
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
 
-#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
-
-
+cpp! { # include "generate-inline.hpp" }
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone)]
 pub struct Foo {
@@ -36,3 +40,8 @@ extern "C" {
     #[link_name = "\u{1}_Z3foov"]
     pub fn foo() -> ::std::os::raw::c_int;
 }
+extern "C" {
+    #[link_name = "\u{1}_ZL3barii"]
+    pub fn bar(x: ::std::os::raw::c_int, y: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
+}
+cpp! { int _ZL3barii ( const int x , const int y ) { return bar ( x , y ) ; } }

tests/expectations/tests/libclang-5/generate-c-inline.rs

@@ -0,0 +1,20 @@
+/* automatically generated by rust-bindgen */
+
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+c! { # include "generate-c-inline.h" }
+extern "C" {
+    #[link_name = "\u{1}_foo"]
+    pub fn foo(x: ::std::os::raw::c_int, y: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
+}
+c! { int _foo ( const int x , const int y ) { return foo ( x , y ) ; } }
+extern "C" {
+    #[link_name = "\u{1}_nop"]
+    pub fn nop();
+}
+c! { void _nop ( ) { nop ( ) ; } }

tests/headers/generate-c-inline.h

@@ -0,0 +1,5 @@
+// bindgen-flags: --generate-inline-functions
+
+inline static int foo(const int x, const int y) { return x + y; }
+static int bar(const int x, const int y) { return x - y; }
+inline static void nop() { return; }

tests/headers/generate-inline.hpp

@@ -10,3 +10,4 @@ class Foo {
 inline int foo() {
   return 42;
 }
+inline static int bar(const int x, const int y) { return x + y; }