Transfer the packed attribute on unions to repr(packed)

c2rust-transpile/src/c_ast/conversion.rs

@@ -1946,6 +1946,8 @@ impl ConversionContext {
                     let name = expect_opt_str(&node.extras[0]).unwrap().map(str::to_string);
                     let has_def = from_value(node.extras[1].clone())
                         .expect("Expected has_def flag on struct");
+                    let attrs = from_value::<Vec<Value>>(node.extras[2].clone())
+                        .expect("Expected attribute array on record");
                     let fields: Option<Vec<CDeclId>> = if has_def {
                         Some(
                             node.children
@@ -1962,7 +1964,18 @@ impl ConversionContext {
                         None
                     };
 
-                    let record = CDeclKind::Union { name, fields };
+                    let mut is_packed = false;
+                    for attr in attrs {
+                        match from_value::<String>(attr.clone())
+                            .expect("Records attributes should be strings")
+                            .as_str()
+                        {
+                            "packed" => is_packed = true,
+                            _ => {}
+                        }
+                    }
+
+                    let record = CDeclKind::Union { name, fields, is_packed };
 
                     self.add_decl(new_id, located(node, record));
                     self.processed_nodes.insert(new_id, RECORD_DECL);

c2rust-transpile/src/c_ast/mod.rs

@@ -933,6 +933,7 @@ pub enum CDeclKind {
     Union {
         name: Option<String>,
         fields: Option<Vec<CFieldId>>,
+        is_packed: bool,
     },
 
     // Field

c2rust-transpile/src/translator/mod.rs

@@ -1614,6 +1614,7 @@ impl<'c> Translation<'c> {
 
             CDeclKind::Union {
                 fields: Some(ref fields),
+                is_packed,
                 ..
             } => {
                 let name = self
@@ -1642,21 +1643,26 @@ impl<'c> Translation<'c> {
                     }
                 }
 
+                let mut repr = vec!["C"];
+                if is_packed {
+                    repr.push("packed");
+                }
+
                 Ok(if field_syns.is_empty() {
                     // Empty unions are a GNU extension, but Rust doesn't allow empty unions.
                     ConvertedDecl::Item(
                         mk().span(s)
                             .pub_()
                             .call_attr("derive", vec!["Copy", "Clone"])
-                            .call_attr("repr", vec!["C"])
+                            .call_attr("repr", repr)
                             .struct_item(name, vec![], false),
                     )
                 } else {
                     ConvertedDecl::Item(
                         mk().span(s)
                             .pub_()
                             .call_attr("derive", vec!["Copy", "Clone"])
-                            .call_attr("repr", vec!["C"])
+                            .call_attr("repr", repr)
                             .union_item(name, field_syns),
                     )
                 })

tests/unions/src/test_unions.rs

@@ -9,12 +9,12 @@ extern "C" {
     fn entry(_: c_uint, _: *mut c_int);
 }
 
-const BUFFER_SIZE: usize = 18;
+const BUFFER_SIZE: usize = 19;
 
 pub fn test_buffer() {
     let mut buffer = [0; BUFFER_SIZE];
     let mut rust_buffer = [0; BUFFER_SIZE];
-    let expected_buffer = [12, 12, 0, 1, 2, 3, 4, 0, 5, 6, 7, 8, 0, 8, 9, 10, 12, 17];
+    let expected_buffer = [12, 12, 0, 5, 1, 2, 3, 4, 0, 5, 6, 7, 8, 0, 8, 9, 10, 12, 18];
 
     unsafe {
         entry(BUFFER_SIZE as u32, buffer.as_mut_ptr());

tests/unions/src/unions.c

@@ -17,6 +17,11 @@ union union_with_anon_struct {
     };
 };
 
+union __attribute__((packed)) packed_union {
+    int as_int;
+    char as_chars[5];
+};
+
 void entry(const unsigned int buffer_size, int buffer[const])
 {
     int i = 0;
@@ -35,6 +40,7 @@ void entry(const unsigned int buffer_size, int buffer[const])
     buffer[i++] = sizeof(union my_union);
     buffer[i++] = sizeof(union my_union_flipped);
     buffer[i++] = sizeof(union empty_union);
+    buffer[i++] = sizeof(union packed_union);
     buffer[i++] = u1.as_int;
     buffer[i++] = u2.as_int;
     buffer[i++] = u3.as_chars[0];