Merge branch 'master' into attrs

Author: calebzulawski

crates/core_simd/src/lib.rs

@@ -1,6 +1,5 @@
 #![no_std]
 #![feature(
-    const_ptr_read,
     const_refs_to_cell,
     const_maybe_uninit_as_mut_ptr,
     const_mut_refs,

crates/core_simd/src/swizzle_dyn.rs

@@ -43,8 +43,9 @@ where
                 32 => transize(x86::_mm256_permutexvar_epi8, self, idxs),
                 // Notable absence: avx512bw shuffle
                 // If avx512bw is available, odds of avx512vbmi are good
-                #[cfg(target_feature = "avx512vbmi")]
-                64 => transize(x86::_mm512_permutexvar_epi8, self, idxs),
+                // FIXME: initial AVX512VBMI variant didn't actually pass muster
+                // #[cfg(target_feature = "avx512vbmi")]
+                // 64 => transize(x86::_mm512_permutexvar_epi8, self, idxs),
                 _ => {
                     let mut array = [0; N];
                     for (i, k) in idxs.to_array().into_iter().enumerate() {
@@ -67,6 +68,7 @@ where
 #[target_feature(enable = "avx2")]
 #[allow(unused)]
 #[inline]
+#[allow(clippy::let_and_return)]
 unsafe fn avx2_pshufb(bytes: Simd<u8, 32>, idxs: Simd<u8, 32>) -> Simd<u8, 32> {
     use crate::simd::SimdPartialOrd;
     #[cfg(target_arch = "x86")]

crates/core_simd/src/vector.rs

@@ -2,6 +2,7 @@ use crate::simd::{
     intrinsics, LaneCount, Mask, MaskElement, SimdCast, SimdCastPtr, SimdConstPtr, SimdMutPtr,
     SimdPartialOrd, SupportedLaneCount, Swizzle,
 };
+use core::convert::{TryFrom, TryInto};
 
 /// A SIMD vector with the shape of `[T; N]` but the operations of `T`.
 ///
@@ -109,7 +110,7 @@ where
     T: SimdElement,
 {
     /// Number of elements in this vector.
-    pub const N: usize = N;
+    pub const LANES: usize = N;
 
     /// Returns the number of elements in this SIMD vector.
     ///
@@ -123,7 +124,7 @@ where
     /// ```
     #[inline]
     pub const fn lanes(&self) -> usize {
-        Self::N
+        Self::LANES
     }
 
     /// Constructs a new SIMD vector with all elements set to the given value.
@@ -159,9 +160,9 @@ where
     /// ```
     #[inline]
     pub const fn as_array(&self) -> &[T; N] {
-        // SAFETY: Transmuting between `Simd<T, N>` and `[T; N]`
-        // is always valid and `Simd<T, N>` never has a lower alignment
-        // than `[T; N]`.
+        // SAFETY: `Simd<T, N>` is just an overaligned `[T; N]` with
+        // potential padding at the end, so pointer casting to a
+        // `&[T; N]` is safe.
         //
         // NOTE: This deliberately doesn't just use `&self.0`, see the comment
         // on the struct definition for details.
@@ -171,9 +172,9 @@ where
     /// Returns a mutable array reference containing the entire SIMD vector.
     #[inline]
     pub fn as_mut_array(&mut self) -> &mut [T; N] {
-        // SAFETY: Transmuting between `Simd<T, N>` and `[T; N]`
-        // is always valid and `Simd<T, N>` never has a lower alignment
-        // than `[T; N]`.
+        // SAFETY: `Simd<T, N>` is just an overaligned `[T; N]` with
+        // potential padding at the end, so pointer casting to a
+        // `&mut [T; N]` is safe.
         //
         // NOTE: This deliberately doesn't just use `&mut self.0`, see the comment
         // on the struct definition for details.
@@ -269,14 +270,12 @@ where
     #[track_caller]
     pub const fn from_slice(slice: &[T]) -> Self {
         assert!(
-            slice.len() >= Self::N,
+            slice.len() >= Self::LANES,
             "slice length must be at least the number of elements"
         );
-        assert!(core::mem::size_of::<Self>() == Self::N * core::mem::size_of::<T>());
-        // Safety:
-        // - We've checked the length is sufficient.
-        // - `T` and `Simd<T, N>` are Copy types.
-        unsafe { slice.as_ptr().cast::<Self>().read_unaligned() }
+        // SAFETY: We just checked that the slice contains
+        // at least `N` elements.
+        unsafe { Self::load(slice.as_ptr().cast()) }
     }
 
     /// Writes a SIMD vector to the first `N` elements of a slice.
@@ -301,14 +300,12 @@ where
     #[track_caller]
     pub fn copy_to_slice(self, slice: &mut [T]) {
         assert!(
-            slice.len() >= Self::N,
+            slice.len() >= Self::LANES,
             "slice length must be at least the number of elements"
         );
-        assert!(core::mem::size_of::<Self>() == Self::N * core::mem::size_of::<T>());
-        // Safety:
-        // - We've checked the length is sufficient
-        // - `T` and `Simd<T, N>` are Copy types.
-        unsafe { slice.as_mut_ptr().cast::<Self>().write_unaligned(self) }
+        // SAFETY: We just checked that the slice contains
+        // at least `N` elements.
+        unsafe { self.store(slice.as_mut_ptr().cast()) }
     }
 
     /// Performs elementwise conversion of a SIMD vector's elements to another SIMD-valid type.
@@ -902,7 +899,7 @@ where
     type Error = core::array::TryFromSliceError;
 
     #[inline]
-    fn try_from(slice: &[T]) -> Result<Self, Self::Error> {
+    fn try_from(slice: &[T]) -> Result<Self, core::array::TryFromSliceError> {
         Ok(Self::from_array(slice.try_into()?))
     }
 }
@@ -915,7 +912,7 @@ where
     type Error = core::array::TryFromSliceError;
 
     #[inline]
-    fn try_from(slice: &mut [T]) -> Result<Self, Self::Error> {
+    fn try_from(slice: &mut [T]) -> Result<Self, core::array::TryFromSliceError> {
         Ok(Self::from_array(slice.try_into()?))
     }
 }