use field offset to handle field level align attribute

Author: flier

src/codegen/mod.rs

@@ -1113,6 +1113,11 @@ impl CodeGenerator for CompInfo {
                 }
             };
 
+            if let Some(padding_field) =
+                struct_layout.pad_field(&field_name, field_ty, field.offset()) {
+                fields.push(padding_field);
+            }
+
             let is_private = field.annotations()
                 .private_fields()
                 .unwrap_or(fields_should_be_private);
@@ -1130,10 +1135,6 @@ impl CodeGenerator for CompInfo {
             let field = field.with_attrs(attrs)
                 .build_ty(ty.clone());
 
-            if let Some(padding_field) = struct_layout.pad_field(field_ty) {
-                fields.push(padding_field);
-            }
-
             fields.push(field);
 
             // TODO: Factor the following code out, please!

src/codegen/struct_layout.rs

@@ -68,41 +68,56 @@ impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
         self.max_field_align = cmp::max(self.max_field_align, layout.align);
     }
 
-    pub fn pad_field(&mut self, field_ty: &Type) -> Option<ast::StructField> {
+    pub fn pad_field(&mut self,
+                     field_name: &str,
+                     field_ty: &Type,
+                     field_offset: Option<usize>)
+                     -> Option<ast::StructField> {
         field_ty.layout(self.ctx).and_then(|field_layout| {
             self.align_to_latest_field();
 
-            let calculated_layout = field_ty.as_comp()
-                .and_then(|comp| comp.calc_layout(self.ctx))
-                .unwrap_or(field_layout);
-
-            let padding_bytes = if self.comp.packed() {
-                0
-            } else {
-                self.padding_bytes(field_layout)
-            };
-            let align = if self.comp.packed() {
-                mem::size_of::<u8>()
+            let padding_layout = if self.comp.packed() {
+                None
             } else {
-                cmp::min(calculated_layout.align, mem::size_of::<*mut ()>())
+                let calculated_layout = field_ty.as_comp()
+                    .and_then(|comp| comp.calc_layout(self.ctx))
+                    .unwrap_or(field_layout);
+
+                let align = cmp::min(calculated_layout.align, mem::size_of::<*mut ()>());
+
+                let (padding_bytes, need_padding) = match field_offset {
+                    Some(offset) if offset / 8  > self.latest_offset => {
+                        (offset / 8  - self.latest_offset, true)
+                    }
+                    _ => {
+                        (self.padding_bytes(field_layout), (self.latest_offset % field_layout.align) != 0)
+                    }
+                };
+
+                debug!("align field {} to {}/{} with {} padding bytes {:?}, calculated {:?}",
+                    field_name,
+                    self.latest_offset + padding_bytes,
+                    field_offset.unwrap_or(0) / 8,
+                    padding_bytes,
+                    field_layout,
+                    calculated_layout);
+
+                if need_padding &&
+                   (padding_bytes > calculated_layout.align ||
+                    field_layout.align > mem::size_of::<*mut ()>()) {
+                    Some(Layout::new(padding_bytes, align))
+                } else {
+                    None
+                }
             };
 
-            let need_padding = (self.latest_offset % field_layout.align) != 0 &&
-                               (padding_bytes > calculated_layout.align ||
-                                field_layout.align > mem::size_of::<*mut ()>());
+            self.latest_offset += padding_layout.map(|layout| layout.size).unwrap_or(0) +
+                                  field_ty.calc_size(self.ctx).unwrap_or(field_layout.size);
 
-            self.latest_offset += padding_bytes +
-                                  field_ty.calc_size(self.ctx)
-                .unwrap_or(field_layout.size);
             self.latest_field_layout = Some(field_layout);
-            self.max_field_align = cmp::max(self.max_field_align,
-                                            field_layout.align);
+            self.max_field_align = cmp::max(self.max_field_align, field_layout.align);
 
-            if need_padding {
-                Some(self.padding_field(Layout::new(padding_bytes, align)))
-            } else {
-                None
-            }
+            padding_layout.map(|layout| self.padding_field(layout))
         })
     }
 
@@ -114,16 +129,19 @@ impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
             None
         } else {
             let padding_bytes = layout.size - self.latest_offset;
+            let struct_align = cmp::min(layout.align,
+                                        mem::size_of::<*mut ()>());
 
-            let align = if self.comp.packed() {
-                mem::size_of::<u8>()
-            } else {
-                cmp::min(layout.align, mem::size_of::<*mut ()>())
-            };
-
-            if padding_bytes >= align ||
+            if padding_bytes > struct_align ||
                (layout.align > mem::size_of::<*mut ()>() && padding_bytes > 0) {
-                Some(self.padding_field(Layout::new(padding_bytes, align)))
+                let padding_align = if self.comp.packed() {
+                    1
+                } else {
+                    cmp::min(1 << padding_bytes.trailing_zeros(),
+                             mem::size_of::<*mut ()>())
+                };
+
+                Some(self.padding_field(Layout::new(padding_bytes, padding_align)))
             } else {
                 None
             }
@@ -165,7 +183,9 @@ impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
     }
 
     fn align_to_latest_field(&mut self) {
-        if let Some(layout) = self.latest_field_layout {
+        if self.comp.packed() {
+            // skip to align field when packed
+        } else if let Some(layout) = self.latest_field_layout {
             self.latest_offset += self.padding_bytes(layout);
         }
     }

tests/expectations/tests/layout_kni_mbuf.rs

@@ -0,0 +1,82 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+pub const RTE_CACHE_LINE_MIN_SIZE: ::std::os::raw::c_uint = 64;
+pub const RTE_CACHE_LINE_SIZE: ::std::os::raw::c_uint = 64;
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct rte_kni_mbuf {
+    pub buf_addr: *mut ::std::os::raw::c_void,
+    pub buf_physaddr: u64,
+    pub pad0: [::std::os::raw::c_char; 2usize],
+    /**< Start address of data in segment buffer. */
+    pub data_off: u16,
+    pub pad1: [::std::os::raw::c_char; 2usize],
+    /**< Number of segments. */
+    pub nb_segs: u8,
+    pub pad4: [::std::os::raw::c_char; 1usize],
+    /**< Offload features. */
+    pub ol_flags: u64,
+    pub pad2: [::std::os::raw::c_char; 4usize],
+    /**< Total pkt len: sum of all segment data_len. */
+    pub pkt_len: u32,
+    /**< Amount of data in segment buffer. */
+    pub data_len: u16,
+    pub __bindgen_padding_0: [u8; 22usize],
+    pub pad3: [::std::os::raw::c_char; 8usize],
+    pub pool: *mut ::std::os::raw::c_void,
+    pub next: *mut ::std::os::raw::c_void,
+    pub __bindgen_padding_1: [u64; 5usize],
+}
+#[test]
+fn bindgen_test_layout_rte_kni_mbuf() {
+    assert_eq!(::std::mem::size_of::<rte_kni_mbuf>() , 128usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_kni_mbuf ) ) . buf_addr as * const _
+                as usize } , 0usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_kni_mbuf ) ) . buf_physaddr as *
+                const _ as usize } , 8usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_kni_mbuf ) ) . pad0 as * const _ as
+                usize } , 16usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_kni_mbuf ) ) . data_off as * const _
+                as usize } , 18usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_kni_mbuf ) ) . pad1 as * const _ as
+                usize } , 20usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_kni_mbuf ) ) . nb_segs as * const _
+                as usize } , 22usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_kni_mbuf ) ) . pad4 as * const _ as
+                usize } , 23usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_kni_mbuf ) ) . ol_flags as * const _
+                as usize } , 24usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_kni_mbuf ) ) . pad2 as * const _ as
+                usize } , 32usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_kni_mbuf ) ) . pkt_len as * const _
+                as usize } , 36usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_kni_mbuf ) ) . data_len as * const _
+                as usize } , 40usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_kni_mbuf ) ) . pad3 as * const _ as
+                usize } , 64usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_kni_mbuf ) ) . pool as * const _ as
+                usize } , 72usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const rte_kni_mbuf ) ) . next as * const _ as
+                usize } , 80usize);
+}
+impl Clone for rte_kni_mbuf {
+    fn clone(&self) -> Self { *self }
+}

tests/expectations/tests/layout_mbuf.rs

@@ -103,7 +103,7 @@ pub struct rte_mbuf {
     pub priv_size: u16,
     /** Timesync flags for use with IEEE1588. */
     pub timesync: u16,
-    pub __bindgen_padding_0: [u64; 3usize],
+    pub __bindgen_padding_0: [u32; 7usize],
 }
 /**
 	 * 16-bit Reference counter.

tests/headers/layout_kni_mbuf.h

@@ -0,0 +1,32 @@
+
+#define RTE_CACHE_LINE_MIN_SIZE 64	/**< Minimum Cache line size. */
+
+#define RTE_CACHE_LINE_SIZE 64
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+
+/*
+ * The kernel image of the rte_mbuf struct, with only the relevant fields.
+ * Padding is necessary to assure the offsets of these fields
+ */
+struct rte_kni_mbuf {
+	void *buf_addr __attribute__((__aligned__(RTE_CACHE_LINE_SIZE)));
+	uint64_t buf_physaddr;
+	char pad0[2];
+	uint16_t data_off;      /**< Start address of data in segment buffer. */
+	char pad1[2];
+	uint8_t nb_segs;        /**< Number of segments. */
+	char pad4[1];
+	uint64_t ol_flags;      /**< Offload features. */
+	char pad2[4];
+	uint32_t pkt_len;       /**< Total pkt len: sum of all segment data_len. */
+	uint16_t data_len;      /**< Amount of data in segment buffer. */
+
+	/* fields on second cache line */
+	char pad3[8] __attribute__((__aligned__(RTE_CACHE_LINE_MIN_SIZE)));
+	void *pool;
+	void *next;
+};