WIP issue rust-lang#1076

Author: fitzgen

src/codegen/mod.rs

@@ -1189,16 +1189,18 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit {
         };
         fields.extend(Some(field));
 
+        let field_int_align = self.layout().align;
         let mut field_int_size = self.layout().size;
         if !field_int_size.is_power_of_two() {
             field_int_size = field_int_size.next_power_of_two();
         }
 
         let unit_field_int_ty = match field_int_size {
+            1 => quote! { u8  },
+            n if field_int_align == 1 => quote! { [u8; #n] },
             8 => quote! { u64 },
             4 => quote! { u32 },
             2 => quote! { u16 },
-            1 => quote! { u8  },
             size => {
                 debug_assert!(size > 8);
                 // Can't generate bitfield accessors for unit sizes larget than

src/ir/comp.rs

@@ -574,7 +574,13 @@ fn bitfields_to_allocation_units<E, I>(
             .layout(ctx)
             .expect("Bitfield without layout? Gah!");
         let bitfield_size = bitfield_layout.size;
-        let bitfield_align = bitfield_layout.align;
+        let bitfield_align = if bitfield.name().is_none() {
+            // Anonymous bitfields can never be read, so unaligned reads are not
+            // a worry, and they don't contribute to alignement.
+            1
+        } else {
+            bitfield_layout.align
+        };
 
         let mut offset = unit_size_in_bits;
         if is_ms_struct {
@@ -612,20 +618,22 @@ fn bitfields_to_allocation_units<E, I>(
             }
         }
 
+        max_align = cmp::max(max_align, bitfield_align);
+
+        // NB: The `bitfield_width` here is completely, absolutely intentional.
+        // Alignment of the allocation unit is based on the maximum bitfield
+        // width, not (directly) on the bitfields' types' alignment.
+        if bitfield.name().is_some() {
+            unit_align = cmp::max(unit_align, bitfield_width);
+        }
+
         // Always keep all bitfields around. While unnamed bitifields are used
         // for padding (and usually not needed hereafter), large unnamed
         // bitfields over their types size cause weird allocation size behavior from clang.
         // Therefore, all bitfields needed to be kept around in order to check for this
         // and make the struct opaque in this case
         bitfields_in_unit.push(Bitfield::new(offset, bitfield));
 
-        max_align = cmp::max(max_align, bitfield_align);
-
-        // NB: The `bitfield_width` here is completely, absolutely intentional.
-        // Alignment of the allocation unit is based on the maximum bitfield
-        // width, not (directly) on the bitfields' types' alignment.
-        unit_align = cmp::max(unit_align, bitfield_width);
-
         unit_size_in_bits = offset + bitfield_width;
 
         // Compute what the physical unit's final size would be given what we

tests/headers/issue-1076-anon-bitfields-and-alignment.h

@@ -0,0 +1,8 @@
+/**
+ * Because anonymous bitfields can't be read, we don't need to worry about
+ * unaligned reads, and therefore they don't contribute to alignment.
+ */
+struct S1 {
+    signed : 15;
+    unsigned : 6
+};