diff options
20 files changed, 2750 insertions, 488 deletions
diff --git a/bindgen-integration/cpp/Test.cc b/bindgen-integration/cpp/Test.cc index 9d91250c..f125109a 100644 --- a/bindgen-integration/cpp/Test.cc +++ b/bindgen-integration/cpp/Test.cc @@ -76,4 +76,29 @@ Date2::assert(unsigned short nWeekDay, this->byte == byte; } +bool +Fifth::assert(unsigned short nWeekDay, + unsigned short nMonthDay, + unsigned short nMonth, + unsigned short nYear, + unsigned char byte) +{ + return this->nWeekDay == nWeekDay && + this->nMonthDay == nMonthDay && + this->nMonth == nMonth && + this->nYear == nYear && + this->byte == byte; +} + +bool +Sixth::assert(unsigned char byte, + unsigned char nWeekDay, + unsigned char nMonth, + unsigned char nMonthDay) { + return this->nWeekDay == nWeekDay && + this->nMonthDay == nMonthDay && + this->nMonth == nMonth && + this->byte == byte; +}; + } // namespace bitfields diff --git a/bindgen-integration/cpp/Test.h b/bindgen-integration/cpp/Test.h index 4b8c1690..e23a32e6 100644 --- a/bindgen-integration/cpp/Test.h +++ b/bindgen-integration/cpp/Test.h @@ -92,6 +92,36 @@ struct Date2 { unsigned short byte); }; + +struct Fifth { + unsigned short nWeekDay : 3; // 0..7 (3 bits) + unsigned short nMonthDay : 6; // 0..31 (6 bits) + unsigned short nMonth : 5; // 0..12 (5 bits) + unsigned short nYear : 8; // 0..100 (8 bits) + unsigned char byte; + + /// Returns true if the bitfields match the arguments, false otherwise. + bool assert(unsigned short nWeekDay, + unsigned short nMonthDay, + unsigned short nMonth, + unsigned short nYear, + unsigned char byte); +}; + +struct Sixth { + unsigned char byte; + unsigned char nWeekDay : 3; + unsigned char nMonth : 5; + unsigned char nMonthDay : 6; + + /// Returns true if the bitfields match the arguments, false otherwise. + bool assert(unsigned char byte, + unsigned char nWeekDay, + unsigned char nMonth, + unsigned char nMonthDay); +}; + + } // namespace bitfields struct AutoRestoreBool { diff --git a/bindgen-integration/src/lib.rs b/bindgen-integration/src/lib.rs index ea2b77b2..fdb02dbb 100755 --- a/bindgen-integration/src/lib.rs +++ b/bindgen-integration/src/lib.rs @@ -138,6 +138,48 @@ fn test_bitfields_date2() { } #[test] +fn test_bitfields_fifth() { + let mut date: bindings::bitfields::Fifth = unsafe { + mem::zeroed() + }; + + assert!(unsafe { + date.assert(0, 0, 0, 0, 0) + }); + + date.byte = 255; // Set this first, to ensure we don't override it. + + date.set_nWeekDay(6); // saturdays are the best + date.set_nMonthDay(20); + date.set_nMonth(11); + date.set_nYear(95); + + assert!(unsafe { + date.assert(6, 20, 11, 95, 255) + }); +} + +#[test] +fn test_bitfields_sixth() { + let mut date: bindings::bitfields::Sixth = unsafe { + mem::zeroed() + }; + + assert!(unsafe { + date.assert(0, 0, 0, 0) + }); + + date.byte = 255; + date.set_nWeekDay(6); // saturdays are the best + date.set_nMonthDay(20); + date.set_nMonth(11); + + assert!(unsafe { + date.assert(255, 6, 11, 20) + }); +} + +#[test] fn test_bitfield_constructors() { use std::mem; let mut first = bindings::bitfields::First { diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs index 8d979dce..bd5b1f3b 100644 --- a/src/codegen/mod.rs +++ b/src/codegen/mod.rs @@ -1113,9 +1113,9 @@ impl Bitfield { #[inline] $fn_prefix $ctor_name($params $param_name : $bitfield_ty) -> $unit_field_int_ty { - ($body | - (($param_name as $bitfield_int_ty as $unit_field_int_ty) << $offset) & - ($mask as $unit_field_int_ty)) + ($body | + (($param_name as $bitfield_int_ty as $unit_field_int_ty) << $offset) & + ($mask as $unit_field_int_ty)) } } ).unwrap() @@ -1147,12 +1147,18 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit { .build_ty(field_ty.clone()); fields.extend(Some(field)); - let unit_field_int_ty = match self.layout().size { + let mut field_int_size = self.layout().size; + if !field_int_size.is_power_of_two() { + field_int_size = field_int_size.next_power_of_two(); + } + + let unit_field_int_ty = match field_int_size { 8 => quote_ty!(ctx.ext_cx(), u64), 4 => quote_ty!(ctx.ext_cx(), u32), 2 => quote_ty!(ctx.ext_cx(), u16), 1 => quote_ty!(ctx.ext_cx(), u8), - _ => { + size => { + debug_assert!(size > 8); // Can't generate bitfield accessors for unit sizes larget than // 64 bits at the moment. struct_layout.saw_bitfield_unit(self.layout()); @@ -1273,7 +1279,7 @@ impl<'a> FieldCodegen<'a> for Bitfield { let bitfield_ty = bitfield_ty.to_rust_ty_or_opaque(ctx, bitfield_ty_item); let offset = self.offset_into_unit(); - let mask: usize = self.mask(); + let mask = self.mask(); let impl_item = quote_item!( ctx.ext_cx(), @@ -1282,7 +1288,9 @@ impl<'a> FieldCodegen<'a> for Bitfield { pub fn $getter_name(&self) -> $bitfield_ty { let mask = $mask as $unit_field_int_ty; let unit_field_val: $unit_field_int_ty = unsafe { - ::$prefix::mem::transmute(self.$unit_field_ident) + ::$prefix::ptr::read_unaligned( + &self.$unit_field_ident as *const _ as *const $unit_field_int_ty + ) }; let val = (unit_field_val & mask) >> $offset; unsafe { @@ -1296,14 +1304,19 @@ impl<'a> FieldCodegen<'a> for Bitfield { let val = val as $bitfield_int_ty as $unit_field_int_ty; let mut unit_field_val: $unit_field_int_ty = unsafe { - ::$prefix::mem::transmute(self.$unit_field_ident) + ::$prefix::ptr::read_unaligned( + &self.$unit_field_ident as *const _ as *const $unit_field_int_ty) }; + unit_field_val &= !mask; unit_field_val |= (val << $offset) & mask; - self.$unit_field_ident = unsafe { - ::$prefix::mem::transmute(unit_field_val) - }; + unsafe { + ::$prefix::ptr::write_unaligned( + &mut self.$unit_field_ident as *mut _ as *mut $unit_field_int_ty, + unit_field_val + ); + } } } ).unwrap(); diff --git a/src/ir/comp.rs b/src/ir/comp.rs index 171f130c..315d342a 100644 --- a/src/ir/comp.rs +++ b/src/ir/comp.rs @@ -293,18 +293,15 @@ impl Bitfield { /// Get the mask value that when &'ed with this bitfield's allocation unit /// produces this bitfield's value. - /// - /// TODO(emilio): This should probably use the target's word size, and what - /// about bitfields that are bigger than that? - pub fn mask(&self) -> usize { + pub fn mask(&self) -> u64 { use std::mem; - use std::usize; + use std::u64; let unoffseted_mask = - if self.width() as usize == mem::size_of::<usize>() * 8 { - usize::MAX + if self.width() as u64 == mem::size_of::<u64>() as u64 * 8 { + u64::MAX } else { - ((1usize << self.width()) - 1usize) + ((1u64 << self.width()) - 1u64) }; unoffseted_mask << self.offset_into_unit() @@ -488,8 +485,9 @@ fn bitfields_to_allocation_units<E, I>(ctx: &BindgenContext, where E: Extend<Field> { *bitfield_unit_count += 1; - let layout = Layout::new(bytes_from_bits_pow2(unit_size_in_bits), - bytes_from_bits_pow2(unit_align_in_bits)); + let align = bytes_from_bits_pow2(unit_align_in_bits); + let size = align_to(unit_size_in_bits, align * 8) / 8; + let layout = Layout::new(size, align); fields.extend(Some(Field::Bitfields(BitfieldUnit { nth: *bitfield_unit_count, layout: layout, diff --git a/tests/expectations/tests/bitfield-32bit-overflow.rs b/tests/expectations/tests/bitfield-32bit-overflow.rs new file mode 100644 index 00000000..ff11d5bc --- /dev/null +++ b/tests/expectations/tests/bitfield-32bit-overflow.rs @@ -0,0 +1,1303 @@ +/* automatically generated by rust-bindgen */ + + +#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)] + + +#[repr(C)] +#[derive(Debug, Default, Copy)] +pub struct MuchBitfield { + pub _bitfield_1: [u8; 5usize], + pub __bindgen_align: [u8; 0usize], +} +#[test] +fn bindgen_test_layout_MuchBitfield() { + assert_eq!(::std::mem::size_of::<MuchBitfield>() , 5usize , concat ! ( + "Size of: " , stringify ! ( MuchBitfield ) )); + assert_eq! (::std::mem::align_of::<MuchBitfield>() , 1usize , concat ! ( + "Alignment of " , stringify ! ( MuchBitfield ) )); +} +impl Clone for MuchBitfield { + fn clone(&self) -> Self { *self } +} +impl MuchBitfield { + #[inline] + pub fn m0(&self) -> ::std::os::raw::c_char { + let mask = 1u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 0usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m0(&mut self, val: ::std::os::raw::c_char) { + let mask = 1u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 0usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m1(&self) -> ::std::os::raw::c_char { + let mask = 2u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 1usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m1(&mut self, val: ::std::os::raw::c_char) { + let mask = 2u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 1usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m2(&self) -> ::std::os::raw::c_char { + let mask = 4u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 2usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m2(&mut self, val: ::std::os::raw::c_char) { + let mask = 4u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 2usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m3(&self) -> ::std::os::raw::c_char { + let mask = 8u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 3usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m3(&mut self, val: ::std::os::raw::c_char) { + let mask = 8u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 3usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m4(&self) -> ::std::os::raw::c_char { + let mask = 16u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 4usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m4(&mut self, val: ::std::os::raw::c_char) { + let mask = 16u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 4usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m5(&self) -> ::std::os::raw::c_char { + let mask = 32u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 5usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m5(&mut self, val: ::std::os::raw::c_char) { + let mask = 32u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 5usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m6(&self) -> ::std::os::raw::c_char { + let mask = 64u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 6usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m6(&mut self, val: ::std::os::raw::c_char) { + let mask = 64u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 6usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m7(&self) -> ::std::os::raw::c_char { + let mask = 128u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 7usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m7(&mut self, val: ::std::os::raw::c_char) { + let mask = 128u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 7usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m8(&self) -> ::std::os::raw::c_char { + let mask = 256u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 8usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m8(&mut self, val: ::std::os::raw::c_char) { + let mask = 256u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 8usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m9(&self) -> ::std::os::raw::c_char { + let mask = 512u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 9usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m9(&mut self, val: ::std::os::raw::c_char) { + let mask = 512u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 9usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m10(&self) -> ::std::os::raw::c_char { + let mask = 1024u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 10usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m10(&mut self, val: ::std::os::raw::c_char) { + let mask = 1024u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 10usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m11(&self) -> ::std::os::raw::c_char { + let mask = 2048u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 11usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m11(&mut self, val: ::std::os::raw::c_char) { + let mask = 2048u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 11usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m12(&self) -> ::std::os::raw::c_char { + let mask = 4096u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 12usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m12(&mut self, val: ::std::os::raw::c_char) { + let mask = 4096u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 12usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m13(&self) -> ::std::os::raw::c_char { + let mask = 8192u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 13usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m13(&mut self, val: ::std::os::raw::c_char) { + let mask = 8192u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 13usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m14(&self) -> ::std::os::raw::c_char { + let mask = 16384u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 14usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m14(&mut self, val: ::std::os::raw::c_char) { + let mask = 16384u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 14usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m15(&self) -> ::std::os::raw::c_char { + let mask = 32768u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 15usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m15(&mut self, val: ::std::os::raw::c_char) { + let mask = 32768u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 15usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m16(&self) -> ::std::os::raw::c_char { + let mask = 65536u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 16usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m16(&mut self, val: ::std::os::raw::c_char) { + let mask = 65536u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 16usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m17(&self) -> ::std::os::raw::c_char { + let mask = 131072u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 17usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m17(&mut self, val: ::std::os::raw::c_char) { + let mask = 131072u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 17usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m18(&self) -> ::std::os::raw::c_char { + let mask = 262144u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 18usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m18(&mut self, val: ::std::os::raw::c_char) { + let mask = 262144u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 18usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m19(&self) -> ::std::os::raw::c_char { + let mask = 524288u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 19usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m19(&mut self, val: ::std::os::raw::c_char) { + let mask = 524288u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 19usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m20(&self) -> ::std::os::raw::c_char { + let mask = 1048576u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 20usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m20(&mut self, val: ::std::os::raw::c_char) { + let mask = 1048576u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 20usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m21(&self) -> ::std::os::raw::c_char { + let mask = 2097152u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 21usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m21(&mut self, val: ::std::os::raw::c_char) { + let mask = 2097152u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 21usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m22(&self) -> ::std::os::raw::c_char { + let mask = 4194304u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 22usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m22(&mut self, val: ::std::os::raw::c_char) { + let mask = 4194304u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 22usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m23(&self) -> ::std::os::raw::c_char { + let mask = 8388608u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 23usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m23(&mut self, val: ::std::os::raw::c_char) { + let mask = 8388608u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 23usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m24(&self) -> ::std::os::raw::c_char { + let mask = 16777216u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 24usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m24(&mut self, val: ::std::os::raw::c_char) { + let mask = 16777216u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 24usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m25(&self) -> ::std::os::raw::c_char { + let mask = 33554432u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 25usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m25(&mut self, val: ::std::os::raw::c_char) { + let mask = 33554432u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 25usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m26(&self) -> ::std::os::raw::c_char { + let mask = 67108864u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 26usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m26(&mut self, val: ::std::os::raw::c_char) { + let mask = 67108864u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 26usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m27(&self) -> ::std::os::raw::c_char { + let mask = 134217728u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 27usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m27(&mut self, val: ::std::os::raw::c_char) { + let mask = 134217728u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 27usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m28(&self) -> ::std::os::raw::c_char { + let mask = 268435456u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 28usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m28(&mut self, val: ::std::os::raw::c_char) { + let mask = 268435456u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 28usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m29(&self) -> ::std::os::raw::c_char { + let mask = 536870912u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 29usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m29(&mut self, val: ::std::os::raw::c_char) { + let mask = 536870912u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 29usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m30(&self) -> ::std::os::raw::c_char { + let mask = 1073741824u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 30usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m30(&mut self, val: ::std::os::raw::c_char) { + let mask = 1073741824u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 30usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m31(&self) -> ::std::os::raw::c_char { + let mask = 2147483648u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 31usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m31(&mut self, val: ::std::os::raw::c_char) { + let mask = 2147483648u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 31usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn m32(&self) -> ::std::os::raw::c_char { + let mask = 4294967296u64 as u64; + let unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + let val = (unit_field_val & mask) >> 32usize; + unsafe { ::std::mem::transmute(val as u8) } + } + #[inline] + pub fn set_m32(&mut self, val: ::std::os::raw::c_char) { + let mask = 4294967296u64 as u64; + let val = val as u8 as u64; + let mut unit_field_val: u64 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 32usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } + } + #[inline] + pub fn new_bitfield_1(m0: ::std::os::raw::c_char, + m1: ::std::os::raw::c_char, + m2: ::std::os::raw::c_char, + m3: ::std::os::raw::c_char, + m4: ::std::os::raw::c_char, + m5: ::std::os::raw::c_char, + m6: ::std::os::raw::c_char, + m7: ::std::os::raw::c_char, + m8: ::std::os::raw::c_char, + m9: ::std::os::raw::c_char, + m10: ::std::os::raw::c_char, + m11: ::std::os::raw::c_char, + m12: ::std::os::raw::c_char, + m13: ::std::os::raw::c_char, + m14: ::std::os::raw::c_char, + m15: ::std::os::raw::c_char, + m16: ::std::os::raw::c_char, + m17: ::std::os::raw::c_char, + m18: ::std::os::raw::c_char, + m19: ::std::os::raw::c_char, + m20: ::std::os::raw::c_char, + m21: ::std::os::raw::c_char, + m22: ::std::os::raw::c_char, + m23: ::std::os::raw::c_char, + m24: ::std::os::raw::c_char, + m25: ::std::os::raw::c_char, + m26: ::std::os::raw::c_char, + m27: ::std::os::raw::c_char, + m28: ::std::os::raw::c_char, + m29: ::std::os::raw::c_char, + m30: ::std::os::raw::c_char, + m31: ::std::os::raw::c_char, + m32: ::std::os::raw::c_char) -> u64 { + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + ({ + 0 + } + | + ((m0 + as + u8 + as + u64) + << + 0usize) + & + (1u64 + as + u64)) + } + | + ((m1 + as + u8 + as + u64) + << + 1usize) + & + (2u64 + as + u64)) + } + | + ((m2 + as + u8 + as + u64) + << + 2usize) + & + (4u64 + as + u64)) + } + | + ((m3 + as + u8 + as + u64) + << + 3usize) + & + (8u64 + as + u64)) + } + | + ((m4 + as + u8 + as + u64) + << + 4usize) + & + (16u64 + as + u64)) + } + | + ((m5 + as + u8 + as + u64) + << + 5usize) + & + (32u64 + as + u64)) + } + | + ((m6 + as + u8 + as + u64) + << + 6usize) + & + (64u64 + as + u64)) + } + | + ((m7 + as + u8 + as + u64) + << + 7usize) + & + (128u64 + as + u64)) + } + | + ((m8 + as + u8 + as + u64) + << + 8usize) + & + (256u64 + as + u64)) + } + | + ((m9 + as + u8 + as + u64) + << + 9usize) + & + (512u64 + as + u64)) + } + | + ((m10 + as + u8 + as + u64) + << + 10usize) + & + (1024u64 + as + u64)) + } + | + ((m11 + as + u8 + as + u64) + << + 11usize) + & + (2048u64 + as + u64)) + } + | + ((m12 + as + u8 + as + u64) + << + 12usize) + & + (4096u64 + as + u64)) + } + | + ((m13 + as + u8 + as + u64) + << + 13usize) + & + (8192u64 + as + u64)) + } + | + ((m14 + as + u8 + as + u64) + << + 14usize) + & + (16384u64 + as + u64)) + } + | + ((m15 + as + u8 + as + u64) + << + 15usize) + & + (32768u64 + as + u64)) + } + | + ((m16 + as + u8 + as + u64) + << + 16usize) + & + (65536u64 + as + u64)) + } + | + ((m17 + as + u8 + as + u64) + << + 17usize) + & + (131072u64 + as + u64)) + } + | + ((m18 + as + u8 + as + u64) + << + 18usize) + & + (262144u64 + as + u64)) + } | + ((m19 + as + u8 + as + u64) + << + 19usize) + & + (524288u64 + as + u64)) + } | + ((m20 + as + u8 + as + u64) + << + 20usize) + & + (1048576u64 + as + u64)) + } | + ((m21 as + u8 + as + u64) + << + 21usize) + & + (2097152u64 + as + u64)) + } | + ((m22 as u8 as + u64) << + 22usize) & + (4194304u64 + as + u64)) + } | + ((m23 as u8 as u64) + << 23usize) & + (8388608u64 as + u64)) + } | + ((m24 as u8 as u64) << + 24usize) & + (16777216u64 as u64)) + } | + ((m25 as u8 as u64) << + 25usize) & + (33554432u64 as u64)) + } | + ((m26 as u8 as u64) << 26usize) & + (67108864u64 as u64)) + } | + ((m27 as u8 as u64) << 27usize) & + (134217728u64 as u64)) + } | + ((m28 as u8 as u64) << 28usize) & + (268435456u64 as u64)) + } | + ((m29 as u8 as u64) << 29usize) & + (536870912u64 as u64)) + } | + ((m30 as u8 as u64) << 30usize) & + (1073741824u64 as u64)) + } | ((m31 as u8 as u64) << 31usize) & (2147483648u64 as u64)) + } | ((m32 as u8 as u64) << 32usize) & (4294967296u64 as u64)) + } +} diff --git a/tests/expectations/tests/bitfield-method-same-name.rs b/tests/expectations/tests/bitfield-method-same-name.rs index f0ef0e31..74dd11e2 100644 --- a/tests/expectations/tests/bitfield-method-same-name.rs +++ b/tests/expectations/tests/bitfield-method-same-name.rs @@ -35,29 +35,37 @@ impl Clone for Foo { impl Foo { #[inline] pub fn type__bindgen_bitfield(&self) -> ::std::os::raw::c_char { - let mask = 7usize as u8; + let mask = 7u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u8) } } #[inline] pub fn set_type__bindgen_bitfield(&mut self, val: ::std::os::raw::c_char) { - let mask = 7usize as u8; + let mask = 7u64 as u8; let val = val as u8 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn new_bitfield_1(type__bindgen_bitfield: ::std::os::raw::c_char) -> u8 { ({ 0 } | - ((type__bindgen_bitfield as u8 as u8) << 0usize) & - (7usize as u8)) + ((type__bindgen_bitfield as u8 as u8) << 0usize) & (7u64 as u8)) } #[inline] pub unsafe fn type_(&mut self) -> ::std::os::raw::c_char { diff --git a/tests/expectations/tests/bitfield_align.rs b/tests/expectations/tests/bitfield_align.rs index 9b1fc603..233ae5ab 100644 --- a/tests/expectations/tests/bitfield_align.rs +++ b/tests/expectations/tests/bitfield_align.rs @@ -33,183 +33,273 @@ impl Clone for A { impl A { #[inline] pub fn b1(&self) -> ::std::os::raw::c_uint { - let mask = 1usize as u16; + let mask = 1u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) { - let mask = 1usize as u16; + let mask = 1u64 as u16; let val = val as u32 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn b2(&self) -> ::std::os::raw::c_uint { - let mask = 2usize as u16; + let mask = 2u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 1usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) { - let mask = 2usize as u16; + let mask = 2u64 as u16; let val = val as u32 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 1usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn b3(&self) -> ::std::os::raw::c_uint { - let mask = 4usize as u16; + let mask = 4u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 2usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_b3(&mut self, val: ::std::os::raw::c_uint) { - let mask = 4usize as u16; + let mask = 4u64 as u16; let val = val as u32 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 2usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn b4(&self) -> ::std::os::raw::c_uint { - let mask = 8usize as u16; + let mask = 8u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 3usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_b4(&mut self, val: ::std::os::raw::c_uint) { - let mask = 8usize as u16; + let mask = 8u64 as u16; let val = val as u32 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 3usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn b5(&self) -> ::std::os::raw::c_uint { - let mask = 16usize as u16; + let mask = 16u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 4usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_b5(&mut self, val: ::std::os::raw::c_uint) { - let mask = 16usize as u16; + let mask = 16u64 as u16; let val = val as u32 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 4usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn b6(&self) -> ::std::os::raw::c_uint { - let mask = 32usize as u16; + let mask = 32u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 5usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_b6(&mut self, val: ::std::os::raw::c_uint) { - let mask = 32usize as u16; + let mask = 32u64 as u16; let val = val as u32 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 5usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn b7(&self) -> ::std::os::raw::c_uint { - let mask = 64usize as u16; + let mask = 64u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 6usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_b7(&mut self, val: ::std::os::raw::c_uint) { - let mask = 64usize as u16; + let mask = 64u64 as u16; let val = val as u32 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 6usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn b8(&self) -> ::std::os::raw::c_uint { - let mask = 128usize as u16; + let mask = 128u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 7usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_b8(&mut self, val: ::std::os::raw::c_uint) { - let mask = 128usize as u16; + let mask = 128u64 as u16; let val = val as u32 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 7usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn b9(&self) -> ::std::os::raw::c_uint { - let mask = 256usize as u16; + let mask = 256u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 8usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_b9(&mut self, val: ::std::os::raw::c_uint) { - let mask = 256usize as u16; + let mask = 256u64 as u16; let val = val as u32 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 8usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn b10(&self) -> ::std::os::raw::c_uint { - let mask = 512usize as u16; + let mask = 512u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 9usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_b10(&mut self, val: ::std::os::raw::c_uint) { - let mask = 512usize as u16; + let mask = 512u64 as u16; let val = val as u32 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 9usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn new_bitfield_1(b1: ::std::os::raw::c_uint, @@ -234,27 +324,27 @@ impl A { ({ 0 } | ((b1 as u32 as u16) << 0usize) & - (1usize as u16)) + (1u64 as u16)) } | ((b2 as u32 as u16) << 1usize) & - (2usize as u16)) + (2u64 as u16)) } | ((b3 as u32 as u16) << 2usize) - & (4usize as u16)) + & (4u64 as u16)) } | ((b4 as u32 as u16) << 3usize) & - (8usize as u16)) + (8u64 as u16)) } | ((b5 as u32 as u16) << 4usize) & - (16usize as u16)) + (16u64 as u16)) } | ((b6 as u32 as u16) << 5usize) & - (32usize as u16)) - } | ((b7 as u32 as u16) << 6usize) & (64usize as u16)) - } | ((b8 as u32 as u16) << 7usize) & (128usize as u16)) - } | ((b9 as u32 as u16) << 8usize) & (256usize as u16)) - } | ((b10 as u32 as u16) << 9usize) & (512usize as u16)) + (32u64 as u16)) + } | ((b7 as u32 as u16) << 6usize) & (64u64 as u16)) + } | ((b8 as u32 as u16) << 7usize) & (128u64 as u16)) + } | ((b9 as u32 as u16) << 8usize) & (256u64 as u16)) + } | ((b10 as u32 as u16) << 9usize) & (512u64 as u16)) } } #[repr(C)] @@ -276,47 +366,65 @@ impl Clone for B { impl B { #[inline] pub fn foo(&self) -> ::std::os::raw::c_uint { - let mask = 2147483647usize as u32; + let mask = 2147483647u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_foo(&mut self, val: ::std::os::raw::c_uint) { - let mask = 2147483647usize as u32; + let mask = 2147483647u64 as u32; let val = val as u32 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn bar(&self) -> ::std::os::raw::c_uchar { - let mask = 2147483648usize as u32; + let mask = 2147483648u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 31usize; unsafe { ::std::mem::transmute(val as u8) } } #[inline] pub fn set_bar(&mut self, val: ::std::os::raw::c_uchar) { - let mask = 2147483648usize as u32; + let mask = 2147483648u64 as u32; let val = val as u8 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 31usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn new_bitfield_1(foo: ::std::os::raw::c_uint, bar: ::std::os::raw::c_uchar) -> u32 { ({ ({ 0 } | - ((foo as u32 as u32) << 0usize) & (2147483647usize as u32)) - } | ((bar as u8 as u32) << 31usize) & (2147483648usize as u32)) + ((foo as u32 as u32) << 0usize) & (2147483647u64 as u32)) + } | ((bar as u8 as u32) << 31usize) & (2147483648u64 as u32)) } } #[repr(C)] @@ -348,51 +456,70 @@ impl Clone for C { impl C { #[inline] pub fn b1(&self) -> ::std::os::raw::c_uint { - let mask = 1usize as u8; + let mask = 1u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) { - let mask = 1usize as u8; + let mask = 1u64 as u8; let val = val as u32 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn b2(&self) -> ::std::os::raw::c_uint { - let mask = 2usize as u8; + let mask = 2u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 1usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) { - let mask = 2usize as u8; + let mask = 2u64 as u8; let val = val as u32 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 1usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn new_bitfield_1(b1: ::std::os::raw::c_uint, b2: ::std::os::raw::c_uint) -> u8 { - ({ ({ 0 } | ((b1 as u32 as u8) << 0usize) & (1usize as u8)) } | - ((b2 as u32 as u8) << 1usize) & (2usize as u8)) + ({ ({ 0 } | ((b1 as u32 as u8) << 0usize) & (1u64 as u8)) } | + ((b2 as u32 as u8) << 1usize) & (2u64 as u8)) } } #[repr(C)] #[derive(Debug, Default, Copy)] pub struct Date1 { - pub _bitfield_1: [u8; 4usize], + pub _bitfield_1: [u8; 3usize], + pub __bindgen_padding_0: u8, pub __bindgen_align: [u16; 0usize], } #[test] @@ -408,75 +535,111 @@ impl Clone for Date1 { impl Date1 { #[inline] pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort { - let mask = 7usize as u32; + let mask = 7u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) { - let mask = 7usize as u32; + let mask = 7u64 as u32; let val = val as u16 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort { - let mask = 504usize as u32; + let mask = 504u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 3usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) { - let mask = 504usize as u32; + let mask = 504u64 as u32; let val = val as u16 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 3usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn nMonth(&self) -> ::std::os::raw::c_ushort { - let mask = 15872usize as u32; + let mask = 15872u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 9usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) { - let mask = 15872usize as u32; + let mask = 15872u64 as u32; let val = val as u16 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 9usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn nYear(&self) -> ::std::os::raw::c_ushort { - let mask = 16711680usize as u32; + let mask = 16711680u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 16usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) { - let mask = 16711680usize as u32; + let mask = 16711680u64 as u32; let val = val as u16 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 16usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn new_bitfield_1(nWeekDay: ::std::os::raw::c_ushort, @@ -488,12 +651,12 @@ impl Date1 { ({ ({ 0 } | ((nWeekDay as u16 as u32) << 0usize) & - (7usize as u32)) + (7u64 as u32)) } | ((nMonthDay as u16 as u32) << 3usize) & - (504usize as u32)) - } | ((nMonth as u16 as u32) << 9usize) & (15872usize as u32)) - } | ((nYear as u16 as u32) << 16usize) & (16711680usize as u32)) + (504u64 as u32)) + } | ((nMonth as u16 as u32) << 9usize) & (15872u64 as u32)) + } | ((nYear as u16 as u32) << 16usize) & (16711680u64 as u32)) } } #[repr(C)] @@ -515,93 +678,138 @@ impl Clone for Date2 { impl Date2 { #[inline] pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort { - let mask = 7usize as u32; + let mask = 7u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) { - let mask = 7usize as u32; + let mask = 7u64 as u32; let val = val as u16 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort { - let mask = 504usize as u32; + let mask = 504u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 3usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) { - let mask = 504usize as u32; + let mask = 504u64 as u32; let val = val as u16 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 3usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn nMonth(&self) -> ::std::os::raw::c_ushort { - let mask = 15872usize as u32; + let mask = 15872u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 9usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) { - let mask = 15872usize as u32; + let mask = 15872u64 as u32; let val = val as u16 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 9usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn nYear(&self) -> ::std::os::raw::c_ushort { - let mask = 16711680usize as u32; + let mask = 16711680u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 16usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) { - let mask = 16711680usize as u32; + let mask = 16711680u64 as u32; let val = val as u16 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 16usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn byte(&self) -> ::std::os::raw::c_uchar { - let mask = 4278190080usize as u32; + let mask = 4278190080u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 24usize; unsafe { ::std::mem::transmute(val as u8) } } #[inline] pub fn set_byte(&mut self, val: ::std::os::raw::c_uchar) { - let mask = 4278190080usize as u32; + let mask = 4278190080u64 as u32; let val = val as u8 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 24usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn new_bitfield_1(nWeekDay: ::std::os::raw::c_ushort, @@ -615,14 +823,161 @@ impl Date2 { ({ ({ 0 } | ((nWeekDay as u16 as u32) << 0usize) & - (7usize as u32)) + (7u64 as u32)) } | ((nMonthDay as u16 as u32) << 3usize) & - (504usize as u32)) + (504u64 as u32)) + } | ((nMonth as u16 as u32) << 9usize) & (15872u64 as u32)) + } | ((nYear as u16 as u32) << 16usize) & (16711680u64 as u32)) + } | ((byte as u8 as u32) << 24usize) & (4278190080u64 as u32)) + } +} +#[repr(C)] +#[derive(Debug, Default, Copy)] +pub struct Date3 { + pub _bitfield_1: [u8; 3usize], + pub byte: ::std::os::raw::c_uchar, + pub __bindgen_align: [u16; 0usize], +} +#[test] +fn bindgen_test_layout_Date3() { + assert_eq!(::std::mem::size_of::<Date3>() , 4usize , concat ! ( + "Size of: " , stringify ! ( Date3 ) )); + assert_eq! (::std::mem::align_of::<Date3>() , 2usize , concat ! ( + "Alignment of " , stringify ! ( Date3 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const Date3 ) ) . byte as * const _ as usize } + , 3usize , concat ! ( + "Alignment of field: " , stringify ! ( Date3 ) , "::" , + stringify ! ( byte ) )); +} +impl Clone for Date3 { + fn clone(&self) -> Self { *self } +} +impl Date3 { + #[inline] + pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort { + let mask = 7u64 as u32; + let unit_field_val: u32 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; + let val = (unit_field_val & mask) >> 0usize; + unsafe { ::std::mem::transmute(val as u16) } + } + #[inline] + pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) { + let mask = 7u64 as u32; + let val = val as u16 as u32; + let mut unit_field_val: u32 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 0usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } + } + #[inline] + pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort { + let mask = 504u64 as u32; + let unit_field_val: u32 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; + let val = (unit_field_val & mask) >> 3usize; + unsafe { ::std::mem::transmute(val as u16) } + } + #[inline] + pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) { + let mask = 504u64 as u32; + let val = val as u16 as u32; + let mut unit_field_val: u32 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 3usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } + } + #[inline] + pub fn nMonth(&self) -> ::std::os::raw::c_ushort { + let mask = 15872u64 as u32; + let unit_field_val: u32 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; + let val = (unit_field_val & mask) >> 9usize; + unsafe { ::std::mem::transmute(val as u16) } + } + #[inline] + pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) { + let mask = 15872u64 as u32; + let val = val as u16 as u32; + let mut unit_field_val: u32 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 9usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } + } + #[inline] + pub fn nYear(&self) -> ::std::os::raw::c_ushort { + let mask = 16711680u64 as u32; + let unit_field_val: u32 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; + let val = (unit_field_val & mask) >> 16usize; + unsafe { ::std::mem::transmute(val as u16) } + } + #[inline] + pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) { + let mask = 16711680u64 as u32; + let val = val as u16 as u32; + let mut unit_field_val: u32 = + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; + unit_field_val &= !mask; + unit_field_val |= (val << 16usize) & mask; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } + } + #[inline] + pub fn new_bitfield_1(nWeekDay: ::std::os::raw::c_ushort, + nMonthDay: ::std::os::raw::c_ushort, + nMonth: ::std::os::raw::c_ushort, + nYear: ::std::os::raw::c_ushort) -> u32 { + ({ + ({ + ({ + ({ 0 } | + ((nWeekDay as u16 as u32) << 0usize) & + (7u64 as u32)) } | - ((nMonth as u16 as u32) << 9usize) & - (15872usize as u32)) - } | ((nYear as u16 as u32) << 16usize) & (16711680usize as u32)) - } | ((byte as u8 as u32) << 24usize) & (4278190080usize as u32)) + ((nMonthDay as u16 as u32) << 3usize) & + (504u64 as u32)) + } | ((nMonth as u16 as u32) << 9usize) & (15872u64 as u32)) + } | ((nYear as u16 as u32) << 16usize) & (16711680u64 as u32)) } } diff --git a/tests/expectations/tests/bitfield_align_2.rs b/tests/expectations/tests/bitfield_align_2.rs index f406948c..f0d444a4 100644 --- a/tests/expectations/tests/bitfield_align_2.rs +++ b/tests/expectations/tests/bitfield_align_2.rs @@ -29,44 +29,62 @@ impl Default for TaggedPtr { impl TaggedPtr { #[inline] pub fn tag(&self) -> MyEnum { - let mask = 3usize as u64; + let mask = 3u64 as u64; let unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_tag(&mut self, val: MyEnum) { - let mask = 3usize as u64; + let mask = 3u64 as u64; let val = val as u32 as u64; let mut unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } } #[inline] pub fn ptr(&self) -> ::std::os::raw::c_long { - let mask = 18446744073709551612usize as u64; + let mask = 18446744073709551612u64 as u64; let unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; let val = (unit_field_val & mask) >> 2usize; unsafe { ::std::mem::transmute(val as u64) } } #[inline] pub fn set_ptr(&mut self, val: ::std::os::raw::c_long) { - let mask = 18446744073709551612usize as u64; + let mask = 18446744073709551612u64 as u64; let val = val as u64 as u64; let mut unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; unit_field_val &= !mask; unit_field_val |= (val << 2usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } } #[inline] pub fn new_bitfield_1(tag: MyEnum, ptr: ::std::os::raw::c_long) -> u64 { - ({ ({ 0 } | ((tag as u32 as u64) << 0usize) & (3usize as u64)) } | + ({ ({ 0 } | ((tag as u32 as u64) << 0usize) & (3u64 as u64)) } | ((ptr as u64 as u64) << 2usize) & - (18446744073709551612usize as u64)) + (18446744073709551612u64 as u64)) } } diff --git a/tests/expectations/tests/bitfield_method_mangling.rs b/tests/expectations/tests/bitfield_method_mangling.rs index 314121a9..86c0dd95 100644 --- a/tests/expectations/tests/bitfield_method_mangling.rs +++ b/tests/expectations/tests/bitfield_method_mangling.rs @@ -26,46 +26,62 @@ impl Clone for mach_msg_type_descriptor_t { impl mach_msg_type_descriptor_t { #[inline] pub fn pad3(&self) -> ::std::os::raw::c_uint { - let mask = 16777215usize as u32; + let mask = 16777215u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_pad3(&mut self, val: ::std::os::raw::c_uint) { - let mask = 16777215usize as u32; + let mask = 16777215u64 as u32; let val = val as u32 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn type_(&self) -> ::std::os::raw::c_uint { - let mask = 4278190080usize as u32; + let mask = 4278190080u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 24usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_type(&mut self, val: ::std::os::raw::c_uint) { - let mask = 4278190080usize as u32; + let mask = 4278190080u64 as u32; let val = val as u32 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 24usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn new_bitfield_1(pad3: ::std::os::raw::c_uint, type_: ::std::os::raw::c_uint) -> u32 { - ({ - ({ 0 } | - ((pad3 as u32 as u32) << 0usize) & (16777215usize as u32)) - } | ((type_ as u32 as u32) << 24usize) & (4278190080usize as u32)) + ({ ({ 0 } | ((pad3 as u32 as u32) << 0usize) & (16777215u64 as u32)) } + | ((type_ as u32 as u32) << 24usize) & (4278190080u64 as u32)) } } diff --git a/tests/expectations/tests/jsval_layout_opaque.rs b/tests/expectations/tests/jsval_layout_opaque.rs index 4010b0d8..02e282a6 100644 --- a/tests/expectations/tests/jsval_layout_opaque.rs +++ b/tests/expectations/tests/jsval_layout_opaque.rs @@ -132,49 +132,67 @@ impl Default for jsval_layout__bindgen_ty_1 { impl jsval_layout__bindgen_ty_1 { #[inline] pub fn payload47(&self) -> u64 { - let mask = 140737488355327usize as u64; + let mask = 140737488355327u64 as u64; let unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u64) } } #[inline] pub fn set_payload47(&mut self, val: u64) { - let mask = 140737488355327usize as u64; + let mask = 140737488355327u64 as u64; let val = val as u64 as u64; let mut unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } } #[inline] pub fn tag(&self) -> JSValueTag { - let mask = 18446603336221196288usize as u64; + let mask = 18446603336221196288u64 as u64; let unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; let val = (unit_field_val & mask) >> 47usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_tag(&mut self, val: JSValueTag) { - let mask = 18446603336221196288usize as u64; + let mask = 18446603336221196288u64 as u64; let val = val as u32 as u64; let mut unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; unit_field_val &= !mask; unit_field_val |= (val << 47usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } } #[inline] pub fn new_bitfield_1(payload47: u64, tag: JSValueTag) -> u64 { ({ ({ 0 } | ((payload47 as u64 as u64) << 0usize) & - (140737488355327usize as u64)) + (140737488355327u64 as u64)) } | ((tag as u32 as u64) << 47usize) & - (18446603336221196288usize as u64)) + (18446603336221196288u64 as u64)) } } #[repr(C)] diff --git a/tests/expectations/tests/layout_align.rs b/tests/expectations/tests/layout_align.rs index efcb9753..2a6c08b0 100644 --- a/tests/expectations/tests/layout_align.rs +++ b/tests/expectations/tests/layout_align.rs @@ -92,57 +92,84 @@ impl Clone for rte_eth_link { impl rte_eth_link { #[inline] pub fn link_duplex(&self) -> u16 { - let mask = 1usize as u8; + let mask = 1u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_link_duplex(&mut self, val: u16) { - let mask = 1usize as u8; + let mask = 1u64 as u8; let val = val as u16 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn link_autoneg(&self) -> u16 { - let mask = 2usize as u8; + let mask = 2u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 1usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_link_autoneg(&mut self, val: u16) { - let mask = 2usize as u8; + let mask = 2u64 as u8; let val = val as u16 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 1usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn link_status(&self) -> u16 { - let mask = 4usize as u8; + let mask = 4u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 2usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_link_status(&mut self, val: u16) { - let mask = 4usize as u8; + let mask = 4u64 as u8; let val = val as u16 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 2usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn new_bitfield_1(link_duplex: u16, link_autoneg: u16, @@ -150,9 +177,8 @@ impl rte_eth_link { ({ ({ ({ 0 } | - ((link_duplex as u16 as u8) << 0usize) & - (1usize as u8)) - } | ((link_autoneg as u16 as u8) << 1usize) & (2usize as u8)) - } | ((link_status as u16 as u8) << 2usize) & (4usize as u8)) + ((link_duplex as u16 as u8) << 0usize) & (1u64 as u8)) + } | ((link_autoneg as u16 as u8) << 1usize) & (2u64 as u8)) + } | ((link_status as u16 as u8) << 2usize) & (4u64 as u8)) } } diff --git a/tests/expectations/tests/layout_eth_conf.rs b/tests/expectations/tests/layout_eth_conf.rs index 17ce893b..0c8619ac 100644 --- a/tests/expectations/tests/layout_eth_conf.rs +++ b/tests/expectations/tests/layout_eth_conf.rs @@ -121,165 +121,246 @@ impl Default for rte_eth_rxmode { impl rte_eth_rxmode { #[inline] pub fn header_split(&self) -> u16 { - let mask = 1usize as u16; + let mask = 1u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_header_split(&mut self, val: u16) { - let mask = 1usize as u16; + let mask = 1u64 as u16; let val = val as u16 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn hw_ip_checksum(&self) -> u16 { - let mask = 2usize as u16; + let mask = 2u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 1usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_hw_ip_checksum(&mut self, val: u16) { - let mask = 2usize as u16; + let mask = 2u64 as u16; let val = val as u16 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 1usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn hw_vlan_filter(&self) -> u16 { - let mask = 4usize as u16; + let mask = 4u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 2usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_hw_vlan_filter(&mut self, val: u16) { - let mask = 4usize as u16; + let mask = 4u64 as u16; let val = val as u16 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 2usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn hw_vlan_strip(&self) -> u16 { - let mask = 8usize as u16; + let mask = 8u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 3usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_hw_vlan_strip(&mut self, val: u16) { - let mask = 8usize as u16; + let mask = 8u64 as u16; let val = val as u16 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 3usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn hw_vlan_extend(&self) -> u16 { - let mask = 16usize as u16; + let mask = 16u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 4usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_hw_vlan_extend(&mut self, val: u16) { - let mask = 16usize as u16; + let mask = 16u64 as u16; let val = val as u16 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 4usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn jumbo_frame(&self) -> u16 { - let mask = 32usize as u16; + let mask = 32u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 5usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_jumbo_frame(&mut self, val: u16) { - let mask = 32usize as u16; + let mask = 32u64 as u16; let val = val as u16 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 5usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn hw_strip_crc(&self) -> u16 { - let mask = 64usize as u16; + let mask = 64u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 6usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_hw_strip_crc(&mut self, val: u16) { - let mask = 64usize as u16; + let mask = 64u64 as u16; let val = val as u16 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 6usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn enable_scatter(&self) -> u16 { - let mask = 128usize as u16; + let mask = 128u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 7usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_enable_scatter(&mut self, val: u16) { - let mask = 128usize as u16; + let mask = 128u64 as u16; let val = val as u16 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 7usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn enable_lro(&self) -> u16 { - let mask = 256usize as u16; + let mask = 256u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 8usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_enable_lro(&mut self, val: u16) { - let mask = 256usize as u16; + let mask = 256u64 as u16; let val = val as u16 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 8usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn new_bitfield_1(header_split: u16, hw_ip_checksum: u16, @@ -298,30 +379,30 @@ impl rte_eth_rxmode { ({ 0 } | ((header_split as u16 as u16) << 0usize) & - (1usize as u16)) + (1u64 as u16)) } | ((hw_ip_checksum as u16 as u16) << 1usize) & - (2usize as u16)) + (2u64 as u16)) } | ((hw_vlan_filter as u16 as u16) << - 2usize) & (4usize as u16)) + 2usize) & (4u64 as u16)) } | ((hw_vlan_strip as u16 as u16) << - 3usize) & (8usize as u16)) + 3usize) & (8u64 as u16)) } | ((hw_vlan_extend as u16 as u16) << 4usize) & - (16usize as u16)) + (16u64 as u16)) } | ((jumbo_frame as u16 as u16) << 5usize) & - (32usize as u16)) + (32u64 as u16)) } | ((hw_strip_crc as u16 as u16) << 6usize) & - (64usize as u16)) + (64u64 as u16)) } | ((enable_scatter as u16 as u16) << 7usize) & - (128usize as u16)) - } | ((enable_lro as u16 as u16) << 8usize) & (256usize as u16)) + (128u64 as u16)) + } | ((enable_lro as u16 as u16) << 8usize) & (256u64 as u16)) } } #[repr(u32)] @@ -374,57 +455,84 @@ impl Default for rte_eth_txmode { impl rte_eth_txmode { #[inline] pub fn hw_vlan_reject_tagged(&self) -> u8 { - let mask = 1usize as u8; + let mask = 1u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u8) } } #[inline] pub fn set_hw_vlan_reject_tagged(&mut self, val: u8) { - let mask = 1usize as u8; + let mask = 1u64 as u8; let val = val as u8 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn hw_vlan_reject_untagged(&self) -> u8 { - let mask = 2usize as u8; + let mask = 2u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 1usize; unsafe { ::std::mem::transmute(val as u8) } } #[inline] pub fn set_hw_vlan_reject_untagged(&mut self, val: u8) { - let mask = 2usize as u8; + let mask = 2u64 as u8; let val = val as u8 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 1usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn hw_vlan_insert_pvid(&self) -> u8 { - let mask = 4usize as u8; + let mask = 4u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 2usize; unsafe { ::std::mem::transmute(val as u8) } } #[inline] pub fn set_hw_vlan_insert_pvid(&mut self, val: u8) { - let mask = 4usize as u8; + let mask = 4u64 as u8; let val = val as u8 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 2usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn new_bitfield_1(hw_vlan_reject_tagged: u8, @@ -434,11 +542,11 @@ impl rte_eth_txmode { ({ ({ 0 } | ((hw_vlan_reject_tagged as u8 as u8) << 0usize) & - (1usize as u8)) + (1u64 as u8)) } | ((hw_vlan_reject_untagged as u8 as u8) << 1usize) & - (2usize as u8)) - } | ((hw_vlan_insert_pvid as u8 as u8) << 2usize) & (4usize as u8)) + (2u64 as u8)) + } | ((hw_vlan_insert_pvid as u8 as u8) << 2usize) & (4u64 as u8)) } } /** diff --git a/tests/expectations/tests/layout_mbuf.rs b/tests/expectations/tests/layout_mbuf.rs index e0e95a1f..faf9002f 100644 --- a/tests/expectations/tests/layout_mbuf.rs +++ b/tests/expectations/tests/layout_mbuf.rs @@ -178,129 +178,192 @@ impl Clone for rte_mbuf__bindgen_ty_2__bindgen_ty_1 { impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 { #[inline] pub fn l2_type(&self) -> u32 { - let mask = 15usize as u32; + let mask = 15u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_l2_type(&mut self, val: u32) { - let mask = 15usize as u32; + let mask = 15u64 as u32; let val = val as u32 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn l3_type(&self) -> u32 { - let mask = 240usize as u32; + let mask = 240u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 4usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_l3_type(&mut self, val: u32) { - let mask = 240usize as u32; + let mask = 240u64 as u32; let val = val as u32 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 4usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn l4_type(&self) -> u32 { - let mask = 3840usize as u32; + let mask = 3840u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 8usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_l4_type(&mut self, val: u32) { - let mask = 3840usize as u32; + let mask = 3840u64 as u32; let val = val as u32 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 8usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn tun_type(&self) -> u32 { - let mask = 61440usize as u32; + let mask = 61440u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 12usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_tun_type(&mut self, val: u32) { - let mask = 61440usize as u32; + let mask = 61440u64 as u32; let val = val as u32 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 12usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn inner_l2_type(&self) -> u32 { - let mask = 983040usize as u32; + let mask = 983040u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 16usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_inner_l2_type(&mut self, val: u32) { - let mask = 983040usize as u32; + let mask = 983040u64 as u32; let val = val as u32 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 16usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn inner_l3_type(&self) -> u32 { - let mask = 15728640usize as u32; + let mask = 15728640u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 20usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_inner_l3_type(&mut self, val: u32) { - let mask = 15728640usize as u32; + let mask = 15728640u64 as u32; let val = val as u32 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 20usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn inner_l4_type(&self) -> u32 { - let mask = 251658240usize as u32; + let mask = 251658240u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 24usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_inner_l4_type(&mut self, val: u32) { - let mask = 251658240usize as u32; + let mask = 251658240u64 as u32; let val = val as u32 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 24usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn new_bitfield_1(l2_type: u32, l3_type: u32, l4_type: u32, @@ -314,25 +377,25 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 { ({ ({ 0 } | ((l2_type as u32 as u32) << 0usize) - & (15usize as u32)) + & (15u64 as u32)) } | ((l3_type as u32 as u32) << 4usize) & - (240usize as u32)) + (240u64 as u32)) } | ((l4_type as u32 as u32) << 8usize) & - (3840usize as u32)) + (3840u64 as u32)) } | ((tun_type as u32 as u32) << 12usize) & - (61440usize as u32)) + (61440u64 as u32)) } | ((inner_l2_type as u32 as u32) << 16usize) & - (983040usize as u32)) + (983040u64 as u32)) } | ((inner_l3_type as u32 as u32) << 20usize) & - (15728640usize as u32)) + (15728640u64 as u32)) } | ((inner_l4_type as u32 as u32) << 24usize) & - (251658240usize as u32)) + (251658240u64 as u32)) } } #[test] @@ -588,111 +651,165 @@ impl Clone for rte_mbuf__bindgen_ty_5__bindgen_ty_1 { impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 { #[inline] pub fn l2_len(&self) -> u64 { - let mask = 127usize as u64; + let mask = 127u64 as u64; let unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u64) } } #[inline] pub fn set_l2_len(&mut self, val: u64) { - let mask = 127usize as u64; + let mask = 127u64 as u64; let val = val as u64 as u64; let mut unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } } #[inline] pub fn l3_len(&self) -> u64 { - let mask = 65408usize as u64; + let mask = 65408u64 as u64; let unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; let val = (unit_field_val & mask) >> 7usize; unsafe { ::std::mem::transmute(val as u64) } } #[inline] pub fn set_l3_len(&mut self, val: u64) { - let mask = 65408usize as u64; + let mask = 65408u64 as u64; let val = val as u64 as u64; let mut unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; unit_field_val &= !mask; unit_field_val |= (val << 7usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } } #[inline] pub fn l4_len(&self) -> u64 { - let mask = 16711680usize as u64; + let mask = 16711680u64 as u64; let unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; let val = (unit_field_val & mask) >> 16usize; unsafe { ::std::mem::transmute(val as u64) } } #[inline] pub fn set_l4_len(&mut self, val: u64) { - let mask = 16711680usize as u64; + let mask = 16711680u64 as u64; let val = val as u64 as u64; let mut unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; unit_field_val &= !mask; unit_field_val |= (val << 16usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } } #[inline] pub fn tso_segsz(&self) -> u64 { - let mask = 1099494850560usize as u64; + let mask = 1099494850560u64 as u64; let unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; let val = (unit_field_val & mask) >> 24usize; unsafe { ::std::mem::transmute(val as u64) } } #[inline] pub fn set_tso_segsz(&mut self, val: u64) { - let mask = 1099494850560usize as u64; + let mask = 1099494850560u64 as u64; let val = val as u64 as u64; let mut unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; unit_field_val &= !mask; unit_field_val |= (val << 24usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } } #[inline] pub fn outer_l3_len(&self) -> u64 { - let mask = 561850441793536usize as u64; + let mask = 561850441793536u64 as u64; let unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; let val = (unit_field_val & mask) >> 40usize; unsafe { ::std::mem::transmute(val as u64) } } #[inline] pub fn set_outer_l3_len(&mut self, val: u64) { - let mask = 561850441793536usize as u64; + let mask = 561850441793536u64 as u64; let val = val as u64 as u64; let mut unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; unit_field_val &= !mask; unit_field_val |= (val << 40usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } } #[inline] pub fn outer_l2_len(&self) -> u64 { - let mask = 71494644084506624usize as u64; + let mask = 71494644084506624u64 as u64; let unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; let val = (unit_field_val & mask) >> 49usize; unsafe { ::std::mem::transmute(val as u64) } } #[inline] pub fn set_outer_l2_len(&mut self, val: u64) { - let mask = 71494644084506624usize as u64; + let mask = 71494644084506624u64 as u64; let val = val as u64 as u64; let mut unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u64) + }; unit_field_val &= !mask; unit_field_val |= (val << 49usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u64, unit_field_val); + } } #[inline] pub fn new_bitfield_1(l2_len: u64, l3_len: u64, l4_len: u64, @@ -705,22 +822,22 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 { ({ ({ 0 } | ((l2_len as u64 as u64) << 0usize) & - (127usize as u64)) + (127u64 as u64)) } | ((l3_len as u64 as u64) << 7usize) & - (65408usize as u64)) + (65408u64 as u64)) } | ((l4_len as u64 as u64) << 16usize) & - (16711680usize as u64)) + (16711680u64 as u64)) } | ((tso_segsz as u64 as u64) << 24usize) & - (1099494850560usize as u64)) + (1099494850560u64 as u64)) } | ((outer_l3_len as u64 as u64) << 40usize) & - (561850441793536usize as u64)) + (561850441793536u64 as u64)) } | ((outer_l2_len as u64 as u64) << 49usize) & - (71494644084506624usize as u64)) + (71494644084506624u64 as u64)) } } #[test] diff --git a/tests/expectations/tests/only_bitfields.rs b/tests/expectations/tests/only_bitfields.rs index a47a466c..6e4d6270 100644 --- a/tests/expectations/tests/only_bitfields.rs +++ b/tests/expectations/tests/only_bitfields.rs @@ -23,43 +23,61 @@ impl Clone for C { impl C { #[inline] pub fn a(&self) -> bool { - let mask = 1usize as u8; + let mask = 1u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u8) } } #[inline] pub fn set_a(&mut self, val: bool) { - let mask = 1usize as u8; + let mask = 1u64 as u8; let val = val as u8 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn b(&self) -> bool { - let mask = 254usize as u8; + let mask = 254u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 1usize; unsafe { ::std::mem::transmute(val as u8) } } #[inline] pub fn set_b(&mut self, val: bool) { - let mask = 254usize as u8; + let mask = 254u64 as u8; let val = val as u8 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 1usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn new_bitfield_1(a: bool, b: bool) -> u8 { - ({ ({ 0 } | ((a as u8 as u8) << 0usize) & (1usize as u8)) } | - ((b as u8 as u8) << 1usize) & (254usize as u8)) + ({ ({ 0 } | ((a as u8 as u8) << 0usize) & (1u64 as u8)) } | + ((b as u8 as u8) << 1usize) & (254u64 as u8)) } } diff --git a/tests/expectations/tests/struct_with_bitfields.rs b/tests/expectations/tests/struct_with_bitfields.rs index 44681d2e..2c6a5f2b 100644 --- a/tests/expectations/tests/struct_with_bitfields.rs +++ b/tests/expectations/tests/struct_with_bitfields.rs @@ -29,75 +29,111 @@ impl Clone for bitfield { impl bitfield { #[inline] pub fn a(&self) -> ::std::os::raw::c_ushort { - let mask = 1usize as u8; + let mask = 1u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_a(&mut self, val: ::std::os::raw::c_ushort) { - let mask = 1usize as u8; + let mask = 1u64 as u8; let val = val as u16 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn b(&self) -> ::std::os::raw::c_ushort { - let mask = 2usize as u8; + let mask = 2u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 1usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_b(&mut self, val: ::std::os::raw::c_ushort) { - let mask = 2usize as u8; + let mask = 2u64 as u8; let val = val as u16 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 1usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn c(&self) -> ::std::os::raw::c_ushort { - let mask = 4usize as u8; + let mask = 4u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 2usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_c(&mut self, val: ::std::os::raw::c_ushort) { - let mask = 4usize as u8; + let mask = 4u64 as u8; let val = val as u16 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 2usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn d(&self) -> ::std::os::raw::c_ushort { - let mask = 192usize as u8; + let mask = 192u64 as u8; let unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; let val = (unit_field_val & mask) >> 6usize; unsafe { ::std::mem::transmute(val as u16) } } #[inline] pub fn set_d(&mut self, val: ::std::os::raw::c_ushort) { - let mask = 192usize as u8; + let mask = 192u64 as u8; let val = val as u16 as u8; let mut unit_field_val: u8 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u8) + }; unit_field_val &= !mask; unit_field_val |= (val << 6usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u8, unit_field_val); + } } #[inline] pub fn new_bitfield_1(a: ::std::os::raw::c_ushort, @@ -106,52 +142,70 @@ impl bitfield { d: ::std::os::raw::c_ushort) -> u8 { ({ ({ - ({ ({ 0 } | ((a as u16 as u8) << 0usize) & (1usize as u8)) } - | ((b as u16 as u8) << 1usize) & (2usize as u8)) - } | ((c as u16 as u8) << 2usize) & (4usize as u8)) - } | ((d as u16 as u8) << 6usize) & (192usize as u8)) + ({ ({ 0 } | ((a as u16 as u8) << 0usize) & (1u64 as u8)) } | + ((b as u16 as u8) << 1usize) & (2u64 as u8)) + } | ((c as u16 as u8) << 2usize) & (4u64 as u8)) + } | ((d as u16 as u8) << 6usize) & (192u64 as u8)) } #[inline] pub fn f(&self) -> ::std::os::raw::c_uint { - let mask = 3usize as u64; + let mask = 3u64 as u64; let unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_2) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as + *const u64) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_f(&mut self, val: ::std::os::raw::c_uint) { - let mask = 3usize as u64; + let mask = 3u64 as u64; let val = val as u32 as u64; let mut unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_2) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as + *const u64) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as + *mut u64, unit_field_val); + } } #[inline] pub fn g(&self) -> ::std::os::raw::c_uint { - let mask = 18446744069414584320usize as u64; + let mask = 18446744069414584320u64 as u64; let unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_2) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as + *const u64) + }; let val = (unit_field_val & mask) >> 32usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_g(&mut self, val: ::std::os::raw::c_uint) { - let mask = 18446744069414584320usize as u64; + let mask = 18446744069414584320u64 as u64; let val = val as u32 as u64; let mut unit_field_val: u64 = - unsafe { ::std::mem::transmute(self._bitfield_2) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as + *const u64) + }; unit_field_val &= !mask; unit_field_val |= (val << 32usize) & mask; - self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as + *mut u64, unit_field_val); + } } #[inline] pub fn new_bitfield_2(f: ::std::os::raw::c_uint, g: ::std::os::raw::c_uint) -> u64 { - ({ ({ 0 } | ((f as u32 as u64) << 0usize) & (3usize as u64)) } | + ({ ({ 0 } | ((f as u32 as u64) << 0usize) & (3u64 as u64)) } | ((g as u32 as u64) << 32usize) & - (18446744069414584320usize as u64)) + (18446744069414584320u64 as u64)) } } diff --git a/tests/expectations/tests/union_with_anon_struct_bitfield.rs b/tests/expectations/tests/union_with_anon_struct_bitfield.rs index cf3ab206..a60d1115 100644 --- a/tests/expectations/tests/union_with_anon_struct_bitfield.rs +++ b/tests/expectations/tests/union_with_anon_struct_bitfield.rs @@ -54,45 +54,63 @@ impl Clone for foo__bindgen_ty_1 { impl foo__bindgen_ty_1 { #[inline] pub fn b(&self) -> ::std::os::raw::c_int { - let mask = 127usize as u32; + let mask = 127u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_b(&mut self, val: ::std::os::raw::c_int) { - let mask = 127usize as u32; + let mask = 127u64 as u32; let val = val as u32 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn c(&self) -> ::std::os::raw::c_int { - let mask = 4294967168usize as u32; + let mask = 4294967168u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 7usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_c(&mut self, val: ::std::os::raw::c_int) { - let mask = 4294967168usize as u32; + let mask = 4294967168u64 as u32; let val = val as u32 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 7usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn new_bitfield_1(b: ::std::os::raw::c_int, c: ::std::os::raw::c_int) -> u32 { - ({ ({ 0 } | ((b as u32 as u32) << 0usize) & (127usize as u32)) } | - ((c as u32 as u32) << 7usize) & (4294967168usize as u32)) + ({ ({ 0 } | ((b as u32 as u32) << 0usize) & (127u64 as u32)) } | + ((c as u32 as u32) << 7usize) & (4294967168u64 as u32)) } } #[test] diff --git a/tests/expectations/tests/weird_bitfields.rs b/tests/expectations/tests/weird_bitfields.rs index 2fb9cbc5..5b85c4e3 100644 --- a/tests/expectations/tests/weird_bitfields.rs +++ b/tests/expectations/tests/weird_bitfields.rs @@ -106,137 +106,198 @@ impl Default for Weird { impl Weird { #[inline] pub fn bitTest(&self) -> ::std::os::raw::c_uint { - let mask = 65535usize as u32; + let mask = 65535u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_bitTest(&mut self, val: ::std::os::raw::c_uint) { - let mask = 65535usize as u32; + let mask = 65535u64 as u32; let val = val as u32 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn bitTest2(&self) -> ::std::os::raw::c_uint { - let mask = 2147418112usize as u32; + let mask = 2147418112u64 as u32; let unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; let val = (unit_field_val & mask) >> 16usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_bitTest2(&mut self, val: ::std::os::raw::c_uint) { - let mask = 2147418112usize as u32; + let mask = 2147418112u64 as u32; let val = val as u32 as u32; let mut unit_field_val: u32 = - unsafe { ::std::mem::transmute(self._bitfield_1) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as + *const u32) + }; unit_field_val &= !mask; unit_field_val |= (val << 16usize) & mask; - self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as + *mut u32, unit_field_val); + } } #[inline] pub fn new_bitfield_1(bitTest: ::std::os::raw::c_uint, bitTest2: ::std::os::raw::c_uint) -> u32 { - ({ - ({ 0 } | - ((bitTest as u32 as u32) << 0usize) & (65535usize as u32)) - } | ((bitTest2 as u32 as u32) << 16usize) & (2147418112usize as u32)) + ({ ({ 0 } | ((bitTest as u32 as u32) << 0usize) & (65535u64 as u32)) } + | ((bitTest2 as u32 as u32) << 16usize) & (2147418112u64 as u32)) } #[inline] pub fn mFillOpacitySource(&self) -> nsStyleSVGOpacitySource { - let mask = 7usize as u16; + let mask = 7u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_2) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 0usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_mFillOpacitySource(&mut self, val: nsStyleSVGOpacitySource) { - let mask = 7usize as u16; + let mask = 7u64 as u16; let val = val as u32 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_2) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; - self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn mStrokeOpacitySource(&self) -> nsStyleSVGOpacitySource { - let mask = 56usize as u16; + let mask = 56u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_2) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 3usize; unsafe { ::std::mem::transmute(val as u32) } } #[inline] pub fn set_mStrokeOpacitySource(&mut self, val: nsStyleSVGOpacitySource) { - let mask = 56usize as u16; + let mask = 56u64 as u16; let val = val as u32 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_2) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 3usize) & mask; - self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn mStrokeDasharrayFromObject(&self) -> bool { - let mask = 64usize as u16; + let mask = 64u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_2) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 6usize; unsafe { ::std::mem::transmute(val as u8) } } #[inline] pub fn set_mStrokeDasharrayFromObject(&mut self, val: bool) { - let mask = 64usize as u16; + let mask = 64u64 as u16; let val = val as u8 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_2) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 6usize) & mask; - self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn mStrokeDashoffsetFromObject(&self) -> bool { - let mask = 128usize as u16; + let mask = 128u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_2) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 7usize; unsafe { ::std::mem::transmute(val as u8) } } #[inline] pub fn set_mStrokeDashoffsetFromObject(&mut self, val: bool) { - let mask = 128usize as u16; + let mask = 128u64 as u16; let val = val as u8 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_2) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 7usize) & mask; - self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn mStrokeWidthFromObject(&self) -> bool { - let mask = 256usize as u16; + let mask = 256u64 as u16; let unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_2) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as + *const u16) + }; let val = (unit_field_val & mask) >> 8usize; unsafe { ::std::mem::transmute(val as u8) } } #[inline] pub fn set_mStrokeWidthFromObject(&mut self, val: bool) { - let mask = 256usize as u16; + let mask = 256u64 as u16; let val = val as u8 as u16; let mut unit_field_val: u16 = - unsafe { ::std::mem::transmute(self._bitfield_2) }; + unsafe { + ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as + *const u16) + }; unit_field_val &= !mask; unit_field_val |= (val << 8usize) & mask; - self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) }; + unsafe { + ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as + *mut u16, unit_field_val); + } } #[inline] pub fn new_bitfield_2(mFillOpacitySource: nsStyleSVGOpacitySource, @@ -250,18 +311,18 @@ impl Weird { ({ ({ 0 } | ((mFillOpacitySource as u32 as u16) << - 0usize) & (7usize as u16)) + 0usize) & (7u64 as u16)) } | ((mStrokeOpacitySource as u32 as u16) << 3usize) & - (56usize as u16)) + (56u64 as u16)) } | ((mStrokeDasharrayFromObject as u8 as u16) << 6usize) & - (64usize as u16)) + (64u64 as u16)) } | ((mStrokeDashoffsetFromObject as u8 as u16) << 7usize) & - (128usize as u16)) + (128u64 as u16)) } | ((mStrokeWidthFromObject as u8 as u16) << 8usize) & - (256usize as u16)) + (256u64 as u16)) } } diff --git a/tests/headers/bitfield-32bit-overflow.h b/tests/headers/bitfield-32bit-overflow.h new file mode 100644 index 00000000..90796996 --- /dev/null +++ b/tests/headers/bitfield-32bit-overflow.h @@ -0,0 +1,36 @@ + +struct MuchBitfield { + char m0 : 1; + char m1 : 1; + char m2 : 1; + char m3 : 1; + char m4 : 1; + char m5 : 1; + char m6 : 1; + char m7 : 1; + char m8 : 1; + char m9 : 1; + char m10 : 1; + char m11 : 1; + char m12 : 1; + char m13 : 1; + char m14 : 1; + char m15 : 1; + char m16 : 1; + char m17 : 1; + char m18 : 1; + char m19 : 1; + char m20 : 1; + char m21 : 1; + char m22 : 1; + char m23 : 1; + char m24 : 1; + char m25 : 1; + char m26 : 1; + char m27 : 1; + char m28 : 1; + char m29 : 1; + char m30 : 1; + char m31 : 1; + char m32 : 1; +}; diff --git a/tests/headers/bitfield_align.h b/tests/headers/bitfield_align.h index 5316b697..7b9527a2 100644 --- a/tests/headers/bitfield_align.h +++ b/tests/headers/bitfield_align.h @@ -40,12 +40,10 @@ struct Date2 { unsigned char byte : 8; }; -// FIXME(#734) -// -// struct Date3 { -// unsigned short nWeekDay : 3; // 0..7 (3 bits) -// unsigned short nMonthDay : 6; // 0..31 (6 bits) -// unsigned short nMonth : 5; // 0..12 (5 bits) -// unsigned short nYear : 8; // 0..100 (8 bits) -// unsigned char byte; -// }; +struct Date3 { + unsigned short nWeekDay : 3; // 0..7 (3 bits) + unsigned short nMonthDay : 6; // 0..31 (6 bits) + unsigned short nMonth : 5; // 0..12 (5 bits) + unsigned short nYear : 8; // 0..100 (8 bits) + unsigned char byte; +}; |