Fix an UB in layout tests

 - Replaced dereferencing of null ptr with
   zero bit pattern + transmute + std::ptr::addr_of!
   to avoid UB. It affects only checks of fields offsets
 - Overwritten expected with BINDGEN_OVERWRITE_EXPECTED=1
 - Overwritten test_multiple_header_calls_in_builder and test_mixed_header_and_header_contents
   manually because rust-lang#2054
 - Do not check the layout for repr(C) unions
 - Do not call the destructor of tmp struct to avoid other UB

Author: Apostoln

src/codegen/mod.rs

@@ -2084,8 +2084,12 @@ impl CodeGenerator for CompInfo {
                         .count() >
                         1;
 
+
+                    // The offset of #[repr(C)] union is always 0, don't need to recheck it.
+                    let is_not_packed_union = is_union && !packed;
+
                     let should_skip_field_offset_checks =
-                        is_opaque || too_many_base_vtables;
+                        is_opaque || too_many_base_vtables || is_not_packed_union;
 
                     let check_field_offset = if should_skip_field_offset_checks
                     {
@@ -2105,8 +2109,26 @@ impl CodeGenerator for CompInfo {
 
                                         Some(quote! {
                                             assert_eq!(
-                                                unsafe {
-                                                    &(*(::#prefix::ptr::null::<#canonical_ident>())).#field_name as *const _ as usize
+                                                {
+                                                    // Create an instance of #canonical_ident struct from zero bit pattern
+                                                    const STRUCT_SIZE: usize = std::mem::size_of::<#canonical_ident>();
+                                                    let buffer = [0u8; STRUCT_SIZE];
+                                                    let struct_instance = unsafe {
+                                                        // It's safe since #canonical_ident struct allows zero bit pattern
+                                                        std::mem::transmute::<[u8; STRUCT_SIZE], #canonical_ident>(buffer)
+                                                    };
+                                                    // Get the pointers to the struct and its field
+                                                    let struct_ptr = &struct_instance as *const #canonical_ident;
+                                                    let field_ptr = std::ptr::addr_of!(struct_instance.#field_name);
+
+                                                    // Get the offset of the field
+                                                    let struct_address =  struct_ptr as usize;
+                                                    let field_address = field_ptr as usize;
+
+                                                    //Do not call the destructor
+                                                    std::mem::forget(struct_instance);
+
+                                                    field_address.checked_sub(struct_address).unwrap()
                                                 },
                                                 #field_offset,
                                                 concat!("Offset of field: ", stringify!(#canonical_ident), "::", stringify!(#field_name))

tests/expectations/tests/16-byte-alignment.rs

@@ -43,10 +43,24 @@ fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>(
-            )))
-            .dport as *const _ as usize
+        {
+            const STRUCT_SIZE: usize = std::mem::size_of::<
+                rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1,
+            >();
+            let buffer = [0u8; STRUCT_SIZE];
+            let struct_instance = unsafe {
+                std::mem::transmute::<
+                    [u8; STRUCT_SIZE],
+                    rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1,
+                >(buffer)
+            };
+            let struct_ptr = &struct_instance
+                as *const rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1;
+            let field_ptr = std::ptr::addr_of!(struct_instance.dport);
+            let struct_address = struct_ptr as usize;
+            let field_address = field_ptr as usize;
+            std::mem::forget(struct_instance);
+            field_address.checked_sub(struct_address).unwrap()
         },
         0usize,
         concat!(
@@ -57,10 +71,24 @@ fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>(
-            )))
-            .sport as *const _ as usize
+        {
+            const STRUCT_SIZE: usize = std::mem::size_of::<
+                rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1,
+            >();
+            let buffer = [0u8; STRUCT_SIZE];
+            let struct_instance = unsafe {
+                std::mem::transmute::<
+                    [u8; STRUCT_SIZE],
+                    rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1,
+                >(buffer)
+            };
+            let struct_ptr = &struct_instance
+                as *const rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1;
+            let field_ptr = std::ptr::addr_of!(struct_instance.sport);
+            let struct_address = struct_ptr as usize;
+            let field_address = field_ptr as usize;
+            std::mem::forget(struct_instance);
+            field_address.checked_sub(struct_address).unwrap()
         },
         2usize,
         concat!(
@@ -83,19 +111,6 @@ fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1() {
         4usize,
         concat!("Alignment of ", stringify!(rte_ipv4_tuple__bindgen_ty_1))
     );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<rte_ipv4_tuple__bindgen_ty_1>())).sctp_tag
-                as *const _ as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv4_tuple__bindgen_ty_1),
-            "::",
-            stringify!(sctp_tag)
-        )
-    );
 }
 impl Default for rte_ipv4_tuple__bindgen_ty_1 {
     fn default() -> Self {
@@ -119,9 +134,18 @@ fn bindgen_test_layout_rte_ipv4_tuple() {
         concat!("Alignment of ", stringify!(rte_ipv4_tuple))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<rte_ipv4_tuple>())).src_addr as *const _
-                as usize
+        {
+            const STRUCT_SIZE: usize = std::mem::size_of::<rte_ipv4_tuple>();
+            let buffer = [0u8; STRUCT_SIZE];
+            let struct_instance = unsafe {
+                std::mem::transmute::<[u8; STRUCT_SIZE], rte_ipv4_tuple>(buffer)
+            };
+            let struct_ptr = &struct_instance as *const rte_ipv4_tuple;
+            let field_ptr = std::ptr::addr_of!(struct_instance.src_addr);
+            let struct_address = struct_ptr as usize;
+            let field_address = field_ptr as usize;
+            std::mem::forget(struct_instance);
+            field_address.checked_sub(struct_address).unwrap()
         },
         0usize,
         concat!(
@@ -132,9 +156,18 @@ fn bindgen_test_layout_rte_ipv4_tuple() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<rte_ipv4_tuple>())).dst_addr as *const _
-                as usize
+        {
+            const STRUCT_SIZE: usize = std::mem::size_of::<rte_ipv4_tuple>();
+            let buffer = [0u8; STRUCT_SIZE];
+            let struct_instance = unsafe {
+                std::mem::transmute::<[u8; STRUCT_SIZE], rte_ipv4_tuple>(buffer)
+            };
+            let struct_ptr = &struct_instance as *const rte_ipv4_tuple;
+            let field_ptr = std::ptr::addr_of!(struct_instance.dst_addr);
+            let struct_address = struct_ptr as usize;
+            let field_address = field_ptr as usize;
+            std::mem::forget(struct_instance);
+            field_address.checked_sub(struct_address).unwrap()
         },
         4usize,
         concat!(
@@ -192,10 +225,24 @@ fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>(
-            )))
-            .dport as *const _ as usize
+        {
+            const STRUCT_SIZE: usize = std::mem::size_of::<
+                rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1,
+            >();
+            let buffer = [0u8; STRUCT_SIZE];
+            let struct_instance = unsafe {
+                std::mem::transmute::<
+                    [u8; STRUCT_SIZE],
+                    rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1,
+                >(buffer)
+            };
+            let struct_ptr = &struct_instance
+                as *const rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1;
+            let field_ptr = std::ptr::addr_of!(struct_instance.dport);
+            let struct_address = struct_ptr as usize;
+            let field_address = field_ptr as usize;
+            std::mem::forget(struct_instance);
+            field_address.checked_sub(struct_address).unwrap()
         },
         0usize,
         concat!(
@@ -206,10 +253,24 @@ fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>(
-            )))
-            .sport as *const _ as usize
+        {
+            const STRUCT_SIZE: usize = std::mem::size_of::<
+                rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1,
+            >();
+            let buffer = [0u8; STRUCT_SIZE];
+            let struct_instance = unsafe {
+                std::mem::transmute::<
+                    [u8; STRUCT_SIZE],
+                    rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1,
+                >(buffer)
+            };
+            let struct_ptr = &struct_instance
+                as *const rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1;
+            let field_ptr = std::ptr::addr_of!(struct_instance.sport);
+            let struct_address = struct_ptr as usize;
+            let field_address = field_ptr as usize;
+            std::mem::forget(struct_instance);
+            field_address.checked_sub(struct_address).unwrap()
         },
         2usize,
         concat!(
@@ -232,19 +293,6 @@ fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1() {
         4usize,
         concat!("Alignment of ", stringify!(rte_ipv6_tuple__bindgen_ty_1))
     );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<rte_ipv6_tuple__bindgen_ty_1>())).sctp_tag
-                as *const _ as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_ipv6_tuple__bindgen_ty_1),
-            "::",
-            stringify!(sctp_tag)
-        )
-    );
 }
 impl Default for rte_ipv6_tuple__bindgen_ty_1 {
     fn default() -> Self {
@@ -268,9 +316,18 @@ fn bindgen_test_layout_rte_ipv6_tuple() {
         concat!("Alignment of ", stringify!(rte_ipv6_tuple))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<rte_ipv6_tuple>())).src_addr as *const _
-                as usize
+        {
+            const STRUCT_SIZE: usize = std::mem::size_of::<rte_ipv6_tuple>();
+            let buffer = [0u8; STRUCT_SIZE];
+            let struct_instance = unsafe {
+                std::mem::transmute::<[u8; STRUCT_SIZE], rte_ipv6_tuple>(buffer)
+            };
+            let struct_ptr = &struct_instance as *const rte_ipv6_tuple;
+            let field_ptr = std::ptr::addr_of!(struct_instance.src_addr);
+            let struct_address = struct_ptr as usize;
+            let field_address = field_ptr as usize;
+            std::mem::forget(struct_instance);
+            field_address.checked_sub(struct_address).unwrap()
         },
         0usize,
         concat!(
@@ -281,9 +338,18 @@ fn bindgen_test_layout_rte_ipv6_tuple() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<rte_ipv6_tuple>())).dst_addr as *const _
-                as usize
+        {
+            const STRUCT_SIZE: usize = std::mem::size_of::<rte_ipv6_tuple>();
+            let buffer = [0u8; STRUCT_SIZE];
+            let struct_instance = unsafe {
+                std::mem::transmute::<[u8; STRUCT_SIZE], rte_ipv6_tuple>(buffer)
+            };
+            let struct_ptr = &struct_instance as *const rte_ipv6_tuple;
+            let field_ptr = std::ptr::addr_of!(struct_instance.dst_addr);
+            let struct_address = struct_ptr as usize;
+            let field_address = field_ptr as usize;
+            std::mem::forget(struct_instance);
+            field_address.checked_sub(struct_address).unwrap()
         },
         16usize,
         concat!(
@@ -322,30 +388,6 @@ fn bindgen_test_layout_rte_thash_tuple() {
         16usize,
         concat!("Alignment of ", stringify!(rte_thash_tuple))
     );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<rte_thash_tuple>())).v4 as *const _ as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_thash_tuple),
-            "::",
-            stringify!(v4)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<rte_thash_tuple>())).v6 as *const _ as usize
-        },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(rte_thash_tuple),
-            "::",
-            stringify!(v6)
-        )
-    );
 }
 impl Default for rte_thash_tuple {
     fn default() -> Self {