Remove bitmask requirement on generic_const_exprs feature

Author: calebzulawski

crates/core_simd/src/masks.rs

@@ -15,9 +15,6 @@ mod mask_impl;
 mod to_bitmask;
 pub use to_bitmask::{ToBitMask, ToBitMaskArray};
 
-#[cfg(feature = "generic_const_exprs")]
-pub use to_bitmask::bitmask_len;
-
 use crate::simd::{intrinsics, LaneCount, Simd, SimdElement, SupportedLaneCount};
 use core::cmp::Ordering;
 use core::{fmt, mem};

crates/core_simd/src/masks/bitmask.rs

@@ -115,29 +115,31 @@ where
         unsafe { Self(intrinsics::simd_bitmask(value), PhantomData) }
     }
 
-    #[cfg(feature = "generic_const_exprs")]
+    // Safety: N must be the exact number of bytes required to hold the bitmask for this mask
     #[inline]
     #[must_use = "method returns a new array and does not mutate the original value"]
-    pub fn to_bitmask(self) -> [u8; super::bitmask_len(LANES)] {
+    pub unsafe fn to_bitmask_array<const N: usize>(self) -> [u8; N] {
         // Safety: these are the same type and we are laundering the generic
         unsafe { core::mem::transmute_copy(&self.0) }
     }
 
-    #[cfg(feature = "generic_const_exprs")]
+    // Safety: N must be the exact number of bytes required to hold the bitmask for this mask
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
-    pub fn from_bitmask(bitmask: [u8; super::bitmask_len(LANES)]) -> Self {
+    pub unsafe fn from_bitmask_array<const N: usize>(bitmask: [u8; N]) -> Self {
         // Safety: these are the same type and we are laundering the generic
         Self(unsafe { core::mem::transmute_copy(&bitmask) }, PhantomData)
     }
 
+    // Safety: U must be the integer with the exact number of bits required to hold the bitmask for
     #[inline]
-    pub unsafe fn to_bitmask_intrinsic<U>(self) -> U {
+    pub unsafe fn to_bitmask_integer<U>(self) -> U {
         unsafe { core::mem::transmute_copy(&self.0) }
     }
 
+    // Safety: U must be the integer with the exact number of bits required to hold the bitmask for
     #[inline]
-    pub unsafe fn from_bitmask_intrinsic<U>(bitmask: U) -> Self {
+    pub unsafe fn from_bitmask_integer<U>(bitmask: U) -> Self {
         unsafe { Self(core::mem::transmute_copy(&bitmask), PhantomData) }
     }
 

crates/core_simd/src/masks/full_masks.rs

@@ -109,12 +109,12 @@ where
         unsafe { Mask(intrinsics::simd_cast(self.0)) }
     }
 
-    #[cfg(feature = "generic_const_exprs")]
+    // Safety: N must be the exact number of bytes required to hold the bitmask for this mask
     #[inline]
     #[must_use = "method returns a new array and does not mutate the original value"]
-    pub fn to_bitmask(self) -> [u8; super::bitmask_len(LANES)] {
+    pub unsafe fn to_bitmask_array<const N: usize>(self) -> [u8; N] {
         unsafe {
-            let mut bitmask: [u8; super::bitmask_len(LANES)] = intrinsics::simd_bitmask(self.0);
+            let mut bitmask: [u8; N] = intrinsics::simd_bitmask(self.0);
 
             // There is a bug where LLVM appears to implement this operation with the wrong
             // bit order.
@@ -129,10 +129,10 @@ where
         }
     }
 
-    #[cfg(feature = "generic_const_exprs")]
+    // Safety: N must be the exact number of bytes required to hold the bitmask for this mask
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
-    pub fn from_bitmask(mut bitmask: [u8; super::bitmask_len(LANES)]) -> Self {
+    pub unsafe fn from_bitmask_array<const N: usize>(mut bitmask: [u8; N]) -> Self {
         unsafe {
             // There is a bug where LLVM appears to implement this operation with the wrong
             // bit order.
@@ -151,14 +151,18 @@ where
         }
     }
 
+    // Safety: U must be the integer with the exact number of bits required to hold the bitmask for
+    // this mask
     #[inline]
-    pub unsafe fn to_bitmask_intrinsic<U>(self) -> U {
+    pub unsafe fn to_bitmask_integer<U>(self) -> U {
         // Safety: caller must only return bitmask types
         unsafe { intrinsics::simd_bitmask(self.0) }
     }
 
+    // Safety: U must be the integer with the exact number of bits required to hold the bitmask for
+    // this mask
     #[inline]
-    pub unsafe fn from_bitmask_intrinsic<U>(bitmask: U) -> Self {
+    pub unsafe fn from_bitmask_integer<U>(bitmask: U) -> Self {
         // Safety: caller must only pass bitmask types
         unsafe {
             Self::from_int_unchecked(intrinsics::simd_select_bitmask(

crates/core_simd/src/masks/to_bitmask.rs

@@ -35,11 +35,11 @@ macro_rules! impl_integer_intrinsic {
             type BitMask = $int;
 
             fn to_bitmask(self) -> $int {
-                unsafe { self.0.to_bitmask_intrinsic() }
+                unsafe { self.0.to_bitmask_integer() }
             }
 
             fn from_bitmask(bitmask: $int) -> Self {
-                unsafe { Self(mask_impl::Mask::from_bitmask_intrinsic(bitmask)) }
+                unsafe { Self(mask_impl::Mask::from_bitmask_integer(bitmask)) }
             }
         }
         )*
@@ -54,12 +54,10 @@ impl_integer_intrinsic! {
 }
 
 /// Returns the minimum numnber of bytes in a bitmask with `lanes` lanes.
-#[cfg(feature = "generic_const_exprs")]
 pub const fn bitmask_len(lanes: usize) -> usize {
     (lanes + 7) / 8
 }
 
-#[cfg(feature = "generic_const_exprs")]
 macro_rules! impl_array_bitmask {
     { $(impl ToBitMask<[u8; _]> for Mask<_, $lanes:literal>)* } => {
         $(
@@ -68,19 +66,20 @@ macro_rules! impl_array_bitmask {
              const BYTES: usize = bitmask_len($lanes);
 
              fn to_bitmask_array(self) -> [u8; Self::BYTES] {
-                 self.0.to_bitmask()
+                 // Safety: BYTES is the exact size required
+                 unsafe { self.0.to_bitmask_array() }
              }
 
              fn from_bitmask_array(bitmask: [u8; Self::BYTES]) -> Self {
-                 Mask(mask_impl::Mask::from_bitmask(bitmask))
+                 // Safety: BYTES is the exact size required
+                 unsafe { Mask(mask_impl::Mask::from_bitmask_array(bitmask)) }
              }
         }
         )*
     }
 }
 
 // FIXME this should be specified generically, but it doesn't seem to work with rustc, yet
-#[cfg(feature = "generic_const_exprs")]
 impl_array_bitmask! {
     impl ToBitMask<[u8; _]> for Mask<_, 1>
     impl ToBitMask<[u8; _]> for Mask<_, 2>

crates/core_simd/tests/masks.rs

@@ -81,7 +81,6 @@ macro_rules! test_mask_api {
                 assert_eq!(core_simd::Mask::<$type, 16>::from_bitmask(bitmask), mask);
             }
 
-            #[cfg(feature = "generic_const_exprs")]
             #[test]
             fn roundtrip_bitmask_array_conversion() {
                 use core_simd::ToBitMaskArray;