diff --git a/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs b/bindgen-tests/tests/expectations/tests/bitfield-32bit-overflow.rs index 1bd4ecac7c..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -252,7 +254,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); } @@ -290,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; } @@ -299,12 +303,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; @@ -357,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; } @@ -383,7 +393,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); } @@ -424,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; } @@ -434,12 +446,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -252,7 +254,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); } @@ -290,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; } @@ -299,12 +303,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; @@ -357,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; } @@ -383,7 +393,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); } @@ -424,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; } @@ -434,12 +446,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -252,7 +254,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); } @@ -290,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; } @@ -299,12 +303,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; @@ -357,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; } @@ -383,7 +393,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); } @@ -424,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; } @@ -434,12 +446,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; } @@ -251,7 +253,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); } @@ -289,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; } @@ -298,12 +302,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; @@ -356,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; } @@ -382,7 +392,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); } @@ -423,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; } @@ -433,12 +445,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..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; @@ -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() >> @@ -395,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; @@ -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 { @@ -485,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; @@ -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() >> @@ -572,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; @@ -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), + ); +} 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