From 256ea2ec27674549c9eb827798744aef9a0d42ad Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Wed, 21 Feb 2024 17:55:29 +0100 Subject: [PATCH 01/23] Change `Callbacks` API. --- CHANGELOG.md | 2 + bindgen-integration/build.rs | 48 +++++++++--------- bindgen-integration/cpp/Test.h | 2 +- bindgen/callbacks.rs | 89 ++++++++++++++++++++++++---------- bindgen/clang.rs | 13 ++--- bindgen/ir/context.rs | 63 +++++++++++++----------- bindgen/ir/var.rs | 51 ++++++++++++++----- 7 files changed, 169 insertions(+), 99 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1671f13af0..10be4ac40a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -210,6 +210,8 @@ ## Changed - Remove which and lazy-static dependencies (#2809, #2817). - Generate compile-time layout tests (#2787). +- `ParseCallbacks::int_macro` now takes an `i128` instead of an `i64`. +- `ParseCallbacks::func_macro` was renamed to `ParseCallbacks::fn_macro` and now takes a single `FnMacroInfo` argument. ## Removed ## Fixed - Fix `--formatter=prettyplease` not working in `bindgen-cli` by adding `prettyplease` feature and diff --git a/bindgen-integration/build.rs b/bindgen-integration/build.rs index 6b06c91bc3..7e9b37e47c 100644 --- a/bindgen-integration/build.rs +++ b/bindgen-integration/build.rs @@ -1,7 +1,7 @@ extern crate bindgen; use bindgen::callbacks::{ - DeriveInfo, IntKind, MacroParsingBehavior, ParseCallbacks, + DeriveInfo, FnMacroInfo, IntKind, MacroParsingBehavior, ParseCallbacks, }; use bindgen::{Builder, EnumVariation, Formatter}; use std::collections::HashSet; @@ -27,7 +27,7 @@ impl ParseCallbacks for MacroCallback { MacroParsingBehavior::Default } - fn int_macro(&self, name: &str, _value: i64) -> Option { + fn int_macro(&self, name: &str, _value: i128) -> Option { match name { "TESTMACRO_CUSTOMINTKIND_PATH" => Some(IntKind::Custom { name: "crate::MacroInteger", @@ -59,43 +59,45 @@ impl ParseCallbacks for MacroCallback { } } - fn func_macro(&self, name: &str, value: &[&[u8]]) { - match name { + fn fn_macro(&self, info: &FnMacroInfo<'_>) { + let args = info.args(); + let body = info.body(); + + match info.name() { "TESTMACRO_NONFUNCTIONAL" => { - panic!("func_macro was called for a non-functional macro"); + panic!("fn_macro was called for a non-functional macro"); } - "TESTMACRO_FUNCTIONAL_NONEMPTY(TESTMACRO_INTEGER)" => { + "TESTMACRO_FUNCTIONAL_NONEMPTY" => { // Spaces are inserted into the right-hand side of a functional // macro during reconstruction from the tokenization. This might // change in the future, but it is safe by the definition of a // token in C, whereas leaving the spaces out could change // tokenization. - assert_eq!(value, &[b"-" as &[u8], b"TESTMACRO_INTEGER"]); + assert_eq!(args, &["TESTMACRO_INTEGER"]); + assert_eq!(body, &["-", "TESTMACRO_INTEGER"]); *self.seen_funcs.lock().unwrap() += 1; } - "TESTMACRO_FUNCTIONAL_EMPTY(TESTMACRO_INTEGER)" => { - assert_eq!(value, &[] as &[&[u8]]); + "TESTMACRO_FUNCTIONAL_EMPTY" => { + assert_eq!(args, &["TESTMACRO_INTEGER"]); + assert_eq!(body, &[] as &[&str]); *self.seen_funcs.lock().unwrap() += 1; } - "TESTMACRO_FUNCTIONAL_TOKENIZED(a,b,c,d,e)" => { - assert_eq!( - value, - &[b"a" as &[u8], b"/", b"b", b"c", b"d", b"##", b"e"] - ); + "TESTMACRO_FUNCTIONAL_TOKENIZED" => { + assert_eq!(args, &["a", "b", "c", "d", "e"]); + assert_eq!(body, &["a", "/", "b", "c", "d", "##", "e"]); *self.seen_funcs.lock().unwrap() += 1; } - "TESTMACRO_FUNCTIONAL_SPLIT(a,b)" => { - assert_eq!(value, &[b"b", b",", b"a"]); + "TESTMACRO_FUNCTIONAL_SPLIT" => { + assert_eq!(args, &["a", "b"]); + assert_eq!(body, &["b", ",", "a"]); *self.seen_funcs.lock().unwrap() += 1; } - "TESTMACRO_STRING_FUNC_NON_UTF8(x)" => { - assert_eq!( - value, - &[b"(" as &[u8], b"x", b"\"\xff\xff\"", b")"] - ); + "TESTMACRO_STRING_FUNC_NON_UTF8" => { + assert_eq!(args, &["x"]); + assert_eq!(body, &["(", "x", r#""\xFF\xFF""#, ")"]); *self.seen_funcs.lock().unwrap() += 1; } - _ => { + name => { // The system might provide lots of functional macros. // Ensure we did not miss handling one that we meant to handle. assert!(!name.starts_with("TESTMACRO_"), "name = {}", name); @@ -145,7 +147,7 @@ impl Drop for MacroCallback { assert_eq!( *self.seen_funcs.lock().unwrap(), 5, - "func_macro handle was not called once for all relevant macros" + "fn_macro handle was not called once for all relevant macros" ); } } diff --git a/bindgen-integration/cpp/Test.h b/bindgen-integration/cpp/Test.h index 81a921b5f8..b67ea80c93 100644 --- a/bindgen-integration/cpp/Test.h +++ b/bindgen-integration/cpp/Test.h @@ -20,7 +20,7 @@ a //#define TESTMACRO_INVALID("string") // A conforming preprocessor rejects this #define TESTMACRO_STRING_EXPR ("string") -#define TESTMACRO_STRING_FUNC_NON_UTF8(x) (x "ÿÿ") /* invalid UTF-8 on purpose */ +#define TESTMACRO_STRING_FUNC_NON_UTF8(x) (x "\xFF\xFF") /* invalid UTF-8 on purpose */ enum { MY_ANNOYING_MACRO = diff --git a/bindgen/callbacks.rs b/bindgen/callbacks.rs index 0f16c4c0bf..494ad816b2 100644 --- a/bindgen/callbacks.rs +++ b/bindgen/callbacks.rs @@ -27,82 +27,90 @@ pub trait ParseCallbacks: fmt::Debug { } /// This function will be run on every macro that is identified. - fn will_parse_macro(&self, _name: &str) -> MacroParsingBehavior { + #[allow(unused_variables)] + fn will_parse_macro(&self, name: &str) -> MacroParsingBehavior { MacroParsingBehavior::Default } /// This function will run for every extern variable and function. The returned value determines /// the name visible in the bindings. + #[allow(unused_variables)] fn generated_name_override( &self, - _item_info: ItemInfo<'_>, + item_info: ItemInfo<'_>, ) -> Option { None } /// This function will run for every extern variable and function. The returned value determines /// the link name in the bindings. + #[allow(unused_variables)] fn generated_link_name_override( &self, - _item_info: ItemInfo<'_>, + item_info: ItemInfo<'_>, ) -> Option { None } /// The integer kind an integer macro should have, given a name and the /// value of that macro, or `None` if you want the default to be chosen. - fn int_macro(&self, _name: &str, _value: i64) -> Option { + #[allow(unused_variables)] + fn int_macro(&self, name: &str, value: i128) -> Option { None } /// This will be run on every string macro. The callback cannot influence the further /// treatment of the macro, but may use the value to generate additional code or configuration. - fn str_macro(&self, _name: &str, _value: &[u8]) {} + #[allow(unused_variables)] + fn str_macro(&self, name: &str, value: &[u8]) {} /// This will be run on every function-like macro. The callback cannot /// influence the further treatment of the macro, but may use the value to /// generate additional code or configuration. - /// - /// The first parameter represents the name and argument list (including the - /// parentheses) of the function-like macro. The second parameter represents - /// the expansion of the macro as a sequence of tokens. - fn func_macro(&self, _name: &str, _value: &[&[u8]]) {} + #[allow(unused_variables)] + fn fn_macro(&self, info: &FnMacroInfo<'_>) {} /// This function should return whether, given an enum variant /// name, and value, this enum variant will forcibly be a constant. + #[allow(unused_variables)] fn enum_variant_behavior( &self, - _enum_name: Option<&str>, - _original_variant_name: &str, - _variant_value: EnumVariantValue, + enum_name: Option<&str>, + original_variant_name: &str, + variant_value: EnumVariantValue, ) -> Option { None } /// Allows to rename an enum variant, replacing `_original_variant_name`. + #[allow(unused_variables)] fn enum_variant_name( &self, - _enum_name: Option<&str>, - _original_variant_name: &str, - _variant_value: EnumVariantValue, + enum_name: Option<&str>, + original_variant_name: &str, + variant_value: EnumVariantValue, ) -> Option { None } /// Allows to rename an item, replacing `_original_item_name`. - fn item_name(&self, _original_item_name: &str) -> Option { + #[allow(unused_variables)] + fn item_name(&self, original_item_name: &str) -> Option { None } /// This will be called on every header filename passed to (`Builder::header`)[`crate::Builder::header`]. - fn header_file(&self, _filename: &str) {} + #[allow(unused_variables)] + fn header_file(&self, filename: &str) {} /// This will be called on every file inclusion, with the full path of the included file. - fn include_file(&self, _filename: &str) {} + #[allow(unused_variables)] + fn include_file(&self, filename: &str) {} /// This will be called every time `bindgen` reads an environment variable whether it has any /// content or not. - fn read_env_var(&self, _key: &str) {} + #[allow(unused_variables)] + fn read_env_var(&self, key: &str) {} /// This will be called to determine whether a particular blocklisted type /// implements a trait or not. This will be used to implement traits on @@ -113,10 +121,11 @@ pub trait ParseCallbacks: fmt::Debug { /// * `Some(ImplementsTrait::Manually)`: any type including `_name` can't /// derive `_derive_trait` but can implemented it manually /// * `Some(ImplementsTrait::No)`: `_name` doesn't implement `_derive_trait` + #[allow(unused_variables)] fn blocklisted_type_implements_trait( &self, - _name: &str, - _derive_trait: DeriveTrait, + name: &str, + derive_trait: DeriveTrait, ) -> Option { None } @@ -125,12 +134,14 @@ pub trait ParseCallbacks: fmt::Debug { /// /// If no additional attributes are wanted, this function should return an /// empty `Vec`. - fn add_derives(&self, _info: &DeriveInfo<'_>) -> Vec { + #[allow(unused_variables)] + fn add_derives(&self, info: &DeriveInfo<'_>) -> Vec { vec![] } /// Process a source code comment. - fn process_comment(&self, _comment: &str) -> Option { + #[allow(unused_variables)] + fn process_comment(&self, comment: &str) -> Option { None } @@ -138,9 +149,10 @@ pub trait ParseCallbacks: fmt::Debug { /// /// Caution: This allows overriding standard C++ visibility inferred by /// `respect_cxx_access_specs`. + #[allow(unused_variables)] fn field_visibility( &self, - _info: FieldInfo<'_>, + info: FieldInfo<'_>, ) -> Option { None } @@ -151,7 +163,8 @@ pub trait ParseCallbacks: fmt::Debug { /// /// The returned string is new function name. #[cfg(feature = "experimental")] - fn wrap_as_variadic_fn(&self, _name: &str) -> Option { + #[allow(unused_variables)] + fn wrap_as_variadic_fn(&self, name: &str) -> Option { None } } @@ -206,3 +219,27 @@ pub struct FieldInfo<'a> { /// The name of the field. pub field_name: &'a str, } + +/// A struct providing information about the function-like macro being passed to [`ParseCallbacks::fn_macro`]. +pub struct FnMacroInfo<'m> { + pub(crate) name: &'m str, + pub(crate) args: &'m [&'m str], + pub(crate) body: &'m [&'m str], +} + +impl FnMacroInfo<'_> { + /// The macro name. + pub fn name(&self) -> &str { + self.name + } + + /// The macro argument names. + pub fn args(&self) -> &[&str] { + self.args + } + + /// The macro body as delimited `clang` tokens. + pub fn body(&self) -> &[&str] { + self.body + } +} diff --git a/bindgen/clang.rs b/bindgen/clang.rs index 26c02acec9..9267b45826 100644 --- a/bindgen/clang.rs +++ b/bindgen/clang.rs @@ -792,7 +792,7 @@ impl Cursor { (kind == CXCursor_UnexposedAttr && cur.tokens().iter().any(|t| { t.kind == attr.token_kind && - t.spelling() == attr.name + t.spelling().to_bytes() == attr.name })) { *found_attr = true; @@ -1040,12 +1040,9 @@ pub(crate) struct ClangToken { } impl ClangToken { - /// Get the token spelling, without being converted to utf-8. - pub(crate) fn spelling(&self) -> &[u8] { - let c_str = unsafe { - CStr::from_ptr(clang_getCString(self.spelling) as *const _) - }; - c_str.to_bytes() + /// Returns the token spelling. + pub(crate) fn spelling(&self) -> &CStr { + unsafe { CStr::from_ptr(clang_getCString(self.spelling) as *const _) } } /// Converts a ClangToken to a `cexpr` token if possible. @@ -1068,7 +1065,7 @@ impl ClangToken { Some(token::Token { kind, - raw: self.spelling().to_vec().into_boxed_slice(), + raw: self.spelling().to_bytes().to_vec().into_boxed_slice(), }) } } diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs index a1536935b6..85380c3c87 100644 --- a/bindgen/ir/context.rs +++ b/bindgen/ir/context.rs @@ -2273,8 +2273,20 @@ If you encounter an error missing from this list, please file an issue or a PR!" let mut kind = ModuleKind::Normal; let mut looking_for_name = false; for token in cursor.tokens().iter() { - match token.spelling() { - b"inline" => { + let spelling = token.spelling(); + let name = match spelling.to_str() { + Ok(name) => Cow::Borrowed(name), + Err(_) => { + let name = spelling.to_string_lossy(); + warn!( + "Lossy conversion of non-UTF8 token {:?} to {:?}.", + spelling, name + ); + name + } + }; + match name.as_ref() { + "inline" => { debug_assert!( kind != ModuleKind::Inline, "Multiple inline keywords?" @@ -2291,39 +2303,34 @@ If you encounter an error missing from this list, please file an issue or a PR!" // but the tokenization of the second begins with the double // colon. That's ok, so we only need to handle the weird // tokenization here. - b"namespace" | b"::" => { + "namespace" | "::" => { looking_for_name = true; } - b"{" => { + "{" => { // This should be an anonymous namespace. assert!(looking_for_name); break; } - name => { - if looking_for_name { - if module_name.is_none() { - module_name = Some( - String::from_utf8_lossy(name).into_owned(), - ); - } - break; - } else { - // This is _likely_, but not certainly, a macro that's - // been placed just before the namespace keyword. - // Unfortunately, clang tokens don't let us easily see - // through the ifdef tokens, so we don't know what this - // token should really be. Instead of panicking though, - // we warn the user that we assumed the token was blank, - // and then move on. - // - // See also https://github.com/rust-lang/rust-bindgen/issues/1676. - warn!( - "Ignored unknown namespace prefix '{}' at {:?} in {:?}", - String::from_utf8_lossy(name), - token, - cursor - ); + name if looking_for_name => { + if module_name.is_none() { + module_name = Some(name.to_owned()); } + break; + } + name => { + // This is _likely_, but not certainly, a macro that's + // been placed just before the namespace keyword. + // Unfortunately, clang tokens don't let us easily see + // through the ifdef tokens, so we don't know what this + // token should really be. Instead of panicking though, + // we warn the user that we assumed the token was blank, + // and then move on. + // + // See also https://github.com/rust-lang/rust-bindgen/issues/1676. + warn!( + "Ignored unknown namespace prefix '{}' at {:?} in {:?}", + name, token, cursor + ); } } } diff --git a/bindgen/ir/var.rs b/bindgen/ir/var.rs index 9d46135f74..1b20c2ab60 100644 --- a/bindgen/ir/var.rs +++ b/bindgen/ir/var.rs @@ -7,7 +7,7 @@ use super::function::cursor_mangling; use super::int::IntKind; use super::item::Item; use super::ty::{FloatKind, TypeKind}; -use crate::callbacks::{ItemInfo, ItemKind, MacroParsingBehavior}; +use crate::callbacks::{FnMacroInfo, ItemInfo, ItemKind, MacroParsingBehavior}; use crate::clang; use crate::clang::ClangToken; use crate::parse::{ClangSubItemParser, ParseError, ParseResult}; @@ -160,18 +160,43 @@ fn handle_function_macro( ) { let is_closing_paren = |t: &ClangToken| { // Test cheap token kind before comparing exact spellings. - t.kind == clang_sys::CXToken_Punctuation && t.spelling() == b")" + t.kind == clang_sys::CXToken_Punctuation && + t.spelling().to_bytes() == b")" }; - let tokens: Vec<_> = cursor.tokens().iter().collect(); - if let Some(boundary) = tokens.iter().position(is_closing_paren) { - let mut spelled = tokens.iter().map(ClangToken::spelling); - // Add 1, to convert index to length. - let left = spelled.by_ref().take(boundary + 1); - let left = left.collect::>().concat(); - if let Ok(left) = String::from_utf8(left) { - let right: Vec<_> = spelled.collect(); - callbacks.func_macro(&left, &right); - } + let mut raw_tokens: Vec<_> = cursor.tokens().iter().collect(); + if let Some(boundary) = raw_tokens.iter().position(is_closing_paren) { + let tokens: Result, _> = raw_tokens + .iter() + .map(|token| token.spelling().to_str()) + .collect(); + + let mut tokens = if let Ok(tokens) = tokens { + tokens + } else { + let raw_name = raw_tokens.remove(0); + warn!( + "Ignoring macro {:?} containing invalid UTF-8 tokens.", + raw_name.spelling() + ); + return; + }; + + let name = tokens.remove(0); + let args: Vec<_> = tokens + .drain(..boundary) + .skip(1) + .take(boundary - 2) + .filter(|&token| token != ",") + .collect(); + let body = tokens; + + let info = FnMacroInfo { + name, + args: &args, + body: &body, + }; + + callbacks.fn_macro(&info); } } @@ -260,7 +285,7 @@ impl ClangSubItemParser for Var { EvalResult::Int(Wrapping(value)) => { let kind = ctx .options() - .last_callback(|c| c.int_macro(&name, value)) + .last_callback(|c| c.int_macro(&name, value.into())) .unwrap_or_else(|| { default_macro_constant_type(ctx, value) }); From 402ebeaefb3657c202d403de7685e1cc9d9262a0 Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Fri, 16 Jun 2023 12:53:08 +0200 Subject: [PATCH 02/23] Gather all includes, even ones without a source file. --- .../expectations/tests/allowlist-file.rs | 2 +- .../expectations/tests/allowlist_item.rs | 2 +- .../expectations/tests/jsval_layout_opaque.rs | 4 +- .../tests/jsval_layout_opaque_1_0.rs | 4 +- .../tests/expectations/tests/layout_arp.rs | 14 ++--- .../tests/expectations/tests/layout_array.rs | 14 ++--- .../expectations/tests/layout_eth_conf.rs | 50 ++++++++--------- .../expectations/tests/layout_eth_conf_1_0.rs | 50 ++++++++--------- .../tests/expectations/tests/namespace.rs | 4 +- ...mplate_instantiation_with_fn_local_type.rs | 24 ++++----- bindgen-tests/tests/tests.rs | 2 +- bindgen/clang.rs | 53 ++++++++----------- bindgen/ir/context.rs | 6 +-- 13 files changed, 111 insertions(+), 118 deletions(-) diff --git a/bindgen-tests/tests/expectations/tests/allowlist-file.rs b/bindgen-tests/tests/expectations/tests/allowlist-file.rs index cb2aa01c59..e70862cd41 100644 --- a/bindgen-tests/tests/expectations/tests/allowlist-file.rs +++ b/bindgen-tests/tests/expectations/tests/allowlist-file.rs @@ -1,5 +1,4 @@ #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] -pub const SOME_DEFUN: u32 = 123; extern "C" { #[link_name = "\u{1}_Z12SomeFunctionv"] pub fn SomeFunction(); @@ -7,6 +6,7 @@ extern "C" { extern "C" { pub static mut someVar: ::std::os::raw::c_int; } +pub const SOME_DEFUN: u32 = 123; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct someClass { diff --git a/bindgen-tests/tests/expectations/tests/allowlist_item.rs b/bindgen-tests/tests/expectations/tests/allowlist_item.rs index f816f5170b..5b2a701860 100644 --- a/bindgen-tests/tests/expectations/tests/allowlist_item.rs +++ b/bindgen-tests/tests/expectations/tests/allowlist_item.rs @@ -1,5 +1,4 @@ #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] -pub const FooDefault: u32 = 0; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct Foo { @@ -13,3 +12,4 @@ const _: () = { extern "C" { pub fn FooNew(value: ::std::os::raw::c_int) -> Foo; } +pub const FooDefault: u32 = 0; diff --git a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs index 93fcc92b48..4fecd5969d 100644 --- a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs +++ b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs @@ -84,8 +84,6 @@ where } } pub const JSVAL_TAG_SHIFT: u32 = 47; -pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327; -pub const JSVAL_TAG_MASK: i64 = -140737488355328; #[repr(u8)] #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] pub enum JSValueType { @@ -127,6 +125,8 @@ pub enum JSValueShiftedTag { JSVAL_SHIFTED_TAG_NULL = 18445477436314353664, JSVAL_SHIFTED_TAG_OBJECT = 18445618173802708992, } +pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327; +pub const JSVAL_TAG_MASK: i64 = -140737488355328; #[repr(u32)] #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] pub enum JSWhyMagic { diff --git a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs index 7ae53bc40f..c61b3f940f 100644 --- a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs +++ b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs @@ -127,8 +127,6 @@ impl ::std::cmp::PartialEq for __BindgenUnionField { } impl ::std::cmp::Eq for __BindgenUnionField {} pub const JSVAL_TAG_SHIFT: u32 = 47; -pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327; -pub const JSVAL_TAG_MASK: i64 = -140737488355328; #[repr(u8)] #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] pub enum JSValueType { @@ -170,6 +168,8 @@ pub enum JSValueShiftedTag { JSVAL_SHIFTED_TAG_NULL = 18445477436314353664, JSVAL_SHIFTED_TAG_OBJECT = 18445618173802708992, } +pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327; +pub const JSVAL_TAG_MASK: i64 = -140737488355328; #[repr(u32)] #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] pub enum JSWhyMagic { diff --git a/bindgen-tests/tests/expectations/tests/layout_arp.rs b/bindgen-tests/tests/expectations/tests/layout_arp.rs index c48fd0e24e..7ae5585e02 100644 --- a/bindgen-tests/tests/expectations/tests/layout_arp.rs +++ b/bindgen-tests/tests/expectations/tests/layout_arp.rs @@ -1,12 +1,5 @@ #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] pub const ETHER_ADDR_LEN: u32 = 6; -pub const ARP_HRD_ETHER: u32 = 1; -pub const ARP_OP_REQUEST: u32 = 1; -pub const ARP_OP_REPLY: u32 = 2; -pub const ARP_OP_REVREQUEST: u32 = 3; -pub const ARP_OP_REVREPLY: u32 = 4; -pub const ARP_OP_INVREQUEST: u32 = 8; -pub const ARP_OP_INVREPLY: u32 = 9; /** Ethernet address: A universally administered address is uniquely assigned to a device by its manufacturer. The first three octets (in transmission order) contain the @@ -91,3 +84,10 @@ const _: () = { "Offset of field: arp_hdr::arp_data", ][::std::mem::offset_of!(arp_hdr, arp_data) - 8usize]; }; +pub const ARP_HRD_ETHER: u32 = 1; +pub const ARP_OP_REQUEST: u32 = 1; +pub const ARP_OP_REPLY: u32 = 2; +pub const ARP_OP_REVREQUEST: u32 = 3; +pub const ARP_OP_REVREPLY: u32 = 4; +pub const ARP_OP_INVREQUEST: u32 = 8; +pub const ARP_OP_INVREPLY: u32 = 9; diff --git a/bindgen-tests/tests/expectations/tests/layout_array.rs b/bindgen-tests/tests/expectations/tests/layout_array.rs index b910159beb..140a55750b 100644 --- a/bindgen-tests/tests/expectations/tests/layout_array.rs +++ b/bindgen-tests/tests/expectations/tests/layout_array.rs @@ -1,13 +1,6 @@ #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] pub const RTE_CACHE_LINE_SIZE: u32 = 64; pub const RTE_MEMPOOL_OPS_NAMESIZE: u32 = 32; -pub const RTE_MEMPOOL_MAX_OPS_IDX: u32 = 16; -pub const RTE_HEAP_NUM_FREELISTS: u32 = 13; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct rte_mempool { - _unused: [u8; 0], -} /** Prototype for implementation specific data provisioning function. The function should provide the implementation specific memory for @@ -19,6 +12,11 @@ pub struct rte_mempool { pub type rte_mempool_alloc_t = ::std::option::Option< unsafe extern "C" fn(mp: *mut rte_mempool) -> ::std::os::raw::c_int, >; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct rte_mempool { + _unused: [u8; 0], +} /// Free the opaque private data pointed to by mp->pool_data pointer. pub type rte_mempool_free_t = ::std::option::Option< unsafe extern "C" fn(mp: *mut rte_mempool), @@ -122,6 +120,7 @@ impl ::std::cmp::PartialEq for rte_mempool_ops { && self.get_count == other.get_count } } +pub const RTE_MEMPOOL_MAX_OPS_IDX: u32 = 16; /// The rte_spinlock_t type. #[repr(C)] #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)] @@ -207,6 +206,7 @@ impl Default for rte_mempool_ops_table { } } } +pub const RTE_HEAP_NUM_FREELISTS: u32 = 13; /// Structure to hold malloc heap #[repr(C)] #[repr(align(64))] diff --git a/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs b/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs index 9b98bac376..206196b77b 100644 --- a/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs +++ b/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs @@ -90,31 +90,6 @@ pub const ETH_VMDQ_MAX_VLAN_FILTERS: u32 = 64; pub const ETH_DCB_NUM_USER_PRIORITIES: u32 = 8; pub const ETH_VMDQ_DCB_NUM_QUEUES: u32 = 128; pub const ETH_DCB_NUM_QUEUES: u32 = 128; -pub const RTE_ETH_FDIR_MAX_FLEXLEN: u32 = 16; -pub const RTE_ETH_INSET_SIZE_MAX: u32 = 128; -pub const RTE_ETH_FLOW_UNKNOWN: u32 = 0; -pub const RTE_ETH_FLOW_RAW: u32 = 1; -pub const RTE_ETH_FLOW_IPV4: u32 = 2; -pub const RTE_ETH_FLOW_FRAG_IPV4: u32 = 3; -pub const RTE_ETH_FLOW_NONFRAG_IPV4_TCP: u32 = 4; -pub const RTE_ETH_FLOW_NONFRAG_IPV4_UDP: u32 = 5; -pub const RTE_ETH_FLOW_NONFRAG_IPV4_SCTP: u32 = 6; -pub const RTE_ETH_FLOW_NONFRAG_IPV4_OTHER: u32 = 7; -pub const RTE_ETH_FLOW_IPV6: u32 = 8; -pub const RTE_ETH_FLOW_FRAG_IPV6: u32 = 9; -pub const RTE_ETH_FLOW_NONFRAG_IPV6_TCP: u32 = 10; -pub const RTE_ETH_FLOW_NONFRAG_IPV6_UDP: u32 = 11; -pub const RTE_ETH_FLOW_NONFRAG_IPV6_SCTP: u32 = 12; -pub const RTE_ETH_FLOW_NONFRAG_IPV6_OTHER: u32 = 13; -pub const RTE_ETH_FLOW_L2_PAYLOAD: u32 = 14; -pub const RTE_ETH_FLOW_IPV6_EX: u32 = 15; -pub const RTE_ETH_FLOW_IPV6_TCP_EX: u32 = 16; -pub const RTE_ETH_FLOW_IPV6_UDP_EX: u32 = 17; -pub const RTE_ETH_FLOW_PORT: u32 = 18; -pub const RTE_ETH_FLOW_VXLAN: u32 = 19; -pub const RTE_ETH_FLOW_GENEVE: u32 = 20; -pub const RTE_ETH_FLOW_NVGRE: u32 = 21; -pub const RTE_ETH_FLOW_MAX: u32 = 22; #[repr(u32)] /** A set of values to identify what method is to be used to route packets to multiple queues.*/ @@ -1250,6 +1225,8 @@ pub enum rte_eth_payload_type { RTE_ETH_L4_PAYLOAD = 4, RTE_ETH_PAYLOAD_MAX = 8, } +pub const RTE_ETH_FDIR_MAX_FLEXLEN: u32 = 16; +pub const RTE_ETH_INSET_SIZE_MAX: u32 = 128; /** A structure used to select bytes extracted from the protocol layers to flexible payload for filter*/ #[repr(C)] @@ -1326,6 +1303,29 @@ fn bindgen_test_layout_rte_eth_fdir_flex_mask() { "Offset of field: rte_eth_fdir_flex_mask::mask", ); } +pub const RTE_ETH_FLOW_UNKNOWN: u32 = 0; +pub const RTE_ETH_FLOW_RAW: u32 = 1; +pub const RTE_ETH_FLOW_IPV4: u32 = 2; +pub const RTE_ETH_FLOW_FRAG_IPV4: u32 = 3; +pub const RTE_ETH_FLOW_NONFRAG_IPV4_TCP: u32 = 4; +pub const RTE_ETH_FLOW_NONFRAG_IPV4_UDP: u32 = 5; +pub const RTE_ETH_FLOW_NONFRAG_IPV4_SCTP: u32 = 6; +pub const RTE_ETH_FLOW_NONFRAG_IPV4_OTHER: u32 = 7; +pub const RTE_ETH_FLOW_IPV6: u32 = 8; +pub const RTE_ETH_FLOW_FRAG_IPV6: u32 = 9; +pub const RTE_ETH_FLOW_NONFRAG_IPV6_TCP: u32 = 10; +pub const RTE_ETH_FLOW_NONFRAG_IPV6_UDP: u32 = 11; +pub const RTE_ETH_FLOW_NONFRAG_IPV6_SCTP: u32 = 12; +pub const RTE_ETH_FLOW_NONFRAG_IPV6_OTHER: u32 = 13; +pub const RTE_ETH_FLOW_L2_PAYLOAD: u32 = 14; +pub const RTE_ETH_FLOW_IPV6_EX: u32 = 15; +pub const RTE_ETH_FLOW_IPV6_TCP_EX: u32 = 16; +pub const RTE_ETH_FLOW_IPV6_UDP_EX: u32 = 17; +pub const RTE_ETH_FLOW_PORT: u32 = 18; +pub const RTE_ETH_FLOW_VXLAN: u32 = 19; +pub const RTE_ETH_FLOW_GENEVE: u32 = 20; +pub const RTE_ETH_FLOW_NVGRE: u32 = 21; +pub const RTE_ETH_FLOW_MAX: u32 = 22; /** A structure used to define all flexible payload related setting include flex payload and flex mask*/ #[repr(C)] diff --git a/bindgen-tests/tests/expectations/tests/layout_eth_conf_1_0.rs b/bindgen-tests/tests/expectations/tests/layout_eth_conf_1_0.rs index 34688b20b3..20ced62470 100644 --- a/bindgen-tests/tests/expectations/tests/layout_eth_conf_1_0.rs +++ b/bindgen-tests/tests/expectations/tests/layout_eth_conf_1_0.rs @@ -133,31 +133,6 @@ pub const ETH_VMDQ_MAX_VLAN_FILTERS: u32 = 64; pub const ETH_DCB_NUM_USER_PRIORITIES: u32 = 8; pub const ETH_VMDQ_DCB_NUM_QUEUES: u32 = 128; pub const ETH_DCB_NUM_QUEUES: u32 = 128; -pub const RTE_ETH_FDIR_MAX_FLEXLEN: u32 = 16; -pub const RTE_ETH_INSET_SIZE_MAX: u32 = 128; -pub const RTE_ETH_FLOW_UNKNOWN: u32 = 0; -pub const RTE_ETH_FLOW_RAW: u32 = 1; -pub const RTE_ETH_FLOW_IPV4: u32 = 2; -pub const RTE_ETH_FLOW_FRAG_IPV4: u32 = 3; -pub const RTE_ETH_FLOW_NONFRAG_IPV4_TCP: u32 = 4; -pub const RTE_ETH_FLOW_NONFRAG_IPV4_UDP: u32 = 5; -pub const RTE_ETH_FLOW_NONFRAG_IPV4_SCTP: u32 = 6; -pub const RTE_ETH_FLOW_NONFRAG_IPV4_OTHER: u32 = 7; -pub const RTE_ETH_FLOW_IPV6: u32 = 8; -pub const RTE_ETH_FLOW_FRAG_IPV6: u32 = 9; -pub const RTE_ETH_FLOW_NONFRAG_IPV6_TCP: u32 = 10; -pub const RTE_ETH_FLOW_NONFRAG_IPV6_UDP: u32 = 11; -pub const RTE_ETH_FLOW_NONFRAG_IPV6_SCTP: u32 = 12; -pub const RTE_ETH_FLOW_NONFRAG_IPV6_OTHER: u32 = 13; -pub const RTE_ETH_FLOW_L2_PAYLOAD: u32 = 14; -pub const RTE_ETH_FLOW_IPV6_EX: u32 = 15; -pub const RTE_ETH_FLOW_IPV6_TCP_EX: u32 = 16; -pub const RTE_ETH_FLOW_IPV6_UDP_EX: u32 = 17; -pub const RTE_ETH_FLOW_PORT: u32 = 18; -pub const RTE_ETH_FLOW_VXLAN: u32 = 19; -pub const RTE_ETH_FLOW_GENEVE: u32 = 20; -pub const RTE_ETH_FLOW_NVGRE: u32 = 21; -pub const RTE_ETH_FLOW_MAX: u32 = 22; #[repr(u32)] /** A set of values to identify what method is to be used to route packets to multiple queues.*/ @@ -1363,6 +1338,8 @@ pub enum rte_eth_payload_type { RTE_ETH_L4_PAYLOAD = 4, RTE_ETH_PAYLOAD_MAX = 8, } +pub const RTE_ETH_FDIR_MAX_FLEXLEN: u32 = 16; +pub const RTE_ETH_INSET_SIZE_MAX: u32 = 128; /** A structure used to select bytes extracted from the protocol layers to flexible payload for filter*/ #[repr(C)] @@ -1449,6 +1426,29 @@ impl Clone for rte_eth_fdir_flex_mask { *self } } +pub const RTE_ETH_FLOW_UNKNOWN: u32 = 0; +pub const RTE_ETH_FLOW_RAW: u32 = 1; +pub const RTE_ETH_FLOW_IPV4: u32 = 2; +pub const RTE_ETH_FLOW_FRAG_IPV4: u32 = 3; +pub const RTE_ETH_FLOW_NONFRAG_IPV4_TCP: u32 = 4; +pub const RTE_ETH_FLOW_NONFRAG_IPV4_UDP: u32 = 5; +pub const RTE_ETH_FLOW_NONFRAG_IPV4_SCTP: u32 = 6; +pub const RTE_ETH_FLOW_NONFRAG_IPV4_OTHER: u32 = 7; +pub const RTE_ETH_FLOW_IPV6: u32 = 8; +pub const RTE_ETH_FLOW_FRAG_IPV6: u32 = 9; +pub const RTE_ETH_FLOW_NONFRAG_IPV6_TCP: u32 = 10; +pub const RTE_ETH_FLOW_NONFRAG_IPV6_UDP: u32 = 11; +pub const RTE_ETH_FLOW_NONFRAG_IPV6_SCTP: u32 = 12; +pub const RTE_ETH_FLOW_NONFRAG_IPV6_OTHER: u32 = 13; +pub const RTE_ETH_FLOW_L2_PAYLOAD: u32 = 14; +pub const RTE_ETH_FLOW_IPV6_EX: u32 = 15; +pub const RTE_ETH_FLOW_IPV6_TCP_EX: u32 = 16; +pub const RTE_ETH_FLOW_IPV6_UDP_EX: u32 = 17; +pub const RTE_ETH_FLOW_PORT: u32 = 18; +pub const RTE_ETH_FLOW_VXLAN: u32 = 19; +pub const RTE_ETH_FLOW_GENEVE: u32 = 20; +pub const RTE_ETH_FLOW_NVGRE: u32 = 21; +pub const RTE_ETH_FLOW_MAX: u32 = 22; /** A structure used to define all flexible payload related setting include flex payload and flex mask*/ #[repr(C)] diff --git a/bindgen-tests/tests/expectations/tests/namespace.rs b/bindgen-tests/tests/expectations/tests/namespace.rs index 93e201d329..28607dee32 100644 --- a/bindgen-tests/tests/expectations/tests/namespace.rs +++ b/bindgen-tests/tests/expectations/tests/namespace.rs @@ -17,7 +17,7 @@ pub mod root { pub fn in_whatever(); } } - pub mod _bindgen_mod_id_17 { + pub mod _bindgen_mod_id_13 { #[allow(unused_imports)] use self::super::super::root; #[repr(C)] @@ -35,7 +35,7 @@ pub mod root { #[derive(Debug)] pub struct C { pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, - pub _base: root::_bindgen_mod_id_17::A, + pub _base: root::_bindgen_mod_id_13::A, pub m_c: T, pub m_c_ptr: *mut T, pub m_c_arr: [T; 10usize], diff --git a/bindgen-tests/tests/expectations/tests/template_instantiation_with_fn_local_type.rs b/bindgen-tests/tests/expectations/tests/template_instantiation_with_fn_local_type.rs index f152f1ae8e..068a970488 100644 --- a/bindgen-tests/tests/expectations/tests/template_instantiation_with_fn_local_type.rs +++ b/bindgen-tests/tests/expectations/tests/template_instantiation_with_fn_local_type.rs @@ -4,10 +4,6 @@ pub struct Foo { pub _address: u8, } -extern "C" { - #[link_name = "\u{1}_Z1fv"] - pub fn f(); -} const _: () = { [ "Size of template specialization: Foo_open0_Bar_close0", @@ -16,6 +12,18 @@ const _: () = { "Align of template specialization: Foo_open0_Bar_close0", ][::std::mem::align_of::() - 1usize]; }; +const _: () = { + [ + "Size of template specialization: Foo_open0_Boo_close0", + ][::std::mem::size_of::() - 1usize]; + [ + "Align of template specialization: Foo_open0_Boo_close0", + ][::std::mem::align_of::() - 1usize]; +}; +extern "C" { + #[link_name = "\u{1}_Z1fv"] + pub fn f(); +} #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct Baz { @@ -25,14 +33,6 @@ const _: () = { ["Size of Baz"][::std::mem::size_of::() - 1usize]; ["Alignment of Baz"][::std::mem::align_of::() - 1usize]; }; -const _: () = { - [ - "Size of template specialization: Foo_open0_Boo_close0", - ][::std::mem::size_of::() - 1usize]; - [ - "Align of template specialization: Foo_open0_Boo_close0", - ][::std::mem::align_of::() - 1usize]; -}; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct Bar { diff --git a/bindgen-tests/tests/tests.rs b/bindgen-tests/tests/tests.rs index 14988e463f..6bf084bc75 100644 --- a/bindgen-tests/tests/tests.rs +++ b/bindgen-tests/tests/tests.rs @@ -535,9 +535,9 @@ fn test_mixed_header_and_header_contents() { env!("CARGO_MANIFEST_DIR"), "/tests/headers/func_ptr.h" )) - .header(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/headers/char.h")) .header_contents("test.h", "int bar(const char* a);") .header_contents("test2.h", "float bar2(const char* b);") + .header(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/headers/char.h")) .clang_arg("--target=x86_64-unknown-linux") .generate() .unwrap() diff --git a/bindgen/clang.rs b/bindgen/clang.rs index 9267b45826..0f10e19c64 100644 --- a/bindgen/clang.rs +++ b/bindgen/clang.rs @@ -510,17 +510,6 @@ impl Cursor { ) where Visitor: FnMut(&mut BindgenContext, Cursor), { - // FIXME(#2556): The current source order stuff doesn't account well for different levels - // of includes, or includes that show up at the same byte offset because they are passed in - // via CLI. - const SOURCE_ORDER_ENABLED: bool = false; - if !SOURCE_ORDER_ENABLED { - return self.visit(|c| { - visitor(ctx, c); - CXChildVisit_Continue - }); - } - let mut children = self.collect_children(); for child in &children { if child.kind() == CXCursor_InclusionDirective { @@ -528,9 +517,8 @@ impl Cursor { let location = child.location(); let (source_file, _, _, offset) = location.location(); - if let Some(source_file) = source_file.name() { - ctx.add_include(source_file, included_file, offset); - } + let source_file = source_file.name(); + ctx.add_include(source_file, included_file, offset); } } } @@ -557,36 +545,41 @@ impl Cursor { let (file, other_file) = match (file.name(), other_file.name()) { (Some(file), Some(other_file)) => (file, other_file), - // Built-in definitions should come first. - (Some(_), None) => return cmp::Ordering::Greater, - (None, Some(_)) => return cmp::Ordering::Less, - (None, None) => return cmp::Ordering::Equal, + // Keep the original sorting of built-in definitions. + (None, _) | (_, None) => return cmp::Ordering::Equal, }; + // If both items are in the same source file, simply compare the offset. if file == other_file { - // Both items are in the same source file, compare by byte offset. return offset.cmp(&other_offset); } + // `None` here means `file`/`other_file` is the main header file. let include_location = ctx.included_file_location(&file); let other_include_location = ctx.included_file_location(&other_file); + match (include_location, other_include_location) { - (Some((file2, offset2)), _) if file2 == other_file => { + // The main header file (`None`) comes after header passed as CLI argument (`Some((None, _))`). + (None, Some((None, _))) => cmp::Ordering::Greater, + (Some((None, _)), None) => cmp::Ordering::Less, + // If an item was included in the same source file as the other item, + // compare its `#include` location offset the offset of the other item. + (Some((Some(file2), offset2)), _) if file2 == other_file => { offset2.cmp(&other_offset) } - (Some(_), None) => cmp::Ordering::Greater, - (_, Some((other_file2, other_offset2))) if file == other_file2 => { + (_, Some((Some(other_file2), other_offset2))) + if file == other_file2 => + { offset.cmp(&other_offset2) } - (None, Some(_)) => cmp::Ordering::Less, - (Some((file2, offset2)), Some((other_file2, other_offset2))) => { - if file2 == other_file2 { - offset2.cmp(&other_offset2) - } else { - cmp::Ordering::Equal - } + // If both items were included in the same file, compare the offset of their `#include` directives. + (Some((file2, offset2)), Some((other_file2, other_offset2))) + if file2 == other_file2 => + { + offset2.cmp(&other_offset2) } - (None, None) => cmp::Ordering::Equal, + // Otherwise, keep the original sorting. + _ => cmp::Ordering::Equal, } } diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs index 85380c3c87..0707edfe1b 100644 --- a/bindgen/ir/context.rs +++ b/bindgen/ir/context.rs @@ -364,7 +364,7 @@ pub(crate) struct BindgenContext { /// /// The key is the included file, the value is a pair of the source file and /// the position of the `#include` directive in the source file. - includes: StdHashMap, + includes: StdHashMap, usize)>, /// A set of all the included filenames. deps: BTreeSet>, @@ -661,7 +661,7 @@ If you encounter an error missing from this list, please file an issue or a PR!" /// Add the location of the `#include` directive for the `included_file`. pub(crate) fn add_include( &mut self, - source_file: String, + source_file: Option, included_file: String, offset: usize, ) { @@ -674,7 +674,7 @@ If you encounter an error missing from this list, please file an issue or a PR!" pub(crate) fn included_file_location( &self, included_file: &str, - ) -> Option<(String, usize)> { + ) -> Option<(Option, usize)> { self.includes.get(included_file).cloned() } From 7298d4484e721f198df402cd38368e9a93b13625 Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Fri, 16 Jun 2023 12:06:02 +0200 Subject: [PATCH 03/23] Fix test on macOS. --- bindgen-tests/tests/headers/issue-2556.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bindgen-tests/tests/headers/issue-2556.h b/bindgen-tests/tests/headers/issue-2556.h index bbb1b874ec..88a559e191 100644 --- a/bindgen-tests/tests/headers/issue-2556.h +++ b/bindgen-tests/tests/headers/issue-2556.h @@ -1,4 +1,4 @@ -// bindgen-flags: --enable-cxx-namespaces -- -x c++ -Itests/headers -include tests/headers/issue-2556/nsStyleStruct.h -include tests/headers/issue-2556/LayoutConstants.h +// bindgen-flags: --enable-cxx-namespaces -- -x c++ -std=c++11 -Itests/headers -include tests/headers/issue-2556/nsStyleStruct.h -include tests/headers/issue-2556/LayoutConstants.h #include "issue-2556/nsSize.h" #include "issue-2556/nsStyleStruct.h" From e411d787ad4b5fbdc5813c09c4b89317748f649d Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Sat, 17 Jun 2023 15:58:48 +0200 Subject: [PATCH 04/23] Add test for nested includes. --- .../tests/expectations/tests/source-order.rs | 25 +++++++++++++++++++ bindgen-tests/tests/headers/source-order.h | 7 ++++++ .../headers/source-order/source-order-2.h | 7 ++++++ .../headers/source-order/source-order-3.h | 3 +++ 4 files changed, 42 insertions(+) create mode 100644 bindgen-tests/tests/expectations/tests/source-order.rs create mode 100644 bindgen-tests/tests/headers/source-order.h create mode 100644 bindgen-tests/tests/headers/source-order/source-order-2.h create mode 100644 bindgen-tests/tests/headers/source-order/source-order-3.h diff --git a/bindgen-tests/tests/expectations/tests/source-order.rs b/bindgen-tests/tests/expectations/tests/source-order.rs new file mode 100644 index 0000000000..cff74fc90c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/source-order.rs @@ -0,0 +1,25 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const THIS_SHOULD_BE_FIRST: ::std::os::raw::c_int = 1; +extern "C" { + pub fn THIS_SHOULD_BE_SECOND(); +} +pub type THIS_SHOULD_BE_THIRD = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct THIS_SHOULD_BE_FOURTH {} +#[test] +fn bindgen_test_layout_THIS_SHOULD_BE_FOURTH() { + assert_eq!( + ::std::mem::size_of::(), + 0usize, + concat!("Size of: ", stringify!(THIS_SHOULD_BE_FOURTH)), + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!("Alignment of ", stringify!(THIS_SHOULD_BE_FOURTH)), + ); +} +extern "C" { + pub static mut THIS_SHOULD_BE_FIFTH: ::std::os::raw::c_int; +} diff --git a/bindgen-tests/tests/headers/source-order.h b/bindgen-tests/tests/headers/source-order.h new file mode 100644 index 0000000000..a70edfdb30 --- /dev/null +++ b/bindgen-tests/tests/headers/source-order.h @@ -0,0 +1,7 @@ +// bindgen-flags: -- -Itests/headers/source-order + +const int THIS_SHOULD_BE_FIRST = 1; + +#include "source-order-2.h" + +extern int THIS_SHOULD_BE_FIFTH; diff --git a/bindgen-tests/tests/headers/source-order/source-order-2.h b/bindgen-tests/tests/headers/source-order/source-order-2.h new file mode 100644 index 0000000000..af5d4283aa --- /dev/null +++ b/bindgen-tests/tests/headers/source-order/source-order-2.h @@ -0,0 +1,7 @@ +#pragma once + +void THIS_SHOULD_BE_SECOND(); + +#include "source-order-3.h" + +struct THIS_SHOULD_BE_FOURTH {}; diff --git a/bindgen-tests/tests/headers/source-order/source-order-3.h b/bindgen-tests/tests/headers/source-order/source-order-3.h new file mode 100644 index 0000000000..67b9a838cf --- /dev/null +++ b/bindgen-tests/tests/headers/source-order/source-order-3.h @@ -0,0 +1,3 @@ +#pragma once + +typedef int THIS_SHOULD_BE_THIRD; From ff84f486cc2c9a622b8d80ec7cec22cf6a708a2f Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Sat, 17 Jun 2023 18:12:43 +0200 Subject: [PATCH 05/23] Handle all cases in `cmp_by_source_order`. --- bindgen/clang.rs | 163 +++++++++++++++++++++++++++++++++++------- bindgen/ir/context.rs | 32 ++++++++- 2 files changed, 168 insertions(+), 27 deletions(-) diff --git a/bindgen/clang.rs b/bindgen/clang.rs index 0f10e19c64..84a0fda72b 100644 --- a/bindgen/clang.rs +++ b/bindgen/clang.rs @@ -4,7 +4,7 @@ #![allow(non_upper_case_globals, dead_code)] #![deny(clippy::missing_docs_in_private_items)] -use crate::ir::context::BindgenContext; +use crate::ir::context::{BindgenContext, IncludeLocation}; use clang_sys::*; use std::cmp; @@ -554,32 +554,145 @@ impl Cursor { return offset.cmp(&other_offset); } - // `None` here means `file`/`other_file` is the main header file. - let include_location = ctx.included_file_location(&file); - let other_include_location = ctx.included_file_location(&other_file); + let mut include_location = ctx.included_file_location(&file); + let mut other_include_location = + ctx.included_file_location(&other_file); - match (include_location, other_include_location) { - // The main header file (`None`) comes after header passed as CLI argument (`Some((None, _))`). - (None, Some((None, _))) => cmp::Ordering::Greater, - (Some((None, _)), None) => cmp::Ordering::Less, - // If an item was included in the same source file as the other item, - // compare its `#include` location offset the offset of the other item. - (Some((Some(file2), offset2)), _) if file2 == other_file => { - offset2.cmp(&other_offset) - } - (_, Some((Some(other_file2), other_offset2))) - if file == other_file2 => - { - offset.cmp(&other_offset2) - } - // If both items were included in the same file, compare the offset of their `#include` directives. - (Some((file2, offset2)), Some((other_file2, other_offset2))) - if file2 == other_file2 => - { - offset2.cmp(&other_offset2) + use IncludeLocation::*; + + loop { + match (&include_location, &other_include_location) { + // Both items are in the main header file, this should already have been handled at this point. + (Main, Main) => { + unreachable!("Should have been handled at this point.") + } + // Headers passed as CLI arguments come before the main header file. + (Main, Cli { .. }) => return cmp::Ordering::Greater, + (Cli { .. }, Main) => return cmp::Ordering::Less, + // If both were included via CLI arguments, compare their offset. + ( + Cli { offset: offset2 }, + Cli { + offset: other_offset2, + }, + ) => return offset2.cmp(other_offset2), + // If an item was included in the same source file as the other item, + // compare its `#include` location offset the offset of the other item. + ( + File { + file_name: ref file2, + offset: offset2, + }, + Main, + ) => { + if *file2 == other_file { + return offset2.cmp(&other_offset); + } + + // Continue checking one level up. + include_location = ctx.included_file_location(file2); + } + ( + Main, + File { + file_name: ref other_file2, + offset: other_offset2, + }, + ) => { + if file == *other_file2 { + return offset.cmp(other_offset2); + } + + // Continue checking one level up. + other_include_location = + ctx.included_file_location(other_file2); + } + ( + File { + file_name: file2, + offset: offset2, + }, + File { + file_name: other_file2, + offset: other_offset2, + }, + ) => { + // If both items were included in the same file, compare the offset of their `#include` directives. + if file2 == other_file2 { + return offset2.cmp(other_offset2); + } + + // Find the offset of where `file` is transivitely included in `ancestor_file`. + let offset_in_ancestor = + |mut file: String, ancestor_file: &str| { + while file != ancestor_file { + let include_location = + ctx.included_file_location(&file); + file = if let IncludeLocation::File { + file_name: file, + offset, + } = include_location + { + if file == ancestor_file { + return Some(offset); + } + + file + } else { + break; + } + } + + None + }; + + if let Some(offset2) = + offset_in_ancestor(file2.clone(), other_file2) + { + return offset2.cmp(other_offset2); + } + + if let Some(other_offset2) = + offset_in_ancestor(other_file2.clone(), file2) + { + return offset2.cmp(&other_offset2); + } + + // Otherwise, go one level up. + // + // # Example + // + // a.h + // ├── b.h + // └── c.h + // + // When comparing items inside `b.h` and `c.h`, go up one level and + // compare the include locations of `b.h` and `c.h` in `a.h` instead. + include_location = ctx.included_file_location(file2); + other_include_location = + ctx.included_file_location(other_file2); + } + ( + File { + file_name: file2, .. + }, + Cli { .. }, + ) => { + // Continue checking one level up. + include_location = ctx.included_file_location(file2); + } + ( + Cli { .. }, + File { + file_name: other_file2, + .. + }, + ) => { + // Continue checking one level up. + other_include_location = + ctx.included_file_location(other_file2); + } } - // Otherwise, keep the original sorting. - _ => cmp::Ordering::Equal, } } diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs index 0707edfe1b..d3ab443b52 100644 --- a/bindgen/ir/context.rs +++ b/bindgen/ir/context.rs @@ -307,6 +307,25 @@ enum TypeKey { Declaration(Cursor), } +/// Specifies where a header was included from. +#[derive(Debug)] +pub(crate) enum IncludeLocation { + /// Include location of the main header file, i.e. none. + Main, + /// Include location of a header specified as a CLI argument. + Cli { + /// Offset of the include location. + offset: usize, + }, + /// Include location of a header included with the `#include` directive. + File { + /// Source file name of the include location. + file_name: String, + /// Offset of the include location. + offset: usize, + }, +} + /// A context used during parsing and generation of structs. #[derive(Debug)] pub(crate) struct BindgenContext { @@ -674,8 +693,17 @@ If you encounter an error missing from this list, please file an issue or a PR!" pub(crate) fn included_file_location( &self, included_file: &str, - ) -> Option<(Option, usize)> { - self.includes.get(included_file).cloned() + ) -> IncludeLocation { + match self.includes.get(included_file).cloned() { + // Header was not included anywhere, so it must be the main header. + None => IncludeLocation::Main, + // Header has no source location, so it must have been included via CLI arguments. + Some((None, offset)) => IncludeLocation::Cli { offset }, + // Header was included with an `#include` directive. + Some((Some(file_name), offset)) => { + IncludeLocation::File { file_name, offset } + } + } } /// Add an included file. From 610c6f66884ce190a942c118167c2e27a2cd716e Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Mon, 19 Jun 2023 17:17:24 +0200 Subject: [PATCH 06/23] Add source order test for headers that are siblings. --- ...source-order.rs => source-order-nested.rs} | 21 +++++++------------ .../tests/source-order-siblings.rs | 14 +++++++++++++ .../tests/headers/source-order-nested.h | 7 +++++++ .../source-order-nested-2.h} | 2 +- .../source-order-nested-3.h} | 0 .../tests/headers/source-order-siblings.h | 6 ++++++ .../tests/headers/source-order-siblings/a.h | 5 +++++ .../tests/headers/source-order-siblings/aa.h | 3 +++ .../tests/headers/source-order-siblings/b.h | 5 +++++ .../tests/headers/source-order-siblings/bb.h | 3 +++ bindgen-tests/tests/headers/source-order.h | 7 ------- 11 files changed, 52 insertions(+), 21 deletions(-) rename bindgen-tests/tests/expectations/tests/{source-order.rs => source-order-nested.rs} (51%) create mode 100644 bindgen-tests/tests/expectations/tests/source-order-siblings.rs create mode 100644 bindgen-tests/tests/headers/source-order-nested.h rename bindgen-tests/tests/headers/{source-order/source-order-2.h => source-order-nested/source-order-nested-2.h} (69%) rename bindgen-tests/tests/headers/{source-order/source-order-3.h => source-order-nested/source-order-nested-3.h} (100%) create mode 100644 bindgen-tests/tests/headers/source-order-siblings.h create mode 100644 bindgen-tests/tests/headers/source-order-siblings/a.h create mode 100644 bindgen-tests/tests/headers/source-order-siblings/aa.h create mode 100644 bindgen-tests/tests/headers/source-order-siblings/b.h create mode 100644 bindgen-tests/tests/headers/source-order-siblings/bb.h delete mode 100644 bindgen-tests/tests/headers/source-order.h diff --git a/bindgen-tests/tests/expectations/tests/source-order.rs b/bindgen-tests/tests/expectations/tests/source-order-nested.rs similarity index 51% rename from bindgen-tests/tests/expectations/tests/source-order.rs rename to bindgen-tests/tests/expectations/tests/source-order-nested.rs index cff74fc90c..59eadaa48f 100644 --- a/bindgen-tests/tests/expectations/tests/source-order.rs +++ b/bindgen-tests/tests/expectations/tests/source-order-nested.rs @@ -7,19 +7,14 @@ pub type THIS_SHOULD_BE_THIRD = ::std::os::raw::c_int; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct THIS_SHOULD_BE_FOURTH {} -#[test] -fn bindgen_test_layout_THIS_SHOULD_BE_FOURTH() { - assert_eq!( - ::std::mem::size_of::(), - 0usize, - concat!("Size of: ", stringify!(THIS_SHOULD_BE_FOURTH)), - ); - assert_eq!( - ::std::mem::align_of::(), - 1usize, - concat!("Alignment of ", stringify!(THIS_SHOULD_BE_FOURTH)), - ); -} +const _: () = { + [ + "Size of THIS_SHOULD_BE_FOURTH", + ][::std::mem::size_of::() - 0usize]; + [ + "Alignment of THIS_SHOULD_BE_FOURTH", + ][::std::mem::align_of::() - 1usize]; +}; extern "C" { pub static mut THIS_SHOULD_BE_FIFTH: ::std::os::raw::c_int; } diff --git a/bindgen-tests/tests/expectations/tests/source-order-siblings.rs b/bindgen-tests/tests/expectations/tests/source-order-siblings.rs new file mode 100644 index 0000000000..02585bed4b --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/source-order-siblings.rs @@ -0,0 +1,14 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const ROOT: &[u8; 5] = b"root\0"; +pub const A: ::std::os::raw::c_char = 97; +extern "C" { + pub fn AA(); +} +pub const B: u8 = 98u8; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct BB {} +const _: () = { + ["Size of BB"][::std::mem::size_of::() - 0usize]; + ["Alignment of BB"][::std::mem::align_of::() - 1usize]; +}; diff --git a/bindgen-tests/tests/headers/source-order-nested.h b/bindgen-tests/tests/headers/source-order-nested.h new file mode 100644 index 0000000000..2a51cf971c --- /dev/null +++ b/bindgen-tests/tests/headers/source-order-nested.h @@ -0,0 +1,7 @@ +// bindgen-flags: -- -Itests/headers/source-order-nested + +const int THIS_SHOULD_BE_FIRST = 1; + +#include "source-order-nested-2.h" + +extern int THIS_SHOULD_BE_FIFTH; diff --git a/bindgen-tests/tests/headers/source-order/source-order-2.h b/bindgen-tests/tests/headers/source-order-nested/source-order-nested-2.h similarity index 69% rename from bindgen-tests/tests/headers/source-order/source-order-2.h rename to bindgen-tests/tests/headers/source-order-nested/source-order-nested-2.h index af5d4283aa..a9db8fd54f 100644 --- a/bindgen-tests/tests/headers/source-order/source-order-2.h +++ b/bindgen-tests/tests/headers/source-order-nested/source-order-nested-2.h @@ -2,6 +2,6 @@ void THIS_SHOULD_BE_SECOND(); -#include "source-order-3.h" +#include "source-order-nested-3.h" struct THIS_SHOULD_BE_FOURTH {}; diff --git a/bindgen-tests/tests/headers/source-order/source-order-3.h b/bindgen-tests/tests/headers/source-order-nested/source-order-nested-3.h similarity index 100% rename from bindgen-tests/tests/headers/source-order/source-order-3.h rename to bindgen-tests/tests/headers/source-order-nested/source-order-nested-3.h diff --git a/bindgen-tests/tests/headers/source-order-siblings.h b/bindgen-tests/tests/headers/source-order-siblings.h new file mode 100644 index 0000000000..9533152829 --- /dev/null +++ b/bindgen-tests/tests/headers/source-order-siblings.h @@ -0,0 +1,6 @@ +// bindgen-flags: -- -Itests/headers/source-order-siblings + +const char* ROOT = "root"; + +#include "a.h" +#include "b.h" diff --git a/bindgen-tests/tests/headers/source-order-siblings/a.h b/bindgen-tests/tests/headers/source-order-siblings/a.h new file mode 100644 index 0000000000..7821b612df --- /dev/null +++ b/bindgen-tests/tests/headers/source-order-siblings/a.h @@ -0,0 +1,5 @@ +#pragma once + +const char A = 'a'; + +#include "aa.h" diff --git a/bindgen-tests/tests/headers/source-order-siblings/aa.h b/bindgen-tests/tests/headers/source-order-siblings/aa.h new file mode 100644 index 0000000000..9fa550902f --- /dev/null +++ b/bindgen-tests/tests/headers/source-order-siblings/aa.h @@ -0,0 +1,3 @@ +#pragma once + +void AA(); diff --git a/bindgen-tests/tests/headers/source-order-siblings/b.h b/bindgen-tests/tests/headers/source-order-siblings/b.h new file mode 100644 index 0000000000..fc6740afaa --- /dev/null +++ b/bindgen-tests/tests/headers/source-order-siblings/b.h @@ -0,0 +1,5 @@ +#pragma once + +#define B 'b' + +#include "bb.h" diff --git a/bindgen-tests/tests/headers/source-order-siblings/bb.h b/bindgen-tests/tests/headers/source-order-siblings/bb.h new file mode 100644 index 0000000000..81d03e82f7 --- /dev/null +++ b/bindgen-tests/tests/headers/source-order-siblings/bb.h @@ -0,0 +1,3 @@ +#pragma once + +struct BB {}; diff --git a/bindgen-tests/tests/headers/source-order.h b/bindgen-tests/tests/headers/source-order.h deleted file mode 100644 index a70edfdb30..0000000000 --- a/bindgen-tests/tests/headers/source-order.h +++ /dev/null @@ -1,7 +0,0 @@ -// bindgen-flags: -- -Itests/headers/source-order - -const int THIS_SHOULD_BE_FIRST = 1; - -#include "source-order-2.h" - -extern int THIS_SHOULD_BE_FIFTH; From 4ef7437118c386e87958e414e185b2c074b3c309 Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Tue, 20 Jun 2023 20:51:14 +0200 Subject: [PATCH 07/23] Make `SourceLocation` an `enum`. --- bindgen/clang.rs | 340 +++++++++++++++++------------------------ bindgen/codegen/mod.rs | 55 ++++--- bindgen/ir/context.rs | 152 ++++++++++++++---- bindgen/ir/item.rs | 12 +- bindgen/ir/var.rs | 20 ++- 5 files changed, 308 insertions(+), 271 deletions(-) diff --git a/bindgen/clang.rs b/bindgen/clang.rs index 84a0fda72b..166da720f7 100644 --- a/bindgen/clang.rs +++ b/bindgen/clang.rs @@ -8,6 +8,7 @@ use crate::ir::context::{BindgenContext, IncludeLocation}; use clang_sys::*; use std::cmp; +use std::convert::TryInto; use std::ffi::{CStr, CString}; use std::fmt; use std::fs::OpenOptions; @@ -137,8 +138,7 @@ impl Cursor { /// Returns whether the cursor refers to a built-in definition. pub(crate) fn is_builtin(&self) -> bool { - let (file, _, _, _) = self.location().location(); - file.name().is_none() + matches!(self.location(), SourceLocation::Builtin { .. }) } /// Get the `Cursor` for this cursor's referent's lexical parent. @@ -378,8 +378,31 @@ impl Cursor { /// Get the source location for the referent. pub(crate) fn location(&self) -> SourceLocation { unsafe { - SourceLocation { - x: clang_getCursorLocation(self.x), + let location = clang_getCursorLocation(self.x); + + let mut file = mem::zeroed(); + let mut line = 0; + let mut column = 0; + let mut offset = 0; + clang_getSpellingLocation( + location, + &mut file, + &mut line, + &mut column, + &mut offset, + ); + + if file.is_null() { + SourceLocation::Builtin { + offset: offset.try_into().unwrap(), + } + } else { + SourceLocation::File { + file_name: cxstring_into_string(clang_getFileName(file)), + line: line.try_into().unwrap(), + column: column.try_into().unwrap(), + offset: offset.try_into().unwrap(), + } } } } @@ -514,11 +537,7 @@ impl Cursor { for child in &children { if child.kind() == CXCursor_InclusionDirective { if let Some(included_file) = child.get_included_file_name() { - let location = child.location(); - let (source_file, _, _, offset) = location.location(); - - let source_file = source_file.name(); - ctx.add_include(source_file, included_file, offset); + ctx.add_include(included_file, child.location()); } } } @@ -529,171 +548,16 @@ impl Cursor { } } - /// Compare source order of two cursors, considering `#include` directives. - /// - /// Built-in items provided by the compiler (which don't have a source file), - /// are sorted first. Remaining files are sorted by their position in the source file. - /// If the items' source files differ, they are sorted by the position of the first - /// `#include` for their source file. If no source files are included, `None` is returned. + /// Compare two cursors according how they appear in source files. fn cmp_by_source_order( &self, other: &Self, ctx: &BindgenContext, ) -> cmp::Ordering { - let (file, _, _, offset) = self.location().location(); - let (other_file, _, _, other_offset) = other.location().location(); - - let (file, other_file) = match (file.name(), other_file.name()) { - (Some(file), Some(other_file)) => (file, other_file), - // Keep the original sorting of built-in definitions. - (None, _) | (_, None) => return cmp::Ordering::Equal, - }; - - // If both items are in the same source file, simply compare the offset. - if file == other_file { - return offset.cmp(&other_offset); - } - - let mut include_location = ctx.included_file_location(&file); - let mut other_include_location = - ctx.included_file_location(&other_file); - - use IncludeLocation::*; - - loop { - match (&include_location, &other_include_location) { - // Both items are in the main header file, this should already have been handled at this point. - (Main, Main) => { - unreachable!("Should have been handled at this point.") - } - // Headers passed as CLI arguments come before the main header file. - (Main, Cli { .. }) => return cmp::Ordering::Greater, - (Cli { .. }, Main) => return cmp::Ordering::Less, - // If both were included via CLI arguments, compare their offset. - ( - Cli { offset: offset2 }, - Cli { - offset: other_offset2, - }, - ) => return offset2.cmp(other_offset2), - // If an item was included in the same source file as the other item, - // compare its `#include` location offset the offset of the other item. - ( - File { - file_name: ref file2, - offset: offset2, - }, - Main, - ) => { - if *file2 == other_file { - return offset2.cmp(&other_offset); - } + let location = self.location(); + let other_location = other.location(); - // Continue checking one level up. - include_location = ctx.included_file_location(file2); - } - ( - Main, - File { - file_name: ref other_file2, - offset: other_offset2, - }, - ) => { - if file == *other_file2 { - return offset.cmp(other_offset2); - } - - // Continue checking one level up. - other_include_location = - ctx.included_file_location(other_file2); - } - ( - File { - file_name: file2, - offset: offset2, - }, - File { - file_name: other_file2, - offset: other_offset2, - }, - ) => { - // If both items were included in the same file, compare the offset of their `#include` directives. - if file2 == other_file2 { - return offset2.cmp(other_offset2); - } - - // Find the offset of where `file` is transivitely included in `ancestor_file`. - let offset_in_ancestor = - |mut file: String, ancestor_file: &str| { - while file != ancestor_file { - let include_location = - ctx.included_file_location(&file); - file = if let IncludeLocation::File { - file_name: file, - offset, - } = include_location - { - if file == ancestor_file { - return Some(offset); - } - - file - } else { - break; - } - } - - None - }; - - if let Some(offset2) = - offset_in_ancestor(file2.clone(), other_file2) - { - return offset2.cmp(other_offset2); - } - - if let Some(other_offset2) = - offset_in_ancestor(other_file2.clone(), file2) - { - return offset2.cmp(&other_offset2); - } - - // Otherwise, go one level up. - // - // # Example - // - // a.h - // ├── b.h - // └── c.h - // - // When comparing items inside `b.h` and `c.h`, go up one level and - // compare the include locations of `b.h` and `c.h` in `a.h` instead. - include_location = ctx.included_file_location(file2); - other_include_location = - ctx.included_file_location(other_file2); - } - ( - File { - file_name: file2, .. - }, - Cli { .. }, - ) => { - // Continue checking one level up. - include_location = ctx.included_file_location(file2); - } - ( - Cli { .. }, - File { - file_name: other_file2, - .. - }, - ) => { - // Continue checking one level up. - other_include_location = - ctx.included_file_location(other_file2); - } - } - } + location.cmp_by_source_order(&other_location, ctx) } /// Collect all of this cursor's children into a vec and return them. @@ -1698,36 +1562,119 @@ impl ExactSizeIterator for TypeTemplateArgIterator { } } -/// A `SourceLocation` is a file, line, column, and byte offset location for -/// some source text. -pub(crate) struct SourceLocation { - x: CXSourceLocation, +/// A location of some source code. +#[derive(Clone)] +pub(crate) enum SourceLocation { + /// Location of a built-in. + Builtin { + /// Offset. + offset: usize, + }, + /// Location in a source file. + File { + /// Name of the source file. + file_name: String, + /// Line in the source file. + line: usize, + /// Column in the source file. + column: usize, + /// Offset in the source file. + offset: usize, + }, } impl SourceLocation { - /// Get the (file, line, column, byte offset) tuple for this source - /// location. - pub(crate) fn location(&self) -> (File, usize, usize, usize) { - unsafe { - let mut file = mem::zeroed(); - let mut line = 0; - let mut col = 0; - let mut off = 0; - clang_getFileLocation( - self.x, &mut file, &mut line, &mut col, &mut off, - ); - (File { x: file }, line as usize, col as usize, off as usize) + /// Locations of built-in items provided by the compiler (which don't have a source file), + /// are sorted first. Remaining locations are sorted by their position in the source file. + /// If the locations' source files differ, they are sorted by the position of where the + /// source files are first transitively included, see `IncludeLocation::cmp_by_source_order`. + pub fn cmp_by_source_order( + &self, + other: &Self, + ctx: &BindgenContext, + ) -> cmp::Ordering { + match (self, other) { + ( + SourceLocation::Builtin { offset }, + SourceLocation::Builtin { + offset: other_offset, + }, + ) => offset.cmp(other_offset), + // Built-ins come first. + (SourceLocation::Builtin { .. }, _) => cmp::Ordering::Less, + (_, SourceLocation::Builtin { .. }) => { + other.cmp_by_source_order(self, ctx).reverse() + } + ( + SourceLocation::File { + file_name, offset, .. + }, + SourceLocation::File { + file_name: other_file_name, + offset: other_offset, + .. + }, + ) => { + if file_name == other_file_name { + return offset.cmp(other_offset); + } + + // If `file` is transitively included via `ancestor_file`, + // find the offset of the include directive in `ancestor_file`. + let offset_in_ancestor = |file: &str, ancestor_file: &str| { + let mut file = file; + while file != ancestor_file { + let include_location = ctx.include_location(file); + file = if let IncludeLocation::File { + file_name: file, + offset, + .. + } = include_location + { + if file == ancestor_file { + return Some(offset); + } + + file + } else { + break; + } + } + + None + }; + + if let Some(offset) = + offset_in_ancestor(file_name, other_file_name) + { + return offset.cmp(other_offset); + } + + if let Some(other_offset) = + offset_in_ancestor(other_file_name, file_name) + { + return offset.cmp(other_offset); + } + + // If the source files are siblings, compare their include locations. + let parent = ctx.include_location(file_name); + let other_parent = ctx.include_location(other_file_name); + parent.cmp_by_source_order(other_parent, ctx) + } } } } impl fmt::Display for SourceLocation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let (file, line, col, _) = self.location(); - if let Some(name) = file.name() { - write!(f, "{}:{}:{}", name, line, col) - } else { - "builtin definitions".fmt(f) + match self { + Self::Builtin { .. } => "built-in".fmt(f), + Self::File { + file_name, + line, + column, + .. + } => write!(f, "{}:{}:{}", file_name, line, column), } } } @@ -1837,21 +1784,6 @@ impl Iterator for CommentAttributesIterator { } } -/// A source file. -pub(crate) struct File { - x: CXFile, -} - -impl File { - /// Get the name of this source file. - pub(crate) fn name(&self) -> Option { - if self.x.is_null() { - return None; - } - Some(unsafe { cxstring_into_string(clang_getFileName(self.x)) }) - } -} - fn cxstring_to_string_leaky(s: CXString) -> String { if s.data.is_null() { return "".to_owned(); diff --git a/bindgen/codegen/mod.rs b/bindgen/codegen/mod.rs index 0b23e0acc3..193c979abe 100644 --- a/bindgen/codegen/mod.rs +++ b/bindgen/codegen/mod.rs @@ -4631,17 +4631,19 @@ fn unsupported_abi_diagnostic( Level::Note, ); - if let Some(loc) = location { - let (file, line, col, _) = loc.location(); - - if let Some(filename) = file.name() { - if let Ok(Some(source)) = get_line(&filename, line) { - let mut slice = Slice::default(); - slice - .with_source(source) - .with_location(filename, line, col); - diag.add_slice(slice); - } + if let Some(crate::clang::SourceLocation::File { + file_name, + line, + column, + .. + }) = location.cloned() + { + if let Ok(Some(source)) = get_line(&file_name, line) { + let mut slice = Slice::default(); + slice + .with_source(source) + .with_location(file_name, line, column); + diag.add_slice(slice); } } @@ -4649,10 +4651,11 @@ fn unsupported_abi_diagnostic( } } +#[cfg_attr(not(feature = "experimental"), allow(unused_variables))] fn variadic_fn_diagnostic( fn_name: &str, - _location: Option<&crate::clang::SourceLocation>, - _ctx: &BindgenContext, + location: Option<&crate::clang::SourceLocation>, + ctx: &BindgenContext, ) { warn!( "Cannot generate wrapper for the static variadic function `{}`.", @@ -4660,7 +4663,7 @@ fn variadic_fn_diagnostic( ); #[cfg(feature = "experimental")] - if _ctx.options().emit_diagnostics { + if ctx.options().emit_diagnostics { use crate::diagnostics::{get_line, Diagnostic, Level, Slice}; let mut diag = Diagnostic::default(); @@ -4669,17 +4672,19 @@ fn variadic_fn_diagnostic( .add_annotation("The `--wrap-static-fns` feature does not support variadic functions.", Level::Note) .add_annotation("No code will be generated for this function.", Level::Note); - if let Some(loc) = _location { - let (file, line, col, _) = loc.location(); - - if let Some(filename) = file.name() { - if let Ok(Some(source)) = get_line(&filename, line) { - let mut slice = Slice::default(); - slice - .with_source(source) - .with_location(filename, line, col); - diag.add_slice(slice); - } + if let Some(crate::clang::SourceLocation::File { + file_name, + line, + column, + .. + }) = location.cloned() + { + if let Ok(Some(source)) = get_line(&file_name, line) { + let mut slice = Slice::default(); + slice + .with_source(source) + .with_location(file_name, line, column); + diag.add_slice(slice); } } diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs index d3ab443b52..7ef88bfbf3 100644 --- a/bindgen/ir/context.rs +++ b/bindgen/ir/context.rs @@ -31,8 +31,8 @@ use std::cell::{Cell, RefCell}; use std::collections::{BTreeSet, HashMap as StdHashMap}; use std::fs::OpenOptions; use std::io::Write; -use std::mem; use std::path::Path; +use std::{cmp, mem}; /// An identifier for some kind of IR item. #[derive(Debug, Copy, Clone, Eq, PartialOrd, Ord, Hash)] @@ -317,15 +317,99 @@ pub(crate) enum IncludeLocation { /// Offset of the include location. offset: usize, }, - /// Include location of a header included with the `#include` directive. + /// Include location of a header included with an `#include` directive. File { /// Source file name of the include location. file_name: String, + /// Line of the include location. + line: usize, + /// Column of the include location. + column: usize, /// Offset of the include location. offset: usize, }, } +impl IncludeLocation { + /// Header include locations are sorted in the order they appear in, which means + /// headers provided as command line arguments (`-include`) are sorted first, + /// followed by the main header file, and lastly headers included with `#include` + /// directives. + /// + /// Nested headers are sorted according to where they were transitively included first. + pub fn cmp_by_source_order( + &self, + other: &Self, + ctx: &BindgenContext, + ) -> cmp::Ordering { + match (self, other) { + // If both headers are included via CLI argument, compare their offset. + ( + IncludeLocation::Cli { offset }, + IncludeLocation::Cli { + offset: other_offset, + }, + ) => offset.cmp(other_offset), + // Headers included via CLI arguments come first. + (IncludeLocation::Cli { .. }, IncludeLocation::Main) => { + cmp::Ordering::Less + } + (IncludeLocation::Main, IncludeLocation::Cli { .. }) => { + cmp::Ordering::Greater + } + // If both includes refer to the main header file, they are equal. + (IncludeLocation::Main, IncludeLocation::Main) => { + cmp::Ordering::Equal + } + // If one is included via CLI arguments or the main header file, + // recursively compare with the other's include location. + ( + IncludeLocation::Cli { .. } | IncludeLocation::Main, + IncludeLocation::File { + file_name: other_file_name, + .. + }, + ) => { + let other_parent = ctx.include_location(other_file_name); + self.cmp_by_source_order(other_parent, ctx) + } + ( + IncludeLocation::File { .. }, + IncludeLocation::Cli { .. } | IncludeLocation::Main, + ) => other.cmp_by_source_order(self, ctx).reverse(), + // If both include locations are in files, compare them as `SourceLocation`s. + ( + IncludeLocation::File { + file_name, + line, + column, + offset, + }, + IncludeLocation::File { + file_name: other_file_name, + line: other_line, + column: other_column, + offset: other_offset, + }, + ) => SourceLocation::File { + file_name: file_name.clone(), + line: *line, + column: *column, + offset: *offset, + } + .cmp_by_source_order( + &SourceLocation::File { + file_name: other_file_name.clone(), + line: *other_line, + column: *other_column, + offset: *other_offset, + }, + ctx, + ), + } + } +} + /// A context used during parsing and generation of structs. #[derive(Debug)] pub(crate) struct BindgenContext { @@ -383,7 +467,7 @@ pub(crate) struct BindgenContext { /// /// The key is the included file, the value is a pair of the source file and /// the position of the `#include` directive in the source file. - includes: StdHashMap, usize)>, + includes: StdHashMap, /// A set of all the included filenames. deps: BTreeSet>, @@ -677,33 +761,45 @@ If you encounter an error missing from this list, please file an issue or a PR!" ) } - /// Add the location of the `#include` directive for the `included_file`. + /// Add the location of where `included_file` is included. pub(crate) fn add_include( &mut self, - source_file: Option, included_file: String, - offset: usize, + source_location: SourceLocation, ) { + let include_location = match source_location { + // Include location is a built-in, so it must have been included via CLI arguments. + SourceLocation::Builtin { offset } => { + IncludeLocation::Cli { offset } + } + // Header was included with an `#include` directive. + SourceLocation::File { + file_name, + line, + column, + offset, + } => IncludeLocation::File { + file_name, + line, + column, + offset, + }, + }; + self.includes .entry(included_file) - .or_insert((source_file, offset)); + .or_insert(include_location); } /// Get the location of the first `#include` directive for the `included_file`. - pub(crate) fn included_file_location( + pub(crate) fn include_location( &self, included_file: &str, - ) -> IncludeLocation { - match self.includes.get(included_file).cloned() { + ) -> &IncludeLocation { + self.includes.get(included_file).unwrap_or( // Header was not included anywhere, so it must be the main header. - None => IncludeLocation::Main, - // Header has no source location, so it must have been included via CLI arguments. - Some((None, offset)) => IncludeLocation::Cli { offset }, - // Header was included with an `#include` directive. - Some((Some(file_name), offset)) => { - IncludeLocation::File { file_name, offset } - } - } + &IncludeLocation::Main, + ) } /// Add an included file. @@ -2517,16 +2613,16 @@ If you encounter an error missing from this list, please file an issue or a PR!" // Items with a source location in an explicitly allowlisted file // are always included. if !self.options().allowlisted_files.is_empty() { - if let Some(location) = item.location() { - let (file, _, _, _) = location.location(); - if let Some(filename) = file.name() { - if self - .options() - .allowlisted_files - .matches(filename) - { - return true; - } + if let Some(SourceLocation::File { + file_name, .. + }) = item.location() + { + if self + .options() + .allowlisted_files + .matches(file_name) + { + return true; } } } diff --git a/bindgen/ir/item.rs b/bindgen/ir/item.rs index 8dc7bf84ee..5786e37c87 100644 --- a/bindgen/ir/item.rs +++ b/bindgen/ir/item.rs @@ -17,7 +17,7 @@ use super::module::Module; use super::template::{AsTemplateParam, TemplateParameters}; use super::traversal::{EdgeKind, Trace, Tracer}; use super::ty::{Type, TypeKind}; -use crate::clang; +use crate::clang::{self, SourceLocation}; use crate::parse::{ClangSubItemParser, ParseError, ParseResult}; use std::cell::{Cell, OnceCell}; @@ -640,12 +640,10 @@ impl Item { } if !ctx.options().blocklisted_files.is_empty() { - if let Some(location) = &self.location { - let (file, _, _, _) = location.location(); - if let Some(filename) = file.name() { - if ctx.options().blocklisted_files.matches(filename) { - return true; - } + if let Some(SourceLocation::File { file_name, .. }) = &self.location + { + if ctx.options().blocklisted_files.matches(file_name) { + return true; } } } diff --git a/bindgen/ir/var.rs b/bindgen/ir/var.rs index 1b20c2ab60..923d1bd889 100644 --- a/bindgen/ir/var.rs +++ b/bindgen/ir/var.rs @@ -504,10 +504,11 @@ fn get_integer_literal_from_cursor(cursor: &clang::Cursor) -> Option { value } +#[cfg_attr(not(feature = "experimental"), allow(unused_variables))] fn duplicated_macro_diagnostic( macro_name: &str, - _location: crate::clang::SourceLocation, - _ctx: &BindgenContext, + location: crate::clang::SourceLocation, + ctx: &BindgenContext, ) { warn!("Duplicated macro definition: {}", macro_name); @@ -525,19 +526,24 @@ fn duplicated_macro_diagnostic( // // Will trigger this message even though there's nothing wrong with it. #[allow(clippy::overly_complex_bool_expr)] - if false && _ctx.options().emit_diagnostics { + if false && ctx.options().emit_diagnostics { use crate::diagnostics::{get_line, Diagnostic, Level, Slice}; use std::borrow::Cow; let mut slice = Slice::default(); let mut source = Cow::from(macro_name); - let (file, line, col, _) = _location.location(); - if let Some(filename) = file.name() { - if let Ok(Some(code)) = get_line(&filename, line) { + if let crate::clang::SourceLocation::File { + file_name, + line, + column, + .. + } = location + { + if let Ok(Some(code)) = get_line(&file_name, line) { source = code.into(); } - slice.with_location(filename, line, col); + slice.with_location(file_name, line, column); } slice.with_source(source); From d4cba9c654a32e471e46fac342e4fd844d6d4898 Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Wed, 21 Jun 2023 15:50:41 +0200 Subject: [PATCH 08/23] Don't count include locations of main header file. --- .../tests/source-order-recursive.rs | 28 +++++++ .../tests/headers/source-order-recursive.h | 14 ++++ .../source-order-recursive-2.h | 5 ++ bindgen/clang.rs | 59 ++++++++++---- bindgen/codegen/mod.rs | 12 +-- bindgen/diagnostics.rs | 17 ++-- bindgen/ir/context.rs | 81 ++++++++++--------- bindgen/ir/item.rs | 8 +- bindgen/ir/var.rs | 6 +- 9 files changed, 158 insertions(+), 72 deletions(-) create mode 100644 bindgen-tests/tests/expectations/tests/source-order-recursive.rs create mode 100644 bindgen-tests/tests/headers/source-order-recursive.h create mode 100644 bindgen-tests/tests/headers/source-order-recursive/source-order-recursive-2.h diff --git a/bindgen-tests/tests/expectations/tests/source-order-recursive.rs b/bindgen-tests/tests/expectations/tests/source-order-recursive.rs new file mode 100644 index 0000000000..ab92066c97 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/source-order-recursive.rs @@ -0,0 +1,28 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct foo {} +const _: () = { + ["Size of foo"][::std::mem::size_of::() - 0usize]; + ["Alignment of foo"][::std::mem::align_of::() - 1usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct bar { + pub field: foo, +} +const _: () = { + ["Size of bar"][::std::mem::size_of::() - 0usize]; + ["Alignment of bar"][::std::mem::align_of::() - 1usize]; + ["Offset of field: bar::field"][::std::mem::offset_of!(bar, field) - 0usize]; +}; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct baz { + pub field: bar, +} +const _: () = { + ["Size of baz"][::std::mem::size_of::() - 0usize]; + ["Alignment of baz"][::std::mem::align_of::() - 1usize]; + ["Offset of field: baz::field"][::std::mem::offset_of!(baz, field) - 0usize]; +}; diff --git a/bindgen-tests/tests/headers/source-order-recursive.h b/bindgen-tests/tests/headers/source-order-recursive.h new file mode 100644 index 0000000000..6d589a7f7c --- /dev/null +++ b/bindgen-tests/tests/headers/source-order-recursive.h @@ -0,0 +1,14 @@ +// bindgen-flags: -- -Itests/headers -Itests/headers/source-order-recursive + +#ifndef A_H +#define A_H + +struct foo {}; + +#include "source-order-recursive-2.h" + +struct baz { + struct bar field; +}; + +#endif diff --git a/bindgen-tests/tests/headers/source-order-recursive/source-order-recursive-2.h b/bindgen-tests/tests/headers/source-order-recursive/source-order-recursive-2.h new file mode 100644 index 0000000000..01ff1890b1 --- /dev/null +++ b/bindgen-tests/tests/headers/source-order-recursive/source-order-recursive-2.h @@ -0,0 +1,5 @@ +#include "source-order-recursive.h" + +struct bar { + struct foo field; +}; diff --git a/bindgen/clang.rs b/bindgen/clang.rs index 166da720f7..33f00d72a7 100644 --- a/bindgen/clang.rs +++ b/bindgen/clang.rs @@ -7,7 +7,6 @@ use crate::ir::context::{BindgenContext, IncludeLocation}; use clang_sys::*; use std::cmp; - use std::convert::TryInto; use std::ffi::{CStr, CString}; use std::fmt; @@ -15,6 +14,8 @@ use std::fs::OpenOptions; use std::hash::Hash; use std::hash::Hasher; use std::os::raw::{c_char, c_int, c_longlong, c_uint, c_ulong, c_ulonglong}; +use std::path::Path; +use std::path::PathBuf; use std::sync::OnceLock; use std::{mem, ptr, slice}; @@ -397,8 +398,9 @@ impl Cursor { offset: offset.try_into().unwrap(), } } else { + let file_name = cxstring_into_string(clang_getFileName(file)); SourceLocation::File { - file_name: cxstring_into_string(clang_getFileName(file)), + file_path: absolutize_path(file_name), line: line.try_into().unwrap(), column: column.try_into().unwrap(), offset: offset.try_into().unwrap(), @@ -536,8 +538,12 @@ impl Cursor { let mut children = self.collect_children(); for child in &children { if child.kind() == CXCursor_InclusionDirective { - if let Some(included_file) = child.get_included_file_name() { - ctx.add_include(included_file, child.location()); + if let Some(included_file_name) = child.get_included_file_name() + { + ctx.add_include( + absolutize_path(included_file_name), + child.location(), + ); } } } @@ -1573,7 +1579,7 @@ pub(crate) enum SourceLocation { /// Location in a source file. File { /// Name of the source file. - file_name: String, + file_path: PathBuf, /// Line in the source file. line: usize, /// Column in the source file. @@ -1583,6 +1589,18 @@ pub(crate) enum SourceLocation { }, } +fn absolutize_path>(path: P) -> PathBuf { + let path = path.as_ref(); + + if path.is_relative() { + std::env::current_dir() + .expect("Cannot retrieve current directory") + .join(path) + } else { + path.to_owned() + } +} + impl SourceLocation { /// Locations of built-in items provided by the compiler (which don't have a source file), /// are sorted first. Remaining locations are sorted by their position in the source file. @@ -1607,26 +1625,26 @@ impl SourceLocation { } ( SourceLocation::File { - file_name, offset, .. + file_path, offset, .. }, SourceLocation::File { - file_name: other_file_name, + file_path: other_file_path, offset: other_offset, .. }, ) => { - if file_name == other_file_name { + if file_path == other_file_path { return offset.cmp(other_offset); } // If `file` is transitively included via `ancestor_file`, // find the offset of the include directive in `ancestor_file`. - let offset_in_ancestor = |file: &str, ancestor_file: &str| { + let offset_in_ancestor = |file: &Path, ancestor_file: &Path| { let mut file = file; while file != ancestor_file { let include_location = ctx.include_location(file); file = if let IncludeLocation::File { - file_name: file, + file_path: file, offset, .. } = include_location @@ -1645,20 +1663,20 @@ impl SourceLocation { }; if let Some(offset) = - offset_in_ancestor(file_name, other_file_name) + offset_in_ancestor(file_path, other_file_path) { return offset.cmp(other_offset); } if let Some(other_offset) = - offset_in_ancestor(other_file_name, file_name) + offset_in_ancestor(other_file_path, file_path) { return offset.cmp(other_offset); } // If the source files are siblings, compare their include locations. - let parent = ctx.include_location(file_name); - let other_parent = ctx.include_location(other_file_name); + let parent = ctx.include_location(file_path); + let other_parent = ctx.include_location(other_file_path); parent.cmp_by_source_order(other_parent, ctx) } } @@ -1670,11 +1688,11 @@ impl fmt::Display for SourceLocation { match self { Self::Builtin { .. } => "built-in".fmt(f), Self::File { - file_name, + file_path, line, column, .. - } => write!(f, "{}:{}:{}", file_name, line, column), + } => write!(f, "{}:{}:{}", file_path.display(), line, column), } } } @@ -1905,6 +1923,15 @@ impl TranslationUnit { } } + /// Get the source file path of this translation unit. + pub(crate) fn path(&self) -> PathBuf { + let file_name = unsafe { + cxstring_into_string(clang_getTranslationUnitSpelling(self.x)) + }; + + absolutize_path(file_name) + } + /// Save a translation unit to the given file. pub(crate) fn save(&mut self, file: &str) -> Result<(), CXSaveError> { let file = if let Ok(cstring) = CString::new(file) { diff --git a/bindgen/codegen/mod.rs b/bindgen/codegen/mod.rs index 193c979abe..a426cfe0c4 100644 --- a/bindgen/codegen/mod.rs +++ b/bindgen/codegen/mod.rs @@ -4632,17 +4632,17 @@ fn unsupported_abi_diagnostic( ); if let Some(crate::clang::SourceLocation::File { - file_name, + file_path, line, column, .. }) = location.cloned() { - if let Ok(Some(source)) = get_line(&file_name, line) { + if let Ok(Some(source)) = get_line(&file_path, line) { let mut slice = Slice::default(); slice .with_source(source) - .with_location(file_name, line, column); + .with_location(file_path, line, column); diag.add_slice(slice); } } @@ -4673,17 +4673,17 @@ fn variadic_fn_diagnostic( .add_annotation("No code will be generated for this function.", Level::Note); if let Some(crate::clang::SourceLocation::File { - file_name, + file_path, line, column, .. }) = location.cloned() { - if let Ok(Some(source)) = get_line(&file_name, line) { + if let Ok(Some(source)) = get_line(&file_path, line) { let mut slice = Slice::default(); slice .with_source(source) - .with_location(file_name, line, column); + .with_location(file_path, line, column); diag.add_slice(slice); } } diff --git a/bindgen/diagnostics.rs b/bindgen/diagnostics.rs index f765afe970..0cb53a3736 100644 --- a/bindgen/diagnostics.rs +++ b/bindgen/diagnostics.rs @@ -2,8 +2,8 @@ //! //! The entry point of this module is the [`Diagnostic`] type. -use std::fmt::Write; use std::io::{self, BufRead, BufReader}; +use std::path::Path; use std::{borrow::Cow, fs::File}; use annotate_snippets::{ @@ -162,25 +162,24 @@ impl<'a> Slice<'a> { } /// Set the file, line and column. - pub(crate) fn with_location( + pub(crate) fn with_location>( &mut self, - mut name: String, + path: P, line: usize, col: usize, ) -> &mut Self { - write!(name, ":{}:{}", line, col) - .expect("Writing to a string cannot fail"); - self.filename = Some(name); + self.filename = + Some(format!("{}:{}:{}", path.as_ref().display(), line, col)); self.line = Some(line); self } } -pub(crate) fn get_line( - filename: &str, +pub(crate) fn get_line>( + file_path: P, line: usize, ) -> io::Result> { - let file = BufReader::new(File::open(filename)?); + let file = BufReader::new(File::open(file_path.as_ref())?); if let Some(line) = file.lines().nth(line.wrapping_sub(1)) { return line.map(Some); } diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs index 7ef88bfbf3..d15a5e609d 100644 --- a/bindgen/ir/context.rs +++ b/bindgen/ir/context.rs @@ -19,7 +19,7 @@ use super::module::{Module, ModuleKind}; use super::template::{TemplateInstantiation, TemplateParameters}; use super::traversal::{self, Edge, ItemTraversal}; use super::ty::{FloatKind, Type, TypeKind}; -use crate::clang::{self, ABIKind, Cursor}; +use crate::clang::{self, ABIKind, Cursor, SourceLocation}; use crate::codegen::CodegenError; use crate::BindgenOptions; use crate::{Entry, HashMap, HashSet}; @@ -31,7 +31,7 @@ use std::cell::{Cell, RefCell}; use std::collections::{BTreeSet, HashMap as StdHashMap}; use std::fs::OpenOptions; use std::io::Write; -use std::path::Path; +use std::path::{Path, PathBuf}; use std::{cmp, mem}; /// An identifier for some kind of IR item. @@ -320,7 +320,7 @@ pub(crate) enum IncludeLocation { /// Include location of a header included with an `#include` directive. File { /// Source file name of the include location. - file_name: String, + file_path: PathBuf, /// Line of the include location. line: usize, /// Column of the include location. @@ -366,11 +366,11 @@ impl IncludeLocation { ( IncludeLocation::Cli { .. } | IncludeLocation::Main, IncludeLocation::File { - file_name: other_file_name, + file_path: other_file_path, .. }, ) => { - let other_parent = ctx.include_location(other_file_name); + let other_parent = ctx.include_location(other_file_path); self.cmp_by_source_order(other_parent, ctx) } ( @@ -380,26 +380,26 @@ impl IncludeLocation { // If both include locations are in files, compare them as `SourceLocation`s. ( IncludeLocation::File { - file_name, + file_path, line, column, offset, }, IncludeLocation::File { - file_name: other_file_name, + file_path: other_file_path, line: other_line, column: other_column, offset: other_offset, }, ) => SourceLocation::File { - file_name: file_name.clone(), + file_path: file_path.clone(), line: *line, column: *column, offset: *offset, } .cmp_by_source_order( &SourceLocation::File { - file_name: other_file_name.clone(), + file_path: other_file_path.clone(), line: *other_line, column: *other_column, offset: *other_offset, @@ -467,7 +467,7 @@ pub(crate) struct BindgenContext { /// /// The key is the included file, the value is a pair of the source file and /// the position of the `#include` directive in the source file. - includes: StdHashMap, + includes: StdHashMap, /// A set of all the included filenames. deps: BTreeSet>, @@ -764,39 +764,48 @@ If you encounter an error missing from this list, please file an issue or a PR!" /// Add the location of where `included_file` is included. pub(crate) fn add_include( &mut self, - included_file: String, + included_file_path: PathBuf, source_location: SourceLocation, ) { - let include_location = match source_location { - // Include location is a built-in, so it must have been included via CLI arguments. - SourceLocation::Builtin { offset } => { - IncludeLocation::Cli { offset } + if self.includes.contains_key(&included_file_path) { + return; + } + + let include_location = { + // Recursively including the main header file doesn't count. + if self.translation_unit.path() == included_file_path { + IncludeLocation::Main + } else { + match source_location { + // Include location is a built-in, so it must have been included via CLI arguments. + SourceLocation::Builtin { offset } => { + IncludeLocation::Cli { offset } + } + // Header was included with an `#include` directive. + SourceLocation::File { + file_path, + line, + column, + offset, + } => IncludeLocation::File { + file_path, + line, + column, + offset, + }, + } } - // Header was included with an `#include` directive. - SourceLocation::File { - file_name, - line, - column, - offset, - } => IncludeLocation::File { - file_name, - line, - column, - offset, - }, }; - self.includes - .entry(included_file) - .or_insert(include_location); + self.includes.insert(included_file_path, include_location); } - /// Get the location of the first `#include` directive for the `included_file`. - pub(crate) fn include_location( + /// Get the location of the first `#include` directive for the `included_file_path`. + pub(crate) fn include_location>( &self, - included_file: &str, + included_file_path: P, ) -> &IncludeLocation { - self.includes.get(included_file).unwrap_or( + self.includes.get(included_file_path.as_ref()).unwrap_or( // Header was not included anywhere, so it must be the main header. &IncludeLocation::Main, ) @@ -2614,13 +2623,13 @@ If you encounter an error missing from this list, please file an issue or a PR!" // are always included. if !self.options().allowlisted_files.is_empty() { if let Some(SourceLocation::File { - file_name, .. + file_path, .. }) = item.location() { if self .options() .allowlisted_files - .matches(file_name) + .matches(file_path.display().to_string()) { return true; } diff --git a/bindgen/ir/item.rs b/bindgen/ir/item.rs index 5786e37c87..a168aaa5fd 100644 --- a/bindgen/ir/item.rs +++ b/bindgen/ir/item.rs @@ -640,9 +640,13 @@ impl Item { } if !ctx.options().blocklisted_files.is_empty() { - if let Some(SourceLocation::File { file_name, .. }) = &self.location + if let Some(SourceLocation::File { file_path, .. }) = &self.location { - if ctx.options().blocklisted_files.matches(file_name) { + if ctx + .options() + .blocklisted_files + .matches(file_path.display().to_string()) + { return true; } } diff --git a/bindgen/ir/var.rs b/bindgen/ir/var.rs index 923d1bd889..471d878b92 100644 --- a/bindgen/ir/var.rs +++ b/bindgen/ir/var.rs @@ -534,16 +534,16 @@ fn duplicated_macro_diagnostic( let mut source = Cow::from(macro_name); if let crate::clang::SourceLocation::File { - file_name, + file_path, line, column, .. } = location { - if let Ok(Some(code)) = get_line(&file_name, line) { + if let Ok(Some(code)) = get_line(&file_path, line) { source = code.into(); } - slice.with_location(file_name, line, column); + slice.with_location(file_path, line, column); } slice.with_source(source); From 5991e2c902650e4481101040b88fabd06e080c19 Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Tue, 20 Feb 2024 10:13:03 +0100 Subject: [PATCH 09/23] Don't eagerly absolutize source file paths. --- bindgen/clang.rs | 167 ++++++++++++++++++++++++----------------- bindgen/codegen/mod.rs | 6 +- bindgen/deps.rs | 22 +++--- bindgen/ir/context.rs | 42 +++++------ bindgen/ir/item.rs | 17 ++--- bindgen/ir/var.rs | 6 +- 6 files changed, 146 insertions(+), 114 deletions(-) diff --git a/bindgen/clang.rs b/bindgen/clang.rs index 33f00d72a7..7f201474b4 100644 --- a/bindgen/clang.rs +++ b/bindgen/clang.rs @@ -6,8 +6,10 @@ use crate::ir::context::{BindgenContext, IncludeLocation}; use clang_sys::*; +use std::borrow::Cow; use std::cmp; use std::convert::TryInto; +use std::env::current_dir; use std::ffi::{CStr, CString}; use std::fmt; use std::fs::OpenOptions; @@ -398,9 +400,8 @@ impl Cursor { offset: offset.try_into().unwrap(), } } else { - let file_name = cxstring_into_string(clang_getFileName(file)); SourceLocation::File { - file_path: absolutize_path(file_name), + file: SourceFile::from_raw(file), line: line.try_into().unwrap(), column: column.try_into().unwrap(), offset: offset.try_into().unwrap(), @@ -538,12 +539,8 @@ impl Cursor { let mut children = self.collect_children(); for child in &children { if child.kind() == CXCursor_InclusionDirective { - if let Some(included_file_name) = child.get_included_file_name() - { - ctx.add_include( - absolutize_path(included_file_name), - child.location(), - ); + if let Some(included_file) = child.get_included_file() { + ctx.add_include(included_file, child.location()); } } } @@ -936,14 +933,12 @@ impl Cursor { /// Obtain the real path name of a cursor of InclusionDirective kind. /// /// Returns None if the cursor does not include a file, otherwise the file's full name - pub(crate) fn get_included_file_name(&self) -> Option { - let file = unsafe { clang_sys::clang_getIncludedFile(self.x) }; + pub(crate) fn get_included_file(&self) -> Option { + let file = unsafe { clang_getIncludedFile(self.x) }; if file.is_null() { None } else { - Some(unsafe { - cxstring_into_string(clang_sys::clang_getFileName(file)) - }) + Some(unsafe { SourceFile::from_raw(file) }) } } } @@ -1578,8 +1573,8 @@ pub(crate) enum SourceLocation { }, /// Location in a source file. File { - /// Name of the source file. - file_path: PathBuf, + /// The source file. + file: SourceFile, /// Line in the source file. line: usize, /// Column in the source file. @@ -1589,18 +1584,6 @@ pub(crate) enum SourceLocation { }, } -fn absolutize_path>(path: P) -> PathBuf { - let path = path.as_ref(); - - if path.is_relative() { - std::env::current_dir() - .expect("Cannot retrieve current directory") - .join(path) - } else { - path.to_owned() - } -} - impl SourceLocation { /// Locations of built-in items provided by the compiler (which don't have a source file), /// are sorted first. Remaining locations are sorted by their position in the source file. @@ -1624,59 +1607,64 @@ impl SourceLocation { other.cmp_by_source_order(self, ctx).reverse() } ( + SourceLocation::File { file, offset, .. }, SourceLocation::File { - file_path, offset, .. - }, - SourceLocation::File { - file_path: other_file_path, + file: other_file, offset: other_offset, .. }, ) => { + let file_path = file.path(); + let other_file_path = other_file.path(); + if file_path == other_file_path { return offset.cmp(other_offset); } // If `file` is transitively included via `ancestor_file`, // find the offset of the include directive in `ancestor_file`. - let offset_in_ancestor = |file: &Path, ancestor_file: &Path| { - let mut file = file; - while file != ancestor_file { - let include_location = ctx.include_location(file); - file = if let IncludeLocation::File { - file_path: file, - offset, - .. - } = include_location - { - if file == ancestor_file { - return Some(offset); + let offset_in_ancestor = + |file_path: &Path, ancestor_file_path: &Path| { + let mut file_path = Cow::Borrowed(file_path); + while file_path != ancestor_file_path { + let include_location = + ctx.include_location(file_path); + file_path = if let IncludeLocation::File { + file, + offset, + .. + } = include_location + { + let file_path = Cow::Owned(file.path()); + + if file_path == ancestor_file_path { + return Some(offset); + } + + file_path + } else { + break; } - - file - } else { - break; } - } - None - }; + None + }; if let Some(offset) = - offset_in_ancestor(file_path, other_file_path) + offset_in_ancestor(&file_path, &other_file_path) { return offset.cmp(other_offset); } if let Some(other_offset) = - offset_in_ancestor(other_file_path, file_path) + offset_in_ancestor(&other_file_path, &file_path) { return offset.cmp(other_offset); } // If the source files are siblings, compare their include locations. let parent = ctx.include_location(file_path); - let other_parent = ctx.include_location(other_file_path); + let other_parent = ctx.include_location(&other_file_path); parent.cmp_by_source_order(other_parent, ctx) } } @@ -1688,11 +1676,8 @@ impl fmt::Display for SourceLocation { match self { Self::Builtin { .. } => "built-in".fmt(f), Self::File { - file_path, - line, - column, - .. - } => write!(f, "{}:{}:{}", file_path.display(), line, column), + file, line, column, .. + } => write!(f, "{}:{}:{}", file.path().display(), line, column), } } } @@ -1802,17 +1787,63 @@ impl Iterator for CommentAttributesIterator { } } -fn cxstring_to_string_leaky(s: CXString) -> String { +/// A source file. +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] +pub(crate) struct SourceFile { + name: Box, +} + +impl SourceFile { + /// Creates a new `SourceFile` from a file name. + #[inline] + pub fn new>(name: P) -> Self { + Self { + name: name.as_ref().to_owned().into_boxed_str(), + } + } + + /// Creates a new `SourceFile` from a raw pointer. + /// + /// # Safety + /// + /// `file` must point to a valid `CXFile`. + pub unsafe fn from_raw(file: CXFile) -> Self { + let name = unsafe { cxstring_into_string(clang_getFileName(file)) }; + + Self::new(name) + } + + #[inline] + pub fn name(&self) -> &str { + &self.name + } + + /// Get the path of this source file. + pub fn path(&self) -> PathBuf { + let path = Path::new(self.name()); + if path.is_relative() { + current_dir() + .expect("Cannot retrieve current directory") + .join(path) + } else { + path.to_owned() + } + } +} + +unsafe fn cxstring_to_string_leaky(s: CXString) -> String { if s.data.is_null() { - return "".to_owned(); + Cow::Borrowed("") + } else { + let c_str = CStr::from_ptr(clang_getCString(s) as *const _); + c_str.to_string_lossy() } - let c_str = unsafe { CStr::from_ptr(clang_getCString(s) as *const _) }; - c_str.to_string_lossy().into_owned() + .into_owned() } -fn cxstring_into_string(s: CXString) -> String { +unsafe fn cxstring_into_string(s: CXString) -> String { let ret = cxstring_to_string_leaky(s); - unsafe { clang_disposeString(s) }; + clang_disposeString(s); ret } @@ -1923,13 +1954,13 @@ impl TranslationUnit { } } - /// Get the source file path of this translation unit. - pub(crate) fn path(&self) -> PathBuf { - let file_name = unsafe { + /// Get the source file of this. + pub fn file(&self) -> SourceFile { + let name = unsafe { cxstring_into_string(clang_getTranslationUnitSpelling(self.x)) }; - absolutize_path(file_name) + SourceFile::new(name) } /// Save a translation unit to the given file. diff --git a/bindgen/codegen/mod.rs b/bindgen/codegen/mod.rs index a426cfe0c4..cd9c1a7462 100644 --- a/bindgen/codegen/mod.rs +++ b/bindgen/codegen/mod.rs @@ -4632,12 +4632,13 @@ fn unsupported_abi_diagnostic( ); if let Some(crate::clang::SourceLocation::File { - file_path, + file, line, column, .. }) = location.cloned() { + let file_path = file.path(); if let Ok(Some(source)) = get_line(&file_path, line) { let mut slice = Slice::default(); slice @@ -4673,12 +4674,13 @@ fn variadic_fn_diagnostic( .add_annotation("No code will be generated for this function.", Level::Note); if let Some(crate::clang::SourceLocation::File { - file_path, + file, line, column, .. }) = location.cloned() { + let file_path = file.path(); if let Ok(Some(source)) = get_line(&file_path, line) { let mut slice = Slice::default(); slice diff --git a/bindgen/deps.rs b/bindgen/deps.rs index be31f92896..6d26b537d2 100644 --- a/bindgen/deps.rs +++ b/bindgen/deps.rs @@ -1,6 +1,8 @@ /// Generating build depfiles from parsed bindings. use std::{collections::BTreeSet, path::PathBuf}; +use crate::clang::SourceFile; + #[derive(Clone, Debug)] pub(crate) struct DepfileSpec { pub output_module: String, @@ -8,17 +10,17 @@ pub(crate) struct DepfileSpec { } impl DepfileSpec { - pub fn write(&self, deps: &BTreeSet>) -> std::io::Result<()> { + pub fn write(&self, deps: &BTreeSet) -> std::io::Result<()> { std::fs::write(&self.depfile_path, self.to_string(deps)) } - fn to_string(&self, deps: &BTreeSet>) -> String { + fn to_string(&self, deps: &BTreeSet) -> String { // Transforms a string by escaping spaces and backslashes. let escape = |s: &str| s.replace('\\', "\\\\").replace(' ', "\\ "); let mut buf = format!("{}:", escape(&self.output_module)); for file in deps { - buf = format!("{} {}", buf, escape(file)); + buf = format!("{} {}", buf, escape(file.name())); } buf } @@ -36,13 +38,13 @@ mod tests { }; let deps: BTreeSet<_> = vec![ - r"/absolute/path".into(), - r"C:\win\absolute\path".into(), - r"../relative/path".into(), - r"..\win\relative\path".into(), - r"../path/with spaces/in/it".into(), - r"..\win\path\with spaces\in\it".into(), - r"path\with/mixed\separators".into(), + SourceFile::new(r"/absolute/path"), + SourceFile::new(r"C:\win\absolute\path"), + SourceFile::new(r"../relative/path"), + SourceFile::new(r"..\win\relative\path"), + SourceFile::new(r"../path/with spaces/in/it"), + SourceFile::new(r"..\win\path\with spaces\in\it"), + SourceFile::new(r"path\with/mixed\separators"), ] .into_iter() .collect(); diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs index d15a5e609d..cde61fc18e 100644 --- a/bindgen/ir/context.rs +++ b/bindgen/ir/context.rs @@ -19,7 +19,7 @@ use super::module::{Module, ModuleKind}; use super::template::{TemplateInstantiation, TemplateParameters}; use super::traversal::{self, Edge, ItemTraversal}; use super::ty::{FloatKind, Type, TypeKind}; -use crate::clang::{self, ABIKind, Cursor, SourceLocation}; +use crate::clang::{self, ABIKind, Cursor, SourceFile, SourceLocation}; use crate::codegen::CodegenError; use crate::BindgenOptions; use crate::{Entry, HashMap, HashSet}; @@ -320,7 +320,7 @@ pub(crate) enum IncludeLocation { /// Include location of a header included with an `#include` directive. File { /// Source file name of the include location. - file_path: PathBuf, + file: SourceFile, /// Line of the include location. line: usize, /// Column of the include location. @@ -366,11 +366,10 @@ impl IncludeLocation { ( IncludeLocation::Cli { .. } | IncludeLocation::Main, IncludeLocation::File { - file_path: other_file_path, - .. + file: other_file, .. }, ) => { - let other_parent = ctx.include_location(other_file_path); + let other_parent = ctx.include_location(other_file.path()); self.cmp_by_source_order(other_parent, ctx) } ( @@ -380,26 +379,26 @@ impl IncludeLocation { // If both include locations are in files, compare them as `SourceLocation`s. ( IncludeLocation::File { - file_path, + file, line, column, offset, }, IncludeLocation::File { - file_path: other_file_path, + file: other_file, line: other_line, column: other_column, offset: other_offset, }, ) => SourceLocation::File { - file_path: file_path.clone(), + file: file.clone(), line: *line, column: *column, offset: *offset, } .cmp_by_source_order( &SourceLocation::File { - file_path: other_file_path.clone(), + file: other_file.clone(), line: *other_line, column: *other_column, offset: *other_offset, @@ -470,7 +469,7 @@ pub(crate) struct BindgenContext { includes: StdHashMap, /// A set of all the included filenames. - deps: BTreeSet>, + deps: BTreeSet, /// The active replacements collected from replaces="xxx" annotations. replacements: HashMap, ItemId>, @@ -675,7 +674,7 @@ If you encounter an error missing from this list, please file an issue or a PR!" let root_module_id = root_module.id().as_module_id_unchecked(); // depfiles need to include the explicitly listed headers too - let deps = options.input_headers.iter().cloned().collect(); + let deps = options.input_headers.iter().map(SourceFile::new).collect(); BindgenContext { items: vec![Some(root_module)], @@ -764,16 +763,18 @@ If you encounter an error missing from this list, please file an issue or a PR!" /// Add the location of where `included_file` is included. pub(crate) fn add_include( &mut self, - included_file_path: PathBuf, + included_file: SourceFile, source_location: SourceLocation, ) { + let included_file_path = included_file.path(); + if self.includes.contains_key(&included_file_path) { return; } let include_location = { // Recursively including the main header file doesn't count. - if self.translation_unit.path() == included_file_path { + if self.translation_unit.file().path() == included_file_path { IncludeLocation::Main } else { match source_location { @@ -783,12 +784,12 @@ If you encounter an error missing from this list, please file an issue or a PR!" } // Header was included with an `#include` directive. SourceLocation::File { - file_path, + file, line, column, offset, } => IncludeLocation::File { - file_path, + file, line, column, offset, @@ -812,12 +813,12 @@ If you encounter an error missing from this list, please file an issue or a PR!" } /// Add an included file. - pub(crate) fn add_dep(&mut self, dep: Box) { + pub(crate) fn add_dep(&mut self, dep: SourceFile) { self.deps.insert(dep); } /// Get any included files. - pub(crate) fn deps(&self) -> &BTreeSet> { + pub(crate) fn deps(&self) -> &BTreeSet { &self.deps } @@ -2622,14 +2623,13 @@ If you encounter an error missing from this list, please file an issue or a PR!" // Items with a source location in an explicitly allowlisted file // are always included. if !self.options().allowlisted_files.is_empty() { - if let Some(SourceLocation::File { - file_path, .. - }) = item.location() + if let Some(SourceLocation::File { file, .. }) = + item.location() { if self .options() .allowlisted_files - .matches(file_path.display().to_string()) + .matches(file.path().display().to_string()) { return true; } diff --git a/bindgen/ir/item.rs b/bindgen/ir/item.rs index a168aaa5fd..6815050f01 100644 --- a/bindgen/ir/item.rs +++ b/bindgen/ir/item.rs @@ -640,12 +640,11 @@ impl Item { } if !ctx.options().blocklisted_files.is_empty() { - if let Some(SourceLocation::File { file_path, .. }) = &self.location - { + if let Some(SourceLocation::File { file, .. }) = &self.location { if ctx .options() .blocklisted_files - .matches(file_path.display().to_string()) + .matches(file.path().display().to_string()) { return true; } @@ -1431,17 +1430,17 @@ impl Item { } CXCursor_InclusionDirective => { - let file = cursor.get_included_file_name(); + let file = cursor.get_included_file(); match file { - None => { - warn!("Inclusion of a nameless file in {:?}", cursor); - } Some(included_file) => { for cb in &ctx.options().parse_callbacks { - cb.include_file(&included_file); + cb.include_file(included_file.name()); } - ctx.add_dep(included_file.into_boxed_str()); + ctx.add_dep(included_file); + } + None => { + warn!("Inclusion of a nameless file in {:?}", cursor) } } Err(ParseError::Continue) diff --git a/bindgen/ir/var.rs b/bindgen/ir/var.rs index 471d878b92..a17a8c5148 100644 --- a/bindgen/ir/var.rs +++ b/bindgen/ir/var.rs @@ -534,12 +534,10 @@ fn duplicated_macro_diagnostic( let mut source = Cow::from(macro_name); if let crate::clang::SourceLocation::File { - file_path, - line, - column, - .. + file, line, column, .. } = location { + let file_path = file.path(); if let Ok(Some(code)) = get_line(&file_path, line) { source = code.into(); } From 6731cd782d00143af5027eefc60875453a300dfe Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Tue, 20 Feb 2024 10:21:15 +0100 Subject: [PATCH 10/23] Use name instead of absolute path for checking allow/blocklist. --- bindgen/ir/context.rs | 2 +- bindgen/ir/item.rs | 6 +----- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs index cde61fc18e..e4a7a96a91 100644 --- a/bindgen/ir/context.rs +++ b/bindgen/ir/context.rs @@ -2629,7 +2629,7 @@ If you encounter an error missing from this list, please file an issue or a PR!" if self .options() .allowlisted_files - .matches(file.path().display().to_string()) + .matches(file.name()) { return true; } diff --git a/bindgen/ir/item.rs b/bindgen/ir/item.rs index 6815050f01..c7c91792ce 100644 --- a/bindgen/ir/item.rs +++ b/bindgen/ir/item.rs @@ -641,11 +641,7 @@ impl Item { if !ctx.options().blocklisted_files.is_empty() { if let Some(SourceLocation::File { file, .. }) = &self.location { - if ctx - .options() - .blocklisted_files - .matches(file.path().display().to_string()) - { + if ctx.options().blocklisted_files.matches(file.name()) { return true; } } From 9589d54256d8e7972b097df0708a924aafa28e3c Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Tue, 20 Feb 2024 10:38:30 +0100 Subject: [PATCH 11/23] Use name instead of absolute path for diagnostics. --- bindgen/codegen/mod.rs | 22 ++++++++++++---------- bindgen/diagnostics.rs | 15 +++++++-------- bindgen/ir/var.rs | 5 ++--- 3 files changed, 21 insertions(+), 21 deletions(-) diff --git a/bindgen/codegen/mod.rs b/bindgen/codegen/mod.rs index cd9c1a7462..c299a0ad2e 100644 --- a/bindgen/codegen/mod.rs +++ b/bindgen/codegen/mod.rs @@ -4638,12 +4638,13 @@ fn unsupported_abi_diagnostic( .. }) = location.cloned() { - let file_path = file.path(); - if let Ok(Some(source)) = get_line(&file_path, line) { + if let Ok(Some(source)) = get_line(file.path(), line) { let mut slice = Slice::default(); - slice - .with_source(source) - .with_location(file_path, line, column); + slice.with_source(source).with_location( + file.name(), + line, + column, + ); diag.add_slice(slice); } } @@ -4680,12 +4681,13 @@ fn variadic_fn_diagnostic( .. }) = location.cloned() { - let file_path = file.path(); - if let Ok(Some(source)) = get_line(&file_path, line) { + if let Ok(Some(source)) = get_line(file.path(), line) { let mut slice = Slice::default(); - slice - .with_source(source) - .with_location(file_path, line, column); + slice.with_source(source).with_location( + file.name(), + line, + column, + ); diag.add_slice(slice); } } diff --git a/bindgen/diagnostics.rs b/bindgen/diagnostics.rs index 0cb53a3736..df28c0ac3a 100644 --- a/bindgen/diagnostics.rs +++ b/bindgen/diagnostics.rs @@ -110,7 +110,7 @@ impl<'a> Diagnostic<'a> { slices.push(ExtSlice { source: source.as_ref(), line_start: slice.line.unwrap_or_default(), - origin: slice.filename.as_deref(), + origin: slice.origin.as_deref(), annotations: vec![], fold: false, }) @@ -146,9 +146,9 @@ impl<'a> Diagnostic<'a> { /// A slice of source code. #[derive(Default)] pub(crate) struct Slice<'a> { - source: Option>, - filename: Option, line: Option, + origin: Option, + source: Option>, } impl<'a> Slice<'a> { @@ -162,15 +162,14 @@ impl<'a> Slice<'a> { } /// Set the file, line and column. - pub(crate) fn with_location>( + pub(crate) fn with_location( &mut self, - path: P, + file_name: &str, line: usize, - col: usize, + column: usize, ) -> &mut Self { - self.filename = - Some(format!("{}:{}:{}", path.as_ref().display(), line, col)); self.line = Some(line); + self.origin = Some(format!("{file_name}:{line}:{column}")); self } } diff --git a/bindgen/ir/var.rs b/bindgen/ir/var.rs index a17a8c5148..047e00a682 100644 --- a/bindgen/ir/var.rs +++ b/bindgen/ir/var.rs @@ -537,11 +537,10 @@ fn duplicated_macro_diagnostic( file, line, column, .. } = location { - let file_path = file.path(); - if let Ok(Some(code)) = get_line(&file_path, line) { + if let Ok(Some(code)) = get_line(file.path(), line) { source = code.into(); } - slice.with_location(file_path, line, column); + slice.with_location(file.name(), line, column); } slice.with_source(source); From b31453b8207d36718fc384ee1c9654c3dfa7b85a Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Thu, 8 Sep 2022 04:35:39 +0200 Subject: [PATCH 12/23] Support complex macros. --- Cargo.lock | 30 +- Cargo.toml | 4 + bindgen-cli/options.rs | 8 + bindgen-integration/build.rs | 2 +- .../expectations/tests/infinite-macro.rs | 4 +- .../tests/issue-739-pointer-wide-bitfield.rs | 3 + .../expectations/tests/jsval_layout_opaque.rs | 2 +- .../tests/jsval_layout_opaque_1_0.rs | 2 +- .../tests/expectations/tests/macro-cast.rs | 7 + .../expectations/tests/macro-def-after-var.rs | 2 + .../expectations/tests/macro-do-while.rs | 23 + .../expectations/tests/macro-expr-basic.rs | 2 +- .../macro-func-arg-variable-same-name.rs | 11 + .../expectations/tests/macro-func-nested.rs | 17 + .../expectations/tests/macro-macos-limits.rs | 24 + .../tests/expectations/tests/macro-redef.rs | 4 +- .../expectations/tests/macro_concatenation.rs | 10 + .../tests/expectations/tests/macro_const.rs | 20 +- .../expectations/tests/macro_const_1_0.rs | 20 +- .../tests/expectations/tests/macro_enum.rs | 32 ++ .../expectations/tests/macro_expansion.rs | 11 + .../expectations/tests/macro_func_wrapper.rs | 13 + .../tests/macro_memory_barrier.rs | 6 + .../tests/source-order-siblings.rs | 2 +- bindgen-tests/tests/headers/layout_mbuf_1_0.h | 1 - bindgen-tests/tests/headers/macro-cast.h | 7 + .../tests/headers/macro-def-after-var.h | 2 + bindgen-tests/tests/headers/macro-do-while.h | 8 + .../macro-func-arg-variable-same-name.h | 8 + .../tests/headers/macro-func-nested.h | 5 + .../tests/headers/macro-macos-limits.h | 83 +++ .../tests/headers/macro_concatenation.h | 4 + bindgen-tests/tests/headers/macro_enum.h | 28 + bindgen-tests/tests/headers/macro_expansion.h | 6 + .../tests/headers/macro_func_wrapper.h | 10 + .../tests/headers/macro_memory_barrier.h | 3 + bindgen/Cargo.toml | 2 +- bindgen/callbacks.rs | 57 ++ bindgen/clang.rs | 55 +- bindgen/codegen/helpers.rs | 4 +- bindgen/codegen/macro_def.rs | 214 +++++++ bindgen/codegen/mod.rs | 63 ++- bindgen/ir/context.rs | 452 +++++++++------ bindgen/ir/enum_ty.rs | 1 + bindgen/ir/function.rs | 59 +- bindgen/ir/int.rs | 2 +- bindgen/ir/item.rs | 22 +- bindgen/ir/item_kind.rs | 8 + bindgen/ir/macro_def.rs | 149 +++++ bindgen/ir/mod.rs | 1 + bindgen/ir/var.rs | 522 +++++------------- bindgen/options/mod.rs | 18 +- 52 files changed, 1358 insertions(+), 695 deletions(-) create mode 100644 bindgen-tests/tests/expectations/tests/macro-cast.rs create mode 100644 bindgen-tests/tests/expectations/tests/macro-def-after-var.rs create mode 100644 bindgen-tests/tests/expectations/tests/macro-do-while.rs create mode 100644 bindgen-tests/tests/expectations/tests/macro-func-arg-variable-same-name.rs create mode 100644 bindgen-tests/tests/expectations/tests/macro-func-nested.rs create mode 100644 bindgen-tests/tests/expectations/tests/macro-macos-limits.rs create mode 100644 bindgen-tests/tests/expectations/tests/macro_concatenation.rs create mode 100644 bindgen-tests/tests/expectations/tests/macro_enum.rs create mode 100644 bindgen-tests/tests/expectations/tests/macro_expansion.rs create mode 100644 bindgen-tests/tests/expectations/tests/macro_func_wrapper.rs create mode 100644 bindgen-tests/tests/expectations/tests/macro_memory_barrier.rs create mode 100644 bindgen-tests/tests/headers/macro-cast.h create mode 100644 bindgen-tests/tests/headers/macro-def-after-var.h create mode 100644 bindgen-tests/tests/headers/macro-do-while.h create mode 100644 bindgen-tests/tests/headers/macro-func-arg-variable-same-name.h create mode 100644 bindgen-tests/tests/headers/macro-func-nested.h create mode 100644 bindgen-tests/tests/headers/macro-macos-limits.h create mode 100644 bindgen-tests/tests/headers/macro_concatenation.h create mode 100644 bindgen-tests/tests/headers/macro_enum.h create mode 100644 bindgen-tests/tests/headers/macro_expansion.h create mode 100644 bindgen-tests/tests/headers/macro_func_wrapper.h create mode 100644 bindgen-tests/tests/headers/macro_memory_barrier.h create mode 100644 bindgen/codegen/macro_def.rs create mode 100644 bindgen/ir/macro_def.rs diff --git a/Cargo.lock b/Cargo.lock index ace73d6b07..3615531f3a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -27,8 +27,8 @@ version = "0.69.4" dependencies = [ "annotate-snippets", "bitflags 2.2.1", - "cexpr", "clang-sys", + "cmacro", "itertools", "log", "prettyplease", @@ -99,15 +99,6 @@ version = "1.0.78" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a20104e2335ce8a659d6dd92a51a767a0c062599c73b343fd152cb401e828c3d" -[[package]] -name = "cexpr" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766" -dependencies = [ - "nom", -] - [[package]] name = "cfg-if" version = "1.0.0" @@ -171,6 +162,19 @@ dependencies = [ "os_str_bytes", ] +[[package]] +name = "cmacro" +version = "0.2.2" +source = "git+https://github.com/reitermarkus/cmacro-rs#2b93025ebc7ca6b343ab2a801271c96f0ebc9b04" +dependencies = [ + "nom", + "proc-macro2", + "quote", + "semver", + "syn 2.0.18", + "unicode-ident", +] + [[package]] name = "either" version = "1.8.1" @@ -550,6 +554,12 @@ dependencies = [ "windows-sys 0.45.0", ] +[[package]] +name = "semver" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92d43fe69e652f3df9bdc2b85b2854a0825b86e4fb76bc44d945137d053639ca" + [[package]] name = "shlex" version = "1.3.0" diff --git a/Cargo.toml b/Cargo.toml index bc9a80555d..2b685618e9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -42,3 +42,7 @@ release = false [profile.dist] inherits = "release" lto = "thin" + +[patch.crates-io] +# cmacro = { path = "../cmacro-rs" } +cmacro = { git = "https://github.com/reitermarkus/cmacro-rs" } diff --git a/bindgen-cli/options.rs b/bindgen-cli/options.rs index 5edc8c95e5..4fd5711e0a 100644 --- a/bindgen-cli/options.rs +++ b/bindgen-cli/options.rs @@ -210,6 +210,9 @@ struct BindgenCommand { /// Generate string constants as `&CStr` instead of `&[u8]`. #[arg(long)] generate_cstr: bool, + /// Generate code for function-like macros. + #[arg(long, requires = "experimental")] + generate_fn_macros: bool, /// Use extern crate instead of use for block. #[arg(long)] block_extern_crate: bool, @@ -501,6 +504,7 @@ where objc_extern_crate, generate_block, generate_cstr, + generate_fn_macros, block_extern_crate, distrust_clang_mangling, builtins, @@ -850,6 +854,10 @@ where builder = builder.generate_cstr(true); } + if generate_fn_macros { + builder = builder.generate_fn_macros(true); + } + if block_extern_crate { builder = builder.block_extern_crate(true); } diff --git a/bindgen-integration/build.rs b/bindgen-integration/build.rs index 7e9b37e47c..e69da93b4c 100644 --- a/bindgen-integration/build.rs +++ b/bindgen-integration/build.rs @@ -59,7 +59,7 @@ impl ParseCallbacks for MacroCallback { } } - fn fn_macro(&self, info: &FnMacroInfo<'_>) { + fn fn_macro(&self, info: &FnMacroInfo) { let args = info.args(); let body = info.body(); diff --git a/bindgen-tests/tests/expectations/tests/infinite-macro.rs b/bindgen-tests/tests/expectations/tests/infinite-macro.rs index 455a7ae5ed..a1fc8ccfc6 100644 --- a/bindgen-tests/tests/expectations/tests/infinite-macro.rs +++ b/bindgen-tests/tests/expectations/tests/infinite-macro.rs @@ -1,3 +1,3 @@ #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] -pub const INFINITY: f64 = ::std::f64::INFINITY; -pub const NAN: f64 = ::std::f64::NAN; +pub const INFINITY: f32 = ::std::f32::INFINITY; +pub const NAN: f32 = ::std::f32::NAN; diff --git a/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs b/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs index be1eeee425..02361b8017 100644 --- a/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs +++ b/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs @@ -84,6 +84,9 @@ where } } } +pub const POINTER_WIDTH: ::std::os::raw::size_t = ::std::mem::size_of::< + *mut ::std::os::raw::c_void, +>() * 8; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct Foo { diff --git a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs index 4fecd5969d..ba97bd6e30 100644 --- a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs +++ b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs @@ -126,7 +126,7 @@ pub enum JSValueShiftedTag { JSVAL_SHIFTED_TAG_OBJECT = 18445618173802708992, } pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327; -pub const JSVAL_TAG_MASK: i64 = -140737488355328; +pub const JSVAL_TAG_MASK: u64 = 18446603336221196288; #[repr(u32)] #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] pub enum JSWhyMagic { diff --git a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs index c61b3f940f..1ab1d40516 100644 --- a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs +++ b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs @@ -169,7 +169,7 @@ pub enum JSValueShiftedTag { JSVAL_SHIFTED_TAG_OBJECT = 18445618173802708992, } pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327; -pub const JSVAL_TAG_MASK: i64 = -140737488355328; +pub const JSVAL_TAG_MASK: u64 = 18446603336221196288; #[repr(u32)] #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] pub enum JSWhyMagic { diff --git a/bindgen-tests/tests/expectations/tests/macro-cast.rs b/bindgen-tests/tests/expectations/tests/macro-cast.rs new file mode 100644 index 0000000000..56d43bf11c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro-cast.rs @@ -0,0 +1,7 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const ULONG_MAX: u32 = 4294967295; +pub type TickType_t = ::std::os::raw::c_ulong; +pub const portMAX_DELAY: TickType_t = 4294967295u32 as TickType_t; +pub const NEG_TO_POS: ::std::os::raw::c_uint = -1i8 as ::std::os::raw::c_uint; +pub const BIG_TO_SMALL: ::std::os::raw::c_ushort = 4294967295u32 + as ::std::os::raw::c_ushort; diff --git a/bindgen-tests/tests/expectations/tests/macro-def-after-var.rs b/bindgen-tests/tests/expectations/tests/macro-def-after-var.rs new file mode 100644 index 0000000000..533a63bff9 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro-def-after-var.rs @@ -0,0 +1,2 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const FOO: u32 = 3; diff --git a/bindgen-tests/tests/expectations/tests/macro-do-while.rs b/bindgen-tests/tests/expectations/tests/macro-do-while.rs new file mode 100644 index 0000000000..cf91ddf09c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro-do-while.rs @@ -0,0 +1,23 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +extern "C" { + pub fn xTaskDelayUntil( + arg1: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[allow(non_snake_case, unused_mut, unsafe_code)] +#[inline(always)] +pub unsafe extern "C" fn vTaskDelayUntil( + mut pxPreviousWakeTime: ::std::os::raw::c_int, + mut xTimeIncrement: ::std::os::raw::c_int, +) { + loop { + { + let _ = xTaskDelayUntil(pxPreviousWakeTime, xTimeIncrement); + }; + if 0 != 0 { + continue; + } + break; + }; +} diff --git a/bindgen-tests/tests/expectations/tests/macro-expr-basic.rs b/bindgen-tests/tests/expectations/tests/macro-expr-basic.rs index 21c81b317c..a8d5ffc2ef 100644 --- a/bindgen-tests/tests/expectations/tests/macro-expr-basic.rs +++ b/bindgen-tests/tests/expectations/tests/macro-expr-basic.rs @@ -2,7 +2,7 @@ pub const FOO: u32 = 1; pub const BAR: u32 = 4; pub const BAZ: u32 = 5; -pub const MIN: i64 = -9223372036854775808; +pub const MIN: u64 = 9223372036854775808; pub const BARR: u32 = 1; pub const BAZZ: u32 = 7; pub const I_RAN_OUT_OF_DUMB_NAMES: u32 = 7; diff --git a/bindgen-tests/tests/expectations/tests/macro-func-arg-variable-same-name.rs b/bindgen-tests/tests/expectations/tests/macro-func-arg-variable-same-name.rs new file mode 100644 index 0000000000..18dad5edc3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro-func-arg-variable-same-name.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const y: u32 = 2; +#[doc(hidden)] +#[macro_export] +macro_rules! __cmacro__f3 { + ($x:expr) => { + 4 + }; +} +pub use __cmacro__f3 as f3; +pub const x: u32 = 2; diff --git a/bindgen-tests/tests/expectations/tests/macro-func-nested.rs b/bindgen-tests/tests/expectations/tests/macro-func-nested.rs new file mode 100644 index 0000000000..c71a649351 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro-func-nested.rs @@ -0,0 +1,17 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[doc(hidden)] +#[macro_export] +macro_rules! __cmacro__f1 { + ($x:expr) => { + $x * 2 + }; +} +pub use __cmacro__f1 as f1; +#[doc(hidden)] +#[macro_export] +macro_rules! __cmacro__f2 { + ($y:expr) => { + $y * $y * 2 + }; +} +pub use __cmacro__f2 as f2; diff --git a/bindgen-tests/tests/expectations/tests/macro-macos-limits.rs b/bindgen-tests/tests/expectations/tests/macro-macos-limits.rs new file mode 100644 index 0000000000..fd2547422c --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro-macos-limits.rs @@ -0,0 +1,24 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const CHAR_BIT: u32 = 8; +pub const MB_LEN_MAX: u32 = 1; +pub const SCHAR_MIN: i32 = -128; +pub const SCHAR_MAX: u32 = 127; +pub const UCHAR_MAX: u32 = 255; +pub const CHAR_MIN: i32 = -128; +pub const CHAR_MAX: u32 = 127; +pub const SHRT_MIN: i32 = -32768; +pub const SHRT_MAX: u32 = 32767; +pub const USHRT_MAX: u32 = 65535; +pub const INT_MIN: ::std::os::raw::c_int = -::std::os::raw::c_int::MAX - 1; +pub const INT_MAX: ::std::os::raw::c_int = ::std::os::raw::c_int::MAX; +pub const UINT_MAX: ::std::os::raw::c_uint = ::std::os::raw::c_int::MAX + as ::std::os::raw::c_uint * 2 + 1; +pub const LONG_MIN: ::std::os::raw::c_long = -::std::os::raw::c_long::MAX - 1; +pub const LONG_MAX: ::std::os::raw::c_long = ::std::os::raw::c_long::MAX; +pub const ULONG_MAX: ::std::os::raw::c_ulong = ::std::os::raw::c_long::MAX + as ::std::os::raw::c_ulong * 2 + 1; +pub const LONG_LONG_MIN: ::std::os::raw::c_longlong = -::std::os::raw::c_longlong::MAX + - 1; +pub const LONG_LONG_MAX: ::std::os::raw::c_longlong = ::std::os::raw::c_longlong::MAX; +pub const ULONG_LONG_MAX: ::std::os::raw::c_ulonglong = ::std::os::raw::c_longlong::MAX + as ::std::os::raw::c_ulonglong * 2 + 1; diff --git a/bindgen-tests/tests/expectations/tests/macro-redef.rs b/bindgen-tests/tests/expectations/tests/macro-redef.rs index 12e3d3d587..a96572f2da 100644 --- a/bindgen-tests/tests/expectations/tests/macro-redef.rs +++ b/bindgen-tests/tests/expectations/tests/macro-redef.rs @@ -1,4 +1,4 @@ #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] -pub const FOO: u32 = 4; -pub const BAR: u32 = 5; +pub const BAR: u32 = 6; +pub const FOO: u32 = 5; pub const BAZ: u32 = 6; diff --git a/bindgen-tests/tests/expectations/tests/macro_concatenation.rs b/bindgen-tests/tests/expectations/tests/macro_concatenation.rs new file mode 100644 index 0000000000..c7ef96beaa --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro_concatenation.rs @@ -0,0 +1,10 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[doc(hidden)] +#[macro_export] +macro_rules! __cmacro__UL { + ($X:ident) => { + ::std::concat_idents!($X, UL) + }; +} +pub use __cmacro__UL as UL; +pub const ONE: u32 = 1; diff --git a/bindgen-tests/tests/expectations/tests/macro_const.rs b/bindgen-tests/tests/expectations/tests/macro_const.rs index e4e27dea52..94ddd343a8 100644 --- a/bindgen-tests/tests/expectations/tests/macro_const.rs +++ b/bindgen-tests/tests/expectations/tests/macro_const.rs @@ -1,8 +1,16 @@ #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] -pub const foo: &[u8; 4] = b"bar\0"; -pub const CHAR: u8 = 98u8; -pub const CHARR: u8 = 0u8; -pub const FLOAT: f64 = 5.09; -pub const FLOAT_EXPR: f64 = 0.005; +pub const foo: &::std::ffi::CStr = { + const BYTES: &[u8; 4] = b"bar\0"; + #[allow(unsafe_code)] + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(BYTES) } +}; +pub const CHAR: ::std::os::raw::c_char = 'b' as ::std::os::raw::c_char; +pub const CHARR: ::std::os::raw::c_char = '\0' as ::std::os::raw::c_char; +pub const FLOAT: f32 = 5.09; +pub const FLOAT_EXPR: f32 = 0.005; pub const LONG: u32 = 3; -pub const INVALID_UTF8: &[u8; 5] = b"\xF0(\x8C(\0"; +pub const INVALID_UTF8: &::std::ffi::CStr = { + const BYTES: &[u8; 5] = b"\xF0(\x8C(\0"; + #[allow(unsafe_code)] + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(BYTES) } +}; diff --git a/bindgen-tests/tests/expectations/tests/macro_const_1_0.rs b/bindgen-tests/tests/expectations/tests/macro_const_1_0.rs index 2f3e228d80..94ddd343a8 100644 --- a/bindgen-tests/tests/expectations/tests/macro_const_1_0.rs +++ b/bindgen-tests/tests/expectations/tests/macro_const_1_0.rs @@ -1,8 +1,16 @@ #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] -pub const foo: &'static [u8; 4] = b"bar\0"; -pub const CHAR: u8 = 98u8; -pub const CHARR: u8 = 0u8; -pub const FLOAT: f64 = 5.09; -pub const FLOAT_EXPR: f64 = 0.005; +pub const foo: &::std::ffi::CStr = { + const BYTES: &[u8; 4] = b"bar\0"; + #[allow(unsafe_code)] + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(BYTES) } +}; +pub const CHAR: ::std::os::raw::c_char = 'b' as ::std::os::raw::c_char; +pub const CHARR: ::std::os::raw::c_char = '\0' as ::std::os::raw::c_char; +pub const FLOAT: f32 = 5.09; +pub const FLOAT_EXPR: f32 = 0.005; pub const LONG: u32 = 3; -pub const INVALID_UTF8: &'static [u8; 5] = b"\xF0(\x8C(\0"; +pub const INVALID_UTF8: &::std::ffi::CStr = { + const BYTES: &[u8; 5] = b"\xF0(\x8C(\0"; + #[allow(unsafe_code)] + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(BYTES) } +}; diff --git a/bindgen-tests/tests/expectations/tests/macro_enum.rs b/bindgen-tests/tests/expectations/tests/macro_enum.rs new file mode 100644 index 0000000000..435c15bdd3 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro_enum.rs @@ -0,0 +1,32 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const NULL: *mut ::std::os::raw::c_void = ::std::ptr::null_mut(); +pub const eNotifyAction_eNoAction: eNotifyAction = 0; +pub const eNotifyAction_eSetBits: eNotifyAction = 1; +pub const eNotifyAction_eIncrement: eNotifyAction = 2; +pub const eNotifyAction_eSetValueWithOverwrite: eNotifyAction = 3; +pub const eNotifyAction_eSetValueWithoutOverwrite: eNotifyAction = 4; +pub type eNotifyAction = ::std::os::raw::c_uint; +pub const tskDEFAULT_INDEX_TO_NOTIFY: u32 = 0; +pub type TaskHandle_t = *mut ::std::os::raw::c_void; +pub type BaseType_t = ::std::os::raw::c_long; +pub type UBaseType_t = ::std::os::raw::c_ulong; +extern "C" { + pub fn xTaskGenericNotify( + xTaskToNotify: TaskHandle_t, + uxIndexToNotify: UBaseType_t, + ulValue: u32, + eAction: eNotifyAction, + pulPreviousNotificationValue: *mut u32, + ) -> BaseType_t; +} +#[allow(non_snake_case, unused_mut, unsafe_code)] +#[inline(always)] +pub unsafe extern "C" fn xTaskNotifyGive(mut xTaskToNotify: TaskHandle_t) -> BaseType_t { + xTaskGenericNotify( + xTaskToNotify, + 0, + 0, + (eNotifyAction_eIncrement).into(), + ::std::ptr::null_mut(), + ) +} diff --git a/bindgen-tests/tests/expectations/tests/macro_expansion.rs b/bindgen-tests/tests/expectations/tests/macro_expansion.rs new file mode 100644 index 0000000000..182c12a50f --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro_expansion.rs @@ -0,0 +1,11 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[doc(hidden)] +#[macro_export] +macro_rules! __cmacro___IO { + ($a_:expr) => { + $a_ + }; +} +pub use __cmacro___IO as _IO; +pub const UI_DEV_CREATE: u32 = 1; +pub const UI_DEV_DESTROY: u32 = 2; diff --git a/bindgen-tests/tests/expectations/tests/macro_func_wrapper.rs b/bindgen-tests/tests/expectations/tests/macro_func_wrapper.rs new file mode 100644 index 0000000000..638de951e8 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro_func_wrapper.rs @@ -0,0 +1,13 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +extern "C" { + pub fn func(arg1: ::std::os::raw::c_int, arg2: ::std::os::raw::c_int); +} +pub const Y: u32 = 7; +#[doc(hidden)] +#[macro_export] +macro_rules! __cmacro__func { + ($x:expr) => { + func(($x).into(), 7) + }; +} +pub use __cmacro__func as func; diff --git a/bindgen-tests/tests/expectations/tests/macro_memory_barrier.rs b/bindgen-tests/tests/expectations/tests/macro_memory_barrier.rs new file mode 100644 index 0000000000..d972b46f0e --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro_memory_barrier.rs @@ -0,0 +1,6 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +#[allow(non_snake_case, unused_mut, unsafe_code)] +#[inline(always)] +pub unsafe extern "C" fn MEMORY_BARRIER() { + ::std::arch::asm!("", options(preserves_flags),); +} diff --git a/bindgen-tests/tests/expectations/tests/source-order-siblings.rs b/bindgen-tests/tests/expectations/tests/source-order-siblings.rs index 02585bed4b..3aefb99e39 100644 --- a/bindgen-tests/tests/expectations/tests/source-order-siblings.rs +++ b/bindgen-tests/tests/expectations/tests/source-order-siblings.rs @@ -4,7 +4,7 @@ pub const A: ::std::os::raw::c_char = 97; extern "C" { pub fn AA(); } -pub const B: u8 = 98u8; +pub const B: ::std::os::raw::c_char = 'b' as ::std::os::raw::c_char; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct BB {} diff --git a/bindgen-tests/tests/headers/layout_mbuf_1_0.h b/bindgen-tests/tests/headers/layout_mbuf_1_0.h index 2854de5038..2bca582801 100644 --- a/bindgen-tests/tests/headers/layout_mbuf_1_0.h +++ b/bindgen-tests/tests/headers/layout_mbuf_1_0.h @@ -1,6 +1,5 @@ // bindgen-flags: --rust-target 1.0 --with-derive-hash --with-derive-partialeq --with-derive-eq - #define RTE_CACHE_LINE_MIN_SIZE 64 /**< Minimum Cache line size. */ #define RTE_CACHE_LINE_SIZE 64 diff --git a/bindgen-tests/tests/headers/macro-cast.h b/bindgen-tests/tests/headers/macro-cast.h new file mode 100644 index 0000000000..0b42d3eaf0 --- /dev/null +++ b/bindgen-tests/tests/headers/macro-cast.h @@ -0,0 +1,7 @@ +#define ULONG_MAX 4294967295 + +typedef unsigned long TickType_t; +#define portMAX_DELAY (TickType_t) ULONG_MAX + +#define NEG_TO_POS (unsigned int) -1 +#define BIG_TO_SMALL (unsigned short) ULONG_MAX diff --git a/bindgen-tests/tests/headers/macro-def-after-var.h b/bindgen-tests/tests/headers/macro-def-after-var.h new file mode 100644 index 0000000000..10e842033d --- /dev/null +++ b/bindgen-tests/tests/headers/macro-def-after-var.h @@ -0,0 +1,2 @@ +const int FOO = 7; +#define FOO 3 diff --git a/bindgen-tests/tests/headers/macro-do-while.h b/bindgen-tests/tests/headers/macro-do-while.h new file mode 100644 index 0000000000..3e8df9a59a --- /dev/null +++ b/bindgen-tests/tests/headers/macro-do-while.h @@ -0,0 +1,8 @@ +// bindgen-flags: --experimental --generate-fn-macros + +int xTaskDelayUntil(int, int); + +#define vTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement ) \ + do { \ + ( void ) xTaskDelayUntil( ( pxPreviousWakeTime ), ( xTimeIncrement ) ); \ + } while( 0 ) diff --git a/bindgen-tests/tests/headers/macro-func-arg-variable-same-name.h b/bindgen-tests/tests/headers/macro-func-arg-variable-same-name.h new file mode 100644 index 0000000000..e7d8d3f0e4 --- /dev/null +++ b/bindgen-tests/tests/headers/macro-func-arg-variable-same-name.h @@ -0,0 +1,8 @@ +// bindgen-flags: --experimental --generate-fn-macros + +// The `x` argument of the `f3` function-like macro +// and the `x` in the nested `y` macro should be treated +// as different variables. +#define y x +#define f3(x) y + y +#define x 2 diff --git a/bindgen-tests/tests/headers/macro-func-nested.h b/bindgen-tests/tests/headers/macro-func-nested.h new file mode 100644 index 0000000000..fa98e910e6 --- /dev/null +++ b/bindgen-tests/tests/headers/macro-func-nested.h @@ -0,0 +1,5 @@ +// bindgen-flags: --experimental --generate-fn-macros + +// The `f1` macro call in `f2` should be expanded. +#define f1(x) x * 2 +#define f2(y) y * f1(y) diff --git a/bindgen-tests/tests/headers/macro-macos-limits.h b/bindgen-tests/tests/headers/macro-macos-limits.h new file mode 100644 index 0000000000..a2edff0afb --- /dev/null +++ b/bindgen-tests/tests/headers/macro-macos-limits.h @@ -0,0 +1,83 @@ +/* Number of bits in a `char'. */ +#undef CHAR_BIT +#define CHAR_BIT 8 + +/* Maximum length of a multibyte character. */ +#ifndef MB_LEN_MAX +#define MB_LEN_MAX 1 +#endif + +/* Minimum and maximum values a `signed char' can hold. */ +#undef SCHAR_MIN +#define SCHAR_MIN (-128) +#undef SCHAR_MAX +#define SCHAR_MAX 127 + +/* Maximum value an `unsigned char' can hold. (Minimum is 0). */ +#undef UCHAR_MAX +#define UCHAR_MAX 255 + +/* Minimum and maximum values a `char' can hold. */ +#ifdef __CHAR_UNSIGNED__ +#undef CHAR_MIN +#define CHAR_MIN 0 +#undef CHAR_MAX +#define CHAR_MAX 255 +#else +#undef CHAR_MIN +#define CHAR_MIN (-128) +#undef CHAR_MAX +#define CHAR_MAX 127 +#endif + +/* Minimum and maximum values a `signed short int' can hold. */ +#undef SHRT_MIN +#define SHRT_MIN (-32768) +#undef SHRT_MAX +#define SHRT_MAX 32767 + +/* Maximum value an `unsigned short int' can hold. (Minimum is 0). */ +#undef USHRT_MAX +#define USHRT_MAX 65535 + +/* Minimum and maximum values a `signed int' can hold. */ +#ifndef __INT_MAX__ +#define __INT_MAX__ 2147483647 +#endif +#undef INT_MIN +#define INT_MIN (-INT_MAX-1) +#undef INT_MAX +#define INT_MAX __INT_MAX__ + +/* Maximum value an `unsigned int' can hold. (Minimum is 0). */ +#undef UINT_MAX +#define UINT_MAX (INT_MAX * 2U + 1) + +/* Minimum and maximum values a `signed long int' can hold. + (Same as `int'). */ +#ifndef __LONG_MAX__ +#define __LONG_MAX__ 2147483647L +#endif +#undef LONG_MIN +#define LONG_MIN (-LONG_MAX-1) +#undef LONG_MAX +#define LONG_MAX __LONG_MAX__ + +/* Maximum value an `unsigned long int' can hold. (Minimum is 0). */ +#undef ULONG_MAX +#define ULONG_MAX (LONG_MAX * 2UL + 1) + +#if defined (__GNU_LIBRARY__) ? defined (__USE_GNU) : !defined (__STRICT_ANSI__) +/* Minimum and maximum values a `signed long long int' can hold. */ +#ifndef __LONG_LONG_MAX__ +#define __LONG_LONG_MAX__ 9223372036854775807LL +#endif +#undef LONG_LONG_MIN +#define LONG_LONG_MIN (-LONG_LONG_MAX-1) +#undef LONG_LONG_MAX +#define LONG_LONG_MAX __LONG_LONG_MAX__ + +/* Maximum value an `unsigned long long int' can hold. (Minimum is 0). */ +#undef ULONG_LONG_MAX +#define ULONG_LONG_MAX (LONG_LONG_MAX * 2ULL + 1) +#endif diff --git a/bindgen-tests/tests/headers/macro_concatenation.h b/bindgen-tests/tests/headers/macro_concatenation.h new file mode 100644 index 0000000000..edcb2b759a --- /dev/null +++ b/bindgen-tests/tests/headers/macro_concatenation.h @@ -0,0 +1,4 @@ +// bindgen-flags: --experimental --generate-fn-macros + +#define UL(X) X ## UL +#define ONE UL(1) diff --git a/bindgen-tests/tests/headers/macro_enum.h b/bindgen-tests/tests/headers/macro_enum.h new file mode 100644 index 0000000000..9d040578d3 --- /dev/null +++ b/bindgen-tests/tests/headers/macro_enum.h @@ -0,0 +1,28 @@ +// bindgen-flags: --experimental --generate-fn-macros + +typedef unsigned int uint32_t; +#define NULL ((void*)0) + +typedef enum +{ + eNoAction = 0, /* Notify the task without updating its notify value. */ + eSetBits, /* Set bits in the task's notification value. */ + eIncrement, /* Increment the task's notification value. */ + eSetValueWithOverwrite, /* Set the task's notification value to a specific value even if the previous value has not yet been read by the task. */ + eSetValueWithoutOverwrite /* Set the task's notification value if the previous value has been read by the task. */ +} eNotifyAction; + +#define tskDEFAULT_INDEX_TO_NOTIFY ( 0 ) +typedef void * TaskHandle_t; +typedef long BaseType_t; +typedef unsigned long UBaseType_t; + +BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify, + UBaseType_t uxIndexToNotify, + uint32_t ulValue, + eNotifyAction eAction, + uint32_t * pulPreviousNotificationValue ); + +#define xTaskNotifyGive( xTaskToNotify ) \ + xTaskGenericNotify( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( 0 ), eIncrement, NULL ) + diff --git a/bindgen-tests/tests/headers/macro_expansion.h b/bindgen-tests/tests/headers/macro_expansion.h new file mode 100644 index 0000000000..62c05ab038 --- /dev/null +++ b/bindgen-tests/tests/headers/macro_expansion.h @@ -0,0 +1,6 @@ +// bindgen-flags: --experimental --generate-fn-macros + +#define _IO(a_) (a_) + +#define UI_DEV_CREATE _IO(1) +#define UI_DEV_DESTROY _IO(2) diff --git a/bindgen-tests/tests/headers/macro_func_wrapper.h b/bindgen-tests/tests/headers/macro_func_wrapper.h new file mode 100644 index 0000000000..637e469172 --- /dev/null +++ b/bindgen-tests/tests/headers/macro_func_wrapper.h @@ -0,0 +1,10 @@ +// bindgen-flags: --experimental --generate-fn-macros + +void func(int, int); + +#define Y 7 + +// This macro is invalid, since it tries to call the `func` macro with two arguments, not the `func` function. +#define wrapper_func(x) func(x, Y) + +#define func(x) func(x, Y) diff --git a/bindgen-tests/tests/headers/macro_memory_barrier.h b/bindgen-tests/tests/headers/macro_memory_barrier.h new file mode 100644 index 0000000000..85a8b14c68 --- /dev/null +++ b/bindgen-tests/tests/headers/macro_memory_barrier.h @@ -0,0 +1,3 @@ +// bindgen-flags: --experimental --generate-fn-macros + +#define MEMORY_BARRIER() __asm__ volatile ( "" ::: "memory" ) diff --git a/bindgen/Cargo.toml b/bindgen/Cargo.toml index 2ea1def69d..711a3cf8ec 100644 --- a/bindgen/Cargo.toml +++ b/bindgen/Cargo.toml @@ -27,7 +27,7 @@ path = "lib.rs" [dependencies] annotate-snippets = { version = "0.9.1", features = ["color"], optional = true } bitflags = "2.2.1" -cexpr = "0.6" +cmacro = "0.2.2" clang-sys = { version = "1", features = ["clang_6_0"] } itertools = { version = ">=0.10,<0.14", default-features = false } log = { version = "0.4", optional = true } diff --git a/bindgen/callbacks.rs b/bindgen/callbacks.rs index 494ad816b2..845d35119a 100644 --- a/bindgen/callbacks.rs +++ b/bindgen/callbacks.rs @@ -67,9 +67,66 @@ pub trait ParseCallbacks: fmt::Debug { /// This will be run on every function-like macro. The callback cannot /// influence the further treatment of the macro, but may use the value to /// generate additional code or configuration. + /// + /// Note that instead of using this callback to handle unsupported macros, + /// consider contributing an improvement to the parsing or code generation in + /// the `cmacro` crate. #[allow(unused_variables)] fn fn_macro(&self, info: &FnMacroInfo<'_>) {} + /// Specify the type of a macro argument. + /// + /// This is needed if you want to generate a function instead of a macro. + /// If all argument types and the return type of a macro can be inferred, + /// a function will be generated instead of a macro. + /// + /// # Examples + /// + /// A macro like + /// + /// ```c + /// #define times(x, y) (x * y) + /// ``` + /// + /// will normally generate + /// + /// ``` + /// macro_rules! times { + /// ($x:expr, $y:expr) => {{ $x * $y }}; + /// } + /// ``` + /// + /// If you specify the types for each argument, i.e. implement + /// + /// ``` + /// # use bindgen::callbacks::ParseCallbacks; + /// # #[derive(Debug)] + /// # struct Callbacks; + /// # impl ParseCallbacks for Callbacks { + /// fn fn_macro_arg_type(&self, name: &str, arg: &str) -> Option { + /// match (name, arg) { + /// ("times", "x" | "y") => Some(syn::parse_quote! { ::core::ffi::c_int }), + /// _ => None, + /// } + /// } + /// # } + /// ``` + /// + /// a function will be generated instead + /// + /// ``` + /// pub fn times(x: ::core::ffi::c_int, y: ::core::ffi::c_int) -> ::core::ffi::c_int { + /// x * y + /// } + /// ``` + /// + /// since all types can be resolved. + #[cfg(feature = "experimental")] + #[allow(unused_variables)] + fn fn_macro_arg_type(&self, name: &str, arg: &str) -> Option { + None + } + /// This function should return whether, given an enum variant /// name, and value, this enum variant will forcibly be a constant. #[allow(unused_variables)] diff --git a/bindgen/clang.rs b/bindgen/clang.rs index 7f201474b4..9c241ffc2a 100644 --- a/bindgen/clang.rs +++ b/bindgen/clang.rs @@ -8,14 +8,14 @@ use crate::ir::context::{BindgenContext, IncludeLocation}; use clang_sys::*; use std::borrow::Cow; use std::cmp; -use std::convert::TryInto; +use std::convert::{TryFrom, TryInto}; use std::env::current_dir; use std::ffi::{CStr, CString}; use std::fmt; use std::fs::OpenOptions; use std::hash::Hash; use std::hash::Hasher; -use std::os::raw::{c_char, c_int, c_longlong, c_uint, c_ulong, c_ulonglong}; +use std::os::raw::{c_char, c_int, c_longlong, c_uint, c_ulong}; use std::path::Path; use std::path::PathBuf; use std::sync::OnceLock; @@ -922,14 +922,6 @@ impl Cursor { RawTokens::new(self) } - /// Gets the tokens that correspond to that cursor as `cexpr` tokens. - pub(crate) fn cexpr_tokens(self) -> Vec { - self.tokens() - .iter() - .filter_map(|token| token.as_cexpr_token()) - .collect() - } - /// Obtain the real path name of a cursor of InclusionDirective kind. /// /// Returns None if the cursor does not include a file, otherwise the file's full name @@ -1015,30 +1007,6 @@ impl ClangToken { pub(crate) fn spelling(&self) -> &CStr { unsafe { CStr::from_ptr(clang_getCString(self.spelling) as *const _) } } - - /// Converts a ClangToken to a `cexpr` token if possible. - pub(crate) fn as_cexpr_token(&self) -> Option { - use cexpr::token; - - let kind = match self.kind { - CXToken_Punctuation => token::Kind::Punctuation, - CXToken_Literal => token::Kind::Literal, - CXToken_Identifier => token::Kind::Identifier, - CXToken_Keyword => token::Kind::Keyword, - // NB: cexpr is not too happy about comments inside - // expressions, so we strip them down here. - CXToken_Comment => return None, - _ => { - warn!("Found unexpected token kind: {:?}", self); - return None; - } - }; - - Some(token::Token { - kind, - raw: self.spelling().to_bytes().to_vec().into_boxed_slice(), - }) - } } impl Drop for ClangToken { @@ -2444,29 +2412,20 @@ impl EvalResult { } /// Try to get back the result as an integer. - pub(crate) fn as_int(&self) -> Option { + pub(crate) fn as_int(&self) -> Option { if self.kind() != CXEval_Int { return None; } if unsafe { clang_EvalResult_isUnsignedInt(self.x) } != 0 { let value = unsafe { clang_EvalResult_getAsUnsigned(self.x) }; - if value > i64::MAX as c_ulonglong { - return None; - } - - return Some(value as i64); + #[allow(clippy::unnecessary_fallible_conversions)] + return i128::try_from(value).ok(); } let value = unsafe { clang_EvalResult_getAsLongLong(self.x) }; - if value > i64::MAX as c_longlong { - return None; - } - if value < i64::MIN as c_longlong { - return None; - } - #[allow(clippy::unnecessary_cast)] - Some(value as i64) + #[allow(clippy::unnecessary_fallible_conversions)] + i128::try_from(value).ok() } /// Evaluates the expression as a literal string, that may or may not be diff --git a/bindgen/codegen/helpers.rs b/bindgen/codegen/helpers.rs index fa1dde8786..d171708b64 100644 --- a/bindgen/codegen/helpers.rs +++ b/bindgen/codegen/helpers.rs @@ -276,9 +276,9 @@ pub(crate) mod ast_ty { } } - pub(crate) fn int_expr(val: i64) -> TokenStream { + pub(crate) fn int_expr(val: i128) -> TokenStream { // Don't use quote! { #val } because that adds the type suffix. - let val = proc_macro2::Literal::i64_unsuffixed(val); + let val = proc_macro2::Literal::i128_unsuffixed(val); quote!(#val) } diff --git a/bindgen/codegen/macro_def.rs b/bindgen/codegen/macro_def.rs new file mode 100644 index 0000000000..704a8add72 --- /dev/null +++ b/bindgen/codegen/macro_def.rs @@ -0,0 +1,214 @@ +use cmacro::{Expr, Lit, LitInt, LitString}; +use cmacro::{FnMacro, VarMacro}; + +use crate::callbacks::IntKind; +use crate::ir::context::BindgenContext; +use crate::ir::item::{Item, ItemCanonicalName}; +use crate::ir::macro_def::MacroDef; + +use super::{ + attributes, helpers::ast_ty, CodeGenerator, CodegenResult, + MacroTypeVariation, +}; + +fn default_macro_constant_type(ctx: &BindgenContext, value: i128) -> IntKind { + if value < 0 || + ctx.options().default_macro_constant_type == + MacroTypeVariation::Signed + { + if value < i64::MIN as i128 || value > i64::MAX as i128 { + IntKind::I128 + } else if value < i32::MIN as i128 || value > i32::MAX as i128 { + IntKind::I64 + } else if !ctx.options().fit_macro_constants || + value < i16::MIN as i128 || + value > i16::MAX as i128 + { + IntKind::I32 + } else if value < i8::MIN as i128 || value > i8::MAX as i128 { + IntKind::I16 + } else { + IntKind::I8 + } + } else if value > u32::MAX as i128 { + IntKind::U64 + } else if !ctx.options().fit_macro_constants || value > u16::MAX as i128 { + IntKind::U32 + } else if value > u8::MAX as i128 { + IntKind::U16 + } else { + IntKind::U8 + } +} + +impl CodeGenerator for MacroDef { + type Extra = Item; + type Return = (); + + fn codegen( + &self, + ctx: &BindgenContext, + result: &mut CodegenResult<'_>, + item: &Item, + ) { + debug!("::codegen: item = {:?}", item); + debug_assert!(item.is_enabled_for_codegen(ctx)); + + let canonical_name = item.canonical_name(ctx); + + let mut attrs = vec![]; + if let Some(comment) = item.comment(ctx) { + attrs.push(attributes::doc(comment)); + } + + match self { + Self::Fn(name) => { + if !ctx.options().generate_fn_macros { + return; + } + + if result.seen_fn_macro(name) { + return; + } + result.saw_fn_macro(name); + + let mut fn_macro = match ctx.macro_set.expand_fn_macro(name) { + Ok((args, body)) => { + match FnMacro::parse(name, &args, &body) { + Ok(fn_macro) => fn_macro, + Err(err) => { + warn!( + "Cannot parse function-like macro `{}`: {}", + name, err + ); + return; + } + } + } + Err(cmacro::ExpansionError::MacroNotFound) => return, + Err(err) => { + warn!( + "Cannot expand function-like macro `{}`: {}", + name, err + ); + return; + } + }; + + let generated_value = match fn_macro.generate(ctx) { + Ok(value) => value, + Err(err) => { + warn!( + "Cannot generate function-like macro `{}`: {:?}\n{:?}", + name, err, fn_macro + ); + return; + } + }; + + result.push(quote! { + #(#attrs)* + #generated_value + }); + } + Self::Var(name) => { + if result.seen_var_macro(name) { + return; + } + result.saw_var_macro(name); + + let canonical_ident = ctx.rust_ident(canonical_name); + + let mut var_macro = match ctx.macro_set.expand_var_macro(name) { + Ok(body) => match VarMacro::parse(name, &body) { + Ok(var_macro) => var_macro, + Err(err) => { + warn!( + "Cannot parse variable-like macro {}: {}", + name, err + ); + return; + } + }, + Err(cmacro::ExpansionError::MacroNotFound) => return, + Err(err) => { + warn!( + "Cannot expand variable-like macro {}: {}", + name, err + ); + return; + } + }; + + let (generated_value, generated_type) = match var_macro + .generate(ctx) + { + Ok((value, ty)) => (value, ty), + Err(err) => { + warn!( + "Cannot generate variable-like macro {}: {:?}\n{:?}", + name, + err, var_macro + ); + return; + } + }; + + let value = if let Some(value) = var_macro.value() { + value + } else { + // Variable-like macro has no value. + return; + }; + + match value { + Expr::Literal(Lit::Int(LitInt { value, .. })) => { + let value = *value; + let int_kind = ctx + .options() + .last_callback(|c| c.int_macro(self.name(), value)) + .unwrap_or_else(|| { + default_macro_constant_type(ctx, value) + }); + + let ty = + ast_ty::int_kind_rust_type(ctx, int_kind, None); + let value = if int_kind.is_signed() { + ast_ty::int_expr(value) + } else { + ast_ty::uint_expr(value as _) + }; + + result.push(quote! { + #(#attrs)* + pub const #canonical_ident : #ty = #value; + }); + } + expr => { + if let Expr::Literal(Lit::String( + LitString::Ordinary(ref bytes), + )) = expr + { + for callbacks in &ctx.options().parse_callbacks { + callbacks.str_macro(self.name(), bytes); + } + } + + if let Some(ty) = generated_type { + result.push(quote! { + #(#attrs)* + pub const #canonical_ident : #ty = #generated_value; + }); + } else { + warn!( + "Unhandled variable-like macro: {} = {:?}", + var_macro.name(), + expr + ); + } + } + } + } + } + } +} diff --git a/bindgen/codegen/mod.rs b/bindgen/codegen/mod.rs index c299a0ad2e..356208ef42 100644 --- a/bindgen/codegen/mod.rs +++ b/bindgen/codegen/mod.rs @@ -13,6 +13,7 @@ pub(crate) mod struct_layout; pub(crate) mod bitfield_unit; #[cfg(all(test, target_endian = "little"))] mod bitfield_unit_tests; +mod macro_def; use self::dyngen::DynamicItems; use self::helpers::attributes; @@ -269,7 +270,9 @@ struct CodegenResult<'a> { /// /// Being these two different declarations. functions_seen: HashSet, + fn_macros_seen: HashSet, vars_seen: HashSet, + var_macros_seen: HashSet, /// Used for making bindings to overloaded functions. Maps from a canonical /// function name to the number of overloads we have already codegen'd for @@ -295,6 +298,8 @@ impl<'a> CodegenResult<'a> { items_seen: Default::default(), functions_seen: Default::default(), vars_seen: Default::default(), + fn_macros_seen: Default::default(), + var_macros_seen: Default::default(), overload_counters: Default::default(), items_to_serialize: Default::default(), } @@ -340,6 +345,14 @@ impl<'a> CodegenResult<'a> { self.functions_seen.insert(name.into()); } + fn seen_fn_macro(&self, name: &str) -> bool { + self.fn_macros_seen.contains(name) + } + + fn saw_fn_macro(&mut self, name: &str) { + self.fn_macros_seen.insert(name.into()); + } + /// Get the overload number for the given function name. Increments the /// counter internally so the next time we ask for the overload for this /// name, we get the incremented value, and so on. @@ -358,6 +371,14 @@ impl<'a> CodegenResult<'a> { self.vars_seen.insert(name.into()); } + fn seen_var_macro(&self, name: &str) -> bool { + self.var_macros_seen.contains(name) + } + + fn saw_var_macro(&mut self, name: &str) { + self.var_macros_seen.insert(name.into()); + } + fn inner(&mut self, cb: F) -> Vec where F: FnOnce(&mut Self), @@ -540,6 +561,9 @@ impl CodeGenerator for Item { ItemKind::Var(ref var) => { var.codegen(ctx, result, self); } + ItemKind::MacroDef(ref macro_def) => { + macro_def.codegen(ctx, result, self); + } ItemKind::Type(ref ty) => { ty.codegen(ctx, result, self); } @@ -661,6 +685,14 @@ impl CodeGenerator for Var { let canonical_name = item.canonical_name(ctx); + // If there is a variable-like macro defined with the same name, it came + // after this variable, otherwise it would have been undefined. + if ctx.macro_set.expand_var_macro(&canonical_name) != + Err(cmacro::ExpansionError::MacroNotFound) + { + return; + } + if result.seen_var(&canonical_name) { return; } @@ -2316,7 +2348,7 @@ impl CodeGenerator for CompInfo { if let Some(explicit) = explicit_align { // Ensure that the struct has the correct alignment even in // presence of alignas. - let explicit = helpers::ast_ty::int_expr(explicit as i64); + let explicit = helpers::ast_ty::int_expr(explicit as i128); attributes.push(quote! { #[repr(align(#explicit))] }); @@ -3226,7 +3258,7 @@ impl<'a> EnumBuilder<'a> { helpers::ast_ty::uint_expr(v as u64) } EnumVariantValue::Boolean(v) => quote!(#v), - EnumVariantValue::Signed(v) => helpers::ast_ty::int_expr(v), + EnumVariantValue::Signed(v) => helpers::ast_ty::int_expr(v as i128), EnumVariantValue::Unsigned(v) => helpers::ast_ty::uint_expr(v), }; @@ -3584,20 +3616,12 @@ impl CodeGenerator for Enum { enum_rust_ty: syn::Type, result: &mut CodegenResult<'_>, ) { - let constant_name = if enum_.name().is_some() { - if ctx.options().prepend_enum_name { - format!("{}_{}", enum_canonical_name, variant_name) - } else { - format!("{}", variant_name) - } - } else { - format!("{}", variant_name) - }; - let constant_name = ctx.rust_ident(constant_name); - + let constant_name = ctx.enum_variant_const_name( + enum_.name().map(move |_| enum_canonical_name), + variant_name, + ); result.push(quote! { - pub const #constant_name : #enum_rust_ty = - #enum_canonical_name :: #referenced_name ; + pub const #constant_name: #enum_rust_ty = #enum_canonical_name::#referenced_name; }); } @@ -4372,12 +4396,7 @@ impl CodeGenerator for Function { let is_internal = matches!(self.linkage(), Linkage::Internal); - let signature_item = ctx.resolve_item(self.signature()); - let signature = signature_item.kind().expect_type().canonical_type(ctx); - let signature = match *signature.kind() { - TypeKind::Function(ref sig) => sig, - _ => panic!("Signature kind is not a Function: {:?}", signature), - }; + let signature = ctx.resolve_sig(self.signature()); if is_internal { if !ctx.options().wrap_static_fns { @@ -5485,7 +5504,7 @@ pub(crate) mod utils { }) } - fn fnsig_return_ty_internal( + pub(crate) fn fnsig_return_ty_internal( ctx: &BindgenContext, sig: &FunctionSig, ) -> syn::Type { diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs index e4a7a96a91..65b18aa648 100644 --- a/bindgen/ir/context.rs +++ b/bindgen/ir/context.rs @@ -11,16 +11,21 @@ use super::derive::{ CanDerive, CanDeriveCopy, CanDeriveDebug, CanDeriveDefault, CanDeriveEq, CanDeriveHash, CanDeriveOrd, CanDerivePartialEq, CanDerivePartialOrd, }; -use super::function::Function; +use super::function::{Function, FunctionSig, Linkage}; use super::int::IntKind; use super::item::{IsOpaque, Item, ItemAncestors, ItemSet}; use super::item_kind::ItemKind; +use super::macro_def::MacroDef; use super::module::{Module, ModuleKind}; use super::template::{TemplateInstantiation, TemplateParameters}; use super::traversal::{self, Edge, ItemTraversal}; use super::ty::{FloatKind, Type, TypeKind}; use crate::clang::{self, ABIKind, Cursor, SourceFile, SourceLocation}; +use crate::codegen::utils::type_from_named; +use crate::codegen::utils::{fnsig_argument_type, fnsig_return_ty_internal}; use crate::codegen::CodegenError; +use crate::codegen::ToRustTyOrOpaque; +use crate::ir::item::ItemCanonicalName; use crate::BindgenOptions; use crate::{Entry, HashMap, HashSet}; @@ -29,8 +34,6 @@ use quote::ToTokens; use std::borrow::Cow; use std::cell::{Cell, RefCell}; use std::collections::{BTreeSet, HashMap as StdHashMap}; -use std::fs::OpenOptions; -use std::io::Write; use std::path::{Path, PathBuf}; use std::{cmp, mem}; @@ -453,12 +456,26 @@ pub(crate) struct BindgenContext { /// potentially break that assumption. currently_parsed_types: Vec, - /// A map with all the already parsed macro names. This is done to avoid - /// hard errors while parsing duplicated macros, as well to allow macro - /// expression parsing. + /// A map with all the already parsed macro names. /// - /// This needs to be an std::HashMap because the cexpr API requires it. - parsed_macros: StdHashMap, cexpr::expr::EvalResult>, + /// This is needed to handle redefined macros so they are not + /// generated multiple times. + parsed_macros: StdHashMap, + + /// A set with all defined macros. + /// + /// This is needed to expand nested macros. + pub(crate) macro_set: cmacro::MacroSet, + + /// A map with all defined functions. + /// + /// This is needed for inferring types for function calls in macros. + function_names: StdHashMap, + + /// A map with all defined types. + /// + /// This is needed to resolve types used in macros. + type_names: StdHashMap, /// A map with all include locations. /// @@ -481,9 +498,6 @@ pub(crate) struct BindgenContext { /// The translation unit for parsing. translation_unit: clang::TranslationUnit, - /// The translation unit for macro fallback parsing. - fallback_tu: Option, - /// Target information that can be useful for some stuff. target_info: clang::TargetInfo, @@ -535,6 +549,10 @@ pub(crate) struct BindgenContext { /// and is always `None` before that and `Some` after. enum_typedef_combos: Option>, + /// A map of all enum variants, mapping the variant name to + /// the generated constant name and/or path. + enum_variants: HashMap, + /// The set of (`ItemId`s of) types that can't derive debug. /// /// This is populated when we enter codegen by `compute_cannot_derive_debug` @@ -688,11 +706,13 @@ If you encounter an error missing from this list, please file an issue or a PR!" semantic_parents: Default::default(), currently_parsed_types: vec![], parsed_macros: Default::default(), + macro_set: Default::default(), + function_names: Default::default(), + type_names: Default::default(), replacements: Default::default(), collected_typerefs: false, in_codegen: false, translation_unit, - fallback_tu: None, target_info, options, generated_bindgen_complex: Cell::new(false), @@ -703,6 +723,7 @@ If you encounter an error missing from this list, please file an issue or a PR!" used_template_parameters: None, need_bitfield_allocation: Default::default(), enum_typedef_combos: None, + enum_variants: Default::default(), cannot_derive_debug: None, cannot_derive_default: None, cannot_derive_copy: None, @@ -845,32 +866,69 @@ If you encounter an error missing from this list, please file an issue or a PR!" "Adding a type without declaration?" ); + let macro_name = if let ItemKind::MacroDef(ref m) = item.kind() { + if let Some(id) = self.parsed_macros.get(m.name()) { + self.items[id.0] = None; + } + + Some(m.name().to_owned()) + } else { + None + }; + let id = item.id(); - let is_type = item.kind().is_type(); - let is_unnamed = is_type && item.expect_type().name().is_none(); - let is_template_instantiation = - is_type && item.expect_type().is_template_instantiation(); if item.id() != self.root_module { self.add_item_to_module(&item); } - if is_type && item.expect_type().is_comp() { - self.need_bitfield_allocation.push(id); + if item.kind().is_function() { + let function = item.expect_function(); + let function_id = id.as_function_id_unchecked(); + self.function_names + .insert(function.name().to_owned(), function_id); } + let type_info: Option<(Option, _, _)> = if item.kind().is_type() + { + let ty = item.expect_type(); + + Some(( + ty.name().map(|n| n.to_owned()), + ty.is_comp(), + ty.is_template_instantiation(), + )) + } else { + None + }; + let old_item = mem::replace(&mut self.items[id.0], Some(item)); assert!( old_item.is_none(), "should not have already associated an item with the given id" ); + if let Some(macro_name) = macro_name { + self.parsed_macros.insert(macro_name, id); + } + // Unnamed items can have an USR, but they can't be referenced from // other sites explicitly and the USR can match if the unnamed items are // nested, so don't bother tracking them. - if !is_type || is_template_instantiation { + let (type_name, is_comp, is_template_instantiation) = + if let Some(type_info) = type_info { + type_info + } else { + return; + }; + if is_comp { + self.need_bitfield_allocation.push(id); + } + + if is_template_instantiation { return; } + if let Some(mut declaration) = declaration { if !declaration.is_valid() { if let Some(location) = location { @@ -897,19 +955,25 @@ If you encounter an error missing from this list, please file an issue or a PR!" return; } - let key = if is_unnamed { - TypeKey::Declaration(declaration) - } else if let Some(usr) = declaration.usr() { - TypeKey::Usr(usr) + let type_id = id.as_type_id_unchecked(); + + let key = if let Some(type_name) = type_name { + self.type_names.insert(type_name, type_id); + + if let Some(usr) = declaration.usr() { + TypeKey::Usr(usr) + } else { + warn!( + "Valid declaration with no USR: {:?}, {:?}", + declaration, location + ); + TypeKey::Declaration(declaration) + } } else { - warn!( - "Valid declaration with no USR: {:?}, {:?}", - declaration, location - ); TypeKey::Declaration(declaration) }; - let old = self.types.insert(key, id.as_type_id_unchecked()); + let old = self.types.insert(key, type_id); debug_assert_eq!(old, None); } } @@ -1356,6 +1420,7 @@ If you encounter an error missing from this list, please file an issue or a PR!" self.compute_has_destructor(); self.find_used_template_parameters(); self.compute_enum_typedef_combos(); + self.compute_enum_variants(); self.compute_cannot_derive_debug(); self.compute_cannot_derive_default(); self.compute_cannot_derive_copy(); @@ -1624,6 +1689,18 @@ If you encounter an error missing from this list, please file an issue or a PR!" self.resolve_item(func_id).kind().expect_function() } + /// Resolve a function signature with the given ID. + /// + /// Panics if there is no type for the given `TypeId` or if the resolved + /// `Type` is not a function. + pub(crate) fn resolve_sig(&self, sig_id: TypeId) -> &FunctionSig { + let signature = self.resolve_type(sig_id).canonical_type(self); + match *signature.kind() { + TypeKind::Function(ref sig) => sig, + _ => panic!("Signature kind is not a Function: {:?}", signature), + } + } + /// Resolve the given `ItemId` as a type, or `None` if there is no item with /// the given ID. /// @@ -2089,13 +2166,13 @@ If you encounter an error missing from this list, please file an issue or a PR!" /// Needed to handle const methods in C++, wrapping the type . pub(crate) fn build_const_wrapper( &mut self, - with_id: ItemId, wrapped_id: TypeId, parent_id: Option, ty: &clang::Type, ) -> TypeId { + let id = self.next_item_id(); self.build_wrapper( - with_id, wrapped_id, parent_id, ty, /* is_const = */ true, + id, wrapped_id, parent_id, ty, /* is_const = */ true, ) } @@ -2111,6 +2188,7 @@ If you encounter an error missing from this list, please file an issue or a PR!" let layout = ty.fallible_layout(self).ok(); let location = ty.declaration().location(); let type_kind = TypeKind::ResolvedTypeRef(wrapped_id); + let ty = Type::new(Some(spelling), layout, type_kind, is_const); let item = Item::new( with_id, @@ -2121,9 +2199,22 @@ If you encounter an error missing from this list, please file an issue or a PR!" Some(location), ); self.add_builtin_item(item); + with_id.as_type_id_unchecked() } + /// Get a function signature by its name. + pub(crate) fn function_by_name(&self, name: &str) -> Option<&Function> { + self.function_names + .get(name) + .map(|id| self.resolve_func(*id)) + } + + /// Get a type by its name. + pub(crate) fn type_by_name(&self, name: &str) -> Option<&TypeId> { + self.type_names.get(name) + } + /// Returns the next item ID to be used for an item. pub(crate) fn next_item_id(&mut self) -> ItemId { let ret = ItemId(self.items.len()); @@ -2201,135 +2292,6 @@ If you encounter an error missing from this list, please file an issue or a PR!" &self.translation_unit } - /// Initialize fallback translation unit if it does not exist and - /// then return a mutable reference to the fallback translation unit. - pub(crate) fn try_ensure_fallback_translation_unit( - &mut self, - ) -> Option<&mut clang::FallbackTranslationUnit> { - if self.fallback_tu.is_none() { - let file = format!( - "{}/.macro_eval.c", - match self.options().clang_macro_fallback_build_dir { - Some(ref path) => path.as_os_str().to_str()?, - None => ".", - } - ); - - let index = clang::Index::new(false, false); - - let mut header_names_to_compile = Vec::new(); - let mut header_paths = Vec::new(); - let mut header_contents = String::new(); - for input_header in self.options.input_headers.iter() { - let path = Path::new(input_header.as_ref()); - if let Some(header_path) = path.parent() { - if header_path == Path::new("") { - header_paths.push("."); - } else { - header_paths.push(header_path.as_os_str().to_str()?); - } - } else { - header_paths.push("."); - } - let header_name = path.file_name()?.to_str()?; - header_names_to_compile - .push(header_name.split(".h").next()?.to_string()); - header_contents += - format!("\n#include <{header_name}>").as_str(); - } - let header_to_precompile = format!( - "{}/{}", - match self.options().clang_macro_fallback_build_dir { - Some(ref path) => path.as_os_str().to_str()?, - None => ".", - }, - header_names_to_compile.join("-") + "-precompile.h" - ); - let pch = header_to_precompile.clone() + ".pch"; - - let mut header_to_precompile_file = OpenOptions::new() - .create(true) - .truncate(true) - .write(true) - .open(&header_to_precompile) - .ok()?; - header_to_precompile_file - .write_all(header_contents.as_bytes()) - .ok()?; - - let mut c_args = Vec::new(); - c_args.push("-x".to_string().into_boxed_str()); - c_args.push("c-header".to_string().into_boxed_str()); - for header_path in header_paths { - c_args.push(format!("-I{header_path}").into_boxed_str()); - } - c_args.extend( - self.options - .clang_args - .iter() - .filter(|next| { - !self.options.input_headers.contains(next) && - next.as_ref() != "-include" - }) - .cloned(), - ); - let mut tu = clang::TranslationUnit::parse( - &index, - &header_to_precompile, - &c_args, - &[], - clang_sys::CXTranslationUnit_ForSerialization, - )?; - tu.save(&pch).ok()?; - - let mut c_args = vec![ - "-include-pch".to_string().into_boxed_str(), - pch.clone().into_boxed_str(), - ]; - c_args.extend( - self.options - .clang_args - .clone() - .iter() - .filter(|next| { - !self.options.input_headers.contains(next) && - next.as_ref() != "-include" - }) - .cloned(), - ); - self.fallback_tu = Some(clang::FallbackTranslationUnit::new( - file, - header_to_precompile, - pch, - &c_args, - )?); - } - - self.fallback_tu.as_mut() - } - - /// Have we parsed the macro named `macro_name` already? - pub(crate) fn parsed_macro(&self, macro_name: &[u8]) -> bool { - self.parsed_macros.contains_key(macro_name) - } - - /// Get the currently parsed macros. - pub(crate) fn parsed_macros( - &self, - ) -> &StdHashMap, cexpr::expr::EvalResult> { - debug_assert!(!self.in_codegen_phase()); - &self.parsed_macros - } - - /// Mark the macro named `macro_name` as parsed. - pub(crate) fn note_parsed_macro( - &mut self, - id: Vec, - value: cexpr::expr::EvalResult, - ) { - self.parsed_macros.insert(id, value); - } - /// Are we in the codegen phase? pub(crate) fn in_codegen_phase(&self) -> bool { self.in_codegen @@ -2651,6 +2613,15 @@ If you encounter an error missing from this list, please file an issue or a PR!" ItemKind::Var(_) => { self.options().allowlisted_vars.matches(&name) } + ItemKind::MacroDef(ref macro_def) => match macro_def { + MacroDef::Fn(_) => self + .options() + .allowlisted_functions + .matches(&name), + MacroDef::Var(_) => { + self.options().allowlisted_vars.matches(&name) + } + }, ItemKind::Type(ref ty) => { if self.options().allowlisted_types.matches(&name) { return true; @@ -2806,6 +2777,85 @@ If you encounter an error missing from this list, please file an issue or a PR!" self.generated_bindgen_float16.get() } + /// Generate the constant name for an enum variant. + pub(crate) fn enum_variant_const_name( + &self, + enum_canonical_name: Option<&Ident>, + variant_name: &Ident, + ) -> Ident { + if self.options().prepend_enum_name { + if let Some(enum_canonical_name) = enum_canonical_name { + return self.rust_ident(format!( + "{}_{}", + enum_canonical_name, variant_name + )); + } + } + + variant_name.clone() + } + + fn compute_enum_variants(&mut self) { + for item in &self.items { + if let Some(item) = item.as_ref() { + if let ItemKind::Type(ty) = item.kind() { + if let TypeKind::Enum(enum_ty) = ty.kind() { + let variation = + enum_ty.computed_enum_variation(self, item); + + use crate::EnumVariation; + + for variant in enum_ty.variants() { + let variant_name = self.rust_ident(variant.name()); + + let variant_expr = if ty.name().is_some() { + let enum_canonical_name = + item.canonical_name(self); + let enum_canonical_name = + self.rust_ident(enum_canonical_name); + + match variation { + EnumVariation::Rust { .. } | + EnumVariation::NewType { + is_global: false, + .. + } | + EnumVariation::ModuleConsts => { + syn::parse_quote! { #enum_canonical_name::#variant_name } + } + EnumVariation::NewType { + is_global: true, + .. + } | + EnumVariation::Consts { .. } => { + let constant_name = self + .enum_variant_const_name( + Some(&enum_canonical_name), + &variant_name, + ); + syn::parse_quote! { #constant_name } + } + } + } else { + let constant_name = self + .enum_variant_const_name( + None, + &variant_name, + ); + syn::parse_quote! { #constant_name } + }; + + self.enum_variants.insert( + variant.name().to_owned(), + variant_expr, + ); + } + } + } + } + } + } + /// Compute which `enum`s have an associated `typedef` definition. fn compute_enum_typedef_combos(&mut self) { let _t = self.timer("compute_enum_typedef_combos"); @@ -2860,6 +2910,15 @@ If you encounter an error missing from this list, please file an issue or a PR!" self.enum_typedef_combos = Some(enum_typedef_combos); } + /// Get the generated name of an enum variant. + pub(crate) fn enum_variant(&self, variant: &str) -> Option<&syn::Expr> { + assert!( + self.in_codegen_phase(), + "We only compute enum_variants when we enter codegen", + ); + self.enum_variants.get(variant) + } + /// Look up whether `id` refers to an `enum` whose underlying type is /// defined by a `typedef`. pub(crate) fn is_enum_typedef_combo(&self, id: ItemId) -> bool { @@ -3130,6 +3189,81 @@ If you encounter an error missing from this list, please file an issue or a PR!" } } +impl cmacro::CodegenContext for BindgenContext { + fn ffi_prefix(&self) -> Option { + Some(match self.options().ctypes_prefix { + Some(ref prefix) => syn::parse_str(prefix.as_str()).unwrap(), + None => syn::parse_quote! { ::std::os::raw }, + }) + } + + fn trait_prefix(&self) -> Option { + let trait_prefix = self.trait_prefix(); + Some(syn::parse_quote! { ::#trait_prefix }) + } + + #[cfg(feature = "experimental")] + fn macro_arg_ty(&self, name: &str, arg: &str) -> Option { + self.options() + .last_callback(|c| c.fn_macro_arg_type(name, arg)) + } + + fn resolve_enum_variant(&self, variant: &str) -> Option { + self.enum_variant(variant).cloned() + } + + fn resolve_ty(&self, ty: &str) -> Option { + if let Some(ty) = type_from_named(self, ty) { + return Some(ty); + } + + if let Some(ty) = self.type_by_name(ty) { + return Some(ty.to_rust_ty_or_opaque(self, &())); + } + + None + } + + fn function(&self, name: &str) -> Option<(Vec, syn::Type)> { + let allowlisted_functions = &self.options().allowlisted_functions; + if !allowlisted_functions.is_empty() && + !allowlisted_functions.matches(name) + { + return None; + } + + if let Some(f) = self.function_by_name(name) { + // Cannot call functions with internal linkage. + if matches!(f.linkage(), Linkage::Internal) { + return None; + } + + let sig = self.resolve_sig(f.signature()); + + let arg_types = sig + .argument_types() + .iter() + .map(|(_, ty)| fnsig_argument_type(self, ty)) + .collect(); + + let ret_type = fnsig_return_ty_internal(self, sig); + + return Some((arg_types, ret_type)); + } + + None + } + + fn rust_target(&self) -> Option { + // FIXME: Workaround until `generate_cstr` is the default. + if !self.options().generate_cstr { + return Some("1.0".into()); + } + + Some(self.options().rust_target.to_string()) + } +} + /// A builder struct for configuring item resolution options. #[derive(Debug, Copy, Clone)] pub(crate) struct ItemResolver { diff --git a/bindgen/ir/enum_ty.rs b/bindgen/ir/enum_ty.rs index 70cf0eae88..72b2f0dc95 100644 --- a/bindgen/ir/enum_ty.rs +++ b/bindgen/ir/enum_ty.rs @@ -136,6 +136,7 @@ impl Enum { .unwrap_or_else(|| name.clone()); let comment = cursor.raw_comment(); + variants.push(EnumVariant::new( new_name, name, diff --git a/bindgen/ir/function.rs b/bindgen/ir/function.rs index 1557843d03..c29af8705f 100644 --- a/bindgen/ir/function.rs +++ b/bindgen/ir/function.rs @@ -431,14 +431,13 @@ impl FunctionSig { return Err(ParseError::Continue); } - let spelling = cursor.spelling(); + let name = cursor.spelling(); // Don't parse operatorxx functions in C++ - let is_operator = |spelling: &str| { - spelling.starts_with("operator") && - !clang::is_valid_identifier(spelling) + let is_operator = |name: &str| { + name.starts_with("operator") && !clang::is_valid_identifier(name) }; - if is_operator(&spelling) { + if is_operator(&name) { return Err(ParseError::Continue); } @@ -446,7 +445,7 @@ impl FunctionSig { // include the template parameter in their name. Just skip them, since // we don't handle well non-type template parameters anyway. if (kind == CXCursor_Constructor || kind == CXCursor_Destructor) && - spelling.contains('<') + name.contains('<') { return Err(ParseError::Continue); } @@ -547,13 +546,7 @@ impl FunctionSig { let class = class.as_type_id_unchecked(); let class = if is_const { - let const_class_id = ctx.next_item_id(); - ctx.build_const_wrapper( - const_class_id, - class, - None, - &parent.cur_type(), - ) + ctx.build_const_wrapper(class, None, &parent.cur_type()) } else { class }; @@ -605,7 +598,7 @@ impl FunctionSig { } Ok(Self { - name: spelling, + name, return_type: ret, argument_types: args, is_variadic: ty.is_variadic(), @@ -722,7 +715,7 @@ impl FunctionSig { impl ClangSubItemParser for Function { fn parse( cursor: clang::Cursor, - context: &mut BindgenContext, + ctx: &mut BindgenContext, ) -> Result, ParseError> { use clang_sys::*; @@ -753,8 +746,8 @@ impl ClangSubItemParser for Function { .definition() .map_or(false, |x| x.is_inlined_function()) { - if !context.options().generate_inline_functions && - !context.options().wrap_static_fns + if !ctx.options().generate_inline_functions && + !ctx.options().wrap_static_fns { return Err(ParseError::Continue); } @@ -764,7 +757,7 @@ impl ClangSubItemParser for Function { } // We cannot handle `inline` functions that are not `static`. - if context.options().wrap_static_fns && + if ctx.options().wrap_static_fns && cursor.is_inlined_function() && matches!(linkage, Linkage::External) { @@ -773,11 +766,19 @@ impl ClangSubItemParser for Function { } // Grab the signature using Item::from_ty. - let sig = Item::from_ty(&cursor.cur_type(), cursor, None, context)?; + let sig = Item::from_ty(&cursor.cur_type(), cursor, None, ctx)?; let mut name = cursor.spelling(); assert!(!name.is_empty(), "Empty function name?"); + // If a function exists, there cannot be a variable-like macro with the same name, + // except if the macro expands to its own name, in which case it is useless anyways. + ctx.macro_set.undefine_var_macro(&name); + + // If a function exists, there cannot be a function-like macro with the same name, + // except if the macro expands to the function, in which case it is useless anyways. + ctx.macro_set.undefine_fn_macro(&name); + if cursor.kind() == CXCursor_Destructor { // Remove the leading `~`. The alternative to this is special-casing // code-generation for destructor functions, which seems less than @@ -791,7 +792,7 @@ impl ClangSubItemParser for Function { // but seems easy enough to handle it here. name.push_str("_destructor"); } - if let Some(nm) = context.options().last_callback(|callbacks| { + if let Some(nm) = ctx.options().last_callback(|callbacks| { callbacks.generated_name_override(ItemInfo { name: name.as_str(), kind: ItemKind::Function, @@ -801,25 +802,19 @@ impl ClangSubItemParser for Function { } assert!(!name.is_empty(), "Empty function name."); - let mangled_name = cursor_mangling(context, &cursor); + let mangled_name = cursor_mangling(ctx, &cursor); - let link_name = context.options().last_callback(|callbacks| { + let link_name = ctx.options().last_callback(|callbacks| { callbacks.generated_link_name_override(ItemInfo { name: name.as_str(), kind: ItemKind::Function, }) }); - let function = Self::new( - name.clone(), - mangled_name, - link_name, - sig, - kind, - linkage, - ); - - Ok(ParseResult::New(function, Some(cursor))) + Ok(ParseResult::New( + Self::new(name, mangled_name, link_name, sig, kind, linkage), + Some(cursor), + )) } } diff --git a/bindgen/ir/int.rs b/bindgen/ir/int.rs index 4251b3753a..d0d6cfe540 100644 --- a/bindgen/ir/int.rs +++ b/bindgen/ir/int.rs @@ -121,7 +121,7 @@ impl IntKind { } /// Whether this type's signedness matches the value. - pub(crate) fn signedness_matches(&self, val: i64) -> bool { + pub(crate) fn signedness_matches(&self, val: i128) -> bool { val >= 0 || self.is_signed() } } diff --git a/bindgen/ir/item.rs b/bindgen/ir/item.rs index c7c91792ce..ae1d410b9e 100644 --- a/bindgen/ir/item.rs +++ b/bindgen/ir/item.rs @@ -18,6 +18,7 @@ use super::template::{AsTemplateParam, TemplateParameters}; use super::traversal::{EdgeKind, Trace, Tracer}; use super::ty::{Type, TypeKind}; use crate::clang::{self, SourceLocation}; +use crate::ir::{macro_def::MacroDef, var::Var}; use crate::parse::{ClangSubItemParser, ParseError, ParseResult}; use std::cell::{Cell, OnceCell}; @@ -186,6 +187,7 @@ impl AsTemplateParam for ItemKind { ItemKind::Module(..) | ItemKind::Function(..) | ItemKind::Var(..) => None, + ItemKind::MacroDef(..) => None, } } } @@ -289,6 +291,7 @@ impl Trace for Item { ItemKind::Var(ref var) => { tracer.visit_kind(var.ty().into(), EdgeKind::VarType); } + ItemKind::MacroDef(_) => {} ItemKind::Module(_) => { // Module -> children edges are "weak", and we do not want to // trace them. If we did, then allowlisting wouldn't work as @@ -655,10 +658,11 @@ impl Item { ctx.options().blocklisted_types.matches(&name) || ctx.is_replaced_type(path, self.id) } - ItemKind::Function(..) => { + ItemKind::Function(..) | + ItemKind::MacroDef(MacroDef::Fn(..)) => { ctx.options().blocklisted_functions.matches(&name) } - ItemKind::Var(..) => { + ItemKind::Var(..) | ItemKind::MacroDef(MacroDef::Var(..)) => { ctx.options().blocklisted_vars.matches(&name) } // TODO: Add namespace blocklisting? @@ -783,6 +787,7 @@ impl Item { match *self.kind() { ItemKind::Var(ref var) => var.name().to_owned(), + ItemKind::MacroDef(ref var) => var.name().to_owned(), ItemKind::Module(ref module) => { module.name().map(ToOwned::to_owned).unwrap_or_else(|| { format!("_bindgen_mod_{}", self.exposed_id(ctx)) @@ -813,6 +818,7 @@ impl Item { ItemKind::Type(ty) => ty.name().is_none(), ItemKind::Function(_) => false, ItemKind::Var(_) => false, + ItemKind::MacroDef(_) => false, } } @@ -1006,8 +1012,11 @@ impl Item { let cc = &ctx.options().codegen_config; match *self.kind() { ItemKind::Module(..) => true, - ItemKind::Var(_) => cc.vars(), + ItemKind::Var(_) | ItemKind::MacroDef(MacroDef::Var(_)) => { + cc.vars() + } ItemKind::Type(_) => cc.types(), + ItemKind::MacroDef(MacroDef::Fn(_)) => cc.functions(), ItemKind::Function(ref f) => match f.kind() { FunctionKind::Function => cc.functions(), FunctionKind::Method(MethodKind::Constructor) => { @@ -1244,7 +1253,10 @@ impl TemplateParameters for ItemKind { // If we start emitting bindings to explicitly instantiated // functions, then we'll need to check ItemKind::Function for // template params. - ItemKind::Function(_) | ItemKind::Module(_) | ItemKind::Var(_) => { + ItemKind::Module(_) | + ItemKind::Function(_) | + ItemKind::Var(_) | + ItemKind::MacroDef(_) => { vec![] } } @@ -1310,7 +1322,6 @@ impl Item { parent_id: Option, ctx: &mut BindgenContext, ) -> Result { - use crate::ir::var::Var; use clang_sys::*; if !cursor.is_valid() { @@ -1364,6 +1375,7 @@ impl Item { // I guess we can try. try_parse!(Function); try_parse!(Var); + try_parse!(MacroDef); // Types are sort of special, so to avoid parsing template classes // twice, handle them separately. diff --git a/bindgen/ir/item_kind.rs b/bindgen/ir/item_kind.rs index 9221b50579..d858871bb5 100644 --- a/bindgen/ir/item_kind.rs +++ b/bindgen/ir/item_kind.rs @@ -3,6 +3,7 @@ use super::context::BindgenContext; use super::dot::DotAttributes; use super::function::Function; +use super::macro_def::MacroDef; use super::module::Module; use super::ty::Type; use super::var::Var; @@ -23,6 +24,9 @@ pub(crate) enum ItemKind { /// A variable declaration, most likely a static. Var(Var), + + /// A macro definition. + MacroDef(MacroDef), } impl ItemKind { @@ -42,6 +46,7 @@ impl ItemKind { ItemKind::Type(..) => "Type", ItemKind::Function(..) => "Function", ItemKind::Var(..) => "Var", + ItemKind::MacroDef(..) => "MacroDef", } } @@ -130,6 +135,9 @@ impl DotAttributes for ItemKind { ItemKind::Type(ref ty) => ty.dot_attributes(ctx, out), ItemKind::Function(ref func) => func.dot_attributes(ctx, out), ItemKind::Var(ref var) => var.dot_attributes(ctx, out), + ItemKind::MacroDef(ref macro_def) => { + macro_def.dot_attributes(ctx, out) + } } } } diff --git a/bindgen/ir/macro_def.rs b/bindgen/ir/macro_def.rs new file mode 100644 index 0000000000..13a33ccd5a --- /dev/null +++ b/bindgen/ir/macro_def.rs @@ -0,0 +1,149 @@ +//! Intermediate representation of variables. + +use std::borrow::Cow; +use std::io; +use std::str; + +use crate::callbacks::{FnMacroInfo, MacroParsingBehavior}; +use crate::clang; +use crate::parse::{ClangSubItemParser, ParseError, ParseResult}; + +use super::context::BindgenContext; +use super::dot::DotAttributes; + +/// A `MacroDef` is our intermediate representation of a macro definition. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum MacroDef { + /// A function-like macro. + Fn(String), + /// A variable-like macro. + Var(String), +} + +impl MacroDef { + /// Get the macro name. + pub fn name(&self) -> &str { + match self { + Self::Fn(name) => name, + Self::Var(name) => name, + } + } +} + +impl DotAttributes for MacroDef { + fn dot_attributes( + &self, + _ctx: &BindgenContext, + out: &mut W, + ) -> io::Result<()> + where + W: io::Write, + { + writeln!(out, "macrotrue") + } +} + +impl ClangSubItemParser for MacroDef { + fn parse( + cursor: clang::Cursor, + ctx: &mut BindgenContext, + ) -> Result, ParseError> { + use clang_sys::CXCursor_MacroDefinition; + + if cursor.kind() != CXCursor_MacroDefinition { + return Err(ParseError::Continue); + } + + debug!("MacroDef::parse({:?}, {:?})", cursor, cursor.cur_type()); + + match ctx + .options() + .last_callback(|c| Some(c.will_parse_macro(&cursor.spelling()))) + .unwrap_or_default() + { + MacroParsingBehavior::Ignore => { + return Err(ParseError::Continue); + } + MacroParsingBehavior::Default => (), + } + + let clang_tokens = cursor.tokens().iter().collect::>(); + let args_boundary = if cursor.is_macro_function_like() { + clang_tokens.iter().position(|t| { + t.kind == clang_sys::CXToken_Punctuation && + t.spelling().to_bytes() == b")" + }) + } else { + None + }; + let mut cmacro_tokens = clang_tokens + .iter() + .map(|token| { + let spelling = token.spelling(); + match spelling.to_str() { + Ok(token) => Cow::Borrowed(token), + Err(_) => { + let token = spelling.to_string_lossy(); + warn!( + "Lossy conversion of non-UTF8 token {:?} to {:?}.", + spelling, token + ); + token + } + } + }) + .collect::>(); + + let name = cmacro_tokens.remove(0); + + let args = if let Some(args_boundary) = args_boundary { + let args: Vec<_> = cmacro_tokens + .drain(0..args_boundary) + .skip(1) + .take(args_boundary - 2) + .filter(|token| token != ",") + .collect(); + Some(args) + } else { + None + }; + + let body = cmacro_tokens; + + if let Some(args) = args { + let args = args.iter().map(|s| s.as_ref()).collect::>(); + + if !ctx.options().parse_callbacks.is_empty() { + let body = body.iter().map(|s| s.as_ref()).collect::>(); + + let info = FnMacroInfo { + name: &name, + args: &args, + body: &body, + }; + + for callbacks in &ctx.options().parse_callbacks { + callbacks.fn_macro(&info); + } + } + + if ctx.macro_set.define_fn_macro(name.as_ref(), args, body) { + // TODO: Redefined macro. + } + + Ok(ParseResult::New( + MacroDef::Fn(name.into_owned()), + Some(cursor), + )) + } else { + if ctx.macro_set.define_var_macro(name.as_ref(), body) { + // TODO: Redefined macro. + } + + Ok(ParseResult::New( + MacroDef::Var(name.into_owned()), + Some(cursor), + )) + } + } +} diff --git a/bindgen/ir/mod.rs b/bindgen/ir/mod.rs index acdb4896cd..31fd572e24 100644 --- a/bindgen/ir/mod.rs +++ b/bindgen/ir/mod.rs @@ -17,6 +17,7 @@ pub(crate) mod int; pub(crate) mod item; pub(crate) mod item_kind; pub(crate) mod layout; +pub(crate) mod macro_def; pub(crate) mod module; pub(crate) mod objc; pub(crate) mod template; diff --git a/bindgen/ir/var.rs b/bindgen/ir/var.rs index 047e00a682..a1b0d46477 100644 --- a/bindgen/ir/var.rs +++ b/bindgen/ir/var.rs @@ -1,30 +1,29 @@ //! Intermediate representation of variables. -use super::super::codegen::MacroTypeVariation; +use std::borrow::Cow; +use std::io; + use super::context::{BindgenContext, TypeId}; use super::dot::DotAttributes; use super::function::cursor_mangling; use super::int::IntKind; use super::item::Item; -use super::ty::{FloatKind, TypeKind}; -use crate::callbacks::{FnMacroInfo, ItemInfo, ItemKind, MacroParsingBehavior}; +use super::ty::TypeKind; +use crate::callbacks::{ItemInfo, ItemKind}; use crate::clang; -use crate::clang::ClangToken; use crate::parse::{ClangSubItemParser, ParseError, ParseResult}; -use std::io; -use std::num::Wrapping; - /// The type for a constant variable. #[derive(Debug)] pub(crate) enum VarType { /// A boolean. Bool(bool), /// An integer. - Int(i64), + Int(i128), /// A floating point number. Float(f64), /// A character. + #[allow(unused)] Char(u8), /// A string, not necessarily well-formed utf-8. String(Vec), @@ -56,9 +55,9 @@ impl Var { ty: TypeId, val: Option, is_const: bool, - ) -> Var { + ) -> Self { assert!(!name.is_empty()); - Var { + Self { name, mangled_name, link_name, @@ -124,365 +123,157 @@ impl DotAttributes for Var { } } -fn default_macro_constant_type(ctx: &BindgenContext, value: i64) -> IntKind { - if value < 0 || - ctx.options().default_macro_constant_type == - MacroTypeVariation::Signed - { - if value < i32::MIN as i64 || value > i32::MAX as i64 { - IntKind::I64 - } else if !ctx.options().fit_macro_constants || - value < i16::MIN as i64 || - value > i16::MAX as i64 - { - IntKind::I32 - } else if value < i8::MIN as i64 || value > i8::MAX as i64 { - IntKind::I16 - } else { - IntKind::I8 - } - } else if value > u32::MAX as i64 { - IntKind::U64 - } else if !ctx.options().fit_macro_constants || value > u16::MAX as i64 { - IntKind::U32 - } else if value > u8::MAX as i64 { - IntKind::U16 - } else { - IntKind::U8 - } -} - -/// Parses tokens from a CXCursor_MacroDefinition pointing into a function-like -/// macro, and calls the func_macro callback. -fn handle_function_macro( - cursor: &clang::Cursor, - callbacks: &dyn crate::callbacks::ParseCallbacks, -) { - let is_closing_paren = |t: &ClangToken| { - // Test cheap token kind before comparing exact spellings. - t.kind == clang_sys::CXToken_Punctuation && - t.spelling().to_bytes() == b")" - }; - let mut raw_tokens: Vec<_> = cursor.tokens().iter().collect(); - if let Some(boundary) = raw_tokens.iter().position(is_closing_paren) { - let tokens: Result, _> = raw_tokens - .iter() - .map(|token| token.spelling().to_str()) - .collect(); - - let mut tokens = if let Ok(tokens) = tokens { - tokens - } else { - let raw_name = raw_tokens.remove(0); - warn!( - "Ignoring macro {:?} containing invalid UTF-8 tokens.", - raw_name.spelling() - ); - return; - }; - - let name = tokens.remove(0); - let args: Vec<_> = tokens - .drain(..boundary) - .skip(1) - .take(boundary - 2) - .filter(|&token| token != ",") - .collect(); - let body = tokens; - - let info = FnMacroInfo { - name, - args: &args, - body: &body, - }; - - callbacks.fn_macro(&info); - } -} - impl ClangSubItemParser for Var { fn parse( cursor: clang::Cursor, ctx: &mut BindgenContext, ) -> Result, ParseError> { - use cexpr::expr::EvalResult; - use cexpr::literal::CChar; - use clang_sys::*; - match cursor.kind() { - CXCursor_MacroDefinition => { - for callbacks in &ctx.options().parse_callbacks { - match callbacks.will_parse_macro(&cursor.spelling()) { - MacroParsingBehavior::Ignore => { - return Err(ParseError::Continue); - } - MacroParsingBehavior::Default => {} - } - - if cursor.is_macro_function_like() { - handle_function_macro(&cursor, callbacks.as_ref()); - // We handled the macro, skip macro processing below. - return Err(ParseError::Continue); - } - } - - let value = parse_macro(ctx, &cursor); - - let (id, value) = match value { - Some(v) => v, - None => return Err(ParseError::Continue), - }; - - assert!(!id.is_empty(), "Empty macro name?"); - - let previously_defined = ctx.parsed_macro(&id); + use clang_sys::{ + CXCursor_VarDecl, CXLinkage_External, CXType_Auto, + CXType_ConstantArray, CXType_IncompleteArray, CXType_Unexposed, + }; - // NB: It's important to "note" the macro even if the result is - // not an integer, otherwise we might loose other kind of - // derived macros. - ctx.note_parsed_macro(id.clone(), value.clone()); + if cursor.kind() != CXCursor_VarDecl { + return Err(ParseError::Continue); + } - if previously_defined { - let name = String::from_utf8(id).unwrap(); - duplicated_macro_diagnostic(&name, cursor.location(), ctx); - return Err(ParseError::Continue); - } + let mut name = cursor.spelling(); - // NOTE: Unwrapping, here and above, is safe, because the - // identifier of a token comes straight from clang, and we - // enforce utf8 there, so we should have already panicked at - // this point. - let name = String::from_utf8(id).unwrap(); - let (type_kind, val) = match value { - EvalResult::Invalid => return Err(ParseError::Continue), - EvalResult::Float(f) => { - (TypeKind::Float(FloatKind::Double), VarType::Float(f)) - } - EvalResult::Char(c) => { - let c = match c { - CChar::Char(c) => { - assert_eq!(c.len_utf8(), 1); - c as u8 - } - CChar::Raw(c) => { - assert!(c <= u8::MAX as u64); - c as u8 - } - }; - - (TypeKind::Int(IntKind::U8), VarType::Char(c)) - } - EvalResult::Str(val) => { - let char_ty = Item::builtin_type( - TypeKind::Int(IntKind::U8), - true, - ctx, - ); - for callbacks in &ctx.options().parse_callbacks { - callbacks.str_macro(&name, &val); - } - (TypeKind::Pointer(char_ty), VarType::String(val)) - } - EvalResult::Int(Wrapping(value)) => { - let kind = ctx - .options() - .last_callback(|c| c.int_macro(&name, value.into())) - .unwrap_or_else(|| { - default_macro_constant_type(ctx, value) - }); - - (TypeKind::Int(kind), VarType::Int(value)) - } - }; - - let ty = Item::builtin_type(type_kind, true, ctx); - - Ok(ParseResult::New( - Var::new(name, None, None, ty, Some(val), true), - Some(cursor), - )) + if cursor.linkage() == CXLinkage_External { + if let Some(nm) = ctx.options().last_callback(|callbacks| { + callbacks.generated_name_override(ItemInfo { + name: name.as_str(), + kind: ItemKind::Var, + }) + }) { + name = nm; } - CXCursor_VarDecl => { - let mut name = cursor.spelling(); - if cursor.linkage() == CXLinkage_External { - if let Some(nm) = ctx.options().last_callback(|callbacks| { - callbacks.generated_name_override(ItemInfo { - name: name.as_str(), - kind: ItemKind::Var, - }) - }) { - name = nm; - } - } - // No more changes to name - let name = name; + } + // No more changes to name + let name = name; - if name.is_empty() { - warn!("Empty constant name?"); - return Err(ParseError::Continue); - } + if name.is_empty() { + warn!("Empty constant name?"); + return Err(ParseError::Continue); + } - let link_name = ctx.options().last_callback(|callbacks| { - callbacks.generated_link_name_override(ItemInfo { - name: name.as_str(), - kind: ItemKind::Var, - }) - }); - - let ty = cursor.cur_type(); - - // TODO(emilio): do we have to special-case constant arrays in - // some other places? - let is_const = ty.is_const() || - ([CXType_ConstantArray, CXType_IncompleteArray] - .contains(&ty.kind()) && - ty.elem_type() - .map_or(false, |element| element.is_const())); - - let ty = match Item::from_ty(&ty, cursor, None, ctx) { - Ok(ty) => ty, - Err(e) => { - assert!( - matches!(ty.kind(), CXType_Auto | CXType_Unexposed), - "Couldn't resolve constant type, and it \ + // If a variable exists, there cannot be a variable-like macro with the same name, + // except if the macro expands to its own name, in which case it is useless anyways. + ctx.macro_set.undefine_var_macro(&name); + + let link_name = ctx.options().last_callback(|callbacks| { + callbacks.generated_link_name_override(ItemInfo { + name: name.as_str(), + kind: ItemKind::Var, + }) + }); + + let ty = cursor.cur_type(); + + // TODO(emilio): do we have to special-case constant arrays in + // some other places? + let is_const = ty.is_const() || + ([CXType_ConstantArray, CXType_IncompleteArray] + .contains(&ty.kind()) && + ty.elem_type() + .map_or(false, |element| element.is_const())); + + let ty = match Item::from_ty(&ty, cursor, None, ctx) { + Ok(ty) => ty, + Err(e) => { + assert!( + matches!(ty.kind(), CXType_Auto | CXType_Unexposed), + "Couldn't resolve constant type, and it \ wasn't an nondeductible auto type or unexposed \ type!" - ); - return Err(e); - } - }; - - // Note: Ty might not be totally resolved yet, see - // tests/headers/inner_const.hpp - // - // That's fine because in that case we know it's not a literal. - let canonical_ty = ctx - .safe_resolve_type(ty) - .and_then(|t| t.safe_canonical_type(ctx)); - - let is_integer = canonical_ty.map_or(false, |t| t.is_integer()); - let is_float = canonical_ty.map_or(false, |t| t.is_float()); - - // TODO: We could handle `char` more gracefully. - // TODO: Strings, though the lookup is a bit more hard (we need - // to look at the canonical type of the pointee too, and check - // is char, u8, or i8 I guess). - let value = if is_integer { - let kind = match *canonical_ty.unwrap().kind() { - TypeKind::Int(kind) => kind, - _ => unreachable!(), - }; - - let mut val = cursor.evaluate().and_then(|v| v.as_int()); - if val.is_none() || !kind.signedness_matches(val.unwrap()) { - val = get_integer_literal_from_cursor(&cursor); - } - - val.map(|val| { - if kind == IntKind::Bool { - VarType::Bool(val != 0) - } else { - VarType::Int(val) - } - }) - } else if is_float { - cursor - .evaluate() - .and_then(|v| v.as_double()) - .map(VarType::Float) - } else { - cursor - .evaluate() - .and_then(|v| v.as_literal_string()) - .map(VarType::String) - }; - - let mangling = cursor_mangling(ctx, &cursor); - let var = - Var::new(name, mangling, link_name, ty, value, is_const); - - Ok(ParseResult::New(var, Some(cursor))) - } - _ => { - /* TODO */ - Err(ParseError::Continue) + ); + return Err(e); } - } - } -} - -/// This function uses a [`FallbackTranslationUnit`][clang::FallbackTranslationUnit] to parse each -/// macro that cannot be parsed by the normal bindgen process for `#define`s. -/// -/// To construct the [`FallbackTranslationUnit`][clang::FallbackTranslationUnit], first precompiled -/// headers are generated for all input headers. An empty temporary `.c` file is generated to pass -/// to the translation unit. On the evaluation of each macro, a [`String`] is generated with the -/// new contents of the empty file and passed in for reparsing. The precompiled headers and -/// preservation of the [`FallbackTranslationUnit`][clang::FallbackTranslationUnit] across macro -/// evaluations are both optimizations that have significantly improved the performance. -fn parse_macro_clang_fallback( - ctx: &mut BindgenContext, - cursor: &clang::Cursor, -) -> Option<(Vec, cexpr::expr::EvalResult)> { - if !ctx.options().clang_macro_fallback { - return None; - } - - let ftu = ctx.try_ensure_fallback_translation_unit()?; - let contents = format!("int main() {{ {}; }}", cursor.spelling(),); - ftu.reparse(&contents).ok()?; - // Children of root node of AST - let root_children = ftu.translation_unit().cursor().collect_children(); - // Last child in root is function declaration - // Should be FunctionDecl - let main_func = root_children.last()?; - // Children should all be statements in function declaration - let all_stmts = main_func.collect_children(); - // First child in all_stmts should be the statement containing the macro to evaluate - // Should be CompoundStmt - let macro_stmt = all_stmts.first()?; - // Children should all be expressions from the compound statement - let paren_exprs = macro_stmt.collect_children(); - // First child in all_exprs is the expression utilizing the given macro to be evaluated - // Should be ParenExpr - let paren = paren_exprs.first()?; - - Some(( - cursor.spelling().into_bytes(), - cexpr::expr::EvalResult::Int(Wrapping(paren.evaluate()?.as_int()?)), - )) -} + }; -/// Try and parse a macro using all the macros parsed until now. -fn parse_macro( - ctx: &mut BindgenContext, - cursor: &clang::Cursor, -) -> Option<(Vec, cexpr::expr::EvalResult)> { - use cexpr::expr; + // Note: Ty might not be totally resolved yet, see + // tests/headers/inner_const.hpp + // + // That's fine because in that case we know it's not a literal. + let canonical_ty = ctx + .safe_resolve_type(ty) + .and_then(|t| t.safe_canonical_type(ctx)); + + let is_integer = canonical_ty.map_or(false, |t| t.is_integer()); + let is_float = canonical_ty.map_or(false, |t| t.is_float()); + + // TODO: We could handle `char` more gracefully. + // TODO: Strings, though the lookup is a bit more hard (we need + // to look at the canonical type of the pointee too, and check + // is char, u8, or i8 I guess). + let value = if is_integer { + let kind = match *canonical_ty.unwrap().kind() { + TypeKind::Int(kind) => kind, + _ => unreachable!(), + }; + + let mut val = cursor.evaluate().and_then(|v| v.as_int()); + if val.is_none() || !kind.signedness_matches(val.unwrap()) { + val = get_integer_literal_from_cursor(&cursor); + } - let cexpr_tokens = cursor.cexpr_tokens(); + val.map(|val| { + match kind { + IntKind::Bool => VarType::Bool(val != 0), + // IntKind::Char { .. } => VarType::Char(val as u8), + _ => VarType::Int(val), + } + }) + } else if is_float { + cursor + .evaluate() + .and_then(|v| v.as_double()) + .map(VarType::Float) + } else { + cursor + .evaluate() + .and_then(|v| v.as_literal_string()) + .map(VarType::String) + }; - let parser = expr::IdentifierParser::new(ctx.parsed_macros()); + let mangling = cursor_mangling(ctx, &cursor); + let var = Self::new(name, mangling, link_name, ty, value, is_const); - match parser.macro_definition(&cexpr_tokens) { - Ok((_, (id, val))) => Some((id.into(), val)), - _ => parse_macro_clang_fallback(ctx, cursor), + Ok(ParseResult::New(var, Some(cursor))) } } -fn parse_int_literal_tokens(cursor: &clang::Cursor) -> Option { - use cexpr::expr; - use cexpr::expr::EvalResult; +fn parse_int_literal_tokens(cursor: &clang::Cursor) -> Option { + let tokens = cursor.tokens().iter().collect::>(); + let tokens = tokens + .iter() + .map(|token| { + let spelling = token.spelling(); + match spelling.to_str() { + Ok(token) => Cow::Borrowed(token), + Err(_) => { + let token = spelling.to_string_lossy(); + warn!( + "Lossy conversion of non-UTF8 token {:?} to {:?}.", + spelling, token + ); + token + } + } + }) + .collect::>(); - let cexpr_tokens = cursor.cexpr_tokens(); + let macro_set = cmacro::MacroSet::new(); + let cmacro_tokens = macro_set.expand(&tokens).ok()?; // TODO(emilio): We can try to parse other kinds of literals. - match expr::expr(&cexpr_tokens) { - Ok((_, EvalResult::Int(Wrapping(val)))) => Some(val), + match cmacro::LitInt::parse(&cmacro_tokens) { + Ok((_, cmacro::LitInt { value, .. })) => Some(value), _ => None, } } -fn get_integer_literal_from_cursor(cursor: &clang::Cursor) -> Option { +fn get_integer_literal_from_cursor(cursor: &clang::Cursor) -> Option { use clang_sys::*; let mut value = None; cursor.visit(|c| { @@ -503,52 +294,3 @@ fn get_integer_literal_from_cursor(cursor: &clang::Cursor) -> Option { }); value } - -#[cfg_attr(not(feature = "experimental"), allow(unused_variables))] -fn duplicated_macro_diagnostic( - macro_name: &str, - location: crate::clang::SourceLocation, - ctx: &BindgenContext, -) { - warn!("Duplicated macro definition: {}", macro_name); - - #[cfg(feature = "experimental")] - // FIXME (pvdrz & amanjeev): This diagnostic message shows way too often to be actually - // useful. We have to change the logic where this function is called to be able to emit this - // message only when the duplication is an actuall issue. - // - // If I understood correctly, `bindgen` ignores all `#undef` directives. Meaning that this: - // ```c - // #define FOO 1 - // #undef FOO - // #define FOO 2 - // ``` - // - // Will trigger this message even though there's nothing wrong with it. - #[allow(clippy::overly_complex_bool_expr)] - if false && ctx.options().emit_diagnostics { - use crate::diagnostics::{get_line, Diagnostic, Level, Slice}; - use std::borrow::Cow; - - let mut slice = Slice::default(); - let mut source = Cow::from(macro_name); - - if let crate::clang::SourceLocation::File { - file, line, column, .. - } = location - { - if let Ok(Some(code)) = get_line(file.path(), line) { - source = code.into(); - } - slice.with_location(file.name(), line, column); - } - - slice.with_source(source); - - Diagnostic::default() - .with_title("Duplicated macro definition.", Level::Warn) - .add_slice(slice) - .add_annotation("This macro had a duplicate.", Level::Note) - .display(); - } -} diff --git a/bindgen/options/mod.rs b/bindgen/options/mod.rs index d1486397bd..a4408a2c4f 100644 --- a/bindgen/options/mod.rs +++ b/bindgen/options/mod.rs @@ -171,7 +171,7 @@ options! { blocklisted_functions: RegexSet { methods: { regex_option! { - /// Do not generate any bindings for the given function. + /// Do not generate any bindings for the given function (or function-like macro). /// /// This option is not recursive, meaning that it will only block functions whose /// names explicitly match the argument of this method. @@ -312,7 +312,7 @@ options! { allowlisted_functions: RegexSet { methods: { regex_option! { - /// Generate bindings for the given function. + /// Generate bindings for the given function (or function-like macro). /// /// This option is transitive by default. Check the documentation of the /// [`Builder::allowlist_recursively`] method for further information. @@ -328,7 +328,7 @@ options! { allowlisted_vars: RegexSet { methods: { regex_option! { - /// Generate bindings for the given variable. + /// Generate bindings for the given variable (or variable-like macro). /// /// This option is transitive by default. Check the documentation of the /// [`Builder::allowlist_recursively`] method for further information. @@ -1514,6 +1514,18 @@ options! { }, as_args: "--generate-cstr", }, + /// Whether to generate code fore function-like macros. + generate_fn_macros: bool { + methods: { + #[cfg(feature = "experimental")] + /// Set whether code for function-like macros should be generated. + pub fn generate_fn_macros(mut self, doit: bool) -> Self { + self.options.generate_fn_macros = doit; + self + } + }, + as_args: "--generate-fn-macros", + }, /// Whether to emit `#[macro_use] extern crate block;` instead of `use block;` in the prologue /// of the files generated from apple block files. block_extern_crate: bool { From 4cf5064da4ca3b1a6b1033d3b5545d2505c2acc3 Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Fri, 16 Jun 2023 17:58:31 +0200 Subject: [PATCH 13/23] Remove `as` casts. --- bindgen/clang.rs | 305 +++++++++++++++++---------------------------- bindgen/ir/comp.rs | 18 +-- 2 files changed, 122 insertions(+), 201 deletions(-) diff --git a/bindgen/clang.rs b/bindgen/clang.rs index 9c241ffc2a..bffeb8441d 100644 --- a/bindgen/clang.rs +++ b/bindgen/clang.rs @@ -12,12 +12,10 @@ use std::convert::{TryFrom, TryInto}; use std::env::current_dir; use std::ffi::{CStr, CString}; use std::fmt; -use std::fs::OpenOptions; use std::hash::Hash; use std::hash::Hasher; -use std::os::raw::{c_char, c_int, c_longlong, c_uint, c_ulong}; -use std::path::Path; -use std::path::PathBuf; +use std::os::raw::c_char; +use std::path::{Path, PathBuf}; use std::sync::OnceLock; use std::{mem, ptr, slice}; @@ -127,7 +125,7 @@ impl Cursor { if manglings.is_null() { return Err(()); } - let count = (*manglings).Count as usize; + let count = (*manglings).Count.try_into().unwrap(); let mut result = Vec::with_capacity(count); for i in 0..count { @@ -199,7 +197,7 @@ impl Cursor { /// /// NOTE: This may not return `Some` for partial template specializations, /// see #193 and #194. - pub(crate) fn num_template_args(&self) -> Option { + pub(crate) fn num_template_args(&self) -> Option { // XXX: `clang_Type_getNumTemplateArguments` is sort of reliable, while // `clang_Cursor_getNumTemplateArguments` is totally unreliable. // Therefore, try former first, and only fallback to the latter if we @@ -207,11 +205,9 @@ impl Cursor { self.cur_type() .num_template_args() .or_else(|| { - let n: c_int = - unsafe { clang_Cursor_getNumTemplateArguments(self.x) }; - + let n = unsafe { clang_Cursor_getNumTemplateArguments(self.x) }; if n >= 0 { - Some(n as u32) + Some(n.try_into().unwrap()) } else { debug_assert_eq!(n, -1); None @@ -673,7 +669,7 @@ impl Cursor { /// Get the width of this cursor's referent bit field, or `None` if the /// referent is not a bit field or if the width could not be evaluated. - pub(crate) fn bit_width(&self) -> Option { + pub(crate) fn bit_width(&self) -> Option { // It is not safe to check the bit width without ensuring it doesn't // depend on a template parameter. See // https://github.com/rust-lang/rust-bindgen/issues/2239 @@ -682,11 +678,12 @@ impl Cursor { } unsafe { - let w = clang_getFieldDeclBitWidth(self.x); - if w == -1 { - None + let n = clang_getFieldDeclBitWidth(self.x); + if n >= 0 { + Some(n.try_into().unwrap()) } else { - Some(w as u32) + debug_assert_eq!(n, -1); + None } } } @@ -822,7 +819,9 @@ impl Cursor { self.num_args().ok().map(|num| { (0..num) .map(|i| Cursor { - x: unsafe { clang_Cursor_getArgument(self.x, i as c_uint) }, + x: unsafe { + clang_Cursor_getArgument(self.x, i.try_into().unwrap()) + }, }) .collect() }) @@ -833,13 +832,14 @@ impl Cursor { /// /// Returns Err if the cursor's referent is not a function/method call or /// declaration. - pub(crate) fn num_args(&self) -> Result { + pub(crate) fn num_args(&self) -> Result { unsafe { - let w = clang_Cursor_getNumArguments(self.x); - if w == -1 { - Err(()) + let n = clang_Cursor_getNumArguments(self.x); + if n >= 0 { + Ok(n.try_into().unwrap()) } else { - Ok(w as u32) + debug_assert_eq!(n, -1); + Err(()) } } } @@ -869,9 +869,9 @@ impl Cursor { let offset = unsafe { clang_Cursor_getOffsetOfField(self.x) }; if offset < 0 { - Err(LayoutError::from(offset as i32)) + Err(LayoutError::from(i32::try_from(offset).unwrap())) } else { - Ok(offset as usize) + Ok(offset.try_into().unwrap()) } } @@ -940,7 +940,7 @@ pub(crate) struct RawTokens<'a> { cursor: &'a Cursor, tu: CXTranslationUnit, tokens: *mut CXToken, - token_count: c_uint, + token_count: usize, } impl<'a> RawTokens<'a> { @@ -954,7 +954,7 @@ impl<'a> RawTokens<'a> { cursor, tu, tokens, - token_count, + token_count: token_count.try_into().unwrap(), } } @@ -962,7 +962,7 @@ impl<'a> RawTokens<'a> { if self.tokens.is_null() { return &[]; } - unsafe { slice::from_raw_parts(self.tokens, self.token_count as usize) } + unsafe { slice::from_raw_parts(self.tokens, self.token_count) } } /// Get an iterator over these tokens. @@ -981,7 +981,7 @@ impl<'a> Drop for RawTokens<'a> { clang_disposeTokens( self.tu, self.tokens, - self.token_count as c_uint, + self.token_count.try_into().unwrap(), ); } } @@ -1121,11 +1121,13 @@ pub(crate) enum LayoutError { /// Asked for the layout of a field in a type that does not have such a /// field. InvalidFieldName, + /// The type is undeduced. + Undeduced, /// An unknown layout error. Unknown, } -impl ::std::convert::From for LayoutError { +impl From for LayoutError { fn from(val: i32) -> Self { use self::LayoutError::*; @@ -1135,6 +1137,7 @@ impl ::std::convert::From for LayoutError { CXTypeLayoutError_Dependent => Dependent, CXTypeLayoutError_NotConstantSize => NotConstantSize, CXTypeLayoutError_InvalidFieldName => InvalidFieldName, + CXTypeLayoutError_Undeduced => Undeduced, _ => Unknown, } } @@ -1206,41 +1209,10 @@ impl Type { self.canonical_type() == *self } - #[inline] - fn clang_size_of(&self, ctx: &BindgenContext) -> c_longlong { - match self.kind() { - // Work-around https://bugs.llvm.org/show_bug.cgi?id=40975 - CXType_RValueReference | CXType_LValueReference => { - ctx.target_pointer_size() as c_longlong - } - // Work-around https://bugs.llvm.org/show_bug.cgi?id=40813 - CXType_Auto if self.is_non_deductible_auto_type() => -6, - _ => unsafe { clang_Type_getSizeOf(self.x) }, - } - } - - #[inline] - fn clang_align_of(&self, ctx: &BindgenContext) -> c_longlong { - match self.kind() { - // Work-around https://bugs.llvm.org/show_bug.cgi?id=40975 - CXType_RValueReference | CXType_LValueReference => { - ctx.target_pointer_size() as c_longlong - } - // Work-around https://bugs.llvm.org/show_bug.cgi?id=40813 - CXType_Auto if self.is_non_deductible_auto_type() => -6, - _ => unsafe { clang_Type_getAlignOf(self.x) }, - } - } - /// What is the size of this type? Paper over invalid types by returning `0` /// for them. pub(crate) fn size(&self, ctx: &BindgenContext) -> usize { - let val = self.clang_size_of(ctx); - if val < 0 { - 0 - } else { - val as usize - } + self.fallible_size(ctx).unwrap_or(0) } /// What is the size of this type? @@ -1248,23 +1220,30 @@ impl Type { &self, ctx: &BindgenContext, ) -> Result { - let val = self.clang_size_of(ctx); - if val < 0 { - Err(LayoutError::from(val as i32)) - } else { - Ok(val as usize) + match self.kind() { + // Work-around for https://github.com/llvm/llvm-project/issues/40320. + CXType_RValueReference | CXType_LValueReference => { + Ok(ctx.target_pointer_size()) + } + // Work-around for https://github.com/llvm/llvm-project/issues/40159. + CXType_Auto if self.is_non_deductible_auto_type() => { + Err(LayoutError::Undeduced) + } + _ => { + let size = unsafe { clang_Type_getSizeOf(self.x) }; + if size < 0 { + Err(LayoutError::from(i32::try_from(size).unwrap())) + } else { + Ok(size.try_into().unwrap()) + } + } } } /// What is the alignment of this type? Paper over invalid types by /// returning `0`. pub(crate) fn align(&self, ctx: &BindgenContext) -> usize { - let val = self.clang_align_of(ctx); - if val < 0 { - 0 - } else { - val as usize - } + self.fallible_align(ctx).unwrap_or(0) } /// What is the alignment of this type? @@ -1272,11 +1251,23 @@ impl Type { &self, ctx: &BindgenContext, ) -> Result { - let val = self.clang_align_of(ctx); - if val < 0 { - Err(LayoutError::from(val as i32)) - } else { - Ok(val as usize) + match self.kind() { + // Work-around for https://github.com/llvm/llvm-project/issues/40320. + CXType_RValueReference | CXType_LValueReference => { + Ok(ctx.target_pointer_size()) + } + // Work-around for https://github.com/llvm/llvm-project/issues/40159. + CXType_Auto if self.is_non_deductible_auto_type() => { + Err(LayoutError::Undeduced) + } + _ => { + let alignment = unsafe { clang_Type_getAlignOf(self.x) }; + if alignment < 0 { + Err(LayoutError::from(i32::try_from(alignment).unwrap())) + } else { + Ok(alignment.try_into().unwrap()) + } + } } } @@ -1294,10 +1285,10 @@ impl Type { /// Get the number of template arguments this type has, or `None` if it is /// not some kind of template. - pub(crate) fn num_template_args(&self) -> Option { + pub(crate) fn num_template_args(&self) -> Option { let n = unsafe { clang_Type_getNumTemplateArguments(self.x) }; if n >= 0 { - Some(n as u32) + Some(n.try_into().unwrap()) } else { debug_assert_eq!(n, -1); None @@ -1321,7 +1312,9 @@ impl Type { self.num_args().ok().map(|num| { (0..num) .map(|i| Type { - x: unsafe { clang_getArgType(self.x, i as c_uint) }, + x: unsafe { + clang_getArgType(self.x, i.try_into().unwrap()) + }, }) .collect() }) @@ -1330,13 +1323,14 @@ impl Type { /// Given that this type is a function prototype, return the number of arguments it takes. /// /// Returns Err if the type is not a function prototype. - pub(crate) fn num_args(&self) -> Result { + pub(crate) fn num_args(&self) -> Result { unsafe { - let w = clang_getNumArgTypes(self.x); - if w == -1 { - Err(()) + let n = clang_getNumArgTypes(self.x); + if n >= 0 { + Ok(n.try_into().unwrap()) } else { - Ok(w as u32) + debug_assert_eq!(n, -1); + Err(()) } } } @@ -1377,10 +1371,11 @@ impl Type { /// Given that this type is an array or vector type, return its number of /// elements. pub(crate) fn num_elements(&self) -> Option { - let num_elements_returned = unsafe { clang_getNumElements(self.x) }; - if num_elements_returned != -1 { - Some(num_elements_returned as usize) + let n = unsafe { clang_getNumElements(self.x) }; + if n >= 0 { + Some(n.try_into().unwrap()) } else { + debug_assert_eq!(n, -1); None } } @@ -1505,18 +1500,23 @@ impl CanonicalTypeDeclaration { /// An iterator for a type's template arguments. pub(crate) struct TypeTemplateArgIterator { x: CXType, - length: u32, - index: u32, + length: usize, + index: usize, } impl Iterator for TypeTemplateArgIterator { type Item = Type; fn next(&mut self) -> Option { if self.index < self.length { - let idx = self.index as c_uint; + let idx = self.index; self.index += 1; Some(Type { - x: unsafe { clang_Type_getTemplateArgumentAsType(self.x, idx) }, + x: unsafe { + clang_Type_getTemplateArgumentAsType( + self.x, + idx.try_into().unwrap(), + ) + }, }) } else { None @@ -1527,7 +1527,7 @@ impl Iterator for TypeTemplateArgIterator { impl ExactSizeIterator for TypeTemplateArgIterator { fn len(&self) -> usize { assert!(self.index <= self.length); - (self.length - self.index) as usize + self.length - self.index } } @@ -1673,7 +1673,9 @@ impl Comment { pub(crate) fn get_children(&self) -> CommentChildrenIterator { CommentChildrenIterator { parent: self.x, - length: unsafe { clang_Comment_getNumChildren(self.x) }, + length: unsafe { + clang_Comment_getNumChildren(self.x).try_into().unwrap() + }, index: 0, } } @@ -1688,7 +1690,9 @@ impl Comment { pub(crate) fn get_tag_attrs(&self) -> CommentAttributesIterator { CommentAttributesIterator { x: self.x, - length: unsafe { clang_HTMLStartTag_getNumAttrs(self.x) }, + length: unsafe { + clang_HTMLStartTag_getNumAttrs(self.x).try_into().unwrap() + }, index: 0, } } @@ -1697,8 +1701,8 @@ impl Comment { /// An iterator for a comment's children pub(crate) struct CommentChildrenIterator { parent: CXComment, - length: c_uint, - index: c_uint, + length: usize, + index: usize, } impl Iterator for CommentChildrenIterator { @@ -1708,7 +1712,9 @@ impl Iterator for CommentChildrenIterator { let idx = self.index; self.index += 1; Some(Comment { - x: unsafe { clang_Comment_getChild(self.parent, idx) }, + x: unsafe { + clang_Comment_getChild(self.parent, idx.try_into().unwrap()) + }, }) } else { None @@ -1727,15 +1733,15 @@ pub(crate) struct CommentAttribute { /// An iterator for a comment's attributes pub(crate) struct CommentAttributesIterator { x: CXComment, - length: c_uint, - index: c_uint, + length: usize, + index: usize, } impl Iterator for CommentAttributesIterator { type Item = CommentAttribute; fn next(&mut self) -> Option { if self.index < self.length { - let idx = self.index; + let idx = self.index.try_into().unwrap(); self.index += 1; Some(CommentAttribute { name: unsafe { @@ -1831,7 +1837,7 @@ impl Index { pub(crate) fn new(pch: bool, diag: bool) -> Index { unsafe { Index { - x: clang_createIndex(pch as c_int, diag as c_int), + x: clang_createIndex(pch.into(), diag.into()), } } } @@ -1885,9 +1891,9 @@ impl TranslationUnit { ix.x, fname.as_ptr(), c_args.as_ptr(), - c_args.len() as c_int, + c_args.len().try_into().unwrap(), c_unsaved.as_mut_ptr(), - c_unsaved.len() as c_uint, + c_unsaved.len().try_into().unwrap(), opts, ) }; @@ -1902,11 +1908,11 @@ impl TranslationUnit { /// unit. pub(crate) fn diags(&self) -> Vec { unsafe { - let num = clang_getNumDiagnostics(self.x) as usize; + let num = clang_getNumDiagnostics(self.x); let mut diags = vec![]; for i in 0..num { diags.push(Diagnostic { - x: clang_getDiagnostic(self.x, i as c_uint), + x: clang_getDiagnostic(self.x, i), }); } diags @@ -1966,91 +1972,6 @@ impl Drop for TranslationUnit { } } -/// Translation unit used for macro fallback parsing -pub(crate) struct FallbackTranslationUnit { - file_path: String, - header_path: String, - pch_path: String, - idx: Box, - tu: TranslationUnit, -} - -impl fmt::Debug for FallbackTranslationUnit { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - write!(fmt, "FallbackTranslationUnit {{ }}") - } -} - -impl FallbackTranslationUnit { - /// Create a new fallback translation unit - pub(crate) fn new( - file: String, - header_path: String, - pch_path: String, - c_args: &[Box], - ) -> Option { - // Create empty file - OpenOptions::new() - .write(true) - .create(true) - .truncate(true) - .open(&file) - .ok()?; - - let f_index = Box::new(Index::new(true, false)); - let f_translation_unit = TranslationUnit::parse( - &f_index, - &file, - c_args, - &[], - CXTranslationUnit_None, - )?; - Some(FallbackTranslationUnit { - file_path: file, - header_path, - pch_path, - tu: f_translation_unit, - idx: f_index, - }) - } - - /// Get reference to underlying translation unit. - pub(crate) fn translation_unit(&self) -> &TranslationUnit { - &self.tu - } - - /// Reparse a translation unit. - pub(crate) fn reparse( - &mut self, - unsaved_contents: &str, - ) -> Result<(), CXErrorCode> { - let unsaved = &[UnsavedFile::new(&self.file_path, unsaved_contents)]; - let mut c_unsaved: Vec = - unsaved.iter().map(|f| f.x).collect(); - let ret = unsafe { - clang_reparseTranslationUnit( - self.tu.x, - unsaved.len() as c_uint, - c_unsaved.as_mut_ptr(), - clang_defaultReparseOptions(self.tu.x), - ) - }; - if ret != 0 { - Err(ret) - } else { - Ok(()) - } - } -} - -impl Drop for FallbackTranslationUnit { - fn drop(&mut self) { - let _ = std::fs::remove_file(&self.file_path); - let _ = std::fs::remove_file(&self.header_path); - let _ = std::fs::remove_file(&self.pch_path); - } -} - /// A diagnostic message generated while parsing a translation unit. pub(crate) struct Diagnostic { x: CXDiagnostic, @@ -2098,7 +2019,7 @@ impl UnsavedFile { let x = CXUnsavedFile { Filename: name.as_ptr(), Contents: contents.as_ptr(), - Length: contents.as_bytes().len() as c_ulong, + Length: contents.as_bytes().len().try_into().unwrap(), }; UnsavedFile { x, name, contents } } @@ -2500,7 +2421,7 @@ impl TargetInfo { TargetInfo { triple, - pointer_width: pointer_width as usize, + pointer_width: pointer_width.try_into().unwrap(), abi, } } diff --git a/bindgen/ir/comp.rs b/bindgen/ir/comp.rs index 13a8184fc5..1f5c0ea758 100644 --- a/bindgen/ir/comp.rs +++ b/bindgen/ir/comp.rs @@ -145,7 +145,7 @@ pub(crate) trait FieldMethods { fn comment(&self) -> Option<&str>; /// If this is a bitfield, how many bits does it need? - fn bitfield_width(&self) -> Option; + fn bitfield_width(&self) -> Option; /// Is this field declared public? fn is_public(&self) -> bool; @@ -347,7 +347,7 @@ impl Bitfield { } /// Get the bit width of this bitfield. - pub(crate) fn width(&self) -> u32 { + pub(crate) fn width(&self) -> usize { self.data.bitfield_width().unwrap() } @@ -395,7 +395,7 @@ impl FieldMethods for Bitfield { self.data.comment() } - fn bitfield_width(&self) -> Option { + fn bitfield_width(&self) -> Option { self.data.bitfield_width() } @@ -426,7 +426,7 @@ impl RawField { ty: TypeId, comment: Option, annotations: Option, - bitfield_width: Option, + bitfield_width: Option, public: bool, offset: Option, ) -> RawField { @@ -455,7 +455,7 @@ impl FieldMethods for RawField { self.0.comment() } - fn bitfield_width(&self) -> Option { + fn bitfield_width(&self) -> Option { self.0.bitfield_width() } @@ -592,7 +592,7 @@ where const is_ms_struct: bool = false; for bitfield in raw_bitfields { - let bitfield_width = bitfield.bitfield_width().unwrap() as usize; + let bitfield_width = bitfield.bitfield_width().unwrap(); let bitfield_layout = ctx.resolve_type(bitfield.ty()).layout(ctx).ok_or(())?; let bitfield_size = bitfield_layout.size; @@ -883,7 +883,7 @@ pub(crate) struct FieldData { annotations: Annotations, /// If this field is a bitfield, and how many bits does it contain if it is. - bitfield_width: Option, + bitfield_width: Option, /// If the C++ field is declared `public` public: bool, @@ -905,7 +905,7 @@ impl FieldMethods for FieldData { self.comment.as_deref() } - fn bitfield_width(&self) -> Option { + fn bitfield_width(&self) -> Option { self.bitfield_width } @@ -1842,7 +1842,7 @@ impl IsOpaque for CompInfo { .resolve_type(bf.ty()) .layout(ctx) .expect("Bitfield without layout? Gah!"); - bf.width() / 8 > bitfield_layout.size as u32 + bf.width() / 8 > bitfield_layout.size }), }) { return true; From e15e9f0ff44578b7dd205b54abc4f8e82ffa292a Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Sun, 18 Jun 2023 23:51:16 +0200 Subject: [PATCH 14/23] Resolve struct field types in macros. --- bindgen/ir/context.rs | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs index 65b18aa648..00a74d19a7 100644 --- a/bindgen/ir/context.rs +++ b/bindgen/ir/context.rs @@ -25,6 +25,8 @@ use crate::codegen::utils::type_from_named; use crate::codegen::utils::{fnsig_argument_type, fnsig_return_ty_internal}; use crate::codegen::CodegenError; use crate::codegen::ToRustTyOrOpaque; +use crate::ir::comp::Field; +use crate::ir::comp::FieldMethods; use crate::ir::item::ItemCanonicalName; use crate::BindgenOptions; use crate::{Entry, HashMap, HashSet}; @@ -3224,6 +3226,32 @@ impl cmacro::CodegenContext for BindgenContext { None } + fn resolve_field_ty(&self, ty: &str, field: &str) -> Option { + let field_name = field; + + if let Some(ty) = self.type_by_name(ty) { + let ty = self.resolve_type(*ty).canonical_type(self); + + if let TypeKind::Comp(comp_info) = ty.kind() { + for field in comp_info.fields() { + match field { + Field::DataMember(data_member) + if data_member.name() == Some(field_name) => + { + let field_ty = data_member.ty(); + return Some( + field_ty.to_rust_ty_or_opaque(self, &()), + ); + } + _ => (), + } + } + } + } + + None + } + fn function(&self, name: &str) -> Option<(Vec, syn::Type)> { let allowlisted_functions = &self.options().allowlisted_functions; if !allowlisted_functions.is_empty() && From 61cb3b68f187573dafe2e2b4393a7437220c49fc Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Fri, 6 Oct 2023 15:31:35 +0200 Subject: [PATCH 15/23] `semver` doesn't accept partial versions. --- bindgen/features.rs | 8 ++++++++ bindgen/ir/context.rs | 8 ++++++-- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/bindgen/features.rs b/bindgen/features.rs index c07318c5e2..621bd9d13a 100644 --- a/bindgen/features.rs +++ b/bindgen/features.rs @@ -51,6 +51,14 @@ macro_rules! define_rust_targets { } } + pub(crate) fn full_version(self) -> Option { + if let Some(minor) = self.minor() { + Some(format!("1.{}.0", minor)) + } else { + None + } + } + const fn stable_releases() -> [(Self, u64); [$($minor,)*].len()] { [$((Self::$variant, $minor),)*] } diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs index 00a74d19a7..4348f30960 100644 --- a/bindgen/ir/context.rs +++ b/bindgen/ir/context.rs @@ -3285,10 +3285,14 @@ impl cmacro::CodegenContext for BindgenContext { fn rust_target(&self) -> Option { // FIXME: Workaround until `generate_cstr` is the default. if !self.options().generate_cstr { - return Some("1.0".into()); + if self.options().rust_features.static_lifetime_elision { + return Some("1.17.0".into()); + } else { + return Some("1.0.0".into()); + } } - Some(self.options().rust_target.to_string()) + self.options().rust_target.full_version() } } From af8fba377752bee2adb64334b6c179da92794b84 Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Fri, 6 Oct 2023 17:47:16 +0200 Subject: [PATCH 16/23] Fix tests. --- .../tests/issue-739-pointer-wide-bitfield.rs | 5 ++--- .../tests/expectations/tests/macro_const.rs | 6 ++---- .../tests/expectations/tests/macro_const_1_0.rs | 12 ++---------- bindgen-tests/tests/headers/macro_const.h | 2 ++ .../tests/headers/ptr32-has-different-size.h | 1 + 5 files changed, 9 insertions(+), 17 deletions(-) diff --git a/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs b/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs index 02361b8017..941b665f7f 100644 --- a/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs +++ b/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs @@ -84,9 +84,8 @@ where } } } -pub const POINTER_WIDTH: ::std::os::raw::size_t = ::std::mem::size_of::< - *mut ::std::os::raw::c_void, ->() * 8; +pub const POINTER_WIDTH: usize = ::std::mem::size_of::<*mut ::std::os::raw::c_void>() + as usize * 8; #[repr(C)] #[derive(Debug, Default, Copy, Clone)] pub struct Foo { diff --git a/bindgen-tests/tests/expectations/tests/macro_const.rs b/bindgen-tests/tests/expectations/tests/macro_const.rs index 94ddd343a8..f74c292126 100644 --- a/bindgen-tests/tests/expectations/tests/macro_const.rs +++ b/bindgen-tests/tests/expectations/tests/macro_const.rs @@ -1,8 +1,7 @@ #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] pub const foo: &::std::ffi::CStr = { - const BYTES: &[u8; 4] = b"bar\0"; #[allow(unsafe_code)] - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(BYTES) } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"bar\0") } }; pub const CHAR: ::std::os::raw::c_char = 'b' as ::std::os::raw::c_char; pub const CHARR: ::std::os::raw::c_char = '\0' as ::std::os::raw::c_char; @@ -10,7 +9,6 @@ pub const FLOAT: f32 = 5.09; pub const FLOAT_EXPR: f32 = 0.005; pub const LONG: u32 = 3; pub const INVALID_UTF8: &::std::ffi::CStr = { - const BYTES: &[u8; 5] = b"\xF0(\x8C(\0"; #[allow(unsafe_code)] - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(BYTES) } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"\xF0(\x8C(\0") } }; diff --git a/bindgen-tests/tests/expectations/tests/macro_const_1_0.rs b/bindgen-tests/tests/expectations/tests/macro_const_1_0.rs index 94ddd343a8..4a734ac9b6 100644 --- a/bindgen-tests/tests/expectations/tests/macro_const_1_0.rs +++ b/bindgen-tests/tests/expectations/tests/macro_const_1_0.rs @@ -1,16 +1,8 @@ #![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] -pub const foo: &::std::ffi::CStr = { - const BYTES: &[u8; 4] = b"bar\0"; - #[allow(unsafe_code)] - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(BYTES) } -}; +pub const foo: &'static [u8; 4] = b"bar\0"; pub const CHAR: ::std::os::raw::c_char = 'b' as ::std::os::raw::c_char; pub const CHARR: ::std::os::raw::c_char = '\0' as ::std::os::raw::c_char; pub const FLOAT: f32 = 5.09; pub const FLOAT_EXPR: f32 = 0.005; pub const LONG: u32 = 3; -pub const INVALID_UTF8: &::std::ffi::CStr = { - const BYTES: &[u8; 5] = b"\xF0(\x8C(\0"; - #[allow(unsafe_code)] - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(BYTES) } -}; +pub const INVALID_UTF8: &'static [u8; 5] = b"\xF0(\x8C(\0"; diff --git a/bindgen-tests/tests/headers/macro_const.h b/bindgen-tests/tests/headers/macro_const.h index 7c5aa43806..38036195ed 100644 --- a/bindgen-tests/tests/headers/macro_const.h +++ b/bindgen-tests/tests/headers/macro_const.h @@ -1,3 +1,5 @@ +// bindgen-flags: --generate-cstr + #define foo "bar" #define CHAR 'b' #define CHARR '\0' diff --git a/bindgen-tests/tests/headers/ptr32-has-different-size.h b/bindgen-tests/tests/headers/ptr32-has-different-size.h index 8cda702c53..26df17d0db 100644 --- a/bindgen-tests/tests/headers/ptr32-has-different-size.h +++ b/bindgen-tests/tests/headers/ptr32-has-different-size.h @@ -1,4 +1,5 @@ // bindgen-flags: -- -fms-extensions + typedef struct TEST_STRUCT { void* __ptr32 ptr_32bit; } TEST; From b4b0c945be68f3f9a36e5eba835ddc1a6dd43d51 Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Tue, 21 Nov 2023 04:19:18 +0100 Subject: [PATCH 17/23] Fix output formatting. --- bindgen/codegen/macro_def.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bindgen/codegen/macro_def.rs b/bindgen/codegen/macro_def.rs index 704a8add72..1e3f43a3c9 100644 --- a/bindgen/codegen/macro_def.rs +++ b/bindgen/codegen/macro_def.rs @@ -201,7 +201,7 @@ impl CodeGenerator for MacroDef { }); } else { warn!( - "Unhandled variable-like macro: {} = {:?}", + "Unhandled variable-like macro `{}`: {:?}", var_macro.name(), expr ); From 40f8b48cae27d670fdbbf435ac507a2cd6c318fe Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Tue, 21 Nov 2023 07:16:05 +0100 Subject: [PATCH 18/23] Define macros added via command-line arguments. --- bindgen/ir/context.rs | 32 +++++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs index 4348f30960..e92d0c2269 100644 --- a/bindgen/ir/context.rs +++ b/bindgen/ir/context.rs @@ -696,6 +696,36 @@ If you encounter an error missing from this list, please file an issue or a PR!" // depfiles need to include the explicitly listed headers too let deps = options.input_headers.iter().map(SourceFile::new).collect(); + // Define macros added via command-line arguments so that + // dependent macros are generated correctly. + let mut macro_set = cmacro::MacroSet::new(); + let mut next_is_define = false; + for arg in &options.clang_args { + let arg = if next_is_define { + next_is_define = false; + arg.as_ref() + } else if let Some(arg) = arg.strip_prefix("-D") { + if arg.is_empty() { + next_is_define = true; + continue; + } + + arg + } else { + continue; + }; + + let (name, value) = if let Some((name, value)) = arg.split_once('=') + { + // FIXME: Value should be tokenized instead of taken verbatim. + (name, vec![value]) + } else { + (arg, vec![]) + }; + + macro_set.define_var_macro(name, value); + } + BindgenContext { items: vec![Some(root_module)], includes: Default::default(), @@ -708,7 +738,7 @@ If you encounter an error missing from this list, please file an issue or a PR!" semantic_parents: Default::default(), currently_parsed_types: vec![], parsed_macros: Default::default(), - macro_set: Default::default(), + macro_set, function_names: Default::default(), type_names: Default::default(), replacements: Default::default(), From c58a7473dc0a11a115eed04a0e00de31c8d7c19a Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Wed, 21 Feb 2024 15:36:46 +0100 Subject: [PATCH 19/23] Remove whitespace. --- bindgen/codegen/mod.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/bindgen/codegen/mod.rs b/bindgen/codegen/mod.rs index 356208ef42..caccad5af8 100644 --- a/bindgen/codegen/mod.rs +++ b/bindgen/codegen/mod.rs @@ -5495,7 +5495,6 @@ pub(crate) mod utils { primitive_ty(ctx, "usize") } "uintptr_t" => primitive_ty(ctx, "usize"), - "ssize_t" if ctx.options().size_t_is_usize => { primitive_ty(ctx, "isize") } From e8afaec26fc342e9301a383fac750ca3e14d452b Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Wed, 21 Feb 2024 15:37:27 +0100 Subject: [PATCH 20/23] Ignore blocklisted enum variants. --- bindgen/ir/context.rs | 40 ++++++++++++++++++++++++++++------------ 1 file changed, 28 insertions(+), 12 deletions(-) diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs index e92d0c2269..b959192c49 100644 --- a/bindgen/ir/context.rs +++ b/bindgen/ir/context.rs @@ -553,7 +553,7 @@ pub(crate) struct BindgenContext { /// A map of all enum variants, mapping the variant name to /// the generated constant name and/or path. - enum_variants: HashMap, + enum_variants: HashMap, /// The set of (`ItemId`s of) types that can't derive debug. /// @@ -2837,15 +2837,19 @@ If you encounter an error missing from this list, please file an issue or a PR!" use crate::EnumVariation; + let enum_canonical_name = if ty.name().is_some() { + Some(self.rust_ident(item.canonical_name(self))) + } else { + None + }; + for variant in enum_ty.variants() { let variant_name = self.rust_ident(variant.name()); - let variant_expr = if ty.name().is_some() { - let enum_canonical_name = - item.canonical_name(self); - let enum_canonical_name = - self.rust_ident(enum_canonical_name); - + let variant_expr = if let Some( + enum_canonical_name, + ) = &enum_canonical_name + { match variation { EnumVariation::Rust { .. } | EnumVariation::NewType { @@ -2862,7 +2866,7 @@ If you encounter an error missing from this list, please file an issue or a PR!" EnumVariation::Consts { .. } => { let constant_name = self .enum_variant_const_name( - Some(&enum_canonical_name), + Some(enum_canonical_name), &variant_name, ); syn::parse_quote! { #constant_name } @@ -2879,7 +2883,7 @@ If you encounter an error missing from this list, please file an issue or a PR!" self.enum_variants.insert( variant.name().to_owned(), - variant_expr, + (item.id(), variant_expr), ); } } @@ -2943,12 +2947,17 @@ If you encounter an error missing from this list, please file an issue or a PR!" } /// Get the generated name of an enum variant. - pub(crate) fn enum_variant(&self, variant: &str) -> Option<&syn::Expr> { + pub(crate) fn enum_variant( + &self, + variant: &str, + ) -> Option<(ItemId, &syn::Expr)> { assert!( self.in_codegen_phase(), "We only compute enum_variants when we enter codegen", ); - self.enum_variants.get(variant) + self.enum_variants + .get(variant) + .map(|(item_id, variant)| (*item_id, variant)) } /// Look up whether `id` refers to an `enum` whose underlying type is @@ -3241,7 +3250,14 @@ impl cmacro::CodegenContext for BindgenContext { } fn resolve_enum_variant(&self, variant: &str) -> Option { - self.enum_variant(variant).cloned() + let (item_id, enum_variant) = self.enum_variant(variant)?; + + let item = self.resolve_item(item_id); + if item.is_blocklisted(self) { + return None; + } + + Some(enum_variant.clone()) } fn resolve_ty(&self, ty: &str) -> Option { From 4cc61e429f4340734b0e99cbb8823161390435f4 Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Wed, 21 Feb 2024 16:10:34 +0100 Subject: [PATCH 21/23] Support enum types in macros. --- Cargo.lock | 2 +- .../tests/expectations/tests/jsval_layout_opaque.rs | 8 ++++++++ .../expectations/tests/jsval_layout_opaque_1_0.rs | 8 ++++++++ .../tests/expectations/tests/macro_enum_retval.rs | 9 +++++++++ bindgen-tests/tests/headers/macro_enum_retval.h | 9 +++++++++ bindgen/ir/context.rs | 12 ++++++++++-- 6 files changed, 45 insertions(+), 3 deletions(-) create mode 100644 bindgen-tests/tests/expectations/tests/macro_enum_retval.rs create mode 100644 bindgen-tests/tests/headers/macro_enum_retval.h diff --git a/Cargo.lock b/Cargo.lock index 3615531f3a..ebf51c48a5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -165,7 +165,7 @@ dependencies = [ [[package]] name = "cmacro" version = "0.2.2" -source = "git+https://github.com/reitermarkus/cmacro-rs#2b93025ebc7ca6b343ab2a801271c96f0ebc9b04" +source = "git+https://github.com/reitermarkus/cmacro-rs#fa8484fa1076e9aeb0039dc1d14e3a756373bfcb" dependencies = [ "nom", "proc-macro2", diff --git a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs index ba97bd6e30..2be0ee3a27 100644 --- a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs +++ b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs @@ -127,6 +127,14 @@ pub enum JSValueShiftedTag { } pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327; pub const JSVAL_TAG_MASK: u64 = 18446603336221196288; +pub const JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET: JSValueTag = JSValueTag::JSVAL_TAG_NULL; +pub const JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET: JSValueTag = JSValueTag::JSVAL_TAG_OBJECT; +pub const JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET: JSValueTag = JSValueTag::JSVAL_TAG_INT32; +pub const JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET: JSValueTag = JSValueTag::JSVAL_TAG_STRING; +pub const JSVAL_LOWER_INCL_SHIFTED_TAG_OF_OBJ_OR_NULL_SET: JSValueShiftedTag = JSValueShiftedTag::JSVAL_SHIFTED_TAG_NULL; +pub const JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_PRIMITIVE_SET: JSValueShiftedTag = JSValueShiftedTag::JSVAL_SHIFTED_TAG_OBJECT; +pub const JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_NUMBER_SET: JSValueShiftedTag = JSValueShiftedTag::JSVAL_SHIFTED_TAG_UNDEFINED; +pub const JSVAL_LOWER_INCL_SHIFTED_TAG_OF_GCTHING_SET: JSValueShiftedTag = JSValueShiftedTag::JSVAL_SHIFTED_TAG_STRING; #[repr(u32)] #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] pub enum JSWhyMagic { diff --git a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs index 1ab1d40516..8f11dbefdc 100644 --- a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs +++ b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque_1_0.rs @@ -170,6 +170,14 @@ pub enum JSValueShiftedTag { } pub const JSVAL_PAYLOAD_MASK: u64 = 140737488355327; pub const JSVAL_TAG_MASK: u64 = 18446603336221196288; +pub const JSVAL_LOWER_INCL_TAG_OF_OBJ_OR_NULL_SET: JSValueTag = JSValueTag::JSVAL_TAG_NULL; +pub const JSVAL_UPPER_EXCL_TAG_OF_PRIMITIVE_SET: JSValueTag = JSValueTag::JSVAL_TAG_OBJECT; +pub const JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET: JSValueTag = JSValueTag::JSVAL_TAG_INT32; +pub const JSVAL_LOWER_INCL_TAG_OF_GCTHING_SET: JSValueTag = JSValueTag::JSVAL_TAG_STRING; +pub const JSVAL_LOWER_INCL_SHIFTED_TAG_OF_OBJ_OR_NULL_SET: JSValueShiftedTag = JSValueShiftedTag::JSVAL_SHIFTED_TAG_NULL; +pub const JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_PRIMITIVE_SET: JSValueShiftedTag = JSValueShiftedTag::JSVAL_SHIFTED_TAG_OBJECT; +pub const JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_NUMBER_SET: JSValueShiftedTag = JSValueShiftedTag::JSVAL_SHIFTED_TAG_UNDEFINED; +pub const JSVAL_LOWER_INCL_SHIFTED_TAG_OF_GCTHING_SET: JSValueShiftedTag = JSValueShiftedTag::JSVAL_SHIFTED_TAG_STRING; #[repr(u32)] #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] pub enum JSWhyMagic { diff --git a/bindgen-tests/tests/expectations/tests/macro_enum_retval.rs b/bindgen-tests/tests/expectations/tests/macro_enum_retval.rs new file mode 100644 index 0000000000..56e4b33124 --- /dev/null +++ b/bindgen-tests/tests/expectations/tests/macro_enum_retval.rs @@ -0,0 +1,9 @@ +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] +pub const truth_wrong: truth = 0; +pub const truth_right: truth = 1; +pub type truth = ::std::os::raw::c_uint; +#[allow(non_snake_case, unused_mut, unsafe_code)] +#[inline(always)] +pub unsafe extern "C" fn get_wrong() -> truth { + truth_wrong +} diff --git a/bindgen-tests/tests/headers/macro_enum_retval.h b/bindgen-tests/tests/headers/macro_enum_retval.h new file mode 100644 index 0000000000..ef426d2088 --- /dev/null +++ b/bindgen-tests/tests/headers/macro_enum_retval.h @@ -0,0 +1,9 @@ +// bindgen-flags: --experimental --generate-fn-macros + +typedef enum { + wrong = 0, + right, +} truth; + +#define get_wrong() wrong + diff --git a/bindgen/ir/context.rs b/bindgen/ir/context.rs index b959192c49..698dc14403 100644 --- a/bindgen/ir/context.rs +++ b/bindgen/ir/context.rs @@ -3249,7 +3249,10 @@ impl cmacro::CodegenContext for BindgenContext { .last_callback(|c| c.fn_macro_arg_type(name, arg)) } - fn resolve_enum_variant(&self, variant: &str) -> Option { + fn resolve_enum_variant( + &self, + variant: &str, + ) -> Option<(syn::Type, syn::Expr)> { let (item_id, enum_variant) = self.enum_variant(variant)?; let item = self.resolve_item(item_id); @@ -3257,7 +3260,12 @@ impl cmacro::CodegenContext for BindgenContext { return None; } - Some(enum_variant.clone()) + let enum_ty = match item.kind() { + ItemKind::Type(enum_ty) => enum_ty.to_rust_ty_or_opaque(self, item), + _ => return None, + }; + + Some((enum_ty, enum_variant.clone())) } fn resolve_ty(&self, ty: &str) -> Option { From de0758572f63f133910add843424e4c5e6002892 Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Wed, 21 Feb 2024 16:38:46 +0100 Subject: [PATCH 22/23] Fix variable name. --- bindgen/ir/item.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bindgen/ir/item.rs b/bindgen/ir/item.rs index ae1d410b9e..d73cb3dcf2 100644 --- a/bindgen/ir/item.rs +++ b/bindgen/ir/item.rs @@ -787,7 +787,7 @@ impl Item { match *self.kind() { ItemKind::Var(ref var) => var.name().to_owned(), - ItemKind::MacroDef(ref var) => var.name().to_owned(), + ItemKind::MacroDef(ref macro_def) => macro_def.name().to_owned(), ItemKind::Module(ref module) => { module.name().map(ToOwned::to_owned).unwrap_or_else(|| { format!("_bindgen_mod_{}", self.exposed_id(ctx)) From bcaae59d8e6bb79c40c1785d53a5f8a491a4de11 Mon Sep 17 00:00:00 2001 From: Markus Reiter Date: Tue, 28 May 2024 18:03:50 +0200 Subject: [PATCH 23/23] Fix tests. --- .../tests/libclang-9/issue-753.rs | 1 - .../macro_fallback_non_system_dir.rs | 1 - ...ir.rs => macro_fallback_non_system_dir.rs} | 1 - bindgen-tests/tests/tests.rs | 32 +++++-------------- 4 files changed, 8 insertions(+), 27 deletions(-) delete mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/issue-753.rs delete mode 100644 bindgen-tests/tests/expectations/tests/libclang-9/macro_fallback_non_system_dir.rs rename bindgen-tests/tests/expectations/tests/{test_macro_fallback_non_system_dir.rs => macro_fallback_non_system_dir.rs} (83%) diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/issue-753.rs b/bindgen-tests/tests/expectations/tests/libclang-9/issue-753.rs deleted file mode 100644 index fe64295a68..0000000000 --- a/bindgen-tests/tests/expectations/tests/libclang-9/issue-753.rs +++ /dev/null @@ -1 +0,0 @@ -#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] \ No newline at end of file diff --git a/bindgen-tests/tests/expectations/tests/libclang-9/macro_fallback_non_system_dir.rs b/bindgen-tests/tests/expectations/tests/libclang-9/macro_fallback_non_system_dir.rs deleted file mode 100644 index 8f5c4ba2da..0000000000 --- a/bindgen-tests/tests/expectations/tests/libclang-9/macro_fallback_non_system_dir.rs +++ /dev/null @@ -1 +0,0 @@ -pub const NEGATIVE: i32 = -1; diff --git a/bindgen-tests/tests/expectations/tests/test_macro_fallback_non_system_dir.rs b/bindgen-tests/tests/expectations/tests/macro_fallback_non_system_dir.rs similarity index 83% rename from bindgen-tests/tests/expectations/tests/test_macro_fallback_non_system_dir.rs rename to bindgen-tests/tests/expectations/tests/macro_fallback_non_system_dir.rs index bf9739f3fa..ba01f796e0 100644 --- a/bindgen-tests/tests/expectations/tests/test_macro_fallback_non_system_dir.rs +++ b/bindgen-tests/tests/expectations/tests/macro_fallback_non_system_dir.rs @@ -3,4 +3,3 @@ pub const OTHER_CONST: u32 = 6; pub const LARGE_CONST: u32 = 1536; pub const THE_CONST: u32 = 28; pub const MY_CONST: u32 = 69; -pub const NEGATIVE: i32 = -1; diff --git a/bindgen-tests/tests/tests.rs b/bindgen-tests/tests/tests.rs index 6bf084bc75..c4c7cdf4cf 100644 --- a/bindgen-tests/tests/tests.rs +++ b/bindgen-tests/tests/tests.rs @@ -584,30 +584,14 @@ fn test_macro_fallback_non_system_dir() { let actual = format_code(actual).unwrap(); - let (expected_filename, expected) = match clang_version().parsed { - Some((9, _)) => { - let expected_filename = concat!( - env!("CARGO_MANIFEST_DIR"), - "/tests/expectations/tests/libclang-9/macro_fallback_non_system_dir.rs", - ); - let expected = include_str!(concat!( - env!("CARGO_MANIFEST_DIR"), - "/tests/expectations/tests/libclang-9/macro_fallback_non_system_dir.rs", - )); - (expected_filename, expected) - } - _ => { - let expected_filename = concat!( - env!("CARGO_MANIFEST_DIR"), - "/tests/expectations/tests/test_macro_fallback_non_system_dir.rs", - ); - let expected = include_str!(concat!( - env!("CARGO_MANIFEST_DIR"), - "/tests/expectations/tests/test_macro_fallback_non_system_dir.rs", - )); - (expected_filename, expected) - } - }; + let expected_filename = concat!( + env!("CARGO_MANIFEST_DIR"), + "/tests/expectations/tests/macro_fallback_non_system_dir.rs", + ); + let expected = include_str!(concat!( + env!("CARGO_MANIFEST_DIR"), + "/tests/expectations/tests/macro_fallback_non_system_dir.rs", + )); let expected = format_code(expected).unwrap(); if expected != actual { error_diff_mismatch(