use crate::arch::asm; #[cfg(test)] use stdarch_test::assert_instr; // x32 wants to use a 32-bit address size, but asm! defaults to using the full // register name (e.g. rax). We have to explicitly override the placeholder to // use the 32-bit register name in that case. #[cfg(target_pointer_width = "32")] macro_rules! bt { ($inst:expr) => { concat!($inst, " {b:e}, ({p:e})") }; } #[cfg(target_pointer_width = "64")] macro_rules! bt { ($inst:expr) => { concat!($inst, " {b:e}, ({p})") }; } /// Returns the bit in position `b` of the memory addressed by `p`. #[inline] #[cfg_attr(test, assert_instr(bt))] #[stable(feature = "simd_x86_bittest", since = "1.55.0")] pub unsafe fn _bittest(p: *const i32, b: i32) -> u8 { let r: u8; asm!( bt!("btl"), "setc {r}", p = in(reg) p, b = in(reg) b, r = out(reg_byte) r, options(readonly, nostack, pure, att_syntax) ); r } /// Returns the bit in position `b` of the memory addressed by `p`, then sets the bit to `1`. #[inline] #[cfg_attr(test, assert_instr(bts))] #[stable(feature = "simd_x86_bittest", since = "1.55.0")] pub unsafe fn _bittestandset(p: *mut i32, b: i32) -> u8 { let r: u8; asm!( bt!("btsl"), "setc {r}", p = in(reg) p, b = in(reg) b, r = out(reg_byte) r, options(nostack, att_syntax) ); r } /// Returns the bit in position `b` of the memory addressed by `p`, then resets that bit to `0`. #[inline] #[cfg_attr(test, assert_instr(btr))] #[stable(feature = "simd_x86_bittest", since = "1.55.0")] pub unsafe fn _bittestandreset(p: *mut i32, b: i32) -> u8 { let r: u8; asm!( bt!("btrl"), "setc {r}", p = in(reg) p, b = in(reg) b, r = out(reg_byte) r, options(nostack, att_syntax) ); r } /// Returns the bit in position `b` of the memory addressed by `p`, then inverts that bit. #[inline] #[cfg_attr(test, assert_instr(btc))] #[stable(feature = "simd_x86_bittest", since = "1.55.0")] pub unsafe fn _bittestandcomplement(p: *mut i32, b: i32) -> u8 { let r: u8; asm!( bt!("btcl"), "setc {r}", p = in(reg) p, b = in(reg) b, r = out(reg_byte) r, options(nostack, att_syntax) ); r } #[cfg(test)] mod tests { use crate::core_arch::x86::*; #[test] fn test_bittest() { unsafe { let a = 0b0101_0000i32; assert_eq!(_bittest(&a as _, 4), 1); assert_eq!(_bittest(&a as _, 5), 0); } } #[test] fn test_bittestandset() { unsafe { let mut a = 0b0101_0000i32; assert_eq!(_bittestandset(&mut a as _, 4), 1); assert_eq!(_bittestandset(&mut a as _, 4), 1); assert_eq!(_bittestandset(&mut a as _, 5), 0); assert_eq!(_bittestandset(&mut a as _, 5), 1); } } #[test] fn test_bittestandreset() { unsafe { let mut a = 0b0101_0000i32; assert_eq!(_bittestandreset(&mut a as _, 4), 1); assert_eq!(_bittestandreset(&mut a as _, 4), 0); assert_eq!(_bittestandreset(&mut a as _, 5), 0); assert_eq!(_bittestandreset(&mut a as _, 5), 0); } } #[test] fn test_bittestandcomplement() { unsafe { let mut a = 0b0101_0000i32; assert_eq!(_bittestandcomplement(&mut a as _, 4), 1); assert_eq!(_bittestandcomplement(&mut a as _, 4), 0); assert_eq!(_bittestandcomplement(&mut a as _, 4), 1); assert_eq!(_bittestandcomplement(&mut a as _, 5), 0); assert_eq!(_bittestandcomplement(&mut a as _, 5), 1); } } }