diff options
| -rw-r--r-- | CHANGELOG.md | 110 | ||||
| -rw-r--r-- | Cargo.lock | 16 | ||||
| -rw-r--r-- | Cargo.toml | 4 | ||||
| -rw-r--r-- | tests/expectations/tests/issue-816.rs | 808 | ||||
| -rw-r--r-- | tests/headers/issue-816.h | 49 |
5 files changed, 964 insertions, 23 deletions
diff --git a/CHANGELOG.md b/CHANGELOG.md index 09d35839..c4e13b26 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,21 +9,25 @@ - [Removed](#removed) - [Fixed](#fixed) - [Security](#security) -- [0.31.0](#0310) +- [0.32.0](#0320) - [Added](#added-1) - [Changed](#changed-1) - - [Deprecated](#deprecated-1) - - [Removed](#removed-1) - [Fixed](#fixed-1) -- [0.30.0](#0300) +- [0.31.0](#0310) - [Added](#added-2) - [Changed](#changed-2) - - [Deprecated](#deprecated-2) + - [Deprecated](#deprecated-1) + - [Removed](#removed-1) - [Fixed](#fixed-2) -- [0.29.0](#0290) +- [0.30.0](#0300) - [Added](#added-3) - [Changed](#changed-3) + - [Deprecated](#deprecated-2) - [Fixed](#fixed-3) +- [0.29.0](#0290) + - [Added](#added-4) + - [Changed](#changed-4) + - [Fixed](#fixed-4) <!-- END doctoc generated TOC please keep comment here to allow auto update --> @@ -39,13 +43,7 @@ Released YYYY/MM/DD ## Changed -* The `bindgen::Builder::{constified_enum_module,{bitfield,rustified}_enum}` - builder methods and their corresponding CLI flags now compare their argument - to the C/C++ `enum`'s "canonical path", which includes leading namespaces, - rather than its "canonical name", which does not. This is a breaking change - that requires callers which target a namespaced C++ enum to call e.g. - `bitfield_enum("<namespace>::<enum_name>")` rather than e.g. - `bitfield_enum("<enum_name>")`. [#1162][] +* TODO (or remove section if none) ## Deprecated @@ -65,6 +63,92 @@ Released YYYY/MM/DD -------------------------------------------------------------------------------- +# 0.32.0 + +Released 2017/12/08 + +## Added + +* Added support for bit-field allocation units that are larger than 64 bits + wide. Note that individual bit-fields within such units are still restricted + to being no wider than 64 bits. [#1158][] + +* We can now generate random C header files and test that `bindgen` can process + them with the `quickcheck` crate. Initial support landed in [#1159][] with a + few more additions in follow up pull requests. + +## Changed + +* The `bindgen::Builder::{constified_enum_module,{bitfield,rustified}_enum}` + builder methods and their corresponding CLI flags now compare their argument + to the C/C++ `enum`'s "canonical path", which includes leading namespaces, + rather than its "canonical name", which does not. This is a breaking change + that requires callers which target a namespaced C++ enum to call e.g. + `bitfield_enum("<namespace>::<enum_name>")` rather than e.g. + `bitfield_enum("<enum_name>")`. [#1162][] + +* When a struct is packed to a smaller alignment that is still greater than one, + `bindgen` cannot emit Rust bindings that match the input source. Before, it + would emit `#[repr(packed)]` anyways, which packs to an alignment of one, but + this can lead to misalignment and UB. Now, `bindgen` will detect these + situations and convert the struct into an opaque blob of bytes with the proper + alignment. We are eagerly awaiting support for `#[repr(packed(N))]` in + Rust. [#1136][] + +## Fixed + +* There was a perfect storm of conditions that could cause `bindgen` not to emit + any bindings if spawning `rustfmt` to format the bindings failed. This is now + fixed. [#1112][] + +* In some circumstances, `bindgen` would emit type parameters twice for + references to template instantiations. This is now fixed. [#1113][] + +* When a C/C++ struct had a field named with a Rust keyword, and `impl_debug` + was enabled, the generated `impl Debug for ...` blocks could reference the + field by the Rust keyword name, rather than the non-keyword field name we + actually end up generating. This is now fixed. [#1123][] + +* There was a regression in 0.31.0 where C++ template aliases to opaque types + would sometimes not treat the aliased type as opaque. This is now + fixed. [#1118][] + +* There was a regression in 0.31.0 that could cause `bindgen` to panic when + parsing nested template classes. This is now fixed. [#1127][] + +* Unnamed bit-fields do not affect alignment of their struct or class in C/C++, + however `bindgen` interpreted them as doing so, which could generate + `#[repr(C)]` structs expecting to have an incorrect alignment. This is now + fixed. [#1076][] + +* When a zero-sized type was used in a bit-field, `bindgen` could + divide-by-zero. This is now fixed. [#1137][] + +* When a template parameter is used in a bit-field, `bindgen` would panic. This + is now fixed. [#1140][] + +* There was a regression in 0.31.0 where if `bindgen` was given a header file + that did not exist, it would panic. This is now fixed, and it will instead + properly report the error. [#1146][] + +* In some cases, generated bit-field getters and setters could access memory + beyond `self`. This is now fixed. [#954][] + +[#1162]: https://github.com/rust-lang-nursery/rust-bindgen/issues/1162 +[#1113]: https://github.com/rust-lang-nursery/rust-bindgen/issues/1113 +[#1112]: https://github.com/rust-lang-nursery/rust-bindgen/issues/1112 +[#1123]: https://github.com/rust-lang-nursery/rust-bindgen/issues/1123 +[#1127]: https://github.com/rust-lang-nursery/rust-bindgen/issues/1127 +[#1136]: https://github.com/rust-lang-nursery/rust-bindgen/issues/1136 +[#1137]: https://github.com/rust-lang-nursery/rust-bindgen/issues/1137 +[#1140]: https://github.com/rust-lang-nursery/rust-bindgen/issues/1140 +[#1146]: https://github.com/rust-lang-nursery/rust-bindgen/issues/1146 +[#1118]: https://github.com/rust-lang-nursery/rust-bindgen/issues/1118 +[#1076]: https://github.com/rust-lang-nursery/rust-bindgen/issues/1076 +[#1158]: https://github.com/rust-lang-nursery/rust-bindgen/issues/1158 + +-------------------------------------------------------------------------------- + # 0.31.0 Released 2017/10/27 @@ -23,7 +23,7 @@ dependencies = [ [[package]] name = "bindgen" -version = "0.31.3" +version = "0.32.0" dependencies = [ "cexpr 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)", "cfg-if 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -31,7 +31,7 @@ dependencies = [ "clap 2.24.2 (registry+https://github.com/rust-lang/crates.io-index)", "diff 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)", "env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)", - "lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", + "lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", "log 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)", "peeking_take_while 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", "quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)", @@ -65,7 +65,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)", "libc 0.2.23 (registry+https://github.com/rust-lang/crates.io-index)", - "libloading 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", + "libloading 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -113,7 +113,7 @@ dependencies = [ [[package]] name = "lazy_static" -version = "0.2.8" +version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] @@ -123,11 +123,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "libloading" -version = "0.4.0" +version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", - "lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", + "lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -278,9 +278,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3ddf21e73e016298f5cb37d6ef8e8da8e39f91f9ec8b0df44b7deb16a9f8cd5b" "checksum glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "8be18de09a56b60ed0edf84bc9df007e30040691af7acd1c41874faac5895bfb" "checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d" -"checksum lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "3b37545ab726dd833ec6420aaba8231c5b320814b9029ad585555d2a03e94fbf" +"checksum lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c8f31047daa365f19be14b47c29df4f7c3b581832407daabe6ae77397619237d" "checksum libc 0.2.23 (registry+https://github.com/rust-lang/crates.io-index)" = "e7eb6b826bfc1fdea7935d46556250d1799b7fe2d9f7951071f4291710665e3e" -"checksum libloading 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "be99f814beb3e9503a786a592c909692bb6d4fc5a695f6ed7987223acfbd5194" +"checksum libloading 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fd38073de8f7965d0c17d30546d4bb6da311ab428d1c7a3fc71dff7f9d4979b9" "checksum log 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)" = "880f77541efa6e5cc74e76910c9884d9859683118839d6a1dc3b11e63512565b" "checksum memchr 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1dbccc0e46f1ea47b9f17e6d67c5a96bd27030519c519c9c91327e31275a47b4" "checksum nom 1.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "a5b8c256fd9471521bcb84c3cdba98921497f1a331cbc15b8030fc63b82050ce" @@ -13,7 +13,7 @@ name = "bindgen" readme = "README.md" repository = "https://github.com/rust-lang-nursery/rust-bindgen" documentation = "https://docs.rs/bindgen" -version = "0.31.3" +version = "0.32.0" build = "build.rs" include = [ @@ -45,7 +45,7 @@ cfg-if = "0.1.0" # This kinda sucks: https://github.com/rust-lang/cargo/issues/1982 clap = "2" clang-sys = { version = "0.21.0", features = ["runtime", "clang_3_9"] } -lazy_static = "0.2.1" +lazy_static = "1" peeking_take_while = "0.1.2" quote = "0.3.15" regex = "0.2" diff --git a/tests/expectations/tests/issue-816.rs b/tests/expectations/tests/issue-816.rs new file mode 100644 index 00000000..bb8a323a --- /dev/null +++ b/tests/expectations/tests/issue-816.rs @@ -0,0 +1,808 @@ +/* automatically generated by rust-bindgen */ + + +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] + + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit<Storage, Align> +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + storage: Storage, + align: [Align; 0], +} + +impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + pub fn new(storage: Storage) -> Self { + Self { storage, align: [] } + } + + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + + let bit_index = index % 8; + let mask = 1 << bit_index; + + byte & mask == mask + } + + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + + let bit_index = index % 8; + let mask = 1 << bit_index; + + if val { + *byte |= mask; + } else { + *byte &= !mask; + } + } + + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + + let mut val = 0; + + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + val |= 1 << i; + } + } + + val + } + + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + self.set_bit(i + bit_offset, val_bit_is_set); + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct jvmtiCapabilities { + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize], u8>, + pub __bindgen_align: [u32; 0usize], +} +#[test] +fn bindgen_test_layout_jvmtiCapabilities() { + assert_eq!( + ::std::mem::size_of::<jvmtiCapabilities>(), + 16usize, + concat!("Size of: ", stringify!(jvmtiCapabilities)) + ); + assert_eq!( + ::std::mem::align_of::<jvmtiCapabilities>(), + 4usize, + concat!("Alignment of ", stringify!(jvmtiCapabilities)) + ); +} +impl jvmtiCapabilities { + #[inline] + pub fn can_tag_objects(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_tag_objects(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_field_modification_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_field_modification_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_field_access_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_field_access_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_get_bytecodes(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_get_bytecodes(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_get_synthetic_attribute(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_get_synthetic_attribute(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_get_owned_monitor_info(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_get_owned_monitor_info(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_get_current_contended_monitor(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_get_current_contended_monitor(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_get_monitor_info(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_get_monitor_info(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_pop_frame(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_pop_frame(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_redefine_classes(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_redefine_classes(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_signal_thread(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_signal_thread(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_get_source_file_name(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_get_source_file_name(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_get_line_numbers(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_get_line_numbers(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_get_source_debug_extension(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_get_source_debug_extension(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_access_local_variables(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_access_local_variables(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_maintain_original_method_order(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_maintain_original_method_order(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_single_step_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_single_step_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_exception_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_exception_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_frame_pop_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_frame_pop_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_breakpoint_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_breakpoint_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_suspend(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_suspend(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_redefine_any_class(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_redefine_any_class(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_get_current_thread_cpu_time(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_get_current_thread_cpu_time(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_get_thread_cpu_time(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_get_thread_cpu_time(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_method_entry_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_method_entry_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_method_exit_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_method_exit_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(25usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_all_class_hook_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_all_class_hook_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_compiled_method_load_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_compiled_method_load_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(27usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_monitor_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_monitor_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(28usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_vm_object_alloc_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_vm_object_alloc_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_native_method_bind_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_native_method_bind_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(30usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_garbage_collection_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_garbage_collection_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(31usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_object_free_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_object_free_events(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(32usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_force_early_return(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_force_early_return(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(33usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_get_owned_monitor_stack_depth_info(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_get_owned_monitor_stack_depth_info(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(34usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_get_constant_pool(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_get_constant_pool(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(35usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_set_native_method_prefix(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_set_native_method_prefix(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(36usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_retransform_classes(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_retransform_classes(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(37usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_retransform_any_class(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_retransform_any_class(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(38usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_resource_exhaustion_heap_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_resource_exhaustion_heap_events( + &mut self, + val: ::std::os::raw::c_uint, + ) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(39usize, 1u8, val as u64) + } + } + #[inline] + pub fn can_generate_resource_exhaustion_threads_events(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 1u8) as u32) } + } + #[inline] + pub fn set_can_generate_resource_exhaustion_threads_events( + &mut self, + val: ::std::os::raw::c_uint, + ) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(40usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + can_tag_objects: ::std::os::raw::c_uint, + can_generate_field_modification_events: ::std::os::raw::c_uint, + can_generate_field_access_events: ::std::os::raw::c_uint, + can_get_bytecodes: ::std::os::raw::c_uint, + can_get_synthetic_attribute: ::std::os::raw::c_uint, + can_get_owned_monitor_info: ::std::os::raw::c_uint, + can_get_current_contended_monitor: ::std::os::raw::c_uint, + can_get_monitor_info: ::std::os::raw::c_uint, + can_pop_frame: ::std::os::raw::c_uint, + can_redefine_classes: ::std::os::raw::c_uint, + can_signal_thread: ::std::os::raw::c_uint, + can_get_source_file_name: ::std::os::raw::c_uint, + can_get_line_numbers: ::std::os::raw::c_uint, + can_get_source_debug_extension: ::std::os::raw::c_uint, + can_access_local_variables: ::std::os::raw::c_uint, + can_maintain_original_method_order: ::std::os::raw::c_uint, + can_generate_single_step_events: ::std::os::raw::c_uint, + can_generate_exception_events: ::std::os::raw::c_uint, + can_generate_frame_pop_events: ::std::os::raw::c_uint, + can_generate_breakpoint_events: ::std::os::raw::c_uint, + can_suspend: ::std::os::raw::c_uint, + can_redefine_any_class: ::std::os::raw::c_uint, + can_get_current_thread_cpu_time: ::std::os::raw::c_uint, + can_get_thread_cpu_time: ::std::os::raw::c_uint, + can_generate_method_entry_events: ::std::os::raw::c_uint, + can_generate_method_exit_events: ::std::os::raw::c_uint, + can_generate_all_class_hook_events: ::std::os::raw::c_uint, + can_generate_compiled_method_load_events: ::std::os::raw::c_uint, + can_generate_monitor_events: ::std::os::raw::c_uint, + can_generate_vm_object_alloc_events: ::std::os::raw::c_uint, + can_generate_native_method_bind_events: ::std::os::raw::c_uint, + can_generate_garbage_collection_events: ::std::os::raw::c_uint, + can_generate_object_free_events: ::std::os::raw::c_uint, + can_force_early_return: ::std::os::raw::c_uint, + can_get_owned_monitor_stack_depth_info: ::std::os::raw::c_uint, + can_get_constant_pool: ::std::os::raw::c_uint, + can_set_native_method_prefix: ::std::os::raw::c_uint, + can_retransform_classes: ::std::os::raw::c_uint, + can_retransform_any_class: ::std::os::raw::c_uint, + can_generate_resource_exhaustion_heap_events: ::std::os::raw::c_uint, + can_generate_resource_exhaustion_threads_events: ::std::os::raw::c_uint, + ) -> __BindgenBitfieldUnit<[u8; 16usize], u8> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize], u8> = + Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let can_tag_objects: u32 = unsafe { ::std::mem::transmute(can_tag_objects) }; + can_tag_objects as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let can_generate_field_modification_events: u32 = + unsafe { ::std::mem::transmute(can_generate_field_modification_events) }; + can_generate_field_modification_events as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let can_generate_field_access_events: u32 = + unsafe { ::std::mem::transmute(can_generate_field_access_events) }; + can_generate_field_access_events as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let can_get_bytecodes: u32 = unsafe { ::std::mem::transmute(can_get_bytecodes) }; + can_get_bytecodes as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let can_get_synthetic_attribute: u32 = + unsafe { ::std::mem::transmute(can_get_synthetic_attribute) }; + can_get_synthetic_attribute as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let can_get_owned_monitor_info: u32 = + unsafe { ::std::mem::transmute(can_get_owned_monitor_info) }; + can_get_owned_monitor_info as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let can_get_current_contended_monitor: u32 = + unsafe { ::std::mem::transmute(can_get_current_contended_monitor) }; + can_get_current_contended_monitor as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let can_get_monitor_info: u32 = unsafe { ::std::mem::transmute(can_get_monitor_info) }; + can_get_monitor_info as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let can_pop_frame: u32 = unsafe { ::std::mem::transmute(can_pop_frame) }; + can_pop_frame as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let can_redefine_classes: u32 = unsafe { ::std::mem::transmute(can_redefine_classes) }; + can_redefine_classes as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let can_signal_thread: u32 = unsafe { ::std::mem::transmute(can_signal_thread) }; + can_signal_thread as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let can_get_source_file_name: u32 = + unsafe { ::std::mem::transmute(can_get_source_file_name) }; + can_get_source_file_name as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let can_get_line_numbers: u32 = unsafe { ::std::mem::transmute(can_get_line_numbers) }; + can_get_line_numbers as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let can_get_source_debug_extension: u32 = + unsafe { ::std::mem::transmute(can_get_source_debug_extension) }; + can_get_source_debug_extension as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let can_access_local_variables: u32 = + unsafe { ::std::mem::transmute(can_access_local_variables) }; + can_access_local_variables as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let can_maintain_original_method_order: u32 = + unsafe { ::std::mem::transmute(can_maintain_original_method_order) }; + can_maintain_original_method_order as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let can_generate_single_step_events: u32 = + unsafe { ::std::mem::transmute(can_generate_single_step_events) }; + can_generate_single_step_events as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let can_generate_exception_events: u32 = + unsafe { ::std::mem::transmute(can_generate_exception_events) }; + can_generate_exception_events as u64 + }); + __bindgen_bitfield_unit.set(18usize, 1u8, { + let can_generate_frame_pop_events: u32 = + unsafe { ::std::mem::transmute(can_generate_frame_pop_events) }; + can_generate_frame_pop_events as u64 + }); + __bindgen_bitfield_unit.set(19usize, 1u8, { + let can_generate_breakpoint_events: u32 = + unsafe { ::std::mem::transmute(can_generate_breakpoint_events) }; + can_generate_breakpoint_events as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let can_suspend: u32 = unsafe { ::std::mem::transmute(can_suspend) }; + can_suspend as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let can_redefine_any_class: u32 = + unsafe { ::std::mem::transmute(can_redefine_any_class) }; + can_redefine_any_class as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let can_get_current_thread_cpu_time: u32 = + unsafe { ::std::mem::transmute(can_get_current_thread_cpu_time) }; + can_get_current_thread_cpu_time as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let can_get_thread_cpu_time: u32 = + unsafe { ::std::mem::transmute(can_get_thread_cpu_time) }; + can_get_thread_cpu_time as u64 + }); + __bindgen_bitfield_unit.set(24usize, 1u8, { + let can_generate_method_entry_events: u32 = + unsafe { ::std::mem::transmute(can_generate_method_entry_events) }; + can_generate_method_entry_events as u64 + }); + __bindgen_bitfield_unit.set(25usize, 1u8, { + let can_generate_method_exit_events: u32 = + unsafe { ::std::mem::transmute(can_generate_method_exit_events) }; + can_generate_method_exit_events as u64 + }); + __bindgen_bitfield_unit.set(26usize, 1u8, { + let can_generate_all_class_hook_events: u32 = + unsafe { ::std::mem::transmute(can_generate_all_class_hook_events) }; + can_generate_all_class_hook_events as u64 + }); + __bindgen_bitfield_unit.set(27usize, 1u8, { + let can_generate_compiled_method_load_events: u32 = + unsafe { ::std::mem::transmute(can_generate_compiled_method_load_events) }; + can_generate_compiled_method_load_events as u64 + }); + __bindgen_bitfield_unit.set(28usize, 1u8, { + let can_generate_monitor_events: u32 = + unsafe { ::std::mem::transmute(can_generate_monitor_events) }; + can_generate_monitor_events as u64 + }); + __bindgen_bitfield_unit.set(29usize, 1u8, { + let can_generate_vm_object_alloc_events: u32 = + unsafe { ::std::mem::transmute(can_generate_vm_object_alloc_events) }; + can_generate_vm_object_alloc_events as u64 + }); + __bindgen_bitfield_unit.set(30usize, 1u8, { + let can_generate_native_method_bind_events: u32 = + unsafe { ::std::mem::transmute(can_generate_native_method_bind_events) }; + can_generate_native_method_bind_events as u64 + }); + __bindgen_bitfield_unit.set(31usize, 1u8, { + let can_generate_garbage_collection_events: u32 = + unsafe { ::std::mem::transmute(can_generate_garbage_collection_events) }; + can_generate_garbage_collection_events as u64 + }); + __bindgen_bitfield_unit.set(32usize, 1u8, { + let can_generate_object_free_events: u32 = + unsafe { ::std::mem::transmute(can_generate_object_free_events) }; + can_generate_object_free_events as u64 + }); + __bindgen_bitfield_unit.set(33usize, 1u8, { + let can_force_early_return: u32 = + unsafe { ::std::mem::transmute(can_force_early_return) }; + can_force_early_return as u64 + }); + __bindgen_bitfield_unit.set(34usize, 1u8, { + let can_get_owned_monitor_stack_depth_info: u32 = + unsafe { ::std::mem::transmute(can_get_owned_monitor_stack_depth_info) }; + can_get_owned_monitor_stack_depth_info as u64 + }); + __bindgen_bitfield_unit.set(35usize, 1u8, { + let can_get_constant_pool: u32 = + unsafe { ::std::mem::transmute(can_get_constant_pool) }; + can_get_constant_pool as u64 + }); + __bindgen_bitfield_unit.set(36usize, 1u8, { + let can_set_native_method_prefix: u32 = + unsafe { ::std::mem::transmute(can_set_native_method_prefix) }; + can_set_native_method_prefix as u64 + }); + __bindgen_bitfield_unit.set(37usize, 1u8, { + let can_retransform_classes: u32 = + unsafe { ::std::mem::transmute(can_retransform_classes) }; + can_retransform_classes as u64 + }); + __bindgen_bitfield_unit.set(38usize, 1u8, { + let can_retransform_any_class: u32 = + unsafe { ::std::mem::transmute(can_retransform_any_class) }; + can_retransform_any_class as u64 + }); + __bindgen_bitfield_unit.set(39usize, 1u8, { + let can_generate_resource_exhaustion_heap_events: u32 = + unsafe { ::std::mem::transmute(can_generate_resource_exhaustion_heap_events) }; + can_generate_resource_exhaustion_heap_events as u64 + }); + __bindgen_bitfield_unit.set(40usize, 1u8, { + let can_generate_resource_exhaustion_threads_events: u32 = + unsafe { ::std::mem::transmute(can_generate_resource_exhaustion_threads_events) }; + can_generate_resource_exhaustion_threads_events as u64 + }); + __bindgen_bitfield_unit + } +} diff --git a/tests/headers/issue-816.h b/tests/headers/issue-816.h new file mode 100644 index 00000000..cacb0260 --- /dev/null +++ b/tests/headers/issue-816.h @@ -0,0 +1,49 @@ +typedef struct { + unsigned int can_tag_objects : 1; + unsigned int can_generate_field_modification_events : 1; + unsigned int can_generate_field_access_events : 1; + unsigned int can_get_bytecodes : 1; + unsigned int can_get_synthetic_attribute : 1; + unsigned int can_get_owned_monitor_info : 1; + unsigned int can_get_current_contended_monitor : 1; + unsigned int can_get_monitor_info : 1; + unsigned int can_pop_frame : 1; + unsigned int can_redefine_classes : 1; + unsigned int can_signal_thread : 1; + unsigned int can_get_source_file_name : 1; + unsigned int can_get_line_numbers : 1; + unsigned int can_get_source_debug_extension : 1; + unsigned int can_access_local_variables : 1; + unsigned int can_maintain_original_method_order : 1; + unsigned int can_generate_single_step_events : 1; + unsigned int can_generate_exception_events : 1; + unsigned int can_generate_frame_pop_events : 1; + unsigned int can_generate_breakpoint_events : 1; + unsigned int can_suspend : 1; + unsigned int can_redefine_any_class : 1; + unsigned int can_get_current_thread_cpu_time : 1; + unsigned int can_get_thread_cpu_time : 1; + unsigned int can_generate_method_entry_events : 1; + unsigned int can_generate_method_exit_events : 1; + unsigned int can_generate_all_class_hook_events : 1; + unsigned int can_generate_compiled_method_load_events : 1; + unsigned int can_generate_monitor_events : 1; + unsigned int can_generate_vm_object_alloc_events : 1; + unsigned int can_generate_native_method_bind_events : 1; + unsigned int can_generate_garbage_collection_events : 1; + unsigned int can_generate_object_free_events : 1; + unsigned int can_force_early_return : 1; + unsigned int can_get_owned_monitor_stack_depth_info : 1; + unsigned int can_get_constant_pool : 1; + unsigned int can_set_native_method_prefix : 1; + unsigned int can_retransform_classes : 1; + unsigned int can_retransform_any_class : 1; + unsigned int can_generate_resource_exhaustion_heap_events : 1; + unsigned int can_generate_resource_exhaustion_threads_events : 1; + unsigned int : 7; + unsigned int : 16; + unsigned int : 16; + unsigned int : 16; + unsigned int : 16; + unsigned int : 16; +} jvmtiCapabilities; |