codegen: Fix bitfield getter/setters so they work with NPOT sizes.

17 files changed, 1453 insertions, 341 deletions

diff --git a/bindgen-integration/cpp/Test.cc b/bindgen-integration/cpp/Test.cc
index 9d91250c..f125109a 100644
--- a/bindgen-integration/cpp/Test.cc
+++ b/bindgen-integration/cpp/Test.cc
@@ -76,4 +76,29 @@ Date2::assert(unsigned short nWeekDay,
       this->byte == byte;
 }
 
+bool
+Fifth::assert(unsigned short nWeekDay,
+              unsigned short nMonthDay,
+              unsigned short nMonth,
+              unsigned short nYear,
+              unsigned char byte)
+{
+  return this->nWeekDay == nWeekDay &&
+      this->nMonthDay == nMonthDay &&
+      this->nMonth == nMonth &&
+      this->nYear == nYear &&
+      this->byte == byte;
+}
+
+bool
+Sixth::assert(unsigned char byte,
+              unsigned char nWeekDay,
+              unsigned char nMonth,
+              unsigned char nMonthDay) {
+  return this->nWeekDay == nWeekDay &&
+      this->nMonthDay == nMonthDay &&
+      this->nMonth == nMonth &&
+      this->byte == byte;
+};
+
 } // namespace bitfields
diff --git a/bindgen-integration/cpp/Test.h b/bindgen-integration/cpp/Test.h
index 4b8c1690..e23a32e6 100644
--- a/bindgen-integration/cpp/Test.h
+++ b/bindgen-integration/cpp/Test.h
@@ -92,6 +92,36 @@ struct Date2 {
                 unsigned short byte);
 };
 
+
+struct Fifth {
+    unsigned short nWeekDay  : 3;    // 0..7   (3 bits)
+    unsigned short nMonthDay : 6;    // 0..31  (6 bits)
+    unsigned short nMonth    : 5;    // 0..12  (5 bits)
+    unsigned short nYear     : 8;    // 0..100 (8 bits)
+    unsigned char byte;
+
+    /// Returns true if the bitfields match the arguments, false otherwise.
+    bool assert(unsigned short nWeekDay,
+                unsigned short nMonthDay,
+                unsigned short nMonth,
+                unsigned short nYear,
+                unsigned char byte);
+};
+
+struct Sixth {
+    unsigned char byte;
+    unsigned char nWeekDay  : 3;
+    unsigned char nMonth    : 5;
+    unsigned char nMonthDay : 6;
+
+    /// Returns true if the bitfields match the arguments, false otherwise.
+    bool assert(unsigned char byte,
+                unsigned char nWeekDay,
+                unsigned char nMonth,
+                unsigned char nMonthDay);
+};
+
+
 } // namespace bitfields
 
 struct AutoRestoreBool {
diff --git a/bindgen-integration/src/lib.rs b/bindgen-integration/src/lib.rs
index ea2b77b2..fdb02dbb 100755
--- a/bindgen-integration/src/lib.rs
+++ b/bindgen-integration/src/lib.rs
@@ -138,6 +138,48 @@ fn test_bitfields_date2() {
 }
 
 #[test]
+fn test_bitfields_fifth() {
+    let mut date: bindings::bitfields::Fifth = unsafe {
+        mem::zeroed()
+    };
+
+    assert!(unsafe {
+        date.assert(0, 0, 0, 0, 0)
+    });
+
+    date.byte = 255; // Set this first, to ensure we don't override it.
+
+    date.set_nWeekDay(6); // saturdays are the best
+    date.set_nMonthDay(20);
+    date.set_nMonth(11);
+    date.set_nYear(95);
+
+    assert!(unsafe {
+        date.assert(6, 20, 11, 95, 255)
+    });
+}
+
+#[test]
+fn test_bitfields_sixth() {
+    let mut date: bindings::bitfields::Sixth = unsafe {
+        mem::zeroed()
+    };
+
+    assert!(unsafe {
+        date.assert(0, 0, 0, 0)
+    });
+
+    date.byte = 255;
+    date.set_nWeekDay(6); // saturdays are the best
+    date.set_nMonthDay(20);
+    date.set_nMonth(11);
+
+    assert!(unsafe {
+        date.assert(255, 6, 11, 20)
+    });
+}
+
+#[test]
 fn test_bitfield_constructors() {
     use std::mem;
     let mut first = bindings::bitfields::First {
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 30f527e9..bd5b1f3b 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -1288,7 +1288,9 @@ impl<'a> FieldCodegen<'a> for Bitfield {
                 pub fn $getter_name(&self) -> $bitfield_ty {
                     let mask = $mask as $unit_field_int_ty;
                     let unit_field_val: $unit_field_int_ty = unsafe {
-                        ::$prefix::mem::transmute(self.$unit_field_ident)
+                        ::$prefix::ptr::read_unaligned(
+                            &self.$unit_field_ident as *const _ as *const $unit_field_int_ty
+                        )
                     };
                     let val = (unit_field_val & mask) >> $offset;
                     unsafe {
@@ -1302,14 +1304,19 @@ impl<'a> FieldCodegen<'a> for Bitfield {
                     let val = val as $bitfield_int_ty as $unit_field_int_ty;
 
                     let mut unit_field_val: $unit_field_int_ty = unsafe {
-                        ::$prefix::mem::transmute(self.$unit_field_ident)
+                        ::$prefix::ptr::read_unaligned(
+                            &self.$unit_field_ident as *const _ as *const $unit_field_int_ty)
                     };
+
                     unit_field_val &= !mask;
                     unit_field_val |= (val << $offset) & mask;
 
-                    self.$unit_field_ident = unsafe {
-                        ::$prefix::mem::transmute(unit_field_val)
-                    };
+                    unsafe {
+                        ::$prefix::ptr::write_unaligned(
+                            &mut self.$unit_field_ident as *mut _ as *mut $unit_field_int_ty,
+                            unit_field_val
+                        );
+                    }
                 }
             }
         ).unwrap();
diff --git a/tests/expectations/tests/bitfield-32bit-overflow.rs b/tests/expectations/tests/bitfield-32bit-overflow.rs
index 1b38a880..ff11d5bc 100644
--- a/tests/expectations/tests/bitfield-32bit-overflow.rs
+++ b/tests/expectations/tests/bitfield-32bit-overflow.rs
@@ -25,7 +25,10 @@ impl MuchBitfield {
     pub fn m0(&self) -> ::std::os::raw::c_char {
         let mask = 1u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -34,16 +37,25 @@ impl MuchBitfield {
         let mask = 1u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m1(&self) -> ::std::os::raw::c_char {
         let mask = 2u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 1usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -52,16 +64,25 @@ impl MuchBitfield {
         let mask = 2u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 1usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m2(&self) -> ::std::os::raw::c_char {
         let mask = 4u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 2usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -70,16 +91,25 @@ impl MuchBitfield {
         let mask = 4u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 2usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m3(&self) -> ::std::os::raw::c_char {
         let mask = 8u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 3usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -88,16 +118,25 @@ impl MuchBitfield {
         let mask = 8u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 3usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m4(&self) -> ::std::os::raw::c_char {
         let mask = 16u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            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) }
     }
@@ -106,16 +145,25 @@ impl MuchBitfield {
         let mask = 16u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 4usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m5(&self) -> ::std::os::raw::c_char {
         let mask = 32u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            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) }
     }
@@ -124,16 +172,25 @@ impl MuchBitfield {
         let mask = 32u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 5usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m6(&self) -> ::std::os::raw::c_char {
         let mask = 64u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            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) }
     }
@@ -142,16 +199,25 @@ impl MuchBitfield {
         let mask = 64u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 6usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m7(&self) -> ::std::os::raw::c_char {
         let mask = 128u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 7usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -160,16 +226,25 @@ impl MuchBitfield {
         let mask = 128u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 7usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m8(&self) -> ::std::os::raw::c_char {
         let mask = 256u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 8usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -178,16 +253,25 @@ impl MuchBitfield {
         let mask = 256u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 8usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m9(&self) -> ::std::os::raw::c_char {
         let mask = 512u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            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) }
     }
@@ -196,16 +280,25 @@ impl MuchBitfield {
         let mask = 512u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 9usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m10(&self) -> ::std::os::raw::c_char {
         let mask = 1024u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            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) }
     }
@@ -214,16 +307,25 @@ impl MuchBitfield {
         let mask = 1024u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 10usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m11(&self) -> ::std::os::raw::c_char {
         let mask = 2048u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 11usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -232,16 +334,25 @@ impl MuchBitfield {
         let mask = 2048u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 11usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m12(&self) -> ::std::os::raw::c_char {
         let mask = 4096u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 12usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -250,16 +361,25 @@ impl MuchBitfield {
         let mask = 4096u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 12usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m13(&self) -> ::std::os::raw::c_char {
         let mask = 8192u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            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) }
     }
@@ -268,16 +388,25 @@ impl MuchBitfield {
         let mask = 8192u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 13usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m14(&self) -> ::std::os::raw::c_char {
         let mask = 16384u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 14usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -286,16 +415,25 @@ impl MuchBitfield {
         let mask = 16384u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 14usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m15(&self) -> ::std::os::raw::c_char {
         let mask = 32768u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 15usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -304,16 +442,25 @@ impl MuchBitfield {
         let mask = 32768u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 15usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m16(&self) -> ::std::os::raw::c_char {
         let mask = 65536u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 16usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -322,16 +469,25 @@ impl MuchBitfield {
         let mask = 65536u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 16usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m17(&self) -> ::std::os::raw::c_char {
         let mask = 131072u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 17usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -340,16 +496,25 @@ impl MuchBitfield {
         let mask = 131072u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 17usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m18(&self) -> ::std::os::raw::c_char {
         let mask = 262144u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 18usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -358,16 +523,25 @@ impl MuchBitfield {
         let mask = 262144u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 18usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m19(&self) -> ::std::os::raw::c_char {
         let mask = 524288u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 19usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -376,16 +550,25 @@ impl MuchBitfield {
         let mask = 524288u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 19usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m20(&self) -> ::std::os::raw::c_char {
         let mask = 1048576u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 20usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -394,16 +577,25 @@ impl MuchBitfield {
         let mask = 1048576u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 20usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m21(&self) -> ::std::os::raw::c_char {
         let mask = 2097152u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            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) }
     }
@@ -412,16 +604,25 @@ impl MuchBitfield {
         let mask = 2097152u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 21usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m22(&self) -> ::std::os::raw::c_char {
         let mask = 4194304u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 22usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -430,16 +631,25 @@ impl MuchBitfield {
         let mask = 4194304u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 22usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m23(&self) -> ::std::os::raw::c_char {
         let mask = 8388608u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 23usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -448,16 +658,25 @@ impl MuchBitfield {
         let mask = 8388608u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 23usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m24(&self) -> ::std::os::raw::c_char {
         let mask = 16777216u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 24usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -466,16 +685,25 @@ impl MuchBitfield {
         let mask = 16777216u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 24usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m25(&self) -> ::std::os::raw::c_char {
         let mask = 33554432u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 25usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -484,16 +712,25 @@ impl MuchBitfield {
         let mask = 33554432u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 25usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m26(&self) -> ::std::os::raw::c_char {
         let mask = 67108864u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 26usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -502,16 +739,25 @@ impl MuchBitfield {
         let mask = 67108864u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 26usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m27(&self) -> ::std::os::raw::c_char {
         let mask = 134217728u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 27usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -520,16 +766,25 @@ impl MuchBitfield {
         let mask = 134217728u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 27usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m28(&self) -> ::std::os::raw::c_char {
         let mask = 268435456u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 28usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -538,16 +793,25 @@ impl MuchBitfield {
         let mask = 268435456u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 28usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m29(&self) -> ::std::os::raw::c_char {
         let mask = 536870912u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 29usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -556,16 +820,25 @@ impl MuchBitfield {
         let mask = 536870912u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 29usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m30(&self) -> ::std::os::raw::c_char {
         let mask = 1073741824u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 30usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -574,16 +847,25 @@ impl MuchBitfield {
         let mask = 1073741824u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 30usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m31(&self) -> ::std::os::raw::c_char {
         let mask = 2147483648u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 31usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -592,16 +874,25 @@ impl MuchBitfield {
         let mask = 2147483648u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 31usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn m32(&self) -> ::std::os::raw::c_char {
         let mask = 4294967296u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            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) }
     }
@@ -610,10 +901,16 @@ impl MuchBitfield {
         let mask = 4294967296u64 as u64;
         let val = val as u8 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 32usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(m0: ::std::os::raw::c_char,
diff --git a/tests/expectations/tests/bitfield-method-same-name.rs b/tests/expectations/tests/bitfield-method-same-name.rs
index 3eaf0c51..74dd11e2 100644
--- a/tests/expectations/tests/bitfield-method-same-name.rs
+++ b/tests/expectations/tests/bitfield-method-same-name.rs
@@ -37,7 +37,10 @@ impl Foo {
     pub fn type__bindgen_bitfield(&self) -> ::std::os::raw::c_char {
         let mask = 7u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -47,10 +50,16 @@ impl Foo {
         let mask = 7u64 as u8;
         let val = val as u8 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(type__bindgen_bitfield: ::std::os::raw::c_char)
diff --git a/tests/expectations/tests/bitfield_align.rs b/tests/expectations/tests/bitfield_align.rs
index beaa922c..233ae5ab 100644
--- a/tests/expectations/tests/bitfield_align.rs
+++ b/tests/expectations/tests/bitfield_align.rs
@@ -35,7 +35,10 @@ impl A {
     pub fn b1(&self) -> ::std::os::raw::c_uint {
         let mask = 1u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -44,16 +47,25 @@ impl A {
         let mask = 1u64 as u16;
         let val = val as u32 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn b2(&self) -> ::std::os::raw::c_uint {
         let mask = 2u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 1usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -62,16 +74,25 @@ impl A {
         let mask = 2u64 as u16;
         let val = val as u32 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 1usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn b3(&self) -> ::std::os::raw::c_uint {
         let mask = 4u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 2usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -80,16 +101,25 @@ impl A {
         let mask = 4u64 as u16;
         let val = val as u32 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 2usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn b4(&self) -> ::std::os::raw::c_uint {
         let mask = 8u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 3usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -98,16 +128,25 @@ impl A {
         let mask = 8u64 as u16;
         let val = val as u32 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 3usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn b5(&self) -> ::std::os::raw::c_uint {
         let mask = 16u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 4usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -116,16 +155,25 @@ impl A {
         let mask = 16u64 as u16;
         let val = val as u32 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 4usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn b6(&self) -> ::std::os::raw::c_uint {
         let mask = 32u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 5usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -134,16 +182,25 @@ impl A {
         let mask = 32u64 as u16;
         let val = val as u32 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 5usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn b7(&self) -> ::std::os::raw::c_uint {
         let mask = 64u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 6usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -152,16 +209,25 @@ impl A {
         let mask = 64u64 as u16;
         let val = val as u32 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 6usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn b8(&self) -> ::std::os::raw::c_uint {
         let mask = 128u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 7usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -170,16 +236,25 @@ impl A {
         let mask = 128u64 as u16;
         let val = val as u32 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 7usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn b9(&self) -> ::std::os::raw::c_uint {
         let mask = 256u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 8usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -188,16 +263,25 @@ impl A {
         let mask = 256u64 as u16;
         let val = val as u32 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 8usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn b10(&self) -> ::std::os::raw::c_uint {
         let mask = 512u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 9usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -206,10 +290,16 @@ impl A {
         let mask = 512u64 as u16;
         let val = val as u32 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 9usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(b1: ::std::os::raw::c_uint,
@@ -278,7 +368,10 @@ impl B {
     pub fn foo(&self) -> ::std::os::raw::c_uint {
         let mask = 2147483647u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -287,16 +380,25 @@ impl B {
         let mask = 2147483647u64 as u32;
         let val = val as u32 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn bar(&self) -> ::std::os::raw::c_uchar {
         let mask = 2147483648u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 31usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -305,10 +407,16 @@ impl B {
         let mask = 2147483648u64 as u32;
         let val = val as u8 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 31usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(foo: ::std::os::raw::c_uint,
@@ -350,7 +458,10 @@ impl C {
     pub fn b1(&self) -> ::std::os::raw::c_uint {
         let mask = 1u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -359,16 +470,25 @@ impl C {
         let mask = 1u64 as u8;
         let val = val as u32 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn b2(&self) -> ::std::os::raw::c_uint {
         let mask = 2u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 1usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -377,10 +497,16 @@ impl C {
         let mask = 2u64 as u8;
         let val = val as u32 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 1usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(b1: ::std::os::raw::c_uint,
@@ -411,7 +537,10 @@ impl Date1 {
     pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
         let mask = 7u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -420,16 +549,25 @@ impl Date1 {
         let mask = 7u64 as u32;
         let val = val as u16 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
         let mask = 504u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 3usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -438,16 +576,25 @@ impl Date1 {
         let mask = 504u64 as u32;
         let val = val as u16 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 3usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
         let mask = 15872u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 9usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -456,16 +603,25 @@ impl Date1 {
         let mask = 15872u64 as u32;
         let val = val as u16 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 9usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn nYear(&self) -> ::std::os::raw::c_ushort {
         let mask = 16711680u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 16usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -474,10 +630,16 @@ impl Date1 {
         let mask = 16711680u64 as u32;
         let val = val as u16 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 16usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(nWeekDay: ::std::os::raw::c_ushort,
@@ -518,7 +680,10 @@ impl Date2 {
     pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
         let mask = 7u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -527,16 +692,25 @@ impl Date2 {
         let mask = 7u64 as u32;
         let val = val as u16 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
         let mask = 504u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 3usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -545,16 +719,25 @@ impl Date2 {
         let mask = 504u64 as u32;
         let val = val as u16 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 3usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
         let mask = 15872u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 9usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -563,16 +746,25 @@ impl Date2 {
         let mask = 15872u64 as u32;
         let val = val as u16 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 9usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn nYear(&self) -> ::std::os::raw::c_ushort {
         let mask = 16711680u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 16usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -581,16 +773,25 @@ impl Date2 {
         let mask = 16711680u64 as u32;
         let val = val as u16 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 16usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn byte(&self) -> ::std::os::raw::c_uchar {
         let mask = 4278190080u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 24usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -599,10 +800,16 @@ impl Date2 {
         let mask = 4278190080u64 as u32;
         let val = val as u8 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 24usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(nWeekDay: ::std::os::raw::c_ushort,
@@ -652,7 +859,10 @@ impl Date3 {
     pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
         let mask = 7u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -661,16 +871,25 @@ impl Date3 {
         let mask = 7u64 as u32;
         let val = val as u16 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
         let mask = 504u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 3usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -679,16 +898,25 @@ impl Date3 {
         let mask = 504u64 as u32;
         let val = val as u16 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 3usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
         let mask = 15872u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 9usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -697,16 +925,25 @@ impl Date3 {
         let mask = 15872u64 as u32;
         let val = val as u16 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 9usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn nYear(&self) -> ::std::os::raw::c_ushort {
         let mask = 16711680u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 16usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -715,10 +952,16 @@ impl Date3 {
         let mask = 16711680u64 as u32;
         let val = val as u16 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 16usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(nWeekDay: ::std::os::raw::c_ushort,
diff --git a/tests/expectations/tests/bitfield_align_2.rs b/tests/expectations/tests/bitfield_align_2.rs
index 8c81ad0f..f0d444a4 100644
--- a/tests/expectations/tests/bitfield_align_2.rs
+++ b/tests/expectations/tests/bitfield_align_2.rs
@@ -31,7 +31,10 @@ impl TaggedPtr {
     pub fn tag(&self) -> MyEnum {
         let mask = 3u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -40,16 +43,25 @@ impl TaggedPtr {
         let mask = 3u64 as u64;
         let val = val as u32 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn ptr(&self) -> ::std::os::raw::c_long {
         let mask = 18446744073709551612u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 2usize;
         unsafe { ::std::mem::transmute(val as u64) }
     }
@@ -58,10 +70,16 @@ impl TaggedPtr {
         let mask = 18446744073709551612u64 as u64;
         let val = val as u64 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 2usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(tag: MyEnum, ptr: ::std::os::raw::c_long) -> u64 {
diff --git a/tests/expectations/tests/bitfield_method_mangling.rs b/tests/expectations/tests/bitfield_method_mangling.rs
index 56659d75..86c0dd95 100644
--- a/tests/expectations/tests/bitfield_method_mangling.rs
+++ b/tests/expectations/tests/bitfield_method_mangling.rs
@@ -28,7 +28,10 @@ impl mach_msg_type_descriptor_t {
     pub fn pad3(&self) -> ::std::os::raw::c_uint {
         let mask = 16777215u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -37,16 +40,25 @@ impl mach_msg_type_descriptor_t {
         let mask = 16777215u64 as u32;
         let val = val as u32 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn type_(&self) -> ::std::os::raw::c_uint {
         let mask = 4278190080u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 24usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -55,10 +67,16 @@ impl mach_msg_type_descriptor_t {
         let mask = 4278190080u64 as u32;
         let val = val as u32 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 24usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(pad3: ::std::os::raw::c_uint,
diff --git a/tests/expectations/tests/jsval_layout_opaque.rs b/tests/expectations/tests/jsval_layout_opaque.rs
index 7170d31b..02e282a6 100644
--- a/tests/expectations/tests/jsval_layout_opaque.rs
+++ b/tests/expectations/tests/jsval_layout_opaque.rs
@@ -134,7 +134,10 @@ impl jsval_layout__bindgen_ty_1 {
     pub fn payload47(&self) -> u64 {
         let mask = 140737488355327u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u64) }
     }
@@ -143,16 +146,25 @@ impl jsval_layout__bindgen_ty_1 {
         let mask = 140737488355327u64 as u64;
         let val = val as u64 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn tag(&self) -> JSValueTag {
         let mask = 18446603336221196288u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 47usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -161,10 +173,16 @@ impl jsval_layout__bindgen_ty_1 {
         let mask = 18446603336221196288u64 as u64;
         let val = val as u32 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 47usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(payload47: u64, tag: JSValueTag) -> u64 {
diff --git a/tests/expectations/tests/layout_align.rs b/tests/expectations/tests/layout_align.rs
index 611cf06b..2a6c08b0 100644
--- a/tests/expectations/tests/layout_align.rs
+++ b/tests/expectations/tests/layout_align.rs
@@ -94,7 +94,10 @@ impl rte_eth_link {
     pub fn link_duplex(&self) -> u16 {
         let mask = 1u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -103,16 +106,25 @@ impl rte_eth_link {
         let mask = 1u64 as u8;
         let val = val as u16 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn link_autoneg(&self) -> u16 {
         let mask = 2u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 1usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -121,16 +133,25 @@ impl rte_eth_link {
         let mask = 2u64 as u8;
         let val = val as u16 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 1usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn link_status(&self) -> u16 {
         let mask = 4u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 2usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -139,10 +160,16 @@ impl rte_eth_link {
         let mask = 4u64 as u8;
         let val = val as u16 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 2usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(link_duplex: u16, link_autoneg: u16,
diff --git a/tests/expectations/tests/layout_eth_conf.rs b/tests/expectations/tests/layout_eth_conf.rs
index 11a50171..0c8619ac 100644
--- a/tests/expectations/tests/layout_eth_conf.rs
+++ b/tests/expectations/tests/layout_eth_conf.rs
@@ -123,7 +123,10 @@ impl rte_eth_rxmode {
     pub fn header_split(&self) -> u16 {
         let mask = 1u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -132,16 +135,25 @@ impl rte_eth_rxmode {
         let mask = 1u64 as u16;
         let val = val as u16 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn hw_ip_checksum(&self) -> u16 {
         let mask = 2u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 1usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -150,16 +162,25 @@ impl rte_eth_rxmode {
         let mask = 2u64 as u16;
         let val = val as u16 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 1usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn hw_vlan_filter(&self) -> u16 {
         let mask = 4u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 2usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -168,16 +189,25 @@ impl rte_eth_rxmode {
         let mask = 4u64 as u16;
         let val = val as u16 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 2usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn hw_vlan_strip(&self) -> u16 {
         let mask = 8u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 3usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -186,16 +216,25 @@ impl rte_eth_rxmode {
         let mask = 8u64 as u16;
         let val = val as u16 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 3usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn hw_vlan_extend(&self) -> u16 {
         let mask = 16u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 4usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -204,16 +243,25 @@ impl rte_eth_rxmode {
         let mask = 16u64 as u16;
         let val = val as u16 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 4usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn jumbo_frame(&self) -> u16 {
         let mask = 32u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 5usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -222,16 +270,25 @@ impl rte_eth_rxmode {
         let mask = 32u64 as u16;
         let val = val as u16 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 5usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn hw_strip_crc(&self) -> u16 {
         let mask = 64u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 6usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -240,16 +297,25 @@ impl rte_eth_rxmode {
         let mask = 64u64 as u16;
         let val = val as u16 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 6usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn enable_scatter(&self) -> u16 {
         let mask = 128u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 7usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -258,16 +324,25 @@ impl rte_eth_rxmode {
         let mask = 128u64 as u16;
         let val = val as u16 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 7usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn enable_lro(&self) -> u16 {
         let mask = 256u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 8usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -276,10 +351,16 @@ impl rte_eth_rxmode {
         let mask = 256u64 as u16;
         let val = val as u16 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 8usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(header_split: u16, hw_ip_checksum: u16,
@@ -376,7 +457,10 @@ impl rte_eth_txmode {
     pub fn hw_vlan_reject_tagged(&self) -> u8 {
         let mask = 1u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -385,16 +469,25 @@ impl rte_eth_txmode {
         let mask = 1u64 as u8;
         let val = val as u8 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn hw_vlan_reject_untagged(&self) -> u8 {
         let mask = 2u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 1usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -403,16 +496,25 @@ impl rte_eth_txmode {
         let mask = 2u64 as u8;
         let val = val as u8 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 1usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn hw_vlan_insert_pvid(&self) -> u8 {
         let mask = 4u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 2usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -421,10 +523,16 @@ impl rte_eth_txmode {
         let mask = 4u64 as u8;
         let val = val as u8 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 2usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(hw_vlan_reject_tagged: u8,
diff --git a/tests/expectations/tests/layout_mbuf.rs b/tests/expectations/tests/layout_mbuf.rs
index 727bfdb6..faf9002f 100644
--- a/tests/expectations/tests/layout_mbuf.rs
+++ b/tests/expectations/tests/layout_mbuf.rs
@@ -180,7 +180,10 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
     pub fn l2_type(&self) -> u32 {
         let mask = 15u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -189,16 +192,25 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
         let mask = 15u64 as u32;
         let val = val as u32 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn l3_type(&self) -> u32 {
         let mask = 240u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 4usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -207,16 +219,25 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
         let mask = 240u64 as u32;
         let val = val as u32 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 4usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn l4_type(&self) -> u32 {
         let mask = 3840u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 8usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -225,16 +246,25 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
         let mask = 3840u64 as u32;
         let val = val as u32 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 8usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn tun_type(&self) -> u32 {
         let mask = 61440u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 12usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -243,16 +273,25 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
         let mask = 61440u64 as u32;
         let val = val as u32 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 12usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn inner_l2_type(&self) -> u32 {
         let mask = 983040u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 16usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -261,16 +300,25 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
         let mask = 983040u64 as u32;
         let val = val as u32 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 16usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn inner_l3_type(&self) -> u32 {
         let mask = 15728640u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 20usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -279,16 +327,25 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
         let mask = 15728640u64 as u32;
         let val = val as u32 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 20usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn inner_l4_type(&self) -> u32 {
         let mask = 251658240u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 24usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -297,10 +354,16 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
         let mask = 251658240u64 as u32;
         let val = val as u32 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 24usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(l2_type: u32, l3_type: u32, l4_type: u32,
@@ -590,7 +653,10 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
     pub fn l2_len(&self) -> u64 {
         let mask = 127u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u64) }
     }
@@ -599,16 +665,25 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
         let mask = 127u64 as u64;
         let val = val as u64 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn l3_len(&self) -> u64 {
         let mask = 65408u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 7usize;
         unsafe { ::std::mem::transmute(val as u64) }
     }
@@ -617,16 +692,25 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
         let mask = 65408u64 as u64;
         let val = val as u64 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 7usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn l4_len(&self) -> u64 {
         let mask = 16711680u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 16usize;
         unsafe { ::std::mem::transmute(val as u64) }
     }
@@ -635,16 +719,25 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
         let mask = 16711680u64 as u64;
         let val = val as u64 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 16usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn tso_segsz(&self) -> u64 {
         let mask = 1099494850560u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 24usize;
         unsafe { ::std::mem::transmute(val as u64) }
     }
@@ -653,16 +746,25 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
         let mask = 1099494850560u64 as u64;
         let val = val as u64 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 24usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn outer_l3_len(&self) -> u64 {
         let mask = 561850441793536u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 40usize;
         unsafe { ::std::mem::transmute(val as u64) }
     }
@@ -671,16 +773,25 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
         let mask = 561850441793536u64 as u64;
         let val = val as u64 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 40usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn outer_l2_len(&self) -> u64 {
         let mask = 71494644084506624u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 49usize;
         unsafe { ::std::mem::transmute(val as u64) }
     }
@@ -689,10 +800,16 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
         let mask = 71494644084506624u64 as u64;
         let val = val as u64 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 49usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(l2_len: u64, l3_len: u64, l4_len: u64,
diff --git a/tests/expectations/tests/only_bitfields.rs b/tests/expectations/tests/only_bitfields.rs
index dd4fc4d9..6e4d6270 100644
--- a/tests/expectations/tests/only_bitfields.rs
+++ b/tests/expectations/tests/only_bitfields.rs
@@ -25,7 +25,10 @@ impl C {
     pub fn a(&self) -> bool {
         let mask = 1u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -34,16 +37,25 @@ impl C {
         let mask = 1u64 as u8;
         let val = val as u8 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn b(&self) -> bool {
         let mask = 254u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 1usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -52,10 +64,16 @@ impl C {
         let mask = 254u64 as u8;
         let val = val as u8 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 1usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(a: bool, b: bool) -> u8 {
diff --git a/tests/expectations/tests/struct_with_bitfields.rs b/tests/expectations/tests/struct_with_bitfields.rs
index 407c8ad3..2c6a5f2b 100644
--- a/tests/expectations/tests/struct_with_bitfields.rs
+++ b/tests/expectations/tests/struct_with_bitfields.rs
@@ -31,7 +31,10 @@ impl bitfield {
     pub fn a(&self) -> ::std::os::raw::c_ushort {
         let mask = 1u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -40,16 +43,25 @@ impl bitfield {
         let mask = 1u64 as u8;
         let val = val as u16 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn b(&self) -> ::std::os::raw::c_ushort {
         let mask = 2u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 1usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -58,16 +70,25 @@ impl bitfield {
         let mask = 2u64 as u8;
         let val = val as u16 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 1usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn c(&self) -> ::std::os::raw::c_ushort {
         let mask = 4u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 2usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -76,16 +97,25 @@ impl bitfield {
         let mask = 4u64 as u8;
         let val = val as u16 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 2usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn d(&self) -> ::std::os::raw::c_ushort {
         let mask = 192u64 as u8;
         let unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         let val = (unit_field_val & mask) >> 6usize;
         unsafe { ::std::mem::transmute(val as u16) }
     }
@@ -94,10 +124,16 @@ impl bitfield {
         let mask = 192u64 as u8;
         let val = val as u16 as u8;
         let mut unit_field_val: u8 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u8)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 6usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u8, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(a: ::std::os::raw::c_ushort,
@@ -115,7 +151,10 @@ impl bitfield {
     pub fn f(&self) -> ::std::os::raw::c_uint {
         let mask = 3u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_2) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -124,16 +163,25 @@ impl bitfield {
         let mask = 3u64 as u64;
         let val = val as u32 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_2) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn g(&self) -> ::std::os::raw::c_uint {
         let mask = 18446744069414584320u64 as u64;
         let unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_2) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as
+                                               *const u64)
+            };
         let val = (unit_field_val & mask) >> 32usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -142,10 +190,16 @@ impl bitfield {
         let mask = 18446744069414584320u64 as u64;
         let val = val as u32 as u64;
         let mut unit_field_val: u64 =
-            unsafe { ::std::mem::transmute(self._bitfield_2) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as
+                                               *const u64)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 32usize) & mask;
-        self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as
+                                            *mut u64, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_2(f: ::std::os::raw::c_uint,
diff --git a/tests/expectations/tests/union_with_anon_struct_bitfield.rs b/tests/expectations/tests/union_with_anon_struct_bitfield.rs
index 47db2c93..a60d1115 100644
--- a/tests/expectations/tests/union_with_anon_struct_bitfield.rs
+++ b/tests/expectations/tests/union_with_anon_struct_bitfield.rs
@@ -56,7 +56,10 @@ impl foo__bindgen_ty_1 {
     pub fn b(&self) -> ::std::os::raw::c_int {
         let mask = 127u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -65,16 +68,25 @@ impl foo__bindgen_ty_1 {
         let mask = 127u64 as u32;
         let val = val as u32 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn c(&self) -> ::std::os::raw::c_int {
         let mask = 4294967168u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 7usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -83,10 +95,16 @@ impl foo__bindgen_ty_1 {
         let mask = 4294967168u64 as u32;
         let val = val as u32 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 7usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(b: ::std::os::raw::c_int, c: ::std::os::raw::c_int)
diff --git a/tests/expectations/tests/weird_bitfields.rs b/tests/expectations/tests/weird_bitfields.rs
index 00d7a55d..5b85c4e3 100644
--- a/tests/expectations/tests/weird_bitfields.rs
+++ b/tests/expectations/tests/weird_bitfields.rs
@@ -108,7 +108,10 @@ impl Weird {
     pub fn bitTest(&self) -> ::std::os::raw::c_uint {
         let mask = 65535u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -117,16 +120,25 @@ impl Weird {
         let mask = 65535u64 as u32;
         let val = val as u32 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn bitTest2(&self) -> ::std::os::raw::c_uint {
         let mask = 2147418112u64 as u32;
         let unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         let val = (unit_field_val & mask) >> 16usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -135,10 +147,16 @@ impl Weird {
         let mask = 2147418112u64 as u32;
         let val = val as u32 as u32;
         let mut unit_field_val: u32 =
-            unsafe { ::std::mem::transmute(self._bitfield_1) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_1 as *const _ as
+                                               *const u32)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 16usize) & mask;
-        self._bitfield_1 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_1 as *mut _ as
+                                            *mut u32, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_1(bitTest: ::std::os::raw::c_uint,
@@ -150,7 +168,10 @@ impl Weird {
     pub fn mFillOpacitySource(&self) -> nsStyleSVGOpacitySource {
         let mask = 7u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_2) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 0usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -159,16 +180,25 @@ impl Weird {
         let mask = 7u64 as u16;
         let val = val as u32 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_2) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 0usize) & mask;
-        self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn mStrokeOpacitySource(&self) -> nsStyleSVGOpacitySource {
         let mask = 56u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_2) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 3usize;
         unsafe { ::std::mem::transmute(val as u32) }
     }
@@ -177,16 +207,25 @@ impl Weird {
         let mask = 56u64 as u16;
         let val = val as u32 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_2) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 3usize) & mask;
-        self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn mStrokeDasharrayFromObject(&self) -> bool {
         let mask = 64u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_2) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 6usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -195,16 +234,25 @@ impl Weird {
         let mask = 64u64 as u16;
         let val = val as u8 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_2) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 6usize) & mask;
-        self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn mStrokeDashoffsetFromObject(&self) -> bool {
         let mask = 128u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_2) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 7usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -213,16 +261,25 @@ impl Weird {
         let mask = 128u64 as u16;
         let val = val as u8 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_2) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 7usize) & mask;
-        self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn mStrokeWidthFromObject(&self) -> bool {
         let mask = 256u64 as u16;
         let unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_2) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as
+                                               *const u16)
+            };
         let val = (unit_field_val & mask) >> 8usize;
         unsafe { ::std::mem::transmute(val as u8) }
     }
@@ -231,10 +288,16 @@ impl Weird {
         let mask = 256u64 as u16;
         let val = val as u8 as u16;
         let mut unit_field_val: u16 =
-            unsafe { ::std::mem::transmute(self._bitfield_2) };
+            unsafe {
+                ::std::ptr::read_unaligned(&self._bitfield_2 as *const _ as
+                                               *const u16)
+            };
         unit_field_val &= !mask;
         unit_field_val |= (val << 8usize) & mask;
-        self._bitfield_2 = unsafe { ::std::mem::transmute(unit_field_val) };
+        unsafe {
+            ::std::ptr::write_unaligned(&mut self._bitfield_2 as *mut _ as
+                                            *mut u16, unit_field_val);
+        }
     }
     #[inline]
     pub fn new_bitfield_2(mFillOpacitySource: nsStyleSVGOpacitySource,