From d8a22a71859939f6afa0e317bc0415baa34cf300 Mon Sep 17 00:00:00 2001 From: David Hotham Date: Sat, 16 May 2026 18:18:35 +0100 Subject: [PATCH 1/3] Fix clippy::collapsible_match in ObjC interface parsing `cargo clippy -- -D warnings` was failing on stable with a collapsible_match lint in ObjCInterface::from_ty: a nested `if` inside a `CXCursor_ObjCClassRef` match arm should be expressed as a match guard. Collapse it as suggested. No behaviour change. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- bindgen/ir/objc.rs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/bindgen/ir/objc.rs b/bindgen/ir/objc.rs index 6cdadb131d..48012823fb 100644 --- a/bindgen/ir/objc.rs +++ b/bindgen/ir/objc.rs @@ -134,13 +134,13 @@ impl ObjCInterface { cursor.visit(|c| { match c.kind() { - CXCursor_ObjCClassRef => { - if cursor.kind() == CXCursor_ObjCCategoryDecl { - // We are actually a category extension, and we found the reference - // to the original interface, so name this interface appropriately - interface.name = c.spelling(); - interface.category = Some(cursor.spelling()); - } + CXCursor_ObjCClassRef + if cursor.kind() == CXCursor_ObjCCategoryDecl => + { + // We are actually a category extension, and we found the reference + // to the original interface, so name this interface appropriately + interface.name = c.spelling(); + interface.category = Some(cursor.spelling()); } CXCursor_ObjCProtocolRef => { // Gather protocols this interface conforms to From 99a2e01f303ecc7dd377253ef0902e4fd3007a81 Mon Sep 17 00:00:00 2001 From: David Hotham Date: Sat, 16 May 2026 18:07:27 +0100 Subject: [PATCH 2/3] Fix shift-overflow in const-generic bitfield accessors When BIT_WIDTH equals the native word size (e.g. a 64-bit field on a 64-bit target), `(1usize << BIT_WIDTH) - 1` shifted by the full width of usize, panicking in debug builds and producing a wrong mask in release. Affected `get_const`, `set_const`, `raw_get_const` and `raw_set_const`. Guard the value mask with `BIT_WIDTH < usize::BITS` and compute the runtime `set`. Add a regression test exercising width = 64. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../tests/bitfield-32bit-overflow.rs | 28 ++++++-- .../expectations/tests/bitfield-large.rs | 28 ++++++-- .../expectations/tests/bitfield-linux-32.rs | 28 ++++++-- .../tests/bitfield-method-same-name.rs | 28 ++++++-- .../expectations/tests/bitfield-template.rs | 28 ++++++-- .../expectations/tests/bitfield_align.rs | 28 ++++++-- .../expectations/tests/bitfield_align_2.rs | 28 ++++++-- .../tests/bitfield_method_mangling.rs | 28 ++++++-- .../tests/bitfield_pack_offset.rs | 28 ++++++-- .../tests/bitfield_pragma_packed.rs | 28 ++++++-- .../tests/default_visibility_crate.rs | 28 ++++++-- .../tests/default_visibility_private.rs | 28 ++++++-- ...bility_private_respects_cxx_access_spec.rs | 28 ++++++-- .../tests/derive-bitfield-method-same-name.rs | 28 ++++++-- .../tests/derive-debug-bitfield-1-51.rs | 28 ++++++-- .../tests/derive-debug-bitfield-core.rs | 28 ++++++-- .../tests/derive-debug-bitfield.rs | 28 ++++++-- .../tests/derive-partialeq-bitfield.rs | 28 ++++++-- .../tests/divide-by-zero-in-struct-layout.rs | 28 ++++++-- .../tests/field-rename-callback.rs | 28 ++++++-- .../tests/field-visibility-callback.rs | 28 ++++++-- .../expectations/tests/field-visibility.rs | 28 ++++++-- .../tests/incomplete-array-padding.rs | 28 ++++++-- .../tests/expectations/tests/issue-1034.rs | 28 ++++++-- .../issue-1076-unnamed-bitfield-alignment.rs | 28 ++++++-- .../tests/expectations/tests/issue-1947.rs | 28 ++++++-- .../tests/issue-739-pointer-wide-bitfield.rs | 28 ++++++-- .../tests/expectations/tests/issue-743.rs | 28 ++++++-- .../tests/expectations/tests/issue-816.rs | 28 ++++++-- .../expectations/tests/jsval_layout_opaque.rs | 28 ++++++-- .../tests/expectations/tests/layout_align.rs | 28 ++++++-- .../expectations/tests/layout_eth_conf.rs | 28 ++++++-- .../tests/expectations/tests/layout_mbuf.rs | 28 ++++++-- .../expectations/tests/only_bitfields.rs | 28 ++++++-- .../expectations/tests/packed-bitfield.rs | 28 ++++++-- .../expectations/tests/private_fields.rs | 28 ++++++-- .../tests/redundant-packed-and-align.rs | 28 ++++++-- .../tests/struct_with_bitfields.rs | 28 ++++++-- .../tests/expectations/tests/timex.rs | 28 ++++++-- .../expectations/tests/union_bitfield.rs | 28 ++++++-- .../tests/union_with_anon_struct_bitfield.rs | 28 ++++++-- .../expectations/tests/weird_bitfields.rs | 28 ++++++-- bindgen/codegen/bitfield_unit.rs | 30 ++++++-- bindgen/codegen/bitfield_unit_tests.rs | 70 +++++++++++++++++++ 44 files changed, 1018 insertions(+), 258 deletions(-) diff --git a/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs b/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs index 1bd4ecac7c..0c321f0d9a 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/bitfield-large.rs b/bindgen-tests/tests/expectations/tests/bitfield-large.rs index 6abd8acd92..65e9204570 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield-large.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield-large.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs b/bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs index e8f91c3d0c..b4abc5991e 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs b/bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs index 928e626ba7..599011c305 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/bitfield-template.rs b/bindgen-tests/tests/expectations/tests/bitfield-template.rs index 3ce4d0eaae..56fa7ffb3e 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield-template.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield-template.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/bitfield_align.rs b/bindgen-tests/tests/expectations/tests/bitfield_align.rs index 31dbe2dfcb..580f5476a0 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield_align.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield_align.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/bitfield_align_2.rs b/bindgen-tests/tests/expectations/tests/bitfield_align_2.rs index c63b7533aa..38bb273bf7 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield_align_2.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield_align_2.rs @@ -252,7 +252,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -299,12 +301,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -383,7 +391,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -434,12 +444,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs b/bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs index d915950d28..21535b476e 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/bitfield_pack_offset.rs b/bindgen-tests/tests/expectations/tests/bitfield_pack_offset.rs index 0a5ac00e4b..c7bbaff5c1 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield_pack_offset.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield_pack_offset.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs b/bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs index 882e1a6f77..52775259b8 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/default_visibility_crate.rs b/bindgen-tests/tests/expectations/tests/default_visibility_crate.rs index 56722504d4..649c32ce9d 100644 --- a/bindgen-tests/tests/expectations/tests/default_visibility_crate.rs +++ b/bindgen-tests/tests/expectations/tests/default_visibility_crate.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/default_visibility_private.rs b/bindgen-tests/tests/expectations/tests/default_visibility_private.rs index 1b9f9a1557..67d7e00d1b 100644 --- a/bindgen-tests/tests/expectations/tests/default_visibility_private.rs +++ b/bindgen-tests/tests/expectations/tests/default_visibility_private.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/default_visibility_private_respects_cxx_access_spec.rs b/bindgen-tests/tests/expectations/tests/default_visibility_private_respects_cxx_access_spec.rs index 1789d8f2b2..64c583d480 100644 --- a/bindgen-tests/tests/expectations/tests/default_visibility_private_respects_cxx_access_spec.rs +++ b/bindgen-tests/tests/expectations/tests/default_visibility_private_respects_cxx_access_spec.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs b/bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs index a0d18252ab..18414c8b2b 100644 --- a/bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs +++ b/bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-1-51.rs b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-1-51.rs index 78d2b5e990..edc6dcb9cb 100644 --- a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-1-51.rs +++ b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-1-51.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs index 519aaa7a57..6b893bab6f 100644 --- a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs +++ b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs @@ -252,7 +252,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -299,12 +301,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -383,7 +391,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -434,12 +444,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs index 78d2b5e990..edc6dcb9cb 100644 --- a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs +++ b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs index 262b72c432..a0028b1a83 100644 --- a/bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs +++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs b/bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs index c1a2029373..38427d4570 100644 --- a/bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs +++ b/bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/field-rename-callback.rs b/bindgen-tests/tests/expectations/tests/field-rename-callback.rs index 9739b79708..6122386692 100644 --- a/bindgen-tests/tests/expectations/tests/field-rename-callback.rs +++ b/bindgen-tests/tests/expectations/tests/field-rename-callback.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/field-visibility-callback.rs b/bindgen-tests/tests/expectations/tests/field-visibility-callback.rs index e897e5f786..f2f7393094 100644 --- a/bindgen-tests/tests/expectations/tests/field-visibility-callback.rs +++ b/bindgen-tests/tests/expectations/tests/field-visibility-callback.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/field-visibility.rs b/bindgen-tests/tests/expectations/tests/field-visibility.rs index ca29f24108..27725d7c59 100644 --- a/bindgen-tests/tests/expectations/tests/field-visibility.rs +++ b/bindgen-tests/tests/expectations/tests/field-visibility.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs b/bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs index 240c7fea95..2691ff0285 100644 --- a/bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs +++ b/bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/issue-1034.rs b/bindgen-tests/tests/expectations/tests/issue-1034.rs index 2d8b7e23d8..33aaea055e 100644 --- a/bindgen-tests/tests/expectations/tests/issue-1034.rs +++ b/bindgen-tests/tests/expectations/tests/issue-1034.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs b/bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs index 505b29b655..484cb13a56 100644 --- a/bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs +++ b/bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/issue-1947.rs b/bindgen-tests/tests/expectations/tests/issue-1947.rs index 7e88368e8e..205b562549 100644 --- a/bindgen-tests/tests/expectations/tests/issue-1947.rs +++ b/bindgen-tests/tests/expectations/tests/issue-1947.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs b/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs index 88d884ec29..3ff1d6ab0e 100644 --- a/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs +++ b/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs @@ -252,7 +252,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -299,12 +301,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -383,7 +391,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -434,12 +444,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/issue-743.rs b/bindgen-tests/tests/expectations/tests/issue-743.rs index 9a6dfdbc9e..a7458e5cf2 100644 --- a/bindgen-tests/tests/expectations/tests/issue-743.rs +++ b/bindgen-tests/tests/expectations/tests/issue-743.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/issue-816.rs b/bindgen-tests/tests/expectations/tests/issue-816.rs index 0856139a69..578ad270f8 100644 --- a/bindgen-tests/tests/expectations/tests/issue-816.rs +++ b/bindgen-tests/tests/expectations/tests/issue-816.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs index df7d74e4ef..b881ee6a03 100644 --- a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs +++ b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/layout_align.rs b/bindgen-tests/tests/expectations/tests/layout_align.rs index 6c5f6543cf..3f904870e4 100644 --- a/bindgen-tests/tests/expectations/tests/layout_align.rs +++ b/bindgen-tests/tests/expectations/tests/layout_align.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs b/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs index 898079c965..5bde80d940 100644 --- a/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs +++ b/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/layout_mbuf.rs b/bindgen-tests/tests/expectations/tests/layout_mbuf.rs index 0c9e010a0c..d9a7673008 100644 --- a/bindgen-tests/tests/expectations/tests/layout_mbuf.rs +++ b/bindgen-tests/tests/expectations/tests/layout_mbuf.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/only_bitfields.rs b/bindgen-tests/tests/expectations/tests/only_bitfields.rs index 92f8ae8b78..fd3829fa22 100644 --- a/bindgen-tests/tests/expectations/tests/only_bitfields.rs +++ b/bindgen-tests/tests/expectations/tests/only_bitfields.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/packed-bitfield.rs b/bindgen-tests/tests/expectations/tests/packed-bitfield.rs index a1d1ba48db..1d3b861487 100644 --- a/bindgen-tests/tests/expectations/tests/packed-bitfield.rs +++ b/bindgen-tests/tests/expectations/tests/packed-bitfield.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/private_fields.rs b/bindgen-tests/tests/expectations/tests/private_fields.rs index 9f2e6bda55..bc1c2eb883 100644 --- a/bindgen-tests/tests/expectations/tests/private_fields.rs +++ b/bindgen-tests/tests/expectations/tests/private_fields.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/redundant-packed-and-align.rs b/bindgen-tests/tests/expectations/tests/redundant-packed-and-align.rs index c5fdff6601..6996ca72a7 100644 --- a/bindgen-tests/tests/expectations/tests/redundant-packed-and-align.rs +++ b/bindgen-tests/tests/expectations/tests/redundant-packed-and-align.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs b/bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs index f4ee972385..5297b22938 100644 --- a/bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs +++ b/bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/timex.rs b/bindgen-tests/tests/expectations/tests/timex.rs index 4bf28c30a4..592cf3c93a 100644 --- a/bindgen-tests/tests/expectations/tests/timex.rs +++ b/bindgen-tests/tests/expectations/tests/timex.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/union_bitfield.rs b/bindgen-tests/tests/expectations/tests/union_bitfield.rs index ce67d03109..acbd8c3b7e 100644 --- a/bindgen-tests/tests/expectations/tests/union_bitfield.rs +++ b/bindgen-tests/tests/expectations/tests/union_bitfield.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs index 475dc017c5..e6ab14d9d6 100644 --- a/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs +++ b/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen-tests/tests/expectations/tests/weird_bitfields.rs b/bindgen-tests/tests/expectations/tests/weird_bitfields.rs index db0a4f1e46..fcddfb646c 100644 --- a/bindgen-tests/tests/expectations/tests/weird_bitfields.rs +++ b/bindgen-tests/tests/expectations/tests/weird_bitfields.rs @@ -251,7 +251,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -298,12 +300,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let bytes_needed = (BIT_WIDTH as usize + bit_shift + 7) / 8; if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; @@ -382,7 +390,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } @@ -433,12 +443,18 @@ impl __BindgenBitfieldUnit<[u8; N]> { let storage_ptr = this.cast::<[u8; N]>().cast::(); if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> (usize::BITS as usize - BIT_WIDTH as usize); } val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { let byte_val = (val >> (i * 8)) as u8; diff --git a/bindgen/codegen/bitfield_unit.rs b/bindgen/codegen/bitfield_unit.rs index 3ca5a8d6db..abddfcfbdd 100644 --- a/bindgen/codegen/bitfield_unit.rs +++ b/bindgen/codegen/bitfield_unit.rs @@ -346,7 +346,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> @@ -409,7 +411,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { // The compiler eliminates the unused branch since BIT_WIDTH is const. if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> @@ -418,7 +422,12 @@ impl __BindgenBitfieldUnit<[u8; N]> { val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = + if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { @@ -519,7 +528,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { } val >>= bit_shift; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> @@ -588,7 +599,9 @@ impl __BindgenBitfieldUnit<[u8; N]> { // Use usize for fields that fit, u64 only when necessary. if BIT_WIDTH as usize + bit_shift <= usize::BITS as usize { let mut val = val as usize; - val &= (1usize << BIT_WIDTH) - 1; + if (BIT_WIDTH as u32) < usize::BITS { + val &= (1usize << BIT_WIDTH) - 1; + } if cfg!(target_endian = "big") { val = val.reverse_bits() >> @@ -597,7 +610,12 @@ impl __BindgenBitfieldUnit<[u8; N]> { val <<= bit_shift; - let field_mask = ((1usize << BIT_WIDTH) - 1) << bit_shift; + let field_mask = + if BIT_WIDTH as usize + bit_shift >= usize::BITS as usize { + !0usize << bit_shift + } else { + ((1usize << BIT_WIDTH) - 1) << bit_shift + }; let mut i = 0; while i < bytes_needed { diff --git a/bindgen/codegen/bitfield_unit_tests.rs b/bindgen/codegen/bitfield_unit_tests.rs index 8c9ffdb0fa..baa5c938a5 100644 --- a/bindgen/codegen/bitfield_unit_tests.rs +++ b/bindgen/codegen/bitfield_unit_tests.rs @@ -367,3 +367,73 @@ fn bitfield_unit_raw_const_methods() { // Compare by reading back assert_eq!(unit_const.get(0, 16), unit_runtime.get(0, 16)); } + +// Regression: const-generic accessors must not shift-overflow when +// BIT_WIDTH equals the native word size (usize::BITS). Previously +// `(1usize << BIT_WIDTH) - 1` panicked in debug builds for 64-bit +// fields on 64-bit targets (and 32-bit fields on 32-bit targets). +#[test] +fn bitfield_unit_const_full_word_width() { + let storage = [0x12u8, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0]; + let unit = __BindgenBitfieldUnit::<[u8; 8]>::new(storage); + + // Width == 64 on 64-bit hosts, and width == 32 exercises the + // boundary on 32-bit hosts (still safe on 64-bit, just routes + // through a different branch). + assert_eq!(unit.get_const::<0, 64>(), unit.get(0, 64)); + assert_eq!(unit.get_const::<0, 32>(), unit.get(0, 32)); + + unsafe { + assert_eq!( + __BindgenBitfieldUnit::raw_get_const::<0, 64>(&unit), + unit.get(0, 64), + ); + } + + let mut unit_const = __BindgenBitfieldUnit::<[u8; 8]>::new([0; 8]); + let mut unit_runtime = __BindgenBitfieldUnit::<[u8; 8]>::new([0; 8]); + let value = 0xDEAD_BEEF_CAFE_BABE_u64; + + unit_const.set_const::<0, 64>(value); + unit_runtime.set(0, 64, value); + assert_eq!(unit_const.get(0, 64), unit_runtime.get(0, 64)); + + let mut unit_raw = __BindgenBitfieldUnit::<[u8; 8]>::new([0; 8]); + unsafe { + __BindgenBitfieldUnit::raw_set_const::<0, 64>(&mut unit_raw, value); + } + assert_eq!(unit_raw.get(0, 64), value); + + // Exercise the new `field_mask = !0 << bit_shift` branch with a + // non-zero bit_shift (BIT_WIDTH + bit_shift == usize::BITS but + // BIT_WIDTH < usize::BITS, so the value-mask still runs). + let mut unit_shifted_const = + __BindgenBitfieldUnit::<[u8; 9]>::new([0xAA; 9]); + let mut unit_shifted_runtime = + __BindgenBitfieldUnit::<[u8; 9]>::new([0xAA; 9]); + unit_shifted_const.set_const::<1, 63>(value & ((1u64 << 63) - 1)); + unit_shifted_runtime.set(1, 63, value & ((1u64 << 63) - 1)); + assert_eq!( + unit_shifted_const.get(0, 64), + unit_shifted_runtime.get(0, 64), + ); + assert_eq!( + unit_shifted_const.get_const::<1, 63>(), + unit_shifted_runtime.get(1, 63), + ); + + let mut unit_shifted_raw = __BindgenBitfieldUnit::<[u8; 9]>::new([0xAA; 9]); + let mut unit_shifted_raw_runtime = + __BindgenBitfieldUnit::<[u8; 9]>::new([0xAA; 9]); + unsafe { + __BindgenBitfieldUnit::raw_set_const::<1, 63>( + &mut unit_shifted_raw, + value & ((1u64 << 63) - 1), + ); + } + unit_shifted_raw_runtime.set(1, 63, value & ((1u64 << 63) - 1)); + assert_eq!( + unit_shifted_raw.get(0, 64), + unit_shifted_raw_runtime.get(0, 64), + ); +} From 4e2de9c8dab23868946aca6064ffe92e57d62f5a Mon Sep 17 00:00:00 2001 From: David Hotham Date: Sat, 16 May 2026 18:31:14 +0100 Subject: [PATCH 3/3] Tighten upper-bound debug_assert in bitfield_unit accessors The upper-bound check in get/set/raw_get/raw_set and their const-generic siblings used floor division: `(bit_offset + bit_width) / 8 <= len`. The byte-loop touches indices up to `start_byte + bytes_needed - 1 = ceil((bit_offset + bit_width) / 8) - 1`, so the correct check is `(bit_offset + bit_width + 7) / 8 <= len`. Codegen never produces values that would fail the tighter assert, so this is a hardening of the safety check rather than a runtime fix. Regenerate the matching expectations. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../tests/bitfield-32bit-overflow.rs | 18 ++++++++++-------- .../tests/expectations/tests/bitfield-large.rs | 18 ++++++++++-------- .../expectations/tests/bitfield-linux-32.rs | 18 ++++++++++-------- .../tests/bitfield-method-same-name.rs | 18 ++++++++++-------- .../expectations/tests/bitfield-template.rs | 18 ++++++++++-------- .../tests/expectations/tests/bitfield_align.rs | 18 ++++++++++-------- .../expectations/tests/bitfield_align_2.rs | 18 ++++++++++-------- .../tests/bitfield_method_mangling.rs | 18 ++++++++++-------- .../expectations/tests/bitfield_pack_offset.rs | 18 ++++++++++-------- .../tests/bitfield_pragma_packed.rs | 18 ++++++++++-------- .../tests/default_visibility_crate.rs | 18 ++++++++++-------- .../tests/default_visibility_private.rs | 18 ++++++++++-------- ...ibility_private_respects_cxx_access_spec.rs | 18 ++++++++++-------- .../tests/derive-bitfield-method-same-name.rs | 18 ++++++++++-------- .../tests/derive-debug-bitfield-1-51.rs | 18 ++++++++++-------- .../tests/derive-debug-bitfield-core.rs | 18 ++++++++++-------- .../tests/derive-debug-bitfield.rs | 18 ++++++++++-------- .../tests/derive-partialeq-bitfield.rs | 18 ++++++++++-------- .../tests/divide-by-zero-in-struct-layout.rs | 18 ++++++++++-------- .../tests/field-rename-callback.rs | 18 ++++++++++-------- .../tests/field-visibility-callback.rs | 18 ++++++++++-------- .../expectations/tests/field-visibility.rs | 18 ++++++++++-------- .../tests/incomplete-array-padding.rs | 18 ++++++++++-------- .../tests/expectations/tests/issue-1034.rs | 18 ++++++++++-------- .../issue-1076-unnamed-bitfield-alignment.rs | 18 ++++++++++-------- .../tests/expectations/tests/issue-1947.rs | 18 ++++++++++-------- .../tests/issue-739-pointer-wide-bitfield.rs | 18 ++++++++++-------- .../tests/expectations/tests/issue-743.rs | 18 ++++++++++-------- .../tests/expectations/tests/issue-816.rs | 18 ++++++++++-------- .../expectations/tests/jsval_layout_opaque.rs | 18 ++++++++++-------- .../tests/expectations/tests/layout_align.rs | 18 ++++++++++-------- .../expectations/tests/layout_eth_conf.rs | 18 ++++++++++-------- .../tests/expectations/tests/layout_mbuf.rs | 18 ++++++++++-------- .../tests/expectations/tests/only_bitfields.rs | 18 ++++++++++-------- .../expectations/tests/packed-bitfield.rs | 18 ++++++++++-------- .../tests/expectations/tests/private_fields.rs | 18 ++++++++++-------- .../tests/redundant-packed-and-align.rs | 18 ++++++++++-------- .../tests/struct_with_bitfields.rs | 18 ++++++++++-------- .../tests/expectations/tests/timex.rs | 18 ++++++++++-------- .../tests/expectations/tests/union_bitfield.rs | 18 ++++++++++-------- .../tests/union_with_anon_struct_bitfield.rs | 18 ++++++++++-------- .../expectations/tests/weird_bitfields.rs | 18 ++++++++++-------- bindgen/codegen/bitfield_unit.rs | 16 ++++++++-------- 43 files changed, 428 insertions(+), 344 deletions(-) diff --git a/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs b/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs index 0c321f0d9a..3156142c5c 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/bitfield-large.rs b/bindgen-tests/tests/expectations/tests/bitfield-large.rs index 65e9204570..5ef17d3734 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield-large.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield-large.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs b/bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs index b4abc5991e..ef69afe683 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield-linux-32.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs b/bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs index 599011c305..1453b86ba6 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield-method-same-name.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/bitfield-template.rs b/bindgen-tests/tests/expectations/tests/bitfield-template.rs index 56fa7ffb3e..48e633d850 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield-template.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield-template.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/bitfield_align.rs b/bindgen-tests/tests/expectations/tests/bitfield_align.rs index 580f5476a0..4eabaf3d5b 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield_align.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield_align.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/bitfield_align_2.rs b/bindgen-tests/tests/expectations/tests/bitfield_align_2.rs index 38bb273bf7..c1d97b1f36 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield_align_2.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield_align_2.rs @@ -74,7 +74,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -107,7 +107,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -142,7 +143,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -182,7 +183,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -227,7 +229,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -292,7 +294,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -365,7 +367,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -434,7 +436,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs b/bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs index 21535b476e..c985fc6ce0 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield_method_mangling.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/bitfield_pack_offset.rs b/bindgen-tests/tests/expectations/tests/bitfield_pack_offset.rs index c7bbaff5c1..88553d1df3 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield_pack_offset.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield_pack_offset.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs b/bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs index 52775259b8..3dd2d5a9bb 100644 --- a/bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs +++ b/bindgen-tests/tests/expectations/tests/bitfield_pragma_packed.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/default_visibility_crate.rs b/bindgen-tests/tests/expectations/tests/default_visibility_crate.rs index 649c32ce9d..aaaad588b6 100644 --- a/bindgen-tests/tests/expectations/tests/default_visibility_crate.rs +++ b/bindgen-tests/tests/expectations/tests/default_visibility_crate.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/default_visibility_private.rs b/bindgen-tests/tests/expectations/tests/default_visibility_private.rs index 67d7e00d1b..47aa813b6a 100644 --- a/bindgen-tests/tests/expectations/tests/default_visibility_private.rs +++ b/bindgen-tests/tests/expectations/tests/default_visibility_private.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/default_visibility_private_respects_cxx_access_spec.rs b/bindgen-tests/tests/expectations/tests/default_visibility_private_respects_cxx_access_spec.rs index 64c583d480..74daba7311 100644 --- a/bindgen-tests/tests/expectations/tests/default_visibility_private_respects_cxx_access_spec.rs +++ b/bindgen-tests/tests/expectations/tests/default_visibility_private_respects_cxx_access_spec.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs b/bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs index 18414c8b2b..cf6018366b 100644 --- a/bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs +++ b/bindgen-tests/tests/expectations/tests/derive-bitfield-method-same-name.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-1-51.rs b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-1-51.rs index edc6dcb9cb..f782dd7311 100644 --- a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-1-51.rs +++ b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-1-51.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs index 6b893bab6f..4a7e8b97db 100644 --- a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs +++ b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield-core.rs @@ -74,7 +74,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -107,7 +107,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -142,7 +143,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -182,7 +183,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -227,7 +229,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -292,7 +294,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -365,7 +367,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -434,7 +436,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs index edc6dcb9cb..f782dd7311 100644 --- a/bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs +++ b/bindgen-tests/tests/expectations/tests/derive-debug-bitfield.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs b/bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs index a0028b1a83..9b3e6097dc 100644 --- a/bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs +++ b/bindgen-tests/tests/expectations/tests/derive-partialeq-bitfield.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs b/bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs index 38427d4570..0e62c89ce7 100644 --- a/bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs +++ b/bindgen-tests/tests/expectations/tests/divide-by-zero-in-struct-layout.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/field-rename-callback.rs b/bindgen-tests/tests/expectations/tests/field-rename-callback.rs index 6122386692..f0bbf33880 100644 --- a/bindgen-tests/tests/expectations/tests/field-rename-callback.rs +++ b/bindgen-tests/tests/expectations/tests/field-rename-callback.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/field-visibility-callback.rs b/bindgen-tests/tests/expectations/tests/field-visibility-callback.rs index f2f7393094..c572113844 100644 --- a/bindgen-tests/tests/expectations/tests/field-visibility-callback.rs +++ b/bindgen-tests/tests/expectations/tests/field-visibility-callback.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/field-visibility.rs b/bindgen-tests/tests/expectations/tests/field-visibility.rs index 27725d7c59..dccb0e3390 100644 --- a/bindgen-tests/tests/expectations/tests/field-visibility.rs +++ b/bindgen-tests/tests/expectations/tests/field-visibility.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs b/bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs index 2691ff0285..79f638a6ae 100644 --- a/bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs +++ b/bindgen-tests/tests/expectations/tests/incomplete-array-padding.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/issue-1034.rs b/bindgen-tests/tests/expectations/tests/issue-1034.rs index 33aaea055e..d25e4c9f1e 100644 --- a/bindgen-tests/tests/expectations/tests/issue-1034.rs +++ b/bindgen-tests/tests/expectations/tests/issue-1034.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs b/bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs index 484cb13a56..090203d42a 100644 --- a/bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs +++ b/bindgen-tests/tests/expectations/tests/issue-1076-unnamed-bitfield-alignment.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/issue-1947.rs b/bindgen-tests/tests/expectations/tests/issue-1947.rs index 205b562549..c8ec1d7cd2 100644 --- a/bindgen-tests/tests/expectations/tests/issue-1947.rs +++ b/bindgen-tests/tests/expectations/tests/issue-1947.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs b/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs index 3ff1d6ab0e..d6aa53c5d7 100644 --- a/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs +++ b/bindgen-tests/tests/expectations/tests/issue-739-pointer-wide-bitfield.rs @@ -74,7 +74,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -107,7 +107,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -142,7 +143,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -182,7 +183,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -227,7 +229,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -292,7 +294,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -365,7 +367,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -434,7 +436,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/issue-743.rs b/bindgen-tests/tests/expectations/tests/issue-743.rs index a7458e5cf2..31ba1fb458 100644 --- a/bindgen-tests/tests/expectations/tests/issue-743.rs +++ b/bindgen-tests/tests/expectations/tests/issue-743.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/issue-816.rs b/bindgen-tests/tests/expectations/tests/issue-816.rs index 578ad270f8..937c49bbb6 100644 --- a/bindgen-tests/tests/expectations/tests/issue-816.rs +++ b/bindgen-tests/tests/expectations/tests/issue-816.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs index b881ee6a03..f61aca4686 100644 --- a/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs +++ b/bindgen-tests/tests/expectations/tests/jsval_layout_opaque.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/layout_align.rs b/bindgen-tests/tests/expectations/tests/layout_align.rs index 3f904870e4..b8dc2477fe 100644 --- a/bindgen-tests/tests/expectations/tests/layout_align.rs +++ b/bindgen-tests/tests/expectations/tests/layout_align.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs b/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs index 5bde80d940..dee8ee5291 100644 --- a/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs +++ b/bindgen-tests/tests/expectations/tests/layout_eth_conf.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/layout_mbuf.rs b/bindgen-tests/tests/expectations/tests/layout_mbuf.rs index d9a7673008..fa9a799961 100644 --- a/bindgen-tests/tests/expectations/tests/layout_mbuf.rs +++ b/bindgen-tests/tests/expectations/tests/layout_mbuf.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/only_bitfields.rs b/bindgen-tests/tests/expectations/tests/only_bitfields.rs index fd3829fa22..a712808f55 100644 --- a/bindgen-tests/tests/expectations/tests/only_bitfields.rs +++ b/bindgen-tests/tests/expectations/tests/only_bitfields.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/packed-bitfield.rs b/bindgen-tests/tests/expectations/tests/packed-bitfield.rs index 1d3b861487..cf9eb26c0b 100644 --- a/bindgen-tests/tests/expectations/tests/packed-bitfield.rs +++ b/bindgen-tests/tests/expectations/tests/packed-bitfield.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/private_fields.rs b/bindgen-tests/tests/expectations/tests/private_fields.rs index bc1c2eb883..95ed684f7e 100644 --- a/bindgen-tests/tests/expectations/tests/private_fields.rs +++ b/bindgen-tests/tests/expectations/tests/private_fields.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/redundant-packed-and-align.rs b/bindgen-tests/tests/expectations/tests/redundant-packed-and-align.rs index 6996ca72a7..32eca5479a 100644 --- a/bindgen-tests/tests/expectations/tests/redundant-packed-and-align.rs +++ b/bindgen-tests/tests/expectations/tests/redundant-packed-and-align.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs b/bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs index 5297b22938..777921ded5 100644 --- a/bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs +++ b/bindgen-tests/tests/expectations/tests/struct_with_bitfields.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/timex.rs b/bindgen-tests/tests/expectations/tests/timex.rs index 592cf3c93a..86acf12327 100644 --- a/bindgen-tests/tests/expectations/tests/timex.rs +++ b/bindgen-tests/tests/expectations/tests/timex.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/union_bitfield.rs b/bindgen-tests/tests/expectations/tests/union_bitfield.rs index acbd8c3b7e..29d8c6369c 100644 --- a/bindgen-tests/tests/expectations/tests/union_bitfield.rs +++ b/bindgen-tests/tests/expectations/tests/union_bitfield.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs b/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs index e6ab14d9d6..1174feba4d 100644 --- a/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs +++ b/bindgen-tests/tests/expectations/tests/union_with_anon_struct_bitfield.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen-tests/tests/expectations/tests/weird_bitfields.rs b/bindgen-tests/tests/expectations/tests/weird_bitfields.rs index fcddfb646c..38feb7c187 100644 --- a/bindgen-tests/tests/expectations/tests/weird_bitfields.rs +++ b/bindgen-tests/tests/expectations/tests/weird_bitfields.rs @@ -73,7 +73,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return 0; @@ -106,7 +106,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return 0; @@ -141,7 +142,7 @@ where 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(), + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len(), ); if bit_width == 0 { return; @@ -181,7 +182,8 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::(), + (bit_offset + (bit_width as usize) + 7) / 8 + <= core::mem::size_of::(), ); if bit_width == 0 { return; @@ -226,7 +228,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub const fn get_const(&self) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -291,7 +293,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { pub fn set_const(&mut self, val: u64) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } @@ -364,7 +366,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; } @@ -433,7 +435,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; } diff --git a/bindgen/codegen/bitfield_unit.rs b/bindgen/codegen/bitfield_unit.rs index abddfcfbdd..f6e7d57063 100644 --- a/bindgen/codegen/bitfield_unit.rs +++ b/bindgen/codegen/bitfield_unit.rs @@ -95,7 +95,7 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len() ); @@ -144,7 +144,7 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= + (bit_offset + (bit_width as usize) + 7) / 8 <= core::mem::size_of::() ); @@ -190,7 +190,7 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= + (bit_offset + (bit_width as usize) + 7) / 8 <= self.storage.as_ref().len() ); @@ -251,7 +251,7 @@ where debug_assert!(bit_width <= 64); debug_assert!(bit_offset / 8 < core::mem::size_of::()); debug_assert!( - (bit_offset + (bit_width as usize)) / 8 <= + (bit_offset + (bit_width as usize) + 7) / 8 <= core::mem::size_of::() ); @@ -314,7 +314,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; @@ -397,7 +397,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return; @@ -494,7 +494,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) -> u64 { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return 0; @@ -583,7 +583,7 @@ impl __BindgenBitfieldUnit<[u8; N]> { ) { debug_assert!(BIT_WIDTH <= 64); debug_assert!(BIT_OFFSET / 8 < N); - debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize)) / 8 <= N); + debug_assert!((BIT_OFFSET + (BIT_WIDTH as usize) + 7) / 8 <= N); if BIT_WIDTH == 0 { return;