always add padding bytes for latest_offset

Author: flier

src/codegen/struct_layout.rs

@@ -94,9 +94,11 @@ impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
                     }
                 };
 
+                self.latest_offset += padding_bytes;
+
                 debug!("align field {} to {}/{} with {} padding bytes {:?}, calculated {:?}",
                     field_name,
-                    self.latest_offset + padding_bytes,
+                    self.latest_offset,
                     field_offset.unwrap_or(0) / 8,
                     padding_bytes,
                     field_layout,
@@ -111,8 +113,7 @@ impl<'a, 'ctx> StructLayoutTracker<'a, 'ctx> {
                 }
             };
 
-            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 += 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);

tests/expectations/tests/layout_array.rs

@@ -7,6 +7,7 @@
 pub const RTE_CACHE_LINE_SIZE: ::std::os::raw::c_uint = 64;
 pub const RTE_MEMPOOL_OPS_NAMESIZE: ::std::os::raw::c_uint = 32;
 pub const RTE_MEMPOOL_MAX_OPS_IDX: ::std::os::raw::c_uint = 16;
+pub const RTE_HEAP_NUM_FREELISTS: ::std::os::raw::c_uint = 13;
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct rte_mempool([u8; 0]);
@@ -154,3 +155,52 @@ fn bindgen_test_layout_rte_mempool_ops_table() {
 impl Clone for rte_mempool_ops_table {
     fn clone(&self) -> Self { *self }
 }
+/**
+ * Structure to hold malloc heap
+ */
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct malloc_heap {
+    pub lock: rte_spinlock_t,
+    pub free_head: [malloc_heap__bindgen_ty_1; 13usize],
+    pub alloc_count: ::std::os::raw::c_uint,
+    pub total_size: usize,
+}
+#[repr(C)]
+#[derive(Debug, Copy)]
+pub struct malloc_heap__bindgen_ty_1 {
+    pub lh_first: *mut malloc_heap__bindgen_ty_1_malloc_elem,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct malloc_heap__bindgen_ty_1_malloc_elem([u8; 0]);
+#[test]
+fn bindgen_test_layout_malloc_heap__bindgen_ty_1() {
+    assert_eq!(::std::mem::size_of::<malloc_heap__bindgen_ty_1>() , 8usize);
+    assert_eq! (::std::mem::align_of::<malloc_heap__bindgen_ty_1>() , 8usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const malloc_heap__bindgen_ty_1 ) ) . lh_first
+                as * const _ as usize } , 0usize);
+}
+impl Clone for malloc_heap__bindgen_ty_1 {
+    fn clone(&self) -> Self { *self }
+}
+#[test]
+fn bindgen_test_layout_malloc_heap() {
+    assert_eq!(::std::mem::size_of::<malloc_heap>() , 128usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const malloc_heap ) ) . lock as * const _ as
+                usize } , 0usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const malloc_heap ) ) . free_head as * const _
+                as usize } , 8usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const malloc_heap ) ) . alloc_count as * const
+                _ as usize } , 112usize);
+    assert_eq! (unsafe {
+                & ( * ( 0 as * const malloc_heap ) ) . total_size as * const _
+                as usize } , 120usize);
+}
+impl Clone for malloc_heap {
+    fn clone(&self) -> Self { *self }
+}

tests/headers/layout_array.h

@@ -3,6 +3,8 @@ typedef unsigned short uint16_t;
 typedef unsigned int uint32_t;
 typedef unsigned long long uint64_t;
 
+typedef long long size_t;
+
 #define RTE_CACHE_LINE_SIZE 64
 
 /**
@@ -85,4 +87,23 @@ struct rte_mempool_ops_table {
 	 * Storage for all possible ops structs.
 	 */
 	struct rte_mempool_ops ops[RTE_MEMPOOL_MAX_OPS_IDX];
-} __rte_cache_aligned;
+} __rte_cache_aligned;
+
+
+/* Number of free lists per heap, grouped by size. */
+#define RTE_HEAP_NUM_FREELISTS  13
+
+#define LIST_HEAD(name, type)                                           \
+struct name {                                                           \
+		struct type *lh_first;  /* first element */                     \
+}
+
+/**
+ * Structure to hold malloc heap
+ */
+struct malloc_heap {
+	rte_spinlock_t lock;
+	LIST_HEAD(, malloc_elem) free_head[RTE_HEAP_NUM_FREELISTS];
+	unsigned alloc_count;
+	size_t total_size;
+} __rte_cache_aligned;