Support bitfield allocation units larger than 64 bits

Individual bitfields are still limited to at most 64 bits, but this
restriction can be weakened when Rust supports u128.

This implements issue #816.

Usage notes:

* Since common code is added to each generated binding, a program which uses
  more than one binding may need to work around the duplication by including
  each binding in its own module.
* The values created by bitfield allocation unit constructors can be assigned
  directly to the corresponding struct fields with no need for transmutation.

Implementation notes:

__BindgenBitfieldUnit represents a bitfield allocation unit using a Storage
type accessible as a slice of u8. The alignment of the unit is inherited from
an Align type by virtue of the field:

align: [Align; 0],

The position of this field in the struct is irrelevant.

The alignment of the Storage type is intended to be no larger than the
alignment of the Align type, which will be true if the Storage type is, for
example, an array of u8.

Although the double underscore (__) prefix is reserved for implementations of
C++, there are precedents for this convention elsewhere in bindgen and so the
convention is adopted here too.

Acknowledgement:

Thanks to @fitzgen for an initial implementation of __BindgenBitfieldUnit and
code to integrate it into bindgen.

bindgen-integration/build.rs

@@ -20,7 +20,7 @@ impl ParseCallbacks for MacroCallback {
 }
 
 fn main() {
-    gcc::Config::new()
+    gcc::Build::new()
         .cpp(true)
         .file("cpp/Test.cc")
         .compile("libtest.a");

bindgen-integration/cpp/Test.cc

@@ -69,11 +69,11 @@ Date2::assert(unsigned short nWeekDay,
               unsigned short nYear,
               unsigned short byte)
 {
-  return this->nWeekDay == nWeekDay &&
-      this->nMonthDay == nMonthDay &&
-      this->nMonth == nMonth &&
-      this->nYear == nYear &&
-      this->byte == byte;
+    return this->nWeekDay == nWeekDay &&
+        this->nMonthDay == nMonthDay &&
+        this->nMonth == nMonth &&
+        this->nYear == nYear &&
+        this->byte == byte;
 }
 
 bool
@@ -83,22 +83,39 @@ Fifth::assert(unsigned short nWeekDay,
               unsigned short nYear,
               unsigned char byte)
 {
-  return this->nWeekDay == nWeekDay &&
-      this->nMonthDay == nMonthDay &&
-      this->nMonth == nMonth &&
-      this->nYear == nYear &&
-      this->byte == byte;
+    return this->nWeekDay == nWeekDay &&
+        this->nMonthDay == nMonthDay &&
+        this->nMonth == nMonth &&
+        this->nYear == nYear &&
+        this->byte == byte;
 }
 
 bool
 Sixth::assert(unsigned char byte,
               unsigned char nWeekDay,
               unsigned char nMonth,
               unsigned char nMonthDay) {
-  return this->nWeekDay == nWeekDay &&
-      this->nMonthDay == nMonthDay &&
-      this->nMonth == nMonth &&
-      this->byte == byte;
+    return this->nWeekDay == nWeekDay &&
+        this->nMonthDay == nMonthDay &&
+        this->nMonth == nMonth &&
+        this->byte == byte;
+};
+
+bool
+Seventh::assert(bool first,
+                int second,
+                unsigned short third,
+                unsigned int fourth,
+                unsigned short fifth,
+                bool sixth,
+                int seventh) {
+  return this->first_one_bit == first &&
+      this->second_thirty_bits == second &&
+      this->third_two_bits == third &&
+      this->fourth_thirty_bits == fourth &&
+      this->fifth_two_bits == fifth &&
+      this->sixth_one_bit == sixth &&
+      this->seventh_thirty_bits == seventh;
 };
 
 } // namespace bitfields

bindgen-integration/cpp/Test.h

@@ -121,6 +121,24 @@ struct Sixth {
                 unsigned char nMonthDay);
 };
 
+struct Seventh {
+    bool first_one_bit : 1;
+    unsigned int second_thirty_bits : 30;
+    unsigned short third_two_bits : 2;
+    unsigned int fourth_thirty_bits : 30;
+    unsigned short fifth_two_bits : 2;
+    bool sixth_one_bit : 1;
+    unsigned int seventh_thirty_bits : 30;
+
+    /// Returns true if the bitfields match the arguments, false otherwise.
+    bool assert(bool first,
+                int second,
+                unsigned short third,
+                unsigned int fourth,
+                unsigned short fifth,
+                bool sixth,
+                int seventh);
+};
 
 } // namespace bitfields
 

bindgen-integration/src/lib.rs

@@ -179,11 +179,42 @@ fn test_bitfields_sixth() {
     });
 }
 
+#[test]
+fn test_bitfields_seventh() {
+    let mut large: bindings::bitfields::Seventh = unsafe {
+        mem::zeroed()
+    };
+
+    assert!(unsafe {
+        large.assert(false, 0, 0, 0, 0, false, 0)
+    });
+
+    large.set_first_one_bit(true);
+    large.set_second_thirty_bits(375028802);
+    large.set_third_two_bits(2);
+    large.set_fourth_thirty_bits(643472885);
+    large.set_fifth_two_bits(3);
+    large.set_sixth_one_bit(true);
+    large.set_seventh_thirty_bits(1061657575);
+
+    assert!(unsafe {
+        large.assert(true, 375028802, 2, 643472885, 3, true, 1061657575)
+    });
+
+    assert_eq!(large.first_one_bit(), true);
+    assert_eq!(large.second_thirty_bits(), 375028802);
+    assert_eq!(large.third_two_bits(), 2);
+    assert_eq!(large.fourth_thirty_bits(), 643472885);
+    assert_eq!(large.fifth_two_bits(), 3);
+    assert_eq!(large.sixth_one_bit(), true);
+    assert_eq!(large.seventh_thirty_bits(), 1061657575);
+}
+
 #[test]
 fn test_bitfield_constructors() {
     use std::mem;
     let mut first = bindings::bitfields::First {
-        _bitfield_1: unsafe { mem::transmute(bindings::bitfields::First::new_bitfield_1(1, 2, 3)) }
+        _bitfield_1: bindings::bitfields::First::new_bitfield_1(1, 2, 3)
     };
     assert!(unsafe {
         first.assert(1, 2, 3)

src/codegen/bitfield_unit.rs

@@ -0,0 +1,82 @@
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage, Align>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    storage: Storage,
+    align: [Align; 0],
+}
+
+impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn new(storage: Storage) -> Self {
+        Self {
+            storage,
+            align: [],
+        }
+    }
+
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+
+        let bit_index = index % 8;
+        let mask = 1 << bit_index;
+
+        byte & mask == mask
+    }
+
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+
+        let bit_index = index % 8;
+        let mask = 1 << bit_index;
+
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
+
+        let mut val = 0;
+
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                val |= 1 << i;
+            }
+        }
+
+        val
+    }
+
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
+
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            self.set_bit(i + bit_offset, val_bit_is_set);
+        }
+    }
+}