summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rwxr-xr-xbindgen-integration/src/lib.rs3
-rwxr-xr-xsrc/codegen/bitfield_unit.rs9
-rw-r--r--src/codegen/bitfield_unit_tests.rs49
-rw-r--r--src/codegen/helpers.rs9
-rw-r--r--src/codegen/mod.rs15
-rw-r--r--src/ir/comp.rs2
-rw-r--r--tests/expectations/tests/bitfield-32bit-overflow.rs20
-rw-r--r--tests/expectations/tests/bitfield-large.rs33
-rw-r--r--tests/expectations/tests/bitfield-linux-32.rs20
-rw-r--r--tests/expectations/tests/bitfield-method-same-name.rs20
-rw-r--r--tests/expectations/tests/bitfield_align.rs75
-rw-r--r--tests/expectations/tests/bitfield_align_2.rs20
-rw-r--r--tests/expectations/tests/bitfield_method_mangling.rs20
-rw-r--r--tests/expectations/tests/derive-bitfield-method-same-name.rs20
-rw-r--r--tests/expectations/tests/derive-debug-bitfield-core.rs20
-rw-r--r--tests/expectations/tests/derive-debug-bitfield.rs20
-rw-r--r--tests/expectations/tests/derive-partialeq-bitfield.rs20
-rw-r--r--tests/expectations/tests/divide-by-zero-in-struct-layout.rs43
-rw-r--r--tests/expectations/tests/incomplete-array-padding.rs20
-rw-r--r--tests/expectations/tests/issue-1034.rs23
-rw-r--r--tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs23
-rw-r--r--tests/expectations/tests/issue-1947.rs352
-rw-r--r--tests/expectations/tests/issue-739-pointer-wide-bitfield.rs20
-rw-r--r--tests/expectations/tests/issue-816.rs20
-rw-r--r--tests/expectations/tests/jsval_layout_opaque.rs20
-rw-r--r--tests/expectations/tests/jsval_layout_opaque_1_0.rs20
-rw-r--r--tests/expectations/tests/layout_align.rs20
-rw-r--r--tests/expectations/tests/layout_eth_conf.rs31
-rw-r--r--tests/expectations/tests/layout_eth_conf_1_0.rs31
-rw-r--r--tests/expectations/tests/layout_mbuf.rs31
-rw-r--r--tests/expectations/tests/layout_mbuf_1_0.rs31
-rw-r--r--tests/expectations/tests/libclang-9/incomplete-array-padding.rs20
-rw-r--r--tests/expectations/tests/libclang-9/layout_align.rs20
-rw-r--r--tests/expectations/tests/only_bitfields.rs20
-rw-r--r--tests/expectations/tests/packed-bitfield.rs20
-rw-r--r--tests/expectations/tests/struct_with_bitfields.rs31
-rw-r--r--tests/expectations/tests/timex.rs15
-rw-r--r--tests/expectations/tests/union_bitfield.rs31
-rw-r--r--tests/expectations/tests/union_bitfield_1_0.rs37
-rw-r--r--tests/expectations/tests/union_with_anon_struct_bitfield.rs20
-rw-r--r--tests/expectations/tests/union_with_anon_struct_bitfield_1_0.rs20
-rw-r--r--tests/expectations/tests/weird_bitfields.rs31
-rw-r--r--tests/headers/issue-1947.h9
43 files changed, 788 insertions, 546 deletions
diff --git a/bindgen-integration/src/lib.rs b/bindgen-integration/src/lib.rs
index 0468f237..088e8083 100755
--- a/bindgen-integration/src/lib.rs
+++ b/bindgen-integration/src/lib.rs
@@ -175,16 +175,19 @@ fn test_bitfields_seventh() {
fn test_bitfield_constructors() {
use std::mem;
let mut first = bindings::bitfields::First {
+ _bitfield_align_1: [],
_bitfield_1: bindings::bitfields::First::new_bitfield_1(1, 2, 3),
};
assert!(unsafe { first.assert(1, 2, 3) });
let mut second = bindings::bitfields::Second {
+ _bitfield_align_1: [],
_bitfield_1: bindings::bitfields::Second::new_bitfield_1(1337, true),
};
assert!(unsafe { second.assert(1337, true) });
let mut third = bindings::bitfields::Third {
+ _bitfield_align_1: [],
_bitfield_1: bindings::bitfields::Third::new_bitfield_1(
42,
false,
diff --git a/src/codegen/bitfield_unit.rs b/src/codegen/bitfield_unit.rs
index a5a8ac77..73ec2bd6 100755
--- a/src/codegen/bitfield_unit.rs
+++ b/src/codegen/bitfield_unit.rs
@@ -1,18 +1,17 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
diff --git a/src/codegen/bitfield_unit_tests.rs b/src/codegen/bitfield_unit_tests.rs
index 3a9239c2..e143e4ea 100644
--- a/src/codegen/bitfield_unit_tests.rs
+++ b/src/codegen/bitfield_unit_tests.rs
@@ -22,12 +22,10 @@
//! ```
use super::bitfield_unit::__BindgenBitfieldUnit;
-use std::mem;
#[test]
fn bitfield_unit_get_bit() {
- let unit =
- __BindgenBitfieldUnit::<[u8; 2], u64>::new([0b10011101, 0b00011101]);
+ let unit = __BindgenBitfieldUnit::<[u8; 2]>::new([0b10011101, 0b00011101]);
let mut bits = vec![];
for i in 0..16 {
@@ -50,7 +48,7 @@ fn bitfield_unit_get_bit() {
#[test]
fn bitfield_unit_set_bit() {
let mut unit =
- __BindgenBitfieldUnit::<[u8; 2], u64>::new([0b00000000, 0b00000000]);
+ __BindgenBitfieldUnit::<[u8; 2]>::new([0b00000000, 0b00000000]);
for i in 0..16 {
if i % 3 == 0 {
@@ -63,7 +61,7 @@ fn bitfield_unit_set_bit() {
}
let mut unit =
- __BindgenBitfieldUnit::<[u8; 2], u64>::new([0b11111111, 0b11111111]);
+ __BindgenBitfieldUnit::<[u8; 2]>::new([0b11111111, 0b11111111]);
for i in 0..16 {
if i % 3 == 0 {
@@ -76,43 +74,6 @@ fn bitfield_unit_set_bit() {
}
}
-#[test]
-fn bitfield_unit_align() {
- assert_eq!(
- mem::align_of::<__BindgenBitfieldUnit<[u8; 1], u8>>(),
- mem::align_of::<u8>()
- );
- assert_eq!(
- mem::align_of::<__BindgenBitfieldUnit<[u8; 1], u16>>(),
- mem::align_of::<u16>()
- );
- assert_eq!(
- mem::align_of::<__BindgenBitfieldUnit<[u8; 1], u32>>(),
- mem::align_of::<u32>()
- );
- assert_eq!(
- mem::align_of::<__BindgenBitfieldUnit<[u8; 1], u64>>(),
- mem::align_of::<u64>()
- );
-
- assert_eq!(
- mem::align_of::<__BindgenBitfieldUnit<[u8; 8], u8>>(),
- mem::align_of::<u8>()
- );
- assert_eq!(
- mem::align_of::<__BindgenBitfieldUnit<[u8; 8], u16>>(),
- mem::align_of::<u16>()
- );
- assert_eq!(
- mem::align_of::<__BindgenBitfieldUnit<[u8; 8], u32>>(),
- mem::align_of::<u32>()
- );
- assert_eq!(
- mem::align_of::<__BindgenBitfieldUnit<[u8; 8], u64>>(),
- mem::align_of::<u64>()
- );
-}
-
macro_rules! bitfield_unit_get {
(
$(
@@ -123,7 +84,7 @@ macro_rules! bitfield_unit_get {
fn bitfield_unit_get() {
$({
let expected = $expected;
- let unit = __BindgenBitfieldUnit::<_, u64>::new($storage);
+ let unit = __BindgenBitfieldUnit::<_>::new($storage);
let actual = unit.get($start, $len);
println!();
@@ -223,7 +184,7 @@ macro_rules! bitfield_unit_set {
#[test]
fn bitfield_unit_set() {
$(
- let mut unit = __BindgenBitfieldUnit::<[u8; 4], u64>::new([0, 0, 0, 0]);
+ let mut unit = __BindgenBitfieldUnit::<[u8; 4]>::new([0, 0, 0, 0]);
unit.set($start, $len, $val);
let actual = unit.get(0, 32);
diff --git a/src/codegen/helpers.rs b/src/codegen/helpers.rs
index b6825f5e..205995bc 100644
--- a/src/codegen/helpers.rs
+++ b/src/codegen/helpers.rs
@@ -120,16 +120,9 @@ pub fn bitfield_unit(ctx: &BindgenContext, layout: Layout) -> TokenStream {
tokens.append_all(quote! { root:: });
}
- let align = match layout.align {
- n if n >= 8 => quote! { u64 },
- 4 => quote! { u32 },
- 2 => quote! { u16 },
- _ => quote! { u8 },
- };
-
let size = layout.size;
tokens.append_all(quote! {
- __BindgenBitfieldUnit<[u8; #size], #align>
+ __BindgenBitfieldUnit<[u8; #size]>
});
tokens
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 0d93c491..194a461c 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -1437,6 +1437,21 @@ impl<'a> FieldCodegen<'a> for BitfieldUnit {
}
};
+ {
+ let align_field_name = format!("_bitfield_align_{}", self.nth());
+ let align_field_ident = ctx.rust_ident(&align_field_name);
+ let align_ty = match self.layout().align {
+ n if n >= 8 => quote! { u64 },
+ 4 => quote! { u32 },
+ 2 => quote! { u16 },
+ _ => quote! { u8 },
+ };
+ let align_field = quote! {
+ pub #align_field_ident: [#align_ty; 0],
+ };
+ fields.extend(Some(align_field));
+ }
+
let unit_field_name = format!("_bitfield_{}", self.nth());
let unit_field_ident = ctx.rust_ident(&unit_field_name);
diff --git a/src/ir/comp.rs b/src/ir/comp.rs
index 645f6251..a0ca925c 100644
--- a/src/ir/comp.rs
+++ b/src/ir/comp.rs
@@ -575,7 +575,7 @@ where
} else {
bytes_from_bits_pow2(unit_align_in_bits)
};
- let size = align_to(unit_size_in_bits, align * 8) / 8;
+ let size = align_to(unit_size_in_bits, 8) / 8;
let layout = Layout::new(size, align);
fields.extend(Some(Field::Bitfields(BitfieldUnit {
nth: *bitfield_unit_count,
diff --git a/tests/expectations/tests/bitfield-32bit-overflow.rs b/tests/expectations/tests/bitfield-32bit-overflow.rs
index cd2fd177..680b25d8 100644
--- a/tests/expectations/tests/bitfield-32bit-overflow.rs
+++ b/tests/expectations/tests/bitfield-32bit-overflow.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -95,7 +94,8 @@ where
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct MuchBitfield {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 5usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 5usize]>,
}
#[test]
fn bindgen_test_layout_MuchBitfield() {
@@ -575,11 +575,9 @@ impl MuchBitfield {
m30: ::std::os::raw::c_char,
m31: ::std::os::raw::c_char,
m32: ::std::os::raw::c_char,
- ) -> __BindgenBitfieldUnit<[u8; 5usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 5usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 5usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 5usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let m0: u8 = unsafe { ::std::mem::transmute(m0) };
m0 as u64
diff --git a/tests/expectations/tests/bitfield-large.rs b/tests/expectations/tests/bitfield-large.rs
index a29bd4c8..b2c353a2 100644
--- a/tests/expectations/tests/bitfield-large.rs
+++ b/tests/expectations/tests/bitfield-large.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -96,7 +95,8 @@ where
#[repr(align(16))]
#[derive(Debug, Default, Copy, Clone)]
pub struct HasBigBitfield {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize], u64>,
+ pub _bitfield_align_1: [u64; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
}
#[test]
fn bindgen_test_layout_HasBigBitfield() {
@@ -126,13 +126,9 @@ impl HasBigBitfield {
}
}
#[inline]
- pub fn new_bitfield_1(
- x: i128,
- ) -> __BindgenBitfieldUnit<[u8; 16usize], u64> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 16usize],
- u64,
- > = Default::default();
+ pub fn new_bitfield_1(x: i128) -> __BindgenBitfieldUnit<[u8; 16usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 128u8, {
let x: u128 = unsafe { ::std::mem::transmute(x) };
x as u64
@@ -144,7 +140,8 @@ impl HasBigBitfield {
#[repr(align(16))]
#[derive(Debug, Default, Copy, Clone)]
pub struct HasTwoBigBitfields {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize], u64>,
+ pub _bitfield_align_1: [u64; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
}
#[test]
fn bindgen_test_layout_HasTwoBigBitfields() {
@@ -190,11 +187,9 @@ impl HasTwoBigBitfields {
pub fn new_bitfield_1(
x: i128,
y: i128,
- ) -> __BindgenBitfieldUnit<[u8; 16usize], u64> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 16usize],
- u64,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 80u8, {
let x: u128 = unsafe { ::std::mem::transmute(x) };
x as u64
diff --git a/tests/expectations/tests/bitfield-linux-32.rs b/tests/expectations/tests/bitfield-linux-32.rs
index bd2b3917..15c35cee 100644
--- a/tests/expectations/tests/bitfield-linux-32.rs
+++ b/tests/expectations/tests/bitfield-linux-32.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -96,7 +95,8 @@ where
#[derive(Debug, Default, Copy, Clone)]
pub struct Test {
pub foo: u64,
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize], u64>,
+ pub _bitfield_align_1: [u64; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
}
#[test]
fn bindgen_test_layout_Test() {
@@ -147,11 +147,9 @@ impl Test {
pub fn new_bitfield_1(
x: u64,
y: u64,
- ) -> __BindgenBitfieldUnit<[u8; 8usize], u64> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 8usize],
- u64,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 56u8, {
let x: u64 = unsafe { ::std::mem::transmute(x) };
x as u64
diff --git a/tests/expectations/tests/bitfield-method-same-name.rs b/tests/expectations/tests/bitfield-method-same-name.rs
index fc2681e8..e9c1a76d 100644
--- a/tests/expectations/tests/bitfield-method-same-name.rs
+++ b/tests/expectations/tests/bitfield-method-same-name.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -95,7 +94,8 @@ where
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct Foo {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
}
#[test]
fn bindgen_test_layout_Foo() {
@@ -139,11 +139,9 @@ impl Foo {
#[inline]
pub fn new_bitfield_1(
type__bindgen_bitfield: ::std::os::raw::c_char,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 3u8, {
let type__bindgen_bitfield: u8 =
unsafe { ::std::mem::transmute(type__bindgen_bitfield) };
diff --git a/tests/expectations/tests/bitfield_align.rs b/tests/expectations/tests/bitfield_align.rs
index 57f726ef..509981a8 100644
--- a/tests/expectations/tests/bitfield_align.rs
+++ b/tests/expectations/tests/bitfield_align.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -97,7 +96,8 @@ where
#[derive(Debug, Default, Copy, Clone)]
pub struct A {
pub x: ::std::os::raw::c_uchar,
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
pub y: ::std::os::raw::c_uchar,
}
#[test]
@@ -266,11 +266,9 @@ impl A {
b8: ::std::os::raw::c_uint,
b9: ::std::os::raw::c_uint,
b10: ::std::os::raw::c_uint,
- ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 2usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let b1: u32 = unsafe { ::std::mem::transmute(b1) };
b1 as u64
@@ -318,7 +316,8 @@ impl A {
#[repr(align(4))]
#[derive(Debug, Default, Copy, Clone)]
pub struct B {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
+ pub _bitfield_align_1: [u32; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
}
#[test]
fn bindgen_test_layout_B() {
@@ -364,11 +363,9 @@ impl B {
pub fn new_bitfield_1(
foo: ::std::os::raw::c_uint,
bar: ::std::os::raw::c_uchar,
- ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 4usize],
- u32,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 31u8, {
let foo: u32 = unsafe { ::std::mem::transmute(foo) };
foo as u64
@@ -384,7 +381,8 @@ impl B {
#[derive(Debug, Default, Copy, Clone)]
pub struct C {
pub x: ::std::os::raw::c_uchar,
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub baz: ::std::os::raw::c_uint,
}
#[test]
@@ -441,11 +439,9 @@ impl C {
pub fn new_bitfield_1(
b1: ::std::os::raw::c_uint,
b2: ::std::os::raw::c_uint,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let b1: u32 = unsafe { ::std::mem::transmute(b1) };
b1 as u64
@@ -461,7 +457,8 @@ impl C {
#[repr(align(2))]
#[derive(Debug, Default, Copy, Clone)]
pub struct Date1 {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
pub __bindgen_padding_0: u8,
}
#[test]
@@ -536,11 +533,9 @@ impl Date1 {
nMonthDay: ::std::os::raw::c_ushort,
nMonth: ::std::os::raw::c_ushort,
nYear: ::std::os::raw::c_ushort,
- ) -> __BindgenBitfieldUnit<[u8; 3usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 3usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 3u8, {
let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) };
nWeekDay as u64
@@ -564,7 +559,8 @@ impl Date1 {
#[repr(align(2))]
#[derive(Debug, Default, Copy, Clone)]
pub struct Date2 {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
}
#[test]
fn bindgen_test_layout_Date2() {
@@ -652,11 +648,9 @@ impl Date2 {
nMonth: ::std::os::raw::c_ushort,
nYear: ::std::os::raw::c_ushort,
byte: ::std::os::raw::c_uchar,
- ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 4usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 3u8, {
let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) };
nWeekDay as u64
@@ -684,7 +678,8 @@ impl Date2 {
#[repr(align(2))]
#[derive(Debug, Default, Copy, Clone)]
pub struct Date3 {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
pub byte: ::std::os::raw::c_uchar,
}
#[test]
@@ -769,11 +764,9 @@ impl Date3 {
nMonthDay: ::std::os::raw::c_ushort,
nMonth: ::std::os::raw::c_ushort,
nYear: ::std::os::raw::c_ushort,
- ) -> __BindgenBitfieldUnit<[u8; 3usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 3usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 3u8, {
let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) };
nWeekDay as u64
diff --git a/tests/expectations/tests/bitfield_align_2.rs b/tests/expectations/tests/bitfield_align_2.rs
index 5602555b..f4f0c98a 100644
--- a/tests/expectations/tests/bitfield_align_2.rs
+++ b/tests/expectations/tests/bitfield_align_2.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -104,7 +103,8 @@ pub enum MyEnum {
#[repr(align(8))]
#[derive(Debug, Copy, Clone)]
pub struct TaggedPtr {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize], u64>,
+ pub _bitfield_align_1: [u64; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
}
#[test]
fn bindgen_test_layout_TaggedPtr() {
@@ -155,11 +155,9 @@ impl TaggedPtr {
pub fn new_bitfield_1(
tag: MyEnum,
ptr: ::std::os::raw::c_long,
- ) -> __BindgenBitfieldUnit<[u8; 8usize], u64> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 8usize],
- u64,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 2u8, {
let tag: u32 = unsafe { ::std::mem::transmute(tag) };
tag as u64
diff --git a/tests/expectations/tests/bitfield_method_mangling.rs b/tests/expectations/tests/bitfield_method_mangling.rs
index 584b7cc1..42fa3c4c 100644
--- a/tests/expectations/tests/bitfield_method_mangling.rs
+++ b/tests/expectations/tests/bitfield_method_mangling.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -96,7 +95,8 @@ where
#[repr(align(4))]
#[derive(Debug, Default, Copy, Clone)]
pub struct mach_msg_type_descriptor_t {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
+ pub _bitfield_align_1: [u32; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
}
#[test]
fn bindgen_test_layout_mach_msg_type_descriptor_t() {
@@ -142,11 +142,9 @@ impl mach_msg_type_descriptor_t {
pub fn new_bitfield_1(
pad3: ::std::os::raw::c_uint,
type_: ::std::os::raw::c_uint,
- ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 4usize],
- u32,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 24u8, {
let pad3: u32 = unsafe { ::std::mem::transmute(pad3) };
pad3 as u64
diff --git a/tests/expectations/tests/derive-bitfield-method-same-name.rs b/tests/expectations/tests/derive-bitfield-method-same-name.rs
index c804b541..d1c1aefa 100644
--- a/tests/expectations/tests/derive-bitfield-method-same-name.rs
+++ b/tests/expectations/tests/derive-bitfield-method-same-name.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -99,7 +98,8 @@ where
#[derive(Copy, Clone)]
pub struct Foo {
pub large: [::std::os::raw::c_int; 33usize],
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
pub __bindgen_padding_0: u16,
}
#[test]
@@ -183,11 +183,9 @@ impl Foo {
#[inline]
pub fn new_bitfield_1(
type__bindgen_bitfield: ::std::os::raw::c_char,
- ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 2usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 3u8, {
let type__bindgen_bitfield: u8 =
unsafe { ::std::mem::transmute(type__bindgen_bitfield) };
diff --git a/tests/expectations/tests/derive-debug-bitfield-core.rs b/tests/expectations/tests/derive-debug-bitfield-core.rs
index 690078b2..76fa20ba 100644
--- a/tests/expectations/tests/derive-debug-bitfield-core.rs
+++ b/tests/expectations/tests/derive-debug-bitfield-core.rs
@@ -9,17 +9,16 @@ extern crate core;
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -97,7 +96,8 @@ where
#[repr(C)]
#[derive(Copy, Clone)]
pub struct C {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub large_array: [::std::os::raw::c_int; 50usize],
}
#[test]
@@ -171,11 +171,9 @@ impl C {
pub fn new_bitfield_1(
a: bool,
b: bool,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let a: u8 = unsafe { ::core::mem::transmute(a) };
a as u64
diff --git a/tests/expectations/tests/derive-debug-bitfield.rs b/tests/expectations/tests/derive-debug-bitfield.rs
index 2474ec9f..d07642a8 100644
--- a/tests/expectations/tests/derive-debug-bitfield.rs
+++ b/tests/expectations/tests/derive-debug-bitfield.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -95,7 +94,8 @@ where
#[repr(C)]
#[derive(Copy, Clone)]
pub struct C {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub large_array: [::std::os::raw::c_int; 50usize],
}
#[test]
@@ -178,11 +178,9 @@ impl C {
pub fn new_bitfield_1(
a: bool,
b: bool,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let a: u8 = unsafe { ::std::mem::transmute(a) };
a as u64
diff --git a/tests/expectations/tests/derive-partialeq-bitfield.rs b/tests/expectations/tests/derive-partialeq-bitfield.rs
index 9896011f..c7f1231e 100644
--- a/tests/expectations/tests/derive-partialeq-bitfield.rs
+++ b/tests/expectations/tests/derive-partialeq-bitfield.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -95,7 +94,8 @@ where
#[repr(C)]
#[derive(Copy, Clone)]
pub struct C {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub large_array: [::std::os::raw::c_int; 50usize],
}
#[test]
@@ -166,11 +166,9 @@ impl C {
pub fn new_bitfield_1(
a: bool,
b: bool,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let a: u8 = unsafe { ::std::mem::transmute(a) };
a as u64
diff --git a/tests/expectations/tests/divide-by-zero-in-struct-layout.rs b/tests/expectations/tests/divide-by-zero-in-struct-layout.rs
index 1484719b..721d71e2 100644
--- a/tests/expectations/tests/divide-by-zero-in-struct-layout.rs
+++ b/tests/expectations/tests/divide-by-zero-in-struct-layout.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -95,49 +94,45 @@ where
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct WithBitfield {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 0usize], u8>,
- pub __bindgen_padding_0: u32,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub a: ::std::os::raw::c_uint,
}
impl WithBitfield {
#[inline]
- pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 0usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 0usize],
- u8,
- > = Default::default();
+ pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit
}
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct WithBitfieldAndAttrPacked {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub a: ::std::os::raw::c_uint,
}
impl WithBitfieldAndAttrPacked {
#[inline]
- pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit
}
}
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct WithBitfieldAndPacked {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 0usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub a: ::std::os::raw::c_uint,
}
impl WithBitfieldAndPacked {
#[inline]
- pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 0usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 0usize],
- u8,
- > = Default::default();
+ pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit
}
}
diff --git a/tests/expectations/tests/incomplete-array-padding.rs b/tests/expectations/tests/incomplete-array-padding.rs
index 36e523b5..a0fa750c 100644
--- a/tests/expectations/tests/incomplete-array-padding.rs
+++ b/tests/expectations/tests/incomplete-array-padding.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -125,7 +124,8 @@ impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
#[repr(C)]
#[derive(Debug)]
pub struct foo {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub b: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
}
#[test]
@@ -163,11 +163,9 @@ impl foo {
#[inline]
pub fn new_bitfield_1(
a: ::std::os::raw::c_char,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let a: u8 = unsafe { ::std::mem::transmute(a) };
a as u64
diff --git a/tests/expectations/tests/issue-1034.rs b/tests/expectations/tests/issue-1034.rs
index ef122ec0..32f4310e 100644
--- a/tests/expectations/tests/issue-1034.rs
+++ b/tests/expectations/tests/issue-1034.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -92,11 +91,11 @@ where
}
}
}
-#[repr(C)]
+#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct S2 {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
- pub __bindgen_padding_0: u8,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
}
#[test]
fn bindgen_test_layout_S2() {
@@ -113,11 +112,9 @@ fn bindgen_test_layout_S2() {
}
impl S2 {
#[inline]
- pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 2usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
+ Default::default();
__bindgen_bitfield_unit
}
}
diff --git a/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs b/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs
index 9ac4f2fe..d91dd8fa 100644
--- a/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs
+++ b/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -92,11 +91,11 @@ where
}
}
}
-#[repr(C)]
+#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct S1 {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
- pub __bindgen_padding_0: u8,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
}
#[test]
fn bindgen_test_layout_S1() {
@@ -113,11 +112,9 @@ fn bindgen_test_layout_S1() {
}
impl S1 {
#[inline]
- pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 2usize],
- u8,
- > = Default::default();
+ pub fn new_bitfield_1() -> __BindgenBitfieldUnit<[u8; 3usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
+ Default::default();
__bindgen_bitfield_unit
}
}
diff --git a/tests/expectations/tests/issue-1947.rs b/tests/expectations/tests/issue-1947.rs
new file mode 100644
index 00000000..1753ef8d
--- /dev/null
+++ b/tests/expectations/tests/issue-1947.rs
@@ -0,0 +1,352 @@
+#![allow(
+ dead_code,
+ non_snake_case,
+ non_camel_case_types,
+ non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage> {
+ storage: Storage,
+}
+impl<Storage> __BindgenBitfieldUnit<Storage> {
+ #[inline]
+ pub const fn new(storage: Storage) -> Self {
+ Self { storage }
+ }
+}
+impl<Storage> __BindgenBitfieldUnit<Storage>
+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];
+ let bit_index = if cfg!(target_endian = "big") {
+ 7 - (index % 8)
+ } else {
+ 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 = if cfg!(target_endian = "big") {
+ 7 - (index % 8)
+ } else {
+ 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) {
+ 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);
+ 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;
+ let index = if cfg!(target_endian = "big") {
+ bit_width as usize - 1 - i
+ } else {
+ i
+ };
+ self.set_bit(index + bit_offset, val_bit_is_set);
+ }
+ }
+}
+pub type U8 = ::std::os::raw::c_uchar;
+pub type U16 = ::std::os::raw::c_ushort;
+#[repr(C)]
+#[repr(align(2))]
+#[derive(Debug, Default, Copy, Clone)]
+pub struct V56AMDY {
+ pub _bitfield_align_1: [u16; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
+ pub MADK: U8,
+ pub MABR: U8,
+ pub _bitfield_align_2: [u16; 0],
+ pub _bitfield_2: __BindgenBitfieldUnit<[u8; 3usize]>,
+ pub _rB_: U8,
+}
+#[test]
+fn bindgen_test_layout_V56AMDY() {
+ assert_eq!(
+ ::std::mem::size_of::<V56AMDY>(),
+ 8usize,
+ concat!("Size of: ", stringify!(V56AMDY))
+ );
+ assert_eq!(
+ ::std::mem::align_of::<V56AMDY>(),
+ 2usize,
+ concat!("Alignment of ", stringify!(V56AMDY))
+ );
+ assert_eq!(
+ unsafe {
+ &(*(::std::ptr::null::<V56AMDY>())).MADK as *const _ as usize
+ },
+ 2usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(V56AMDY),
+ "::",
+ stringify!(MADK)
+ )
+ );
+ assert_eq!(
+ unsafe {
+ &(*(::std::ptr::null::<V56AMDY>())).MABR as *const _ as usize
+ },
+ 3usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(V56AMDY),
+ "::",
+ stringify!(MABR)
+ )
+ );
+ assert_eq!(
+ unsafe {
+ &(*(::std::ptr::null::<V56AMDY>()))._rB_ as *const _ as usize
+ },
+ 7usize,
+ concat!(
+ "Offset of field: ",
+ stringify!(V56AMDY),
+ "::",
+ stringify!(_rB_)
+ )
+ );
+}
+impl V56AMDY {
+ #[inline]
+ pub fn MADZ(&self) -> U16 {
+ unsafe {
+ ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u16)
+ }
+ }
+ #[inline]
+ pub fn set_MADZ(&mut self, val: U16) {
+ unsafe {
+ let val: u16 = ::std::mem::transmute(val);
+ self._bitfield_1.set(0usize, 10u8, val as u64)
+ }
+ }
+ #[inline]
+ pub fn MAI0(&self) -> U16 {
+ unsafe {
+ ::std::mem::transmute(self._bitfield_1.get(10usize, 2u8) as u16)
+ }
+ }
+ #[inline]
+ pub fn set_MAI0(&mut self, val: U16) {
+ unsafe {
+ let val: u16 = ::std::mem::transmute(val);
+ self._bitfield_1.set(10usize, 2u8, val as u64)
+ }
+ }
+ #[inline]
+ pub fn MAI1(&self) -> U16 {
+ unsafe {
+ ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u16)
+ }
+ }
+ #[inline]
+ pub fn set_MAI1(&mut self, val: U16) {
+ unsafe {
+ let val: u16 = ::std::mem::transmute(val);
+ self._bitfield_1.set(12usize, 2u8, val as u64)
+ }
+ }
+ #[inline]
+ pub fn MAI2(&self) -> U16 {
+ unsafe {
+ ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16)
+ }
+ }
+ #[inline]
+ pub fn set_MAI2(&mut self, val: U16) {
+ unsafe {
+ let val: u16 = ::std::mem::transmute(val);
+ self._bitfield_1.set(14usize, 2u8, val as u64)
+ }
+ }
+ #[inline]
+ pub fn new_bitfield_1(
+ MADZ: U16,
+ MAI0: U16,
+ MAI1: U16,
+ MAI2: U16,
+ ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
+ Default::default();
+ __bindgen_bitfield_unit.set(0usize, 10u8, {
+ let MADZ: u16 = unsafe { ::std::mem::transmute(MADZ) };
+ MADZ as u64
+ });
+ __bindgen_bitfield_unit.set(10usize, 2u8, {
+ let MAI0: u16 = unsafe { ::std::mem::transmute(MAI0) };
+ MAI0 as u64
+ });
+ __bindgen_bitfield_unit.set(12usize, 2u8, {
+ let MAI1: u16 = unsafe { ::std::mem::transmute(MAI1) };
+ MAI1 as u64
+ });
+ __bindgen_bitfield_unit.set(14usize, 2u8, {
+ let MAI2: u16 = unsafe { ::std::mem::transmute(MAI2) };
+ MAI2 as u64
+ });
+ __bindgen_bitfield_unit
+ }
+ #[inline]
+ pub fn MATH(&self) -> U16 {
+ unsafe {
+ ::std::mem::transmute(self._bitfield_2.get(0usize, 10u8) as u16)
+ }
+ }
+ #[inline]
+ pub fn set_MATH(&mut self, val: U16) {
+ unsafe {
+ let val: u16 = ::std::mem::transmute(val);
+ self._bitfield_2.set(0usize, 10u8, val as u64)
+ }
+ }
+ #[inline]
+ pub fn MATE(&self) -> U16 {
+ unsafe {
+ ::std::mem::transmute(self._bitfield_2.get(10usize, 4u8) as u16)
+ }
+ }
+ #[inline]
+ pub fn set_MATE(&mut self, val: U16) {
+ unsafe {
+ let val: u16 = ::std::mem::transmute(val);
+ self._bitfield_2.set(10usize, 4u8, val as u64)
+ }
+ }
+ #[inline]
+ pub fn MATW(&self) -> U16 {
+ unsafe {
+ ::std::mem::transmute(self._bitfield_2.get(14usize, 2u8) as u16)
+ }
+ }
+ #[inline]
+ pub fn set_MATW(&mut self, val: U16) {
+ unsafe {
+ let val: u16 = ::std::mem::transmute(val);
+ self._bitfield_2.set(14usize, 2u8, val as u64)
+ }
+ }
+ #[inline]
+ pub fn MASW(&self) -> U8 {
+ unsafe {
+ ::std::mem::transmute(self._bitfield_2.get(16usize, 4u8) as u8)
+ }
+ }
+ #[inline]
+ pub fn set_MASW(&mut self, val: U8) {
+ unsafe {
+ let val: u8 = ::std::mem::transmute(val);
+ self._bitfield_2.set(16usize, 4u8, val as u64)
+ }
+ }
+ #[inline]
+ pub fn MABW(&self) -> U8 {
+ unsafe {
+ ::std::mem::transmute(self._bitfield_2.get(20usize, 3u8) as u8)
+ }
+ }
+ #[inline]
+ pub fn set_MABW(&mut self, val: U8) {
+ unsafe {
+ let val: u8 = ::std::mem::transmute(val);
+ self._bitfield_2.set(20usize, 3u8, val as u64)
+ }
+ }
+ #[inline]
+ pub fn MAXN(&self) -> U8 {
+ unsafe {
+ ::std::mem::transmute(self._bitfield_2.get(23usize, 1u8) as u8)
+ }
+ }
+ #[inline]
+ pub fn set_MAXN(&mut self, val: U8) {
+ unsafe {
+ let val: u8 = ::std::mem::transmute(val);
+ self._bitfield_2.set(23usize, 1u8, val as u64)
+ }
+ }
+ #[inline]
+ pub fn new_bitfield_2(
+ MATH: U16,
+ MATE: U16,
+ MATW: U16,
+ MASW: U8,
+ MABW: U8,
+ MAXN: U8,
+ ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
+ Default::default();
+ __bindgen_bitfield_unit.set(0usize, 10u8, {
+ let MATH: u16 = unsafe { ::std::mem::transmute(MATH) };
+ MATH as u64
+ });
+ __bindgen_bitfield_unit.set(10usize, 4u8, {
+ let MATE: u16 = unsafe { ::std::mem::transmute(MATE) };
+ MATE as u64
+ });
+ __bindgen_bitfield_unit.set(14usize, 2u8, {
+ let MATW: u16 = unsafe { ::std::mem::transmute(MATW) };
+ MATW as u64
+ });
+ __bindgen_bitfield_unit.set(16usize, 4u8, {
+ let MASW: u8 = unsafe { ::std::mem::transmute(MASW) };
+ MASW as u64
+ });
+ __bindgen_bitfield_unit.set(20usize, 3u8, {
+ let MABW: u8 = unsafe { ::std::mem::transmute(MABW) };
+ MABW as u64
+ });
+ __bindgen_bitfield_unit.set(23usize, 1u8, {
+ let MAXN: u8 = unsafe { ::std::mem::transmute(MAXN) };
+ MAXN as u64
+ });
+ __bindgen_bitfield_unit
+ }
+}
diff --git a/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs b/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs
index 783ea267..7d7b7921 100644
--- a/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs
+++ b/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -96,7 +95,8 @@ where
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone)]
pub struct Foo {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 32usize], u64>,
+ pub _bitfield_align_1: [u64; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 32usize]>,
}
#[test]
fn bindgen_test_layout_Foo() {
@@ -170,11 +170,9 @@ impl Foo {
m_bar: ::std::os::raw::c_ulong,
foo: ::std::os::raw::c_ulong,
bar: ::std::os::raw::c_ulong,
- ) -> __BindgenBitfieldUnit<[u8; 32usize], u64> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 32usize],
- u64,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 32usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 32usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 64u8, {
let m_bitfield: u64 = unsafe { ::std::mem::transmute(m_bitfield) };
m_bitfield as u64
diff --git a/tests/expectations/tests/issue-816.rs b/tests/expectations/tests/issue-816.rs
index 64b58abb..c7f94106 100644
--- a/tests/expectations/tests/issue-816.rs
+++ b/tests/expectations/tests/issue-816.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -96,7 +95,8 @@ where
#[repr(align(4))]
#[derive(Debug, Default, Copy, Clone)]
pub struct capabilities {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
}
#[test]
fn bindgen_test_layout_capabilities() {
@@ -688,11 +688,9 @@ impl capabilities {
bit_39: ::std::os::raw::c_uint,
bit_40: ::std::os::raw::c_uint,
bit_41: ::std::os::raw::c_uint,
- ) -> __BindgenBitfieldUnit<[u8; 16usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 16usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let bit_1: u32 = unsafe { ::std::mem::transmute(bit_1) };
bit_1 as u64
diff --git a/tests/expectations/tests/jsval_layout_opaque.rs b/tests/expectations/tests/jsval_layout_opaque.rs
index c9ce5ca0..92ae978d 100644
--- a/tests/expectations/tests/jsval_layout_opaque.rs
+++ b/tests/expectations/tests/jsval_layout_opaque.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -195,7 +194,8 @@ pub union jsval_layout {
#[repr(align(8))]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct jsval_layout__bindgen_ty_1 {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize], u64>,
+ pub _bitfield_align_1: [u64; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
}
#[test]
fn bindgen_test_layout_jsval_layout__bindgen_ty_1() {
@@ -246,11 +246,9 @@ impl jsval_layout__bindgen_ty_1 {
pub fn new_bitfield_1(
payload47: u64,
tag: JSValueTag,
- ) -> __BindgenBitfieldUnit<[u8; 8usize], u64> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 8usize],
- u64,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 47u8, {
let payload47: u64 = unsafe { ::std::mem::transmute(payload47) };
payload47 as u64
diff --git a/tests/expectations/tests/jsval_layout_opaque_1_0.rs b/tests/expectations/tests/jsval_layout_opaque_1_0.rs
index a5d35c19..e593a2c7 100644
--- a/tests/expectations/tests/jsval_layout_opaque_1_0.rs
+++ b/tests/expectations/tests/jsval_layout_opaque_1_0.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -237,7 +236,8 @@ pub struct jsval_layout {
#[repr(C)]
#[derive(Debug, Copy, Hash, PartialEq, Eq)]
pub struct jsval_layout__bindgen_ty_1 {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize], u64>,
+ pub _bitfield_align_1: [u64; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
pub __bindgen_align: [u64; 0usize],
}
#[test]
@@ -294,11 +294,9 @@ impl jsval_layout__bindgen_ty_1 {
pub fn new_bitfield_1(
payload47: u64,
tag: JSValueTag,
- ) -> __BindgenBitfieldUnit<[u8; 8usize], u64> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 8usize],
- u64,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 47u8, {
let payload47: u64 = unsafe { ::std::mem::transmute(payload47) };
payload47 as u64
diff --git a/tests/expectations/tests/layout_align.rs b/tests/expectations/tests/layout_align.rs
index 316eb7fb..44998a89 100644
--- a/tests/expectations/tests/layout_align.rs
+++ b/tests/expectations/tests/layout_align.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -160,7 +159,8 @@ impl Default for rte_kni_fifo {
pub struct rte_eth_link {
///< ETH_SPEED_NUM_
pub link_speed: u32,
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub __bindgen_padding_0: [u8; 3usize],
}
#[test]
@@ -234,11 +234,9 @@ impl rte_eth_link {
link_duplex: u16,
link_autoneg: u16,
link_status: u16,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let link_duplex: u16 =
unsafe { ::std::mem::transmute(link_duplex) };
diff --git a/tests/expectations/tests/layout_eth_conf.rs b/tests/expectations/tests/layout_eth_conf.rs
index b75a1655..34db2c4a 100644
--- a/tests/expectations/tests/layout_eth_conf.rs
+++ b/tests/expectations/tests/layout_eth_conf.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -156,7 +155,8 @@ pub struct rte_eth_rxmode {
pub max_rx_pkt_len: u32,
///< hdr buf size (header_split enabled).
pub split_hdr_size: u16,
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
}
#[test]
fn bindgen_test_layout_rte_eth_rxmode() {
@@ -344,11 +344,9 @@ impl rte_eth_rxmode {
hw_strip_crc: u16,
enable_scatter: u16,
enable_lro: u16,
- ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 2usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let header_split: u16 =
unsafe { ::std::mem::transmute(header_split) };
@@ -417,7 +415,8 @@ pub struct rte_eth_txmode {
///< TX multi-queues mode.
pub mq_mode: rte_eth_tx_mq_mode,
pub pvid: u16,
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub __bindgen_padding_0: u8,
}
#[test]
@@ -508,11 +507,9 @@ impl rte_eth_txmode {
hw_vlan_reject_tagged: u8,
hw_vlan_reject_untagged: u8,
hw_vlan_insert_pvid: u8,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let hw_vlan_reject_tagged: u8 =
unsafe { ::std::mem::transmute(hw_vlan_reject_tagged) };
diff --git a/tests/expectations/tests/layout_eth_conf_1_0.rs b/tests/expectations/tests/layout_eth_conf_1_0.rs
index 8800cf59..26d2db02 100644
--- a/tests/expectations/tests/layout_eth_conf_1_0.rs
+++ b/tests/expectations/tests/layout_eth_conf_1_0.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -199,7 +198,8 @@ pub struct rte_eth_rxmode {
pub max_rx_pkt_len: u32,
///< hdr buf size (header_split enabled).
pub split_hdr_size: u16,
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
}
#[test]
fn bindgen_test_layout_rte_eth_rxmode() {
@@ -392,11 +392,9 @@ impl rte_eth_rxmode {
hw_strip_crc: u16,
enable_scatter: u16,
enable_lro: u16,
- ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 2usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let header_split: u16 =
unsafe { ::std::mem::transmute(header_split) };
@@ -465,7 +463,8 @@ pub struct rte_eth_txmode {
///< TX multi-queues mode.
pub mq_mode: rte_eth_tx_mq_mode,
pub pvid: u16,
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub __bindgen_padding_0: u8,
}
#[test]
@@ -561,11 +560,9 @@ impl rte_eth_txmode {
hw_vlan_reject_tagged: u8,
hw_vlan_reject_untagged: u8,
hw_vlan_insert_pvid: u8,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let hw_vlan_reject_tagged: u8 =
unsafe { ::std::mem::transmute(hw_vlan_reject_tagged) };
diff --git a/tests/expectations/tests/layout_mbuf.rs b/tests/expectations/tests/layout_mbuf.rs
index e5929ac5..a7f71a30 100644
--- a/tests/expectations/tests/layout_mbuf.rs
+++ b/tests/expectations/tests/layout_mbuf.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -248,7 +247,8 @@ pub union rte_mbuf__bindgen_ty_2 {
#[repr(align(4))]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
}
#[test]
fn bindgen_test_layout_rte_mbuf__bindgen_ty_2__bindgen_ty_1() {
@@ -370,11 +370,9 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
inner_l2_type: u32,
inner_l3_type: u32,
inner_l4_type: u32,
- ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 4usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 4u8, {
let l2_type: u32 = unsafe { ::std::mem::transmute(l2_type) };
l2_type as u64
@@ -746,7 +744,8 @@ pub union rte_mbuf__bindgen_ty_5 {
#[repr(align(8))]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize], u16>,
+ pub _bitfield_align_1: [u16; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 7usize]>,
}
#[test]
fn bindgen_test_layout_rte_mbuf__bindgen_ty_5__bindgen_ty_1() {
@@ -854,11 +853,9 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
tso_segsz: u64,
outer_l3_len: u64,
outer_l2_len: u64,
- ) -> __BindgenBitfieldUnit<[u8; 8usize], u16> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 8usize],
- u16,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 7usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 7usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 7u8, {
let l2_len: u64 = unsafe { ::std::mem::transmute(l2_len) };
l2_len as u64
diff --git a/tests/expectations/tests/layout_mbuf_1_0.rs b/tests/expectations/tests/layout_mbuf_1_0.rs
index 96b38cbb..70d96d95 100644
--- a/tests/expectations/tests/layout_mbuf_1_0.rs
+++ b/tests/expectations/tests/layout_mbuf_1_0.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -296,7 +295,8 @@ pub struct rte_mbuf__bindgen_ty_2 {
#[repr(C)]
#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
pub struct rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
pub __bindgen_align: [u32; 0usize],
}
#[test]
@@ -424,11 +424,9 @@ impl rte_mbuf__bindgen_ty_2__bindgen_ty_1 {
inner_l2_type: u32,
inner_l3_type: u32,
inner_l4_type: u32,
- ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 4usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 4u8, {
let l2_type: u32 = unsafe { ::std::mem::transmute(l2_type) };
l2_type as u64
@@ -813,7 +811,8 @@ pub struct rte_mbuf__bindgen_ty_5 {
#[repr(C)]
#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
pub struct rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize], u16>,
+ pub _bitfield_align_1: [u16; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 7usize]>,
pub __bindgen_align: [u64; 0usize],
}
#[test]
@@ -927,11 +926,9 @@ impl rte_mbuf__bindgen_ty_5__bindgen_ty_1 {
tso_segsz: u64,
outer_l3_len: u64,
outer_l2_len: u64,
- ) -> __BindgenBitfieldUnit<[u8; 8usize], u16> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 8usize],
- u16,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 7usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 7usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 7u8, {
let l2_len: u64 = unsafe { ::std::mem::transmute(l2_len) };
l2_len as u64
diff --git a/tests/expectations/tests/libclang-9/incomplete-array-padding.rs b/tests/expectations/tests/libclang-9/incomplete-array-padding.rs
index 57f15a22..c380a0cc 100644
--- a/tests/expectations/tests/libclang-9/incomplete-array-padding.rs
+++ b/tests/expectations/tests/libclang-9/incomplete-array-padding.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -125,7 +124,8 @@ impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
#[repr(C)]
#[derive(Debug)]
pub struct foo {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub b: __IncompleteArrayField<*mut ::std::os::raw::c_void>,
}
#[test]
@@ -168,11 +168,9 @@ impl foo {
#[inline]
pub fn new_bitfield_1(
a: ::std::os::raw::c_char,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let a: u8 = unsafe { ::std::mem::transmute(a) };
a as u64
diff --git a/tests/expectations/tests/libclang-9/layout_align.rs b/tests/expectations/tests/libclang-9/layout_align.rs
index 228177e1..d153fa5e 100644
--- a/tests/expectations/tests/libclang-9/layout_align.rs
+++ b/tests/expectations/tests/libclang-9/layout_align.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -221,7 +220,8 @@ impl Default for rte_kni_fifo {
pub struct rte_eth_link {
///< ETH_SPEED_NUM_
pub link_speed: u32,
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub __bindgen_padding_0: [u8; 3usize],
}
#[test]
@@ -295,11 +295,9 @@ impl rte_eth_link {
link_duplex: u16,
link_autoneg: u16,
link_status: u16,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let link_duplex: u16 =
unsafe { ::std::mem::transmute(link_duplex) };
diff --git a/tests/expectations/tests/only_bitfields.rs b/tests/expectations/tests/only_bitfields.rs
index fa076d87..2f063b5b 100644
--- a/tests/expectations/tests/only_bitfields.rs
+++ b/tests/expectations/tests/only_bitfields.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -95,7 +94,8 @@ where
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct C {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
}
#[test]
fn bindgen_test_layout_C() {
@@ -141,11 +141,9 @@ impl C {
pub fn new_bitfield_1(
a: bool,
b: bool,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let a: u8 = unsafe { ::std::mem::transmute(a) };
a as u64
diff --git a/tests/expectations/tests/packed-bitfield.rs b/tests/expectations/tests/packed-bitfield.rs
index d64bc85b..f90edb93 100644
--- a/tests/expectations/tests/packed-bitfield.rs
+++ b/tests/expectations/tests/packed-bitfield.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -95,7 +94,8 @@ where
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct Date {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
}
#[test]
fn bindgen_test_layout_Date() {
@@ -155,11 +155,9 @@ impl Date {
day: ::std::os::raw::c_uchar,
month: ::std::os::raw::c_uchar,
year: ::std::os::raw::c_short,
- ) -> __BindgenBitfieldUnit<[u8; 3usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 3usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 5u8, {
let day: u8 = unsafe { ::std::mem::transmute(day) };
day as u64
diff --git a/tests/expectations/tests/struct_with_bitfields.rs b/tests/expectations/tests/struct_with_bitfields.rs
index 7d6da17c..2e95726f 100644
--- a/tests/expectations/tests/struct_with_bitfields.rs
+++ b/tests/expectations/tests/struct_with_bitfields.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -95,9 +94,11 @@ where
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct bitfield {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub e: ::std::os::raw::c_int,
- pub _bitfield_2: __BindgenBitfieldUnit<[u8; 8usize], u32>,
+ pub _bitfield_align_2: [u32; 0],
+ pub _bitfield_2: __BindgenBitfieldUnit<[u8; 8usize]>,
}
#[test]
fn bindgen_test_layout_bitfield() {
@@ -181,11 +182,9 @@ impl bitfield {
b: ::std::os::raw::c_ushort,
c: ::std::os::raw::c_ushort,
d: ::std::os::raw::c_ushort,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let a: u16 = unsafe { ::std::mem::transmute(a) };
a as u64
@@ -234,11 +233,9 @@ impl bitfield {
pub fn new_bitfield_2(
f: ::std::os::raw::c_uint,
g: ::std::os::raw::c_uint,
- ) -> __BindgenBitfieldUnit<[u8; 8usize], u32> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 8usize],
- u32,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 2u8, {
let f: u32 = unsafe { ::std::mem::transmute(f) };
f as u64
diff --git a/tests/expectations/tests/timex.rs b/tests/expectations/tests/timex.rs
index dc33f748..63917d6a 100644
--- a/tests/expectations/tests/timex.rs
+++ b/tests/expectations/tests/timex.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -96,7 +95,8 @@ where
#[derive(Copy, Clone)]
pub struct timex {
pub tai: ::std::os::raw::c_int,
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 44usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 44usize]>,
}
#[test]
fn bindgen_test_layout_timex() {
@@ -130,7 +130,8 @@ impl Default for timex {
#[derive(Copy, Clone)]
pub struct timex_named {
pub tai: ::std::os::raw::c_int,
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 44usize], u32>,
+ pub _bitfield_align_1: [u32; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 44usize]>,
}
#[test]
fn bindgen_test_layout_timex_named() {
diff --git a/tests/expectations/tests/union_bitfield.rs b/tests/expectations/tests/union_bitfield.rs
index c4b91899..22c0de85 100644
--- a/tests/expectations/tests/union_bitfield.rs
+++ b/tests/expectations/tests/union_bitfield.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -95,7 +94,8 @@ where
#[repr(C)]
#[derive(Copy, Clone)]
pub union U4 {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
_bindgen_union_align: u32,
}
#[test]
@@ -133,11 +133,9 @@ impl U4 {
#[inline]
pub fn new_bitfield_1(
derp: ::std::os::raw::c_uint,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let derp: u32 = unsafe { ::std::mem::transmute(derp) };
derp as u64
@@ -148,7 +146,8 @@ impl U4 {
#[repr(C)]
#[derive(Copy, Clone)]
pub union B {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
+ pub _bitfield_align_1: [u32; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
_bindgen_union_align: u32,
}
#[test]
@@ -200,11 +199,9 @@ impl B {
pub fn new_bitfield_1(
foo: ::std::os::raw::c_uint,
bar: ::std::os::raw::c_uchar,
- ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 4usize],
- u32,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 31u8, {
let foo: u32 = unsafe { ::std::mem::transmute(foo) };
foo as u64
diff --git a/tests/expectations/tests/union_bitfield_1_0.rs b/tests/expectations/tests/union_bitfield_1_0.rs
index 2a620b23..7c846da8 100644
--- a/tests/expectations/tests/union_bitfield_1_0.rs
+++ b/tests/expectations/tests/union_bitfield_1_0.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -138,8 +137,8 @@ impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
#[repr(C)]
#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
pub struct U4 {
- pub _bitfield_1:
- __BindgenUnionField<__BindgenBitfieldUnit<[u8; 1usize], u8>>,
+ pub _bitfield_align_1: [u8; 0],
+ pub _bitfield_1: __BindgenUnionField<__BindgenBitfieldUnit<[u8; 1usize]>>,
pub bindgen_union_field: u32,
}
#[test]
@@ -179,11 +178,9 @@ impl U4 {
#[inline]
pub fn new_bitfield_1(
derp: ::std::os::raw::c_uint,
- ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 1usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let derp: u32 = unsafe { ::std::mem::transmute(derp) };
derp as u64
@@ -194,8 +191,8 @@ impl U4 {
#[repr(C)]
#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
pub struct B {
- pub _bitfield_1:
- __BindgenUnionField<__BindgenBitfieldUnit<[u8; 4usize], u32>>,
+ pub _bitfield_align_1: [u32; 0],
+ pub _bitfield_1: __BindgenUnionField<__BindgenBitfieldUnit<[u8; 4usize]>>,
pub bindgen_union_field: u32,
}
#[test]
@@ -251,11 +248,9 @@ impl B {
pub fn new_bitfield_1(
foo: ::std::os::raw::c_uint,
bar: ::std::os::raw::c_uchar,
- ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 4usize],
- u32,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 31u8, {
let foo: u32 = unsafe { ::std::mem::transmute(foo) };
foo as u64
@@ -270,8 +265,8 @@ impl B {
#[repr(C)]
#[derive(Copy)]
pub struct HasBigBitfield {
- pub _bitfield_1:
- __BindgenUnionField<__BindgenBitfieldUnit<[u8; 16usize], u64>>,
+ pub _bitfield_align_1: [u64; 0],
+ pub _bitfield_1: __BindgenUnionField<__BindgenBitfieldUnit<[u8; 16usize]>>,
pub bindgen_union_field: [u8; 16usize],
}
#[test]
diff --git a/tests/expectations/tests/union_with_anon_struct_bitfield.rs b/tests/expectations/tests/union_with_anon_struct_bitfield.rs
index ca825174..445a97ef 100644
--- a/tests/expectations/tests/union_with_anon_struct_bitfield.rs
+++ b/tests/expectations/tests/union_with_anon_struct_bitfield.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -103,7 +102,8 @@ pub union foo {
#[repr(align(4))]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct foo__bindgen_ty_1 {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
+ pub _bitfield_align_1: [u32; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
}
#[test]
fn bindgen_test_layout_foo__bindgen_ty_1() {
@@ -149,11 +149,9 @@ impl foo__bindgen_ty_1 {
pub fn new_bitfield_1(
b: ::std::os::raw::c_int,
c: ::std::os::raw::c_int,
- ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 4usize],
- u32,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 7u8, {
let b: u32 = unsafe { ::std::mem::transmute(b) };
b as u64
diff --git a/tests/expectations/tests/union_with_anon_struct_bitfield_1_0.rs b/tests/expectations/tests/union_with_anon_struct_bitfield_1_0.rs
index 352b32b1..43736b03 100644
--- a/tests/expectations/tests/union_with_anon_struct_bitfield_1_0.rs
+++ b/tests/expectations/tests/union_with_anon_struct_bitfield_1_0.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -145,7 +144,8 @@ pub struct foo {
#[repr(C)]
#[derive(Debug, Default, Copy, Hash, PartialEq, Eq)]
pub struct foo__bindgen_ty_1 {
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
+ pub _bitfield_align_1: [u32; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
pub __bindgen_align: [u32; 0usize],
}
#[test]
@@ -197,11 +197,9 @@ impl foo__bindgen_ty_1 {
pub fn new_bitfield_1(
b: ::std::os::raw::c_int,
c: ::std::os::raw::c_int,
- ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 4usize],
- u32,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 7u8, {
let b: u32 = unsafe { ::std::mem::transmute(b) };
b as u64
diff --git a/tests/expectations/tests/weird_bitfields.rs b/tests/expectations/tests/weird_bitfields.rs
index 2c1a7d25..d25c802e 100644
--- a/tests/expectations/tests/weird_bitfields.rs
+++ b/tests/expectations/tests/weird_bitfields.rs
@@ -7,17 +7,16 @@
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct __BindgenBitfieldUnit<Storage, Align> {
+pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
- align: [Align; 0],
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
- Self { storage, align: [] }
+ Self { storage }
}
}
-impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
@@ -103,7 +102,8 @@ pub enum nsStyleSVGOpacitySource {
#[derive(Debug, Copy, Clone)]
pub struct Weird {
pub mStrokeDasharrayLength: ::std::os::raw::c_uint,
- pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u16>,
+ pub _bitfield_align_1: [u16; 0],
+ pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
pub mClipRule: ::std::os::raw::c_uchar,
pub mColorInterpolation: ::std::os::raw::c_uchar,
pub mColorInterpolationFilters: ::std::os::raw::c_uchar,
@@ -115,7 +115,8 @@ pub struct Weird {
pub mStrokeLinejoin: ::std::os::raw::c_uchar,
pub mTextAnchor: ::std::os::raw::c_uchar,
pub mTextRendering: ::std::os::raw::c_uchar,
- pub _bitfield_2: __BindgenBitfieldUnit<[u8; 2usize], u8>,
+ pub _bitfield_align_2: [u8; 0],
+ pub _bitfield_2: __BindgenBitfieldUnit<[u8; 2usize]>,
pub __bindgen_padding_0: [u8; 3usize],
}
#[test]
@@ -319,11 +320,9 @@ impl Weird {
pub fn new_bitfield_1(
bitTest: ::std::os::raw::c_uint,
bitTest2: ::std::os::raw::c_uint,
- ) -> __BindgenBitfieldUnit<[u8; 4usize], u16> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 4usize],
- u16,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 16u8, {
let bitTest: u32 = unsafe { ::std::mem::transmute(bitTest) };
bitTest as u64
@@ -406,11 +405,9 @@ impl Weird {
mStrokeDasharrayFromObject: bool,
mStrokeDashoffsetFromObject: bool,
mStrokeWidthFromObject: bool,
- ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
- let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<
- [u8; 2usize],
- u8,
- > = Default::default();
+ ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
+ let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
+ Default::default();
__bindgen_bitfield_unit.set(0usize, 3u8, {
let mFillOpacitySource: u32 =
unsafe { ::std::mem::transmute(mFillOpacitySource) };
diff --git a/tests/headers/issue-1947.h b/tests/headers/issue-1947.h
new file mode 100644
index 00000000..e2e9b3e1
--- /dev/null
+++ b/tests/headers/issue-1947.h
@@ -0,0 +1,9 @@
+typedef unsigned char U8;
+typedef unsigned short U16;
+
+typedef struct {
+ U16 MADZ : 10, MAI0 : 2, MAI1 : 2, MAI2 : 2;
+ U8 MADK, MABR;
+ U16 MATH : 10, MATE : 4, MATW : 2;
+ U8 MASW : 4, MABW : 3, MAXN : 1, _rB_;
+} V56AMDY;