summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--CHANGELOG.md110
-rw-r--r--Cargo.lock16
-rw-r--r--Cargo.toml4
-rw-r--r--tests/expectations/tests/issue-816.rs808
-rw-r--r--tests/headers/issue-816.h49
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
diff --git a/Cargo.lock b/Cargo.lock
index 81551c76..2d091c9f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -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"
diff --git a/Cargo.toml b/Cargo.toml
index eee82f0c..bc366145 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -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;