From 109597d81abc0753e6c40dbd31b13daa4c8e31ea Mon Sep 17 00:00:00 2001 From: Nick Fitzgerald Date: Thu, 7 Dec 2017 09:14:12 -0800 Subject: [PATCH] Add a regression test for issue #816 --- tests/expectations/tests/issue-816.rs | 808 ++++++++++++++++++++++++++ tests/headers/issue-816.h | 49 ++ 2 files changed, 857 insertions(+) create mode 100644 tests/expectations/tests/issue-816.rs create mode 100644 tests/headers/issue-816.h diff --git a/tests/expectations/tests/issue-816.rs b/tests/expectations/tests/issue-816.rs new file mode 100644 index 0000000000..bb8a323a7b --- /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 +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + storage: Storage, + align: [Align; 0], +} + +impl __BindgenBitfieldUnit +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::(), + 16usize, + concat!("Size of: ", stringify!(jvmtiCapabilities)) + ); + assert_eq!( + ::std::mem::align_of::(), + 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 0000000000..cacb0260b8 --- /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;