diff options
| author | bors-servo <lbergstrom+bors@mozilla.com> | 2017-06-20 14:14:52 -0700 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2017-06-20 14:14:52 -0700 |
| commit | 49526069a0cb9486cb4838134259589addafff40 (patch) | |
| tree | 0b4783bfdcdb734a1c110837d442d6d3ec4f5db3 | |
| parent | a99bbd865e813143a81d29fac8cb46acd5bf6141 (diff) | |
| parent | 30dc9daa7addb26ff127b3c6a368bdb7ebdc680a (diff) | |
Auto merge of #772 - emilio:ff, r=fitzgenv0.26.1
codegen: Inline {read,write}_unaligned in order to support rust 1.15.
| -rw-r--r-- | Cargo.lock | 2 | ||||
| -rw-r--r-- | Cargo.toml | 2 | ||||
| -rw-r--r-- | src/codegen/mod.rs | 33 | ||||
| -rw-r--r-- | tests/expectations/tests/bitfield-32bit-overflow.rs | 1089 | ||||
| -rw-r--r-- | tests/expectations/tests/bitfield-method-same-name.rs | 33 | ||||
| -rw-r--r-- | tests/expectations/tests/bitfield_align.rs | 891 | ||||
| -rw-r--r-- | tests/expectations/tests/bitfield_align_2.rs | 66 | ||||
| -rw-r--r-- | tests/expectations/tests/bitfield_method_mangling.rs | 66 | ||||
| -rw-r--r-- | tests/expectations/tests/jsval_layout_opaque.rs | 66 | ||||
| -rw-r--r-- | tests/expectations/tests/layout_align.rs | 99 | ||||
| -rw-r--r-- | tests/expectations/tests/layout_eth_conf.rs | 396 | ||||
| -rw-r--r-- | tests/expectations/tests/layout_mbuf.rs | 429 | ||||
| -rw-r--r-- | tests/expectations/tests/only_bitfields.rs | 66 | ||||
| -rw-r--r-- | tests/expectations/tests/struct_with_bitfields.rs | 198 | ||||
| -rw-r--r-- | tests/expectations/tests/union_with_anon_struct_bitfield.rs | 66 | ||||
| -rw-r--r-- | tests/expectations/tests/weird_bitfields.rs | 231 |
16 files changed, 2378 insertions, 1355 deletions
@@ -1,6 +1,6 @@ [root] name = "bindgen" -version = "0.26.0" +version = "0.26.1" dependencies = [ "aster 0.41.0 (registry+https://github.com/rust-lang/crates.io-index)", "cexpr 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -13,7 +13,7 @@ name = "bindgen" readme = "README.md" repository = "https://github.com/servo/rust-bindgen" documentation = "https://docs.rs/bindgen" -version = "0.26.0" +version = "0.26.1" build = "build.rs" exclude = [ diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs index 4f0ea371..2d60d0e8 100644 --- a/src/codegen/mod.rs +++ b/src/codegen/mod.rs @@ -1286,12 +1286,19 @@ impl<'a> FieldCodegen<'a> for Bitfield { impl XxxIgnored { #[inline] 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::ptr::read_unaligned( - &self.$unit_field_ident as *const _ as *const $unit_field_int_ty + let mut unit_field_val: $unit_field_int_ty = unsafe { + ::$prefix::mem::uninitialized() + }; + + unsafe { + ::$prefix::ptr::copy_nonoverlapping( + &self.$unit_field_ident as *const _ as *const u8, + &mut unit_field_val as *mut $unit_field_int_ty as *mut u8, + ::$prefix::mem::size_of::<$unit_field_int_ty>(), ) }; + + let mask = $mask as $unit_field_int_ty; let val = (unit_field_val & mask) >> $offset; unsafe { ::$prefix::mem::transmute(val as $bitfield_int_ty) @@ -1304,17 +1311,25 @@ 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::ptr::read_unaligned( - &self.$unit_field_ident as *const _ as *const $unit_field_int_ty) + ::$prefix::mem::uninitialized() + }; + + unsafe { + ::$prefix::ptr::copy_nonoverlapping( + &self.$unit_field_ident as *const _ as *const u8, + &mut unit_field_val as *mut $unit_field_int_ty as *mut u8, + ::$prefix::mem::size_of::<$unit_field_int_ty>(), + ) }; unit_field_val &= !mask; unit_field_val |= (val << $offset) & mask; unsafe { - ::$prefix::ptr::write_unaligned( - &mut self.$unit_field_ident as *mut _ as *mut $unit_field_int_ty, - unit_field_val + ::$prefix::ptr::copy_nonoverlapping( + &unit_field_val as *const _ as *const u8, + &mut self.$unit_field_ident as *mut _ as *mut u8, + ::$prefix::mem::size_of::<$unit_field_int_ty>(), ); } } diff --git a/tests/expectations/tests/bitfield-32bit-overflow.rs b/tests/expectations/tests/bitfield-32bit-overflow.rs index ff11d5bc..d179ddf9 100644 --- a/tests/expectations/tests/bitfield-32bit-overflow.rs +++ b/tests/expectations/tests/bitfield-32bit-overflow.rs @@ -23,12 +23,15 @@ impl Clone for MuchBitfield { impl MuchBitfield { #[inline] pub fn m0(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -36,26 +39,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m1(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -63,26 +75,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m2(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -90,26 +111,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m3(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -117,26 +147,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m4(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -144,26 +183,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m5(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -171,26 +219,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m6(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -198,26 +255,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m7(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -225,26 +291,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m8(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -252,26 +327,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m9(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -279,26 +363,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m10(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -306,26 +399,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m11(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -333,26 +435,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m12(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -360,26 +471,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m13(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -387,26 +507,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m14(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -414,26 +543,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m15(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -441,26 +579,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m16(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -468,26 +615,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m17(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -495,26 +651,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m18(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -522,26 +687,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m19(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -549,26 +723,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m20(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -576,26 +759,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m21(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -603,26 +795,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m22(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -630,26 +831,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m23(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -657,26 +867,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m24(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -684,26 +903,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m25(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -711,26 +939,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m26(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -738,26 +975,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m27(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -765,26 +1011,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m28(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -792,26 +1047,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m29(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -819,26 +1083,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m30(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -846,26 +1119,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m31(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -873,26 +1155,35 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn m32(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; 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) } } @@ -900,16 +1191,22 @@ impl MuchBitfield { 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) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] diff --git a/tests/expectations/tests/bitfield-method-same-name.rs b/tests/expectations/tests/bitfield-method-same-name.rs index 74dd11e2..dd6b286f 100644 --- a/tests/expectations/tests/bitfield-method-same-name.rs +++ b/tests/expectations/tests/bitfield-method-same-name.rs @@ -35,12 +35,15 @@ impl Clone for Foo { impl Foo { #[inline] pub fn type__bindgen_bitfield(&self) -> ::std::os::raw::c_char { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 7u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -49,16 +52,22 @@ impl Foo { val: ::std::os::raw::c_char) { let mask = 7u64 as u8; let val = val as u8 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] diff --git a/tests/expectations/tests/bitfield_align.rs b/tests/expectations/tests/bitfield_align.rs index 233ae5ab..e2db1329 100644 --- a/tests/expectations/tests/bitfield_align.rs +++ b/tests/expectations/tests/bitfield_align.rs @@ -33,12 +33,15 @@ impl Clone for A { impl A { #[inline] pub fn b1(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 1u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -46,26 +49,35 @@ impl A { pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) { let mask = 1u64 as u16; let val = val as u32 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn b2(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 2u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -73,26 +85,35 @@ impl A { pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) { let mask = 2u64 as u16; let val = val as u32 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 1usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn b3(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 4u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -100,26 +121,35 @@ impl A { pub fn set_b3(&mut self, val: ::std::os::raw::c_uint) { let mask = 4u64 as u16; let val = val as u32 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 2usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn b4(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 8u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -127,26 +157,35 @@ impl A { pub fn set_b4(&mut self, val: ::std::os::raw::c_uint) { let mask = 8u64 as u16; let val = val as u32 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 3usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn b5(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 16u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -154,26 +193,35 @@ impl A { pub fn set_b5(&mut self, val: ::std::os::raw::c_uint) { let mask = 16u64 as u16; let val = val as u32 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 4usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn b6(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 32u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -181,26 +229,35 @@ impl A { pub fn set_b6(&mut self, val: ::std::os::raw::c_uint) { let mask = 32u64 as u16; let val = val as u32 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 5usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn b7(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 64u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -208,26 +265,35 @@ impl A { pub fn set_b7(&mut self, val: ::std::os::raw::c_uint) { let mask = 64u64 as u16; let val = val as u32 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 6usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn b8(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 128u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -235,26 +301,35 @@ impl A { pub fn set_b8(&mut self, val: ::std::os::raw::c_uint) { let mask = 128u64 as u16; let val = val as u32 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 7usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn b9(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 256u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -262,26 +337,35 @@ impl A { pub fn set_b9(&mut self, val: ::std::os::raw::c_uint) { let mask = 256u64 as u16; let val = val as u32 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 8usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn b10(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 512u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -289,16 +373,22 @@ impl A { pub fn set_b10(&mut self, val: ::std::os::raw::c_uint) { let mask = 512u64 as u16; let val = val as u32 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 9usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] @@ -366,12 +456,15 @@ impl Clone for B { impl B { #[inline] pub fn foo(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 2147483647u64 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 u32) } } @@ -379,26 +472,35 @@ impl B { pub fn set_foo(&mut self, val: ::std::os::raw::c_uint) { let mask = 2147483647u64 as u32; let val = val as u32 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn bar(&self) -> ::std::os::raw::c_uchar { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 2147483648u64 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) >> 31usize; unsafe { ::std::mem::transmute(val as u8) } } @@ -406,16 +508,22 @@ impl B { pub fn set_bar(&mut self, val: ::std::os::raw::c_uchar) { let mask = 2147483648u64 as u32; let val = val as u8 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 31usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u32, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] @@ -456,12 +564,15 @@ impl Clone for C { impl C { #[inline] pub fn b1(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 1u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -469,26 +580,35 @@ impl C { pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) { let mask = 1u64 as u8; let val = val as u32 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] pub fn b2(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 2u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -496,16 +616,22 @@ impl C { pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) { let mask = 2u64 as u8; let val = val as u32 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 1usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] @@ -535,12 +661,15 @@ impl Clone for Date1 { impl Date1 { #[inline] pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; 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) } } @@ -548,26 +677,35 @@ impl Date1 { 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) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; 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) } } @@ -575,26 +713,35 @@ impl Date1 { 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) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn nMonth(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; 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) } } @@ -602,26 +749,35 @@ impl Date1 { 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) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn nYear(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; 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) } } @@ -629,16 +785,22 @@ impl Date1 { 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) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] @@ -678,12 +840,15 @@ impl Clone for Date2 { impl Date2 { #[inline] pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; 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) } } @@ -691,26 +856,35 @@ impl Date2 { 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) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; 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) } } @@ -718,26 +892,35 @@ impl Date2 { 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) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn nMonth(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; 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) } } @@ -745,26 +928,35 @@ impl Date2 { 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) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn nYear(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; 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) } } @@ -772,26 +964,35 @@ impl Date2 { 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) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn byte(&self) -> ::std::os::raw::c_uchar { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 4278190080u64 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) >> 24usize; unsafe { ::std::mem::transmute(val as u8) } } @@ -799,16 +1000,22 @@ impl Date2 { pub fn set_byte(&mut self, val: ::std::os::raw::c_uchar) { let mask = 4278190080u64 as u32; let val = val as u8 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 24usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u32, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] @@ -857,12 +1064,15 @@ impl Clone for Date3 { impl Date3 { #[inline] pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; 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) } } @@ -870,26 +1080,35 @@ impl Date3 { 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) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; 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) } } @@ -897,26 +1116,35 @@ impl Date3 { 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) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn nMonth(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; 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) } } @@ -924,26 +1152,35 @@ impl Date3 { 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) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn nYear(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; 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) } } @@ -951,16 +1188,22 @@ impl Date3 { 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) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] diff --git a/tests/expectations/tests/bitfield_align_2.rs b/tests/expectations/tests/bitfield_align_2.rs index f0d444a4..f92f09db 100644 --- a/tests/expectations/tests/bitfield_align_2.rs +++ b/tests/expectations/tests/bitfield_align_2.rs @@ -29,12 +29,15 @@ impl Default for TaggedPtr { impl TaggedPtr { #[inline] pub fn tag(&self) -> MyEnum { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; let mask = 3u64 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 u32) } } @@ -42,26 +45,35 @@ impl TaggedPtr { pub fn set_tag(&mut self, val: MyEnum) { let mask = 3u64 as u64; let val = val as u32 as u64; - let mut unit_field_val: u64 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u64) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn ptr(&self) -> ::std::os::raw::c_long { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; let mask = 18446744073709551612u64 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 u64) } } @@ -69,16 +81,22 @@ impl TaggedPtr { pub fn set_ptr(&mut self, val: ::std::os::raw::c_long) { let mask = 18446744073709551612u64 as u64; let val = val as u64 as u64; - let mut unit_field_val: u64 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u64) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] diff --git a/tests/expectations/tests/bitfield_method_mangling.rs b/tests/expectations/tests/bitfield_method_mangling.rs index 86c0dd95..855ae72b 100644 --- a/tests/expectations/tests/bitfield_method_mangling.rs +++ b/tests/expectations/tests/bitfield_method_mangling.rs @@ -26,12 +26,15 @@ 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 mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 16777215u64 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 u32) } } @@ -39,26 +42,35 @@ impl mach_msg_type_descriptor_t { pub fn set_pad3(&mut self, val: ::std::os::raw::c_uint) { let mask = 16777215u64 as u32; let val = val as u32 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn type_(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 4278190080u64 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) >> 24usize; unsafe { ::std::mem::transmute(val as u32) } } @@ -66,16 +78,22 @@ impl mach_msg_type_descriptor_t { pub fn set_type(&mut self, val: ::std::os::raw::c_uint) { let mask = 4278190080u64 as u32; let val = val as u32 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 24usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u32, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] diff --git a/tests/expectations/tests/jsval_layout_opaque.rs b/tests/expectations/tests/jsval_layout_opaque.rs index 02e282a6..980adbcf 100644 --- a/tests/expectations/tests/jsval_layout_opaque.rs +++ b/tests/expectations/tests/jsval_layout_opaque.rs @@ -132,12 +132,15 @@ impl Default for jsval_layout__bindgen_ty_1 { impl jsval_layout__bindgen_ty_1 { #[inline] pub fn payload47(&self) -> u64 { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; let mask = 140737488355327u64 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 u64) } } @@ -145,26 +148,35 @@ impl jsval_layout__bindgen_ty_1 { pub fn set_payload47(&mut self, val: u64) { let mask = 140737488355327u64 as u64; let val = val as u64 as u64; - let mut unit_field_val: u64 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u64) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn tag(&self) -> JSValueTag { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; let mask = 18446603336221196288u64 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) >> 47usize; unsafe { ::std::mem::transmute(val as u32) } } @@ -172,16 +184,22 @@ impl jsval_layout__bindgen_ty_1 { pub fn set_tag(&mut self, val: JSValueTag) { let mask = 18446603336221196288u64 as u64; let val = val as u32 as u64; - let mut unit_field_val: u64 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u64) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 47usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u64, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] diff --git a/tests/expectations/tests/layout_align.rs b/tests/expectations/tests/layout_align.rs index 2a6c08b0..a8f981e8 100644 --- a/tests/expectations/tests/layout_align.rs +++ b/tests/expectations/tests/layout_align.rs @@ -92,12 +92,15 @@ impl Clone for rte_eth_link { impl rte_eth_link { #[inline] pub fn link_duplex(&self) -> u16 { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 1u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -105,26 +108,35 @@ impl rte_eth_link { pub fn set_link_duplex(&mut self, val: u16) { let mask = 1u64 as u8; let val = val as u16 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] pub fn link_autoneg(&self) -> u16 { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 2u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -132,26 +144,35 @@ impl rte_eth_link { pub fn set_link_autoneg(&mut self, val: u16) { let mask = 2u64 as u8; let val = val as u16 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 1usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] pub fn link_status(&self) -> u16 { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 4u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -159,16 +180,22 @@ impl rte_eth_link { pub fn set_link_status(&mut self, val: u16) { let mask = 4u64 as u8; let val = val as u16 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 2usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] diff --git a/tests/expectations/tests/layout_eth_conf.rs b/tests/expectations/tests/layout_eth_conf.rs index 0c8619ac..d35f8d81 100644 --- a/tests/expectations/tests/layout_eth_conf.rs +++ b/tests/expectations/tests/layout_eth_conf.rs @@ -121,12 +121,15 @@ impl Default for rte_eth_rxmode { impl rte_eth_rxmode { #[inline] pub fn header_split(&self) -> u16 { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 1u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -134,26 +137,35 @@ impl rte_eth_rxmode { pub fn set_header_split(&mut self, val: u16) { let mask = 1u64 as u16; let val = val as u16 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn hw_ip_checksum(&self) -> u16 { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 2u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -161,26 +173,35 @@ impl rte_eth_rxmode { pub fn set_hw_ip_checksum(&mut self, val: u16) { let mask = 2u64 as u16; let val = val as u16 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 1usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn hw_vlan_filter(&self) -> u16 { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 4u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -188,26 +209,35 @@ impl rte_eth_rxmode { pub fn set_hw_vlan_filter(&mut self, val: u16) { let mask = 4u64 as u16; let val = val as u16 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 2usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn hw_vlan_strip(&self) -> u16 { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 8u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -215,26 +245,35 @@ impl rte_eth_rxmode { pub fn set_hw_vlan_strip(&mut self, val: u16) { let mask = 8u64 as u16; let val = val as u16 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 3usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn hw_vlan_extend(&self) -> u16 { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 16u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -242,26 +281,35 @@ impl rte_eth_rxmode { pub fn set_hw_vlan_extend(&mut self, val: u16) { let mask = 16u64 as u16; let val = val as u16 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 4usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn jumbo_frame(&self) -> u16 { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 32u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -269,26 +317,35 @@ impl rte_eth_rxmode { pub fn set_jumbo_frame(&mut self, val: u16) { let mask = 32u64 as u16; let val = val as u16 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 5usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn hw_strip_crc(&self) -> u16 { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 64u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -296,26 +353,35 @@ impl rte_eth_rxmode { pub fn set_hw_strip_crc(&mut self, val: u16) { let mask = 64u64 as u16; let val = val as u16 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 6usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn enable_scatter(&self) -> u16 { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 128u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -323,26 +389,35 @@ impl rte_eth_rxmode { pub fn set_enable_scatter(&mut self, val: u16) { let mask = 128u64 as u16; let val = val as u16 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 7usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn enable_lro(&self) -> u16 { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 256u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -350,16 +425,22 @@ impl rte_eth_rxmode { pub fn set_enable_lro(&mut self, val: u16) { let mask = 256u64 as u16; let val = val as u16 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 8usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] @@ -455,12 +536,15 @@ impl Default for rte_eth_txmode { impl rte_eth_txmode { #[inline] pub fn hw_vlan_reject_tagged(&self) -> u8 { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 1u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -468,26 +552,35 @@ impl rte_eth_txmode { pub fn set_hw_vlan_reject_tagged(&mut self, val: u8) { let mask = 1u64 as u8; let val = val as u8 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] pub fn hw_vlan_reject_untagged(&self) -> u8 { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 2u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -495,26 +588,35 @@ impl rte_eth_txmode { pub fn set_hw_vlan_reject_untagged(&mut self, val: u8) { let mask = 2u64 as u8; let val = val as u8 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 1usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] pub fn hw_vlan_insert_pvid(&self) -> u8 { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 4u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -522,16 +624,22 @@ impl rte_eth_txmode { pub fn set_hw_vlan_insert_pvid(&mut self, val: u8) { let mask = 4u64 as u8; let val = val as u8 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 2usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] diff --git a/tests/expectations/tests/layout_mbuf.rs b/tests/expectations/tests/layout_mbuf.rs index faf9002f..d0598e62 100644 --- a/tests/expectations/tests/layout_mbuf.rs +++ b/tests/expectations/tests/layout_mbuf.rs @@ -178,12 +178,15 @@ 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 mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 15u64 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 u32) } } @@ -191,26 +194,35 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 { pub fn set_l2_type(&mut self, val: u32) { let mask = 15u64 as u32; let val = val as u32 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn l3_type(&self) -> u32 { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 240u64 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) >> 4usize; unsafe { ::std::mem::transmute(val as u32) } } @@ -218,26 +230,35 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 { pub fn set_l3_type(&mut self, val: u32) { let mask = 240u64 as u32; let val = val as u32 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 4usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u32, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn l4_type(&self) -> u32 { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 3840u64 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) >> 8usize; unsafe { ::std::mem::transmute(val as u32) } } @@ -245,26 +266,35 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 { pub fn set_l4_type(&mut self, val: u32) { let mask = 3840u64 as u32; let val = val as u32 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 8usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u32, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn tun_type(&self) -> u32 { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 61440u64 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) >> 12usize; unsafe { ::std::mem::transmute(val as u32) } } @@ -272,26 +302,35 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 { pub fn set_tun_type(&mut self, val: u32) { let mask = 61440u64 as u32; let val = val as u32 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 12usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u32, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn inner_l2_type(&self) -> u32 { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 983040u64 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 u32) } } @@ -299,26 +338,35 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 { pub fn set_inner_l2_type(&mut self, val: u32) { let mask = 983040u64 as u32; let val = val as u32 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn inner_l3_type(&self) -> u32 { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 15728640u64 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) >> 20usize; unsafe { ::std::mem::transmute(val as u32) } } @@ -326,26 +374,35 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 { pub fn set_inner_l3_type(&mut self, val: u32) { let mask = 15728640u64 as u32; let val = val as u32 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 20usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u32, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn inner_l4_type(&self) -> u32 { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 251658240u64 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) >> 24usize; unsafe { ::std::mem::transmute(val as u32) } } @@ -353,16 +410,22 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 { pub fn set_inner_l4_type(&mut self, val: u32) { let mask = 251658240u64 as u32; let val = val as u32 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 24usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u32, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] @@ -651,12 +714,15 @@ 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 mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; let mask = 127u64 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 u64) } } @@ -664,26 +730,35 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 { pub fn set_l2_len(&mut self, val: u64) { let mask = 127u64 as u64; let val = val as u64 as u64; - let mut unit_field_val: u64 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u64) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn l3_len(&self) -> u64 { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; let mask = 65408u64 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 u64) } } @@ -691,26 +766,35 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 { pub fn set_l3_len(&mut self, val: u64) { let mask = 65408u64 as u64; let val = val as u64 as u64; - let mut unit_field_val: u64 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u64) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn l4_len(&self) -> u64 { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; let mask = 16711680u64 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 u64) } } @@ -718,26 +802,35 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 { pub fn set_l4_len(&mut self, val: u64) { let mask = 16711680u64 as u64; let val = val as u64 as u64; - let mut unit_field_val: u64 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u64) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn tso_segsz(&self) -> u64 { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; let mask = 1099494850560u64 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 u64) } } @@ -745,26 +838,35 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 { pub fn set_tso_segsz(&mut self, val: u64) { let mask = 1099494850560u64 as u64; let val = val as u64 as u64; - let mut unit_field_val: u64 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u64) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn outer_l3_len(&self) -> u64 { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; let mask = 561850441793536u64 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) >> 40usize; unsafe { ::std::mem::transmute(val as u64) } } @@ -772,26 +874,35 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 { pub fn set_outer_l3_len(&mut self, val: u64) { let mask = 561850441793536u64 as u64; let val = val as u64 as u64; - let mut unit_field_val: u64 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u64) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 40usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u64, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn outer_l2_len(&self) -> u64 { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; let mask = 71494644084506624u64 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) >> 49usize; unsafe { ::std::mem::transmute(val as u64) } } @@ -799,16 +910,22 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 { pub fn set_outer_l2_len(&mut self, val: u64) { let mask = 71494644084506624u64 as u64; let val = val as u64 as u64; - let mut unit_field_val: u64 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u64) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 49usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u64, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] diff --git a/tests/expectations/tests/only_bitfields.rs b/tests/expectations/tests/only_bitfields.rs index 6e4d6270..64a1fd79 100644 --- a/tests/expectations/tests/only_bitfields.rs +++ b/tests/expectations/tests/only_bitfields.rs @@ -23,12 +23,15 @@ impl Clone for C { impl C { #[inline] pub fn a(&self) -> bool { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 1u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -36,26 +39,35 @@ impl C { pub fn set_a(&mut self, val: bool) { let mask = 1u64 as u8; let val = val as u8 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] pub fn b(&self) -> bool { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 254u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -63,16 +75,22 @@ impl C { pub fn set_b(&mut self, val: bool) { let mask = 254u64 as u8; let val = val as u8 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 1usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] diff --git a/tests/expectations/tests/struct_with_bitfields.rs b/tests/expectations/tests/struct_with_bitfields.rs index 2c6a5f2b..b93b441f 100644 --- a/tests/expectations/tests/struct_with_bitfields.rs +++ b/tests/expectations/tests/struct_with_bitfields.rs @@ -29,12 +29,15 @@ impl Clone for bitfield { impl bitfield { #[inline] pub fn a(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 1u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -42,26 +45,35 @@ impl bitfield { pub fn set_a(&mut self, val: ::std::os::raw::c_ushort) { let mask = 1u64 as u8; let val = val as u16 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] pub fn b(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 2u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -69,26 +81,35 @@ impl bitfield { pub fn set_b(&mut self, val: ::std::os::raw::c_ushort) { let mask = 2u64 as u8; let val = val as u16 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 1usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] pub fn c(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 4u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -96,26 +117,35 @@ impl bitfield { pub fn set_c(&mut self, val: ::std::os::raw::c_ushort) { let mask = 4u64 as u8; let val = val as u16 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 2usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] pub fn d(&self) -> ::std::os::raw::c_ushort { + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; let mask = 192u64 as u8; - let unit_field_val: u8 = - 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) } } @@ -123,16 +153,22 @@ impl bitfield { pub fn set_d(&mut self, val: ::std::os::raw::c_ushort) { let mask = 192u64 as u8; let val = val as u16 as u8; - let mut unit_field_val: u8 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u8) - }; + let mut unit_field_val: u8 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u8 as + *mut u8, + ::std::mem::size_of::<u8>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 6usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u8, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u8>()); } } #[inline] @@ -149,12 +185,15 @@ impl bitfield { } #[inline] pub fn f(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; let mask = 3u64 as u64; - let unit_field_val: u64 = - 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) } } @@ -162,26 +201,35 @@ impl bitfield { pub fn set_f(&mut self, val: ::std::os::raw::c_uint) { let mask = 3u64 as u64; let val = val as u32 as u64; - let mut unit_field_val: u64 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as - *const u64) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as - *mut u64, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_2 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] pub fn g(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; let mask = 18446744069414584320u64 as u64; - let unit_field_val: u64 = - 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) } } @@ -189,16 +237,22 @@ impl bitfield { pub fn set_g(&mut self, val: ::std::os::raw::c_uint) { let mask = 18446744069414584320u64 as u64; let val = val as u32 as u64; - let mut unit_field_val: u64 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as - *const u64) - }; + let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as + *const u8, + &mut unit_field_val as *mut u64 as + *mut u8, + ::std::mem::size_of::<u64>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 32usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as - *mut u64, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_2 as *mut _ as + *mut u8, + ::std::mem::size_of::<u64>()); } } #[inline] diff --git a/tests/expectations/tests/union_with_anon_struct_bitfield.rs b/tests/expectations/tests/union_with_anon_struct_bitfield.rs index a60d1115..e6acd105 100644 --- a/tests/expectations/tests/union_with_anon_struct_bitfield.rs +++ b/tests/expectations/tests/union_with_anon_struct_bitfield.rs @@ -54,12 +54,15 @@ impl Clone for foo__bindgen_ty_1 { impl foo__bindgen_ty_1 { #[inline] pub fn b(&self) -> ::std::os::raw::c_int { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 127u64 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 u32) } } @@ -67,26 +70,35 @@ impl foo__bindgen_ty_1 { pub fn set_b(&mut self, val: ::std::os::raw::c_int) { let mask = 127u64 as u32; let val = val as u32 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn c(&self) -> ::std::os::raw::c_int { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 4294967168u64 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) >> 7usize; unsafe { ::std::mem::transmute(val as u32) } } @@ -94,16 +106,22 @@ impl foo__bindgen_ty_1 { pub fn set_c(&mut self, val: ::std::os::raw::c_int) { let mask = 4294967168u64 as u32; let val = val as u32 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 7usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as - *mut u32, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] diff --git a/tests/expectations/tests/weird_bitfields.rs b/tests/expectations/tests/weird_bitfields.rs index 5b85c4e3..0b97c368 100644 --- a/tests/expectations/tests/weird_bitfields.rs +++ b/tests/expectations/tests/weird_bitfields.rs @@ -106,12 +106,15 @@ impl Default for Weird { impl Weird { #[inline] pub fn bitTest(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 65535u64 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 u32) } } @@ -119,26 +122,35 @@ impl Weird { pub fn set_bitTest(&mut self, val: ::std::os::raw::c_uint) { let mask = 65535u64 as u32; let val = val as u32 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] pub fn bitTest2(&self) -> ::std::os::raw::c_uint { + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<u32>()) + }; let mask = 2147418112u64 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 u32) } } @@ -146,16 +158,22 @@ impl Weird { pub fn set_bitTest2(&mut self, val: ::std::os::raw::c_uint) { let mask = 2147418112u64 as u32; let val = val as u32 as u32; - let mut unit_field_val: u32 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as - *const u32) - }; + let mut unit_field_val: u32 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as + *const u8, + &mut unit_field_val as *mut u32 as + *mut u8, + ::std::mem::size_of::<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); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_1 as *mut _ as + *mut u8, + ::std::mem::size_of::<u32>()); } } #[inline] @@ -166,12 +184,15 @@ impl Weird { } #[inline] pub fn mFillOpacitySource(&self) -> nsStyleSVGOpacitySource { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 7u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -179,26 +200,35 @@ impl Weird { pub fn set_mFillOpacitySource(&mut self, val: nsStyleSVGOpacitySource) { let mask = 7u64 as u16; let val = val as u32 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 0usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_2 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn mStrokeOpacitySource(&self) -> nsStyleSVGOpacitySource { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 56u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -206,26 +236,35 @@ impl Weird { pub fn set_mStrokeOpacitySource(&mut self, val: nsStyleSVGOpacitySource) { let mask = 56u64 as u16; let val = val as u32 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 3usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_2 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn mStrokeDasharrayFromObject(&self) -> bool { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 64u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -233,26 +272,35 @@ impl Weird { pub fn set_mStrokeDasharrayFromObject(&mut self, val: bool) { let mask = 64u64 as u16; let val = val as u8 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 6usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_2 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn mStrokeDashoffsetFromObject(&self) -> bool { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 128u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -260,26 +308,35 @@ impl Weird { pub fn set_mStrokeDashoffsetFromObject(&mut self, val: bool) { let mask = 128u64 as u16; let val = val as u8 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 7usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_2 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] pub fn mStrokeWidthFromObject(&self) -> bool { + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; let mask = 256u64 as u16; - let unit_field_val: u16 = - 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) } } @@ -287,16 +344,22 @@ impl Weird { pub fn set_mStrokeWidthFromObject(&mut self, val: bool) { let mask = 256u64 as u16; let val = val as u8 as u16; - let mut unit_field_val: u16 = - unsafe { - ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as - *const u16) - }; + let mut unit_field_val: u16 = unsafe { ::std::mem::uninitialized() }; + unsafe { + ::std::ptr::copy_nonoverlapping(&self._bitfield_2 as *const _ as + *const u8, + &mut unit_field_val as *mut u16 as + *mut u8, + ::std::mem::size_of::<u16>()) + }; unit_field_val &= !mask; unit_field_val |= (val << 8usize) & mask; unsafe { - ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as - *mut u16, unit_field_val); + ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as + *const u8, + &mut self._bitfield_2 as *mut _ as + *mut u8, + ::std::mem::size_of::<u16>()); } } #[inline] |