)]
mod mask_impl;
-use crate::{SimdI16, SimdI32, SimdI64, SimdI8, SimdIsize};
+use crate::{LaneCount, Simd, SimdElement, SupportedLaneCount};
-mod sealed {
- pub trait Sealed {}
-}
-
-/// Helper trait for mask types.
-pub trait Mask: sealed::Sealed {
- /// The number of lanes for this mask.
- const LANES: usize;
-
- /// Generates a mask with the same value in every lane.
- #[must_use]
- fn splat(val: bool) -> Self;
-}
+/// Marker trait for types that may be used as SIMD mask elements.
+pub unsafe trait MaskElement: SimdElement {
+ #[doc(hidden)]
+ fn valid<const LANES: usize>(values: Simd<Self, LANES>) -> bool
+ where
+ LaneCount<LANES>: SupportedLaneCount;
-macro_rules! define_opaque_mask {
- {
- $(#[$attr:meta])*
- struct $name:ident<const $lanes:ident: usize>($inner_ty:ty);
- @bits $bits_ty:ident
- } => {
- $(#[$attr])*
- #[allow(non_camel_case_types)]
- pub struct $name<const LANES: usize>($inner_ty)
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount;
+ #[doc(hidden)]
+ fn eq(self, other: Self) -> bool;
- impl<const LANES: usize> sealed::Sealed for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {}
+ #[doc(hidden)]
+ const TRUE: Self;
- impl<const LANES: usize> Mask for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- const LANES: usize = LANES;
+ #[doc(hidden)]
+ const FALSE: Self;
+}
- #[inline]
- fn splat(value: bool) -> Self {
- Self::splat(value)
+macro_rules! impl_element {
+ { $ty:ty } => {
+ unsafe impl MaskElement for $ty {
+ fn valid<const LANES: usize>(value: Simd<Self, LANES>) -> bool
+ where
+ LaneCount<LANES>: SupportedLaneCount,
+ {
+ (value.lanes_eq(Simd::splat(0)) | value.lanes_eq(Simd::splat(-1))).all()
}
- }
-
- impl_opaque_mask_reductions! { $name, $bits_ty }
- impl<const LANES: usize> $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- /// Construct a mask by setting all lanes to the given value.
- pub fn splat(value: bool) -> Self {
- Self(<$inner_ty>::splat(value))
- }
+ fn eq(self, other: Self) -> bool { self == other }
- /// Converts an array to a SIMD vector.
- pub fn from_array(array: [bool; LANES]) -> Self {
- let mut vector = Self::splat(false);
- let mut i = 0;
- while i < $lanes {
- vector.set(i, array[i]);
- i += 1;
- }
- vector
- }
+ const TRUE: Self = -1;
+ const FALSE: Self = 0;
+ }
+ }
+}
- /// Converts a SIMD vector to an array.
- pub fn to_array(self) -> [bool; LANES] {
- let mut array = [false; LANES];
- let mut i = 0;
- while i < $lanes {
- array[i] = self.test(i);
- i += 1;
- }
- array
- }
+impl_element! { i8 }
+impl_element! { i16 }
+impl_element! { i32 }
+impl_element! { i64 }
+impl_element! { isize }
+
+/// A SIMD vector mask for `LANES` elements of width specified by `Element`.
+///
+/// The layout of this type is unspecified.
+#[repr(transparent)]
+pub struct Mask<T, const LANES: usize>(mask_impl::Mask<T, LANES>)
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount;
+
+impl<T, const LANES: usize> Copy for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+}
- /// Converts a vector of integers to a mask, where 0 represents `false` and -1
- /// represents `true`.
- ///
- /// # Safety
- /// All lanes must be either 0 or -1.
- #[inline]
- pub unsafe fn from_int_unchecked(value: $bits_ty<LANES>) -> Self {
- Self(<$inner_ty>::from_int_unchecked(value))
- }
+impl<T, const LANES: usize> Clone for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ fn clone(&self) -> Self {
+ *self
+ }
+}
- /// Converts a vector of integers to a mask, where 0 represents `false` and -1
- /// represents `true`.
- ///
- /// # Panics
- /// Panics if any lane is not 0 or -1.
- #[inline]
- pub fn from_int(value: $bits_ty<LANES>) -> Self {
- assert!(
- (value.lanes_eq($bits_ty::splat(0)) | value.lanes_eq($bits_ty::splat(-1))).all(),
- "all values must be either 0 or -1",
- );
- unsafe { Self::from_int_unchecked(value) }
- }
+impl<T, const LANES: usize> Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ /// Construct a mask by setting all lanes to the given value.
+ pub fn splat(value: bool) -> Self {
+ Self(mask_impl::Mask::splat(value))
+ }
- /// Converts the mask to a vector of integers, where 0 represents `false` and -1
- /// represents `true`.
- #[inline]
- pub fn to_int(self) -> $bits_ty<LANES> {
- self.0.to_int()
- }
+ /// Converts an array to a SIMD vector.
+ pub fn from_array(array: [bool; LANES]) -> Self {
+ let mut vector = Self::splat(false);
+ for (i, v) in array.iter().enumerate() {
+ vector.set(i, *v);
+ }
+ vector
+ }
- /// Tests the value of the specified lane.
- ///
- /// # Safety
- /// `lane` must be less than `LANES`.
- #[inline]
- pub unsafe fn test_unchecked(&self, lane: usize) -> bool {
- self.0.test_unchecked(lane)
- }
+ /// Converts a SIMD vector to an array.
+ pub fn to_array(self) -> [bool; LANES] {
+ let mut array = [false; LANES];
+ for (i, v) in array.iter_mut().enumerate() {
+ *v = self.test(i);
+ }
+ array
+ }
- /// 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");
- unsafe { self.test_unchecked(lane) }
- }
+ /// Converts a vector of integers to a mask, where 0 represents `false` and -1
+ /// represents `true`.
+ ///
+ /// # Safety
+ /// All lanes must be either 0 or -1.
+ #[inline]
+ pub unsafe fn from_int_unchecked(value: Simd<T, LANES>) -> Self {
+ Self(mask_impl::Mask::from_int_unchecked(value))
+ }
- /// Sets the value of the specified lane.
- ///
- /// # Safety
- /// `lane` must be less than `LANES`.
- #[inline]
- pub unsafe fn set_unchecked(&mut self, lane: usize, value: bool) {
- self.0.set_unchecked(lane, value);
- }
+ /// Converts a vector of integers to a mask, where 0 represents `false` and -1
+ /// represents `true`.
+ ///
+ /// # Panics
+ /// Panics if any lane is not 0 or -1.
+ #[inline]
+ pub fn from_int(value: Simd<T, LANES>) -> Self {
+ assert!(T::valid(value), "all values must be either 0 or -1",);
+ unsafe { Self::from_int_unchecked(value) }
+ }
- /// 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");
- unsafe { self.set_unchecked(lane, value); }
- }
+ /// Converts the mask to a vector of integers, where 0 represents `false` and -1
+ /// represents `true`.
+ #[inline]
+ pub fn to_int(self) -> Simd<T, LANES> {
+ self.0.to_int()
+ }
- /// Convert this mask to a bitmask, with one bit set per lane.
- pub fn to_bitmask(self) -> <crate::LaneCount<LANES> as crate::SupportedLaneCount>::BitMask {
- self.0.to_bitmask()
- }
+ /// Tests the value of the specified lane.
+ ///
+ /// # Safety
+ /// `lane` must be less than `LANES`.
+ #[inline]
+ pub unsafe fn test_unchecked(&self, lane: usize) -> bool {
+ self.0.test_unchecked(lane)
+ }
- /// Convert a bitmask to a mask.
- pub fn from_bitmask(bitmask: <crate::LaneCount<LANES> as crate::SupportedLaneCount>::BitMask) -> Self {
- Self(<$inner_ty>::from_bitmask(bitmask))
- }
- }
+ /// 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");
+ unsafe { self.test_unchecked(lane) }
+ }
- // vector/array conversion
- impl<const LANES: usize> From<[bool; LANES]> for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- fn from(array: [bool; LANES]) -> Self {
- Self::from_array(array)
- }
- }
+ /// Sets the value of the specified lane.
+ ///
+ /// # Safety
+ /// `lane` must be less than `LANES`.
+ #[inline]
+ pub unsafe fn set_unchecked(&mut self, lane: usize, value: bool) {
+ self.0.set_unchecked(lane, value);
+ }
- impl <const LANES: usize> From<$name<LANES>> for [bool; LANES]
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- fn from(vector: $name<LANES>) -> Self {
- vector.to_array()
- }
+ /// 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");
+ unsafe {
+ self.set_unchecked(lane, value);
}
+ }
- impl<const LANES: usize> Copy for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {}
-
- impl<const LANES: usize> Clone for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- #[inline]
- fn clone(&self) -> Self {
- *self
- }
- }
+ /// Convert this mask to a bitmask, with one bit set per lane.
+ #[cfg(feature = "generic_const_exprs")]
+ pub fn to_bitmask(self) -> [u8; LaneCount::<LANES>::BITMASK_LEN] {
+ self.0.to_bitmask()
+ }
- impl<const LANES: usize> Default for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- #[inline]
- fn default() -> Self {
- Self::splat(false)
- }
- }
+ /// Convert a bitmask to a mask.
+ #[cfg(feature = "generic_const_exprs")]
+ pub fn from_bitmask(bitmask: [u8; LaneCount::<LANES>::BITMASK_LEN]) -> Self {
+ Self(mask_impl::Mask::from_bitmask(bitmask))
+ }
- impl<const LANES: usize> PartialEq for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- #[inline]
- fn eq(&self, other: &Self) -> bool {
- self.0 == other.0
- }
- }
+ /// Returns true if any lane is set, or false otherwise.
+ #[inline]
+ pub fn any(self) -> bool {
+ self.0.any()
+ }
- impl<const LANES: usize> PartialOrd for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- #[inline]
- fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
- self.0.partial_cmp(&other.0)
- }
- }
+ /// Returns true if all lanes are set, or false otherwise.
+ #[inline]
+ pub fn all(self) -> bool {
+ self.0.all()
+ }
+}
- impl<const LANES: usize> core::fmt::Debug for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
- f.debug_list()
- .entries((0..LANES).map(|lane| self.test(lane)))
- .finish()
- }
- }
+// vector/array conversion
+impl<T, const LANES: usize> From<[bool; LANES]> for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ fn from(array: [bool; LANES]) -> Self {
+ Self::from_array(array)
+ }
+}
- impl<const LANES: usize> core::ops::BitAnd for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- type Output = Self;
- #[inline]
- fn bitand(self, rhs: Self) -> Self {
- Self(self.0 & rhs.0)
- }
- }
+impl<T, const LANES: usize> From<Mask<T, LANES>> for [bool; LANES]
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ fn from(vector: Mask<T, LANES>) -> Self {
+ vector.to_array()
+ }
+}
- impl<const LANES: usize> core::ops::BitAnd<bool> for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- type Output = Self;
- #[inline]
- fn bitand(self, rhs: bool) -> Self {
- self & Self::splat(rhs)
- }
- }
+impl<T, const LANES: usize> Default for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ #[inline]
+ fn default() -> Self {
+ Self::splat(false)
+ }
+}
- impl<const LANES: usize> core::ops::BitAnd<$name<LANES>> for bool
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- type Output = $name<LANES>;
- #[inline]
- fn bitand(self, rhs: $name<LANES>) -> $name<LANES> {
- $name::<LANES>::splat(self) & rhs
- }
- }
+impl<T, const LANES: usize> PartialEq for Mask<T, LANES>
+where
+ T: MaskElement + PartialEq,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ #[inline]
+ fn eq(&self, other: &Self) -> bool {
+ self.0 == other.0
+ }
+}
- impl<const LANES: usize> core::ops::BitOr for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- type Output = Self;
- #[inline]
- fn bitor(self, rhs: Self) -> Self {
- Self(self.0 | rhs.0)
- }
- }
+impl<T, const LANES: usize> PartialOrd for Mask<T, LANES>
+where
+ T: MaskElement + PartialOrd,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ #[inline]
+ fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+ self.0.partial_cmp(&other.0)
+ }
+}
- impl<const LANES: usize> core::ops::BitOr<bool> for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- type Output = Self;
- #[inline]
- fn bitor(self, rhs: bool) -> Self {
- self | Self::splat(rhs)
- }
- }
+impl<T, const LANES: usize> core::fmt::Debug for Mask<T, LANES>
+where
+ T: MaskElement + core::fmt::Debug,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ f.debug_list()
+ .entries((0..LANES).map(|lane| self.test(lane)))
+ .finish()
+ }
+}
- impl<const LANES: usize> core::ops::BitOr<$name<LANES>> for bool
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- type Output = $name<LANES>;
- #[inline]
- fn bitor(self, rhs: $name<LANES>) -> $name<LANES> {
- $name::<LANES>::splat(self) | rhs
- }
- }
+impl<T, const LANES: usize> core::ops::BitAnd for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ type Output = Self;
+ #[inline]
+ fn bitand(self, rhs: Self) -> Self {
+ Self(self.0 & rhs.0)
+ }
+}
- impl<const LANES: usize> core::ops::BitXor for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- type Output = Self;
- #[inline]
- fn bitxor(self, rhs: Self) -> Self::Output {
- Self(self.0 ^ rhs.0)
- }
- }
+impl<T, const LANES: usize> core::ops::BitAnd<bool> for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ type Output = Self;
+ #[inline]
+ fn bitand(self, rhs: bool) -> Self {
+ self & Self::splat(rhs)
+ }
+}
- impl<const LANES: usize> core::ops::BitXor<bool> for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- type Output = Self;
- #[inline]
- fn bitxor(self, rhs: bool) -> Self::Output {
- self ^ Self::splat(rhs)
- }
- }
+impl<T, const LANES: usize> core::ops::BitAnd<Mask<T, LANES>> for bool
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ type Output = Mask<T, LANES>;
+ #[inline]
+ fn bitand(self, rhs: Mask<T, LANES>) -> Mask<T, LANES> {
+ Mask::splat(self) & rhs
+ }
+}
- impl<const LANES: usize> core::ops::BitXor<$name<LANES>> for bool
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- type Output = $name<LANES>;
- #[inline]
- fn bitxor(self, rhs: $name<LANES>) -> Self::Output {
- $name::<LANES>::splat(self) ^ rhs
- }
- }
+impl<T, const LANES: usize> core::ops::BitOr for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ type Output = Self;
+ #[inline]
+ fn bitor(self, rhs: Self) -> Self {
+ Self(self.0 | rhs.0)
+ }
+}
- impl<const LANES: usize> core::ops::Not for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- type Output = $name<LANES>;
- #[inline]
- fn not(self) -> Self::Output {
- Self(!self.0)
- }
- }
+impl<T, const LANES: usize> core::ops::BitOr<bool> for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ type Output = Self;
+ #[inline]
+ fn bitor(self, rhs: bool) -> Self {
+ self | Self::splat(rhs)
+ }
+}
- impl<const LANES: usize> core::ops::BitAndAssign for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- #[inline]
- fn bitand_assign(&mut self, rhs: Self) {
- self.0 = self.0 & rhs.0;
- }
- }
+impl<T, const LANES: usize> core::ops::BitOr<Mask<T, LANES>> for bool
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ type Output = Mask<T, LANES>;
+ #[inline]
+ fn bitor(self, rhs: Mask<T, LANES>) -> Mask<T, LANES> {
+ Mask::splat(self) | rhs
+ }
+}
- impl<const LANES: usize> core::ops::BitAndAssign<bool> for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- #[inline]
- fn bitand_assign(&mut self, rhs: bool) {
- *self &= Self::splat(rhs);
- }
- }
+impl<T, const LANES: usize> core::ops::BitXor for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ type Output = Self;
+ #[inline]
+ fn bitxor(self, rhs: Self) -> Self::Output {
+ Self(self.0 ^ rhs.0)
+ }
+}
- impl<const LANES: usize> core::ops::BitOrAssign for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- #[inline]
- fn bitor_assign(&mut self, rhs: Self) {
- self.0 = self.0 | rhs.0;
- }
- }
+impl<T, const LANES: usize> core::ops::BitXor<bool> for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ type Output = Self;
+ #[inline]
+ fn bitxor(self, rhs: bool) -> Self::Output {
+ self ^ Self::splat(rhs)
+ }
+}
- impl<const LANES: usize> core::ops::BitOrAssign<bool> for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- #[inline]
- fn bitor_assign(&mut self, rhs: bool) {
- *self |= Self::splat(rhs);
- }
- }
+impl<T, const LANES: usize> core::ops::BitXor<Mask<T, LANES>> for bool
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ type Output = Mask<T, LANES>;
+ #[inline]
+ fn bitxor(self, rhs: Mask<T, LANES>) -> Self::Output {
+ Mask::splat(self) ^ rhs
+ }
+}
- impl<const LANES: usize> core::ops::BitXorAssign for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- #[inline]
- fn bitxor_assign(&mut self, rhs: Self) {
- self.0 = self.0 ^ rhs.0;
- }
- }
+impl<T, const LANES: usize> core::ops::Not for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ type Output = Mask<T, LANES>;
+ #[inline]
+ fn not(self) -> Self::Output {
+ Self(!self.0)
+ }
+}
- impl<const LANES: usize> core::ops::BitXorAssign<bool> for $name<LANES>
- where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
- {
- #[inline]
- fn bitxor_assign(&mut self, rhs: bool) {
- *self ^= Self::splat(rhs);
- }
- }
- };
+impl<T, const LANES: usize> core::ops::BitAndAssign for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ #[inline]
+ fn bitand_assign(&mut self, rhs: Self) {
+ self.0 = self.0 & rhs.0;
+ }
}
-define_opaque_mask! {
- /// Mask for vectors with `LANES` 8-bit elements.
- ///
- /// The layout of this type is unspecified.
- struct Mask8<const LANES: usize>(mask_impl::Mask8<LANES>);
- @bits SimdI8
+impl<T, const LANES: usize> core::ops::BitAndAssign<bool> for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ #[inline]
+ fn bitand_assign(&mut self, rhs: bool) {
+ *self &= Self::splat(rhs);
+ }
}
-define_opaque_mask! {
- /// Mask for vectors with `LANES` 16-bit elements.
- ///
- /// The layout of this type is unspecified.
- struct Mask16<const LANES: usize>(mask_impl::Mask16<LANES>);
- @bits SimdI16
+impl<T, const LANES: usize> core::ops::BitOrAssign for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ #[inline]
+ fn bitor_assign(&mut self, rhs: Self) {
+ self.0 = self.0 | rhs.0;
+ }
}
-define_opaque_mask! {
- /// Mask for vectors with `LANES` 32-bit elements.
- ///
- /// The layout of this type is unspecified.
- struct Mask32<const LANES: usize>(mask_impl::Mask32<LANES>);
- @bits SimdI32
+impl<T, const LANES: usize> core::ops::BitOrAssign<bool> for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ #[inline]
+ fn bitor_assign(&mut self, rhs: bool) {
+ *self |= Self::splat(rhs);
+ }
}
-define_opaque_mask! {
- /// Mask for vectors with `LANES` 64-bit elements.
- ///
- /// The layout of this type is unspecified.
- struct Mask64<const LANES: usize>(mask_impl::Mask64<LANES>);
- @bits SimdI64
+impl<T, const LANES: usize> core::ops::BitXorAssign for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ #[inline]
+ fn bitxor_assign(&mut self, rhs: Self) {
+ self.0 = self.0 ^ rhs.0;
+ }
}
-define_opaque_mask! {
- /// Mask for vectors with `LANES` pointer-width elements.
- ///
- /// The layout of this type is unspecified.
- struct MaskSize<const LANES: usize>(mask_impl::MaskSize<LANES>);
- @bits SimdIsize
+impl<T, const LANES: usize> core::ops::BitXorAssign<bool> for Mask<T, LANES>
+where
+ T: MaskElement,
+ LaneCount<LANES>: SupportedLaneCount,
+{
+ #[inline]
+ fn bitxor_assign(&mut self, rhs: bool) {
+ *self ^= Self::splat(rhs);
+ }
}
/// Vector of eight 8-bit masks
-pub type mask8x8 = Mask8<8>;
+pub type mask8x8 = Mask<i8, 8>;
/// Vector of 16 8-bit masks
-pub type mask8x16 = Mask8<16>;
+pub type mask8x16 = Mask<i8, 16>;
/// Vector of 32 8-bit masks
-pub type mask8x32 = Mask8<32>;
+pub type mask8x32 = Mask<i8, 32>;
/// Vector of 16 8-bit masks
-pub type mask8x64 = Mask8<64>;
+pub type mask8x64 = Mask<i8, 64>;
/// Vector of four 16-bit masks
-pub type mask16x4 = Mask16<4>;
+pub type mask16x4 = Mask<i16, 4>;
/// Vector of eight 16-bit masks
-pub type mask16x8 = Mask16<8>;
+pub type mask16x8 = Mask<i16, 8>;
/// Vector of 16 16-bit masks
-pub type mask16x16 = Mask16<16>;
+pub type mask16x16 = Mask<i16, 16>;
/// Vector of 32 16-bit masks
-pub type mask16x32 = Mask32<32>;
+pub type mask16x32 = Mask<i32, 32>;
/// Vector of two 32-bit masks
-pub type mask32x2 = Mask32<2>;
+pub type mask32x2 = Mask<i32, 2>;
/// Vector of four 32-bit masks
-pub type mask32x4 = Mask32<4>;
+pub type mask32x4 = Mask<i32, 4>;
/// Vector of eight 32-bit masks
-pub type mask32x8 = Mask32<8>;
+pub type mask32x8 = Mask<i32, 8>;
/// Vector of 16 32-bit masks
-pub type mask32x16 = Mask32<16>;
+pub type mask32x16 = Mask<i32, 16>;
/// Vector of two 64-bit masks
-pub type mask64x2 = Mask64<2>;
+pub type mask64x2 = Mask<i64, 2>;
/// Vector of four 64-bit masks
-pub type mask64x4 = Mask64<4>;
+pub type mask64x4 = Mask<i64, 4>;
/// Vector of eight 64-bit masks
-pub type mask64x8 = Mask64<8>;
+pub type mask64x8 = Mask<i64, 8>;
/// Vector of two pointer-width masks
-pub type masksizex2 = MaskSize<2>;
+pub type masksizex2 = Mask<isize, 2>;
/// Vector of four pointer-width masks
-pub type masksizex4 = MaskSize<4>;
+pub type masksizex4 = Mask<isize, 4>;
/// Vector of eight pointer-width masks
-pub type masksizex8 = MaskSize<8>;
+pub type masksizex8 = Mask<isize, 8>;
macro_rules! impl_from {
- { $from:ident ($from_inner:ident) => $($to:ident ($to_inner:ident)),* } => {
+ { $from:ty => $($to:ty),* } => {
$(
- impl<const LANES: usize> From<$from<LANES>> for $to<LANES>
+ impl<const LANES: usize> From<Mask<$from, LANES>> for Mask<$to, LANES>
where
- crate::LaneCount<LANES>: crate::SupportedLaneCount,
+ LaneCount<LANES>: SupportedLaneCount,
{
- fn from(value: $from<LANES>) -> Self {
- Self(value.0.into())
+ fn from(value: Mask<$from, LANES>) -> Self {
+ Self(value.0.convert())
}
}
)*
}
}
-impl_from! { Mask8 (SimdI8) => Mask16 (SimdI16), Mask32 (SimdI32), Mask64 (SimdI64), MaskSize (SimdIsize) }
-impl_from! { Mask16 (SimdI16) => Mask32 (SimdI32), Mask64 (SimdI64), MaskSize (SimdIsize), Mask8 (SimdI8) }
-impl_from! { Mask32 (SimdI32) => Mask64 (SimdI64), MaskSize (SimdIsize), Mask8 (SimdI8), Mask16 (SimdI16) }
-impl_from! { Mask64 (SimdI64) => MaskSize (SimdIsize), Mask8 (SimdI8), Mask16 (SimdI16), Mask32 (SimdI32) }
-impl_from! { MaskSize (SimdIsize) => Mask8 (SimdI8), Mask16 (SimdI16), Mask32 (SimdI32), Mask64 (SimdI64) }
+impl_from! { i8 => i16, i32, i64, isize }
+impl_from! { i16 => i32, i64, isize, i8 }
+impl_from! { i32 => i64, isize, i8, i16 }
+impl_from! { i64 => isize, i8, i16, i32 }
+impl_from! { isize => i8, i16, i32, i64 }
projects / rust.git / blobdiff