Begin reducing mask API

Author: calebzulawski

crates/core_simd/src/comparisons.rs

@@ -1,7 +1,7 @@
 use crate::LanesAtMost32;
 
 macro_rules! implement_mask_ops {
-    { $($vector:ident => $mask:ident ($inner_mask_ty:ident, $inner_ty:ident),)* } => {
+    { $($vector:ident => $mask:ident ($inner_ty:ident),)* } => {
         $(
             impl<const LANES: usize> crate::$vector<LANES>
             where
@@ -12,53 +12,47 @@ macro_rules! implement_mask_ops {
                 #[inline]
                 pub fn lanes_eq(self, other: Self) -> crate::$mask<LANES> {
                     unsafe {
-                        crate::$inner_mask_ty::from_int_unchecked(crate::intrinsics::simd_eq(self, other))
-                            .into()
+                        crate::$mask::from_int_unchecked(crate::intrinsics::simd_eq(self, other))
                     }
                 }
 
                 /// Test if each lane is not equal to the corresponding lane in `other`.
                 #[inline]
                 pub fn lanes_ne(self, other: Self) -> crate::$mask<LANES> {
                     unsafe {
-                        crate::$inner_mask_ty::from_int_unchecked(crate::intrinsics::simd_ne(self, other))
-                            .into()
+                        crate::$mask::from_int_unchecked(crate::intrinsics::simd_ne(self, other))
                     }
                 }
 
                 /// Test if each lane is less than the corresponding lane in `other`.
                 #[inline]
                 pub fn lanes_lt(self, other: Self) -> crate::$mask<LANES> {
                     unsafe {
-                        crate::$inner_mask_ty::from_int_unchecked(crate::intrinsics::simd_lt(self, other))
-                            .into()
+                        crate::$mask::from_int_unchecked(crate::intrinsics::simd_lt(self, other))
                     }
                 }
 
                 /// Test if each lane is greater than the corresponding lane in `other`.
                 #[inline]
                 pub fn lanes_gt(self, other: Self) -> crate::$mask<LANES> {
                     unsafe {
-                        crate::$inner_mask_ty::from_int_unchecked(crate::intrinsics::simd_gt(self, other))
-                            .into()
+                        crate::$mask::from_int_unchecked(crate::intrinsics::simd_gt(self, other))
                     }
                 }
 
                 /// Test if each lane is less than or equal to the corresponding lane in `other`.
                 #[inline]
                 pub fn lanes_le(self, other: Self) -> crate::$mask<LANES> {
                     unsafe {
-                        crate::$inner_mask_ty::from_int_unchecked(crate::intrinsics::simd_le(self, other))
-                            .into()
+                        crate::$mask::from_int_unchecked(crate::intrinsics::simd_le(self, other))
                     }
                 }
 
                 /// Test if each lane is greater than or equal to the corresponding lane in `other`.
                 #[inline]
                 pub fn lanes_ge(self, other: Self) -> crate::$mask<LANES> {
                     unsafe {
-                        crate::$inner_mask_ty::from_int_unchecked(crate::intrinsics::simd_ge(self, other))
-                            .into()
+                        crate::$mask::from_int_unchecked(crate::intrinsics::simd_ge(self, other))
                     }
                 }
             }
@@ -67,18 +61,18 @@ macro_rules! implement_mask_ops {
 }
 
 implement_mask_ops! {
-    SimdI8 => Mask8 (SimdMask8, SimdI8),
-    SimdI16 => Mask16 (SimdMask16, SimdI16),
-    SimdI32 => Mask32 (SimdMask32, SimdI32),
-    SimdI64 => Mask64 (SimdMask64, SimdI64),
-    SimdIsize => MaskSize (SimdMaskSize, SimdIsize),
+    SimdI8 => Mask8 (SimdI8),
+    SimdI16 => Mask16 (SimdI16),
+    SimdI32 => Mask32 (SimdI32),
+    SimdI64 => Mask64 (SimdI64),
+    SimdIsize => MaskSize (SimdIsize),
 
-    SimdU8 => Mask8 (SimdMask8, SimdI8),
-    SimdU16 => Mask16 (SimdMask16, SimdI16),
-    SimdU32 => Mask32 (SimdMask32, SimdI32),
-    SimdU64 => Mask64 (SimdMask64, SimdI64),
-    SimdUsize => MaskSize (SimdMaskSize, SimdIsize),
+    SimdU8 => Mask8 (SimdI8),
+    SimdU16 => Mask16 (SimdI16),
+    SimdU32 => Mask32 (SimdI32),
+    SimdU64 => Mask64 (SimdI64),
+    SimdUsize => MaskSize (SimdIsize),
 
-    SimdF32 => Mask32 (SimdMask32, SimdI32),
-    SimdF64 => Mask64 (SimdMask64, SimdI64),
+    SimdF32 => Mask32 (SimdI32),
+    SimdF64 => Mask64 (SimdI64),
 }

crates/core_simd/src/lanes_at_most_32.rs

@@ -1,4 +1,4 @@
-/// Implemented for bitmask sizes that are supported by the implementation.
+/// Implemented for vectors that are supported by the implementation.
 pub trait LanesAtMost32 {}
 
 macro_rules! impl_for {
@@ -28,5 +28,3 @@ impl_for! { SimdIsize }
 
 impl_for! { SimdF32 }
 impl_for! { SimdF64 }
-
-impl_for! { BitMask }

crates/core_simd/src/masks/bitmask.rs

@@ -4,14 +4,12 @@ use crate::LanesAtMost32;
 #[derive(Copy, Clone, Debug, PartialOrd, PartialEq, Ord, Eq, Hash)]
 #[repr(transparent)]
 pub struct BitMask<const LANES: usize>(u64)
-where
-    BitMask<LANES>: LanesAtMost32;
 
 impl<const LANES: usize> BitMask<LANES>
 where
     Self: LanesAtMost32,
 {
-    /// Construct a mask by setting all lanes to the given value.
+    #[inline]
     pub fn splat(value: bool) -> Self {
         if value {
             Self(u64::MAX >> (64 - LANES))
@@ -20,23 +18,13 @@ where
         }
     }
 
-    /// Tests the value of the specified lane.
-    ///
-    /// # Panics
-    /// Panics if `lane` is greater than or equal to the number of lanes in the vector.
     #[inline]
-    pub fn test(&self, lane: usize) -> bool {
-        assert!(lane < LANES, "lane index out of range");
+    pub unsafe fn test_unchecked(&self, lane: usize) -> bool {
         (self.0 >> lane) & 0x1 > 0
     }
 
-    /// Sets the value of the specified lane.
-    ///
-    /// # Panics
-    /// Panics if `lane` is greater than or equal to the number of lanes in the vector.
     #[inline]
-    pub fn set(&mut self, lane: usize, value: bool) {
-        assert!(lane < LANES, "lane index out of range");
+    pub unsafe fn set_unchecked(&mut self, lane: usize, value: bool) {
         self.0 ^= ((value ^ self.test(lane)) as u64) << lane
     }
 }