Add additional helpers to bitmask data structure

This commit addresses the case where a struct containing a bitfield
is wrapped in a struct such as UnsafeCell which allows interior
mutability.

Previously, bitfield accessors only allowed a receiver. This becomes
problematic in the case of interior mutability as raw pointer access may
be required so as not to violate the aliasing rules in Rust.

bindgen/codegen/bitfield_unit.rs

@@ -16,12 +16,7 @@ where
  Storage: AsRef<[u8]> + AsMut<[u8]>,
 {
  #[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];
-
+ fn extract_bit(byte: u8, index: usize) -> bool {
  let bit_index = if cfg!(target_endian = "big") {
  7 - (index % 8)
  } else {
@@ -34,12 +29,28 @@ where
  }
 
  #[inline]
- pub fn set_bit(&mut self, index: usize, val: bool) {
+ pub fn get_bit(&self, index: usize) -> 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 byte = self.storage.as_ref()[byte_index];
+
+ Self::extract_bit(byte, index)
+ }
+
+ #[inline]
+ pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
+ debug_assert!(index / 8 < std::mem::size_of::<Storage>());
+
+ let byte_index = index / 8;
+ let byte = *(std::ptr::addr_of!((*this).storage) as *const u8)
+ .offset(byte_index as isize);
+
+ Self::extract_bit(byte, index)
+ }
 
+ #[inline]
+ fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
  let bit_index = if cfg!(target_endian = "big") {
  7 - (index % 8)
  } else {
@@ -48,12 +59,33 @@ where
 
  let mask = 1 << bit_index;
  if val {
- *byte |= mask;
+ byte | mask
  } else {
- *byte &= !mask;
+ byte & !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];
+
+ *byte = Self::change_bit(*byte, index, val);
+ }
+
+ #[inline]
+ pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
+ debug_assert!(index / 8 < std::mem::size_of::<Storage>());
+
+ let byte_index = index / 8;
+ let byte = (std::ptr::addr_of_mut!((*this).storage) as *mut u8)
+ .offset(byte_index as isize);
+
+ *byte = Self::change_bit(*byte, index, val);
+ }
+
  #[inline]
  pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
  debug_assert!(bit_width <= 64);
@@ -79,6 +111,35 @@ where
  val
  }
 
+ #[inline]
+ pub unsafe fn raw_get(
+ this: *const Self,
+ bit_offset: usize,
+ bit_width: u8,
+ ) -> u64 {
+ debug_assert!(bit_width <= 64);
+ debug_assert!(bit_offset / 8 < std::mem::size_of::<Storage>());
+ debug_assert!(
+ (bit_offset + (bit_width as usize)) / 8 <=
+ std::mem::size_of::<Storage>()
+ );
+
+ let mut val = 0;
+
+ for i in 0..(bit_width as usize) {
+ if Self::raw_get_bit(this, i + bit_offset) {
+ let index = if cfg!(target_endian = "big") {
+ bit_width as usize - 1 - i
+ } else {
+ i
+ };
+ val |= 1 << index;
+ }
+ }
+
+ val
+ }
+
  #[inline]
  pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
  debug_assert!(bit_width <= 64);
@@ -99,4 +160,30 @@ where
  self.set_bit(index + bit_offset, val_bit_is_set);
  }
  }
+
+ #[inline]
+ pub unsafe fn raw_set(
+ this: *mut Self,
+ bit_offset: usize,
+ bit_width: u8,
+ val: u64,
+ ) {
+ debug_assert!(bit_width <= 64);
+ debug_assert!(bit_offset / 8 < std::mem::size_of::<Storage>());
+ debug_assert!(
+ (bit_offset + (bit_width as usize)) / 8 <=
+ std::mem::size_of::<Storage>()
+ );
+
+ for i in 0..(bit_width as usize) {
+ let mask = 1 << i;
+ let val_bit_is_set = val & mask == mask;
+ let index = if cfg!(target_endian = "big") {
+ bit_width as usize - 1 - i
+ } else {
+ i
+ };
+ Self::raw_set_bit(this, index + bit_offset, val_bit_is_set);
+ }
+ }
 }

bindgen/codegen/mod.rs

@@ -1849,6 +1849,15 @@ fn bitfield_getter_name(
  quote! { #name }
 }
 
+fn bitfield_raw_getter_name(
+ ctx: &BindgenContext,
+ bitfield: &Bitfield,
+) -> proc_macro2::TokenStream {
+ let name = bitfield.getter_name();
+ let name = ctx.rust_ident_raw(format!("raw_{name}"));
+ quote! { #name }
+}
+
 fn bitfield_setter_name(
  ctx: &BindgenContext,
  bitfield: &Bitfield,
@@ -1858,6 +1867,15 @@ fn bitfield_setter_name(
  quote! { #setter }
 }
 
+fn bitfield_raw_setter_name(
+ ctx: &BindgenContext,
+ bitfield: &Bitfield,
+) -> proc_macro2::TokenStream {
+ let setter = bitfield.setter_name();
+ let setter = ctx.rust_ident_raw(format!("raw_{setter}"));
+ quote! { #setter }
+}
+
 impl<'a> FieldCodegen<'a> for Bitfield {
  type Extra = (&'a str, &'a mut bool, &'a mut FieldVisibilityKind);
 
@@ -1885,6 +1903,8 @@ impl<'a> FieldCodegen<'a> for Bitfield {
  let prefix = ctx.trait_prefix();
  let getter_name = bitfield_getter_name(ctx, self);
  let setter_name = bitfield_setter_name(ctx, self);
+ let raw_getter_name = bitfield_raw_getter_name(ctx, self);
+ let raw_setter_name = bitfield_raw_setter_name(ctx, self);
  let unit_field_ident = Ident::new(unit_field_name, Span::call_site());
 
  let bitfield_ty_item = ctx.resolve_item(self.ty());
@@ -1951,6 +1971,25 @@ impl<'a> FieldCodegen<'a> for Bitfield {
  )
  }
  }
+
+ #[inline]
+ #access_spec unsafe fn #raw_getter_name(this: *const Self) -> #bitfield_ty {
+ unsafe {
+ ::std::mem::transmute(__BindgenBitfieldUnit::raw_get(
+ addr_of!((*this).#unit_field_ident),
+ #offset,
+ #width,
+ ) as #bitfield_int_ty)
+ }
+ }
+
+ #[inline]
+ #access_spec unsafe fn #raw_setter_name(this: *mut Self, val: #bitfield_ty) {
+ unsafe {
+ let val: #bitfield_int_ty = ::std::mem::transmute(val);
+ __BindgenBitfieldUnit::raw_set(addr_of!((*this)._bitfield_1), #offset, #width, val as u64)
+ }
+ }
  }));
  } else {
  methods.extend(Some(quote! {