Add some safety comments

calebzulawski · workingjubilee · commit dddfffcfb3e4 · 2022-02-09T16:15:01.000-08:00
diff --git a/crates/core_simd/src/comparisons.rs b/crates/core_simd/src/comparisons.rs
@@ -10,13 +10,17 @@ where
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
     pub fn lanes_eq(self, other: Self) -> Mask<T::Mask, LANES> {
+        // Safety: `self` is a vector, and the result of the comparison
+        // is always a valid mask.
         unsafe { Mask::from_int_unchecked(intrinsics::simd_eq(self, other)) }
     }
 
     /// Test if each lane is not equal to the corresponding lane in `other`.
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
     pub fn lanes_ne(self, other: Self) -> Mask<T::Mask, LANES> {
+        // Safety: `self` is a vector, and the result of the comparison
+        // is always a valid mask.
         unsafe { Mask::from_int_unchecked(intrinsics::simd_ne(self, other)) }
     }
 }
@@ -30,27 +34,35 @@ where
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
     pub fn lanes_lt(self, other: Self) -> Mask<T::Mask, LANES> {
+        // Safety: `self` is a vector, and the result of the comparison
+        // is always a valid mask.
         unsafe { Mask::from_int_unchecked(intrinsics::simd_lt(self, other)) }
     }
 
     /// Test if each lane is greater than the corresponding lane in `other`.
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
     pub fn lanes_gt(self, other: Self) -> Mask<T::Mask, LANES> {
+        // Safety: `self` is a vector, and the result of the comparison
+        // is always a valid mask.
         unsafe { Mask::from_int_unchecked(intrinsics::simd_gt(self, other)) }
     }
 
     /// Test if each lane is less than or equal to the corresponding lane in `other`.
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
     pub fn lanes_le(self, other: Self) -> Mask<T::Mask, LANES> {
+        // Safety: `self` is a vector, and the result of the comparison
+        // is always a valid mask.
         unsafe { Mask::from_int_unchecked(intrinsics::simd_le(self, other)) }
     }
 
     /// Test if each lane is greater than or equal to the corresponding lane in `other`.
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
     pub fn lanes_ge(self, other: Self) -> Mask<T::Mask, LANES> {
+        // Safety: `self` is a vector, and the result of the comparison
+        // is always a valid mask.
         unsafe { Mask::from_int_unchecked(intrinsics::simd_ge(self, other)) }
     }
 }
diff --git a/crates/core_simd/src/masks.rs b/crates/core_simd/src/masks.rs
@@ -42,6 +42,9 @@ mod sealed {
 use sealed::Sealed;
 
 /// Marker trait for types that may be used as SIMD mask elements.
+///
+/// # Safety
+/// Type must be a signed integer.
 pub unsafe trait MaskElement: SimdElement + Sealed {}
 
 macro_rules! impl_element {
@@ -149,6 +152,7 @@ where
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
     pub unsafe fn from_int_unchecked(value: Simd<T, LANES>) -> Self {
+        // Safety: the caller must confirm this invariant
         unsafe { Self(mask_impl::Mask::from_int_unchecked(value)) }
     }
 
@@ -161,6 +165,7 @@ where
     #[must_use = "method returns a new mask and does not mutate the original value"]
     pub fn from_int(value: Simd<T, LANES>) -> Self {
         assert!(T::valid(value), "all values must be either 0 or -1",);
+        // Safety: the validity has been checked
         unsafe { Self::from_int_unchecked(value) }
     }
 
@@ -179,6 +184,7 @@ where
     #[inline]
     #[must_use = "method returns a new bool and does not mutate the original value"]
     pub unsafe fn test_unchecked(&self, lane: usize) -> bool {
+        // Safety: the caller must confirm this invariant
         unsafe { self.0.test_unchecked(lane) }
     }
 
@@ -190,6 +196,7 @@ where
     #[must_use = "method returns a new bool and does not mutate the original value"]
     pub fn test(&self, lane: usize) -> bool {
         assert!(lane < LANES, "lane index out of range");
+        // Safety: the lane index has been checked
         unsafe { self.test_unchecked(lane) }
     }
 
@@ -199,6 +206,7 @@ where
     /// `lane` must be less than `LANES`.
     #[inline]
     pub unsafe fn set_unchecked(&mut self, lane: usize, value: bool) {
+        // Safety: the caller must confirm this invariant
         unsafe {
             self.0.set_unchecked(lane, value);
         }
@@ -211,6 +219,7 @@ where
     #[inline]
     pub fn set(&mut self, lane: usize, value: bool) {
         assert!(lane < LANES, "lane index out of range");
+        // Safety: the lane index has been checked
         unsafe {
             self.set_unchecked(lane, value);
         }
diff --git a/crates/core_simd/src/masks/bitmask.rs b/crates/core_simd/src/masks/bitmask.rs
@@ -137,6 +137,7 @@ where
     where
         U: MaskElement,
     {
+        // Safety: bitmask layout does not depend on the element width
         unsafe { core::mem::transmute_copy(&self) }
     }
 
diff --git a/crates/core_simd/src/masks/full_masks.rs b/crates/core_simd/src/masks/full_masks.rs
@@ -106,6 +106,7 @@ where
     where
         U: MaskElement,
     {
+        // Safety: masks are simply integer vectors of 0 and -1, and we can cast the element type.
         unsafe { Mask(intrinsics::simd_cast(self.0)) }
     }
 
@@ -155,12 +156,14 @@ where
     #[inline]
     #[must_use = "method returns a new bool and does not mutate the original value"]
     pub fn any(self) -> bool {
+        // Safety: use `self` as an integer vector
         unsafe { intrinsics::simd_reduce_any(self.to_int()) }
     }
 
     #[inline]
     #[must_use = "method returns a new vector and does not mutate the original value"]
     pub fn all(self) -> bool {
+        // Safety: use `self` as an integer vector
         unsafe { intrinsics::simd_reduce_all(self.to_int()) }
     }
 }
@@ -184,6 +187,7 @@ where
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitand(self, rhs: Self) -> Self {
+        // Safety: `self` is an integer vector
         unsafe { Self(intrinsics::simd_and(self.0, rhs.0)) }
     }
 }
@@ -197,6 +201,7 @@ where
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitor(self, rhs: Self) -> Self {
+        // Safety: `self` is an integer vector
         unsafe { Self(intrinsics::simd_or(self.0, rhs.0)) }
     }
 }
@@ -210,6 +215,7 @@ where
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitxor(self, rhs: Self) -> Self {
+        // Safety: `self` is an integer vector
         unsafe { Self(intrinsics::simd_xor(self.0, rhs.0)) }
     }
 }
diff --git a/crates/core_simd/src/math.rs b/crates/core_simd/src/math.rs
@@ -22,6 +22,7 @@ macro_rules! impl_uint_arith {
             /// ```
             #[inline]
             pub fn saturating_add(self, second: Self) -> Self {
+                // Safety: `self` is a vector
                 unsafe { simd_saturating_add(self, second) }
             }
 
@@ -41,6 +42,7 @@ macro_rules! impl_uint_arith {
             /// assert_eq!(sat, Simd::splat(0));
             #[inline]
             pub fn saturating_sub(self, second: Self) -> Self {
+                // Safety: `self` is a vector
                 unsafe { simd_saturating_sub(self, second) }
             }
         })+
@@ -68,6 +70,7 @@ macro_rules! impl_int_arith {
             /// ```
             #[inline]
             pub fn saturating_add(self, second: Self) -> Self {
+                // Safety: `self` is a vector
                 unsafe { simd_saturating_add(self, second) }
             }
 
@@ -87,6 +90,7 @@ macro_rules! impl_int_arith {
             /// assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));
             #[inline]
             pub fn saturating_sub(self, second: Self) -> Self {
+                // Safety: `self` is a vector
                 unsafe { simd_saturating_sub(self, second) }
             }
 
diff --git a/crates/core_simd/src/reduction.rs b/crates/core_simd/src/reduction.rs
@@ -14,24 +14,28 @@ macro_rules! impl_integer_reductions {
             /// Horizontal wrapping add.  Returns the sum of the lanes of the vector, with wrapping addition.
             #[inline]
             pub fn horizontal_sum(self) -> $scalar {
+                // Safety: `self` is an integer vector
                 unsafe { simd_reduce_add_ordered(self, 0) }
             }
 
             /// Horizontal wrapping multiply.  Returns the product of the lanes of the vector, with wrapping multiplication.
             #[inline]
             pub fn horizontal_product(self) -> $scalar {
+                // Safety: `self` is an integer vector
                 unsafe { simd_reduce_mul_ordered(self, 1) }
             }
 
             /// Horizontal maximum.  Returns the maximum lane in the vector.
             #[inline]
             pub fn horizontal_max(self) -> $scalar {
+                // Safety: `self` is an integer vector
                 unsafe { simd_reduce_max(self) }
             }
 
             /// Horizontal minimum.  Returns the minimum lane in the vector.
             #[inline]
             pub fn horizontal_min(self) -> $scalar {
+                // Safety: `self` is an integer vector
                 unsafe { simd_reduce_min(self) }
             }
         }
@@ -63,6 +67,7 @@ macro_rules! impl_float_reductions {
                 if cfg!(all(target_arch = "x86", not(target_feature = "sse2"))) {
                     self.as_array().iter().sum()
                 } else {
+                    // Safety: `self` is a float vector
                     unsafe { simd_reduce_add_ordered(self, 0.) }
                 }
             }
@@ -74,6 +79,7 @@ macro_rules! impl_float_reductions {
                 if cfg!(all(target_arch = "x86", not(target_feature = "sse2"))) {
                     self.as_array().iter().product()
                 } else {
+                    // Safety: `self` is a float vector
                     unsafe { simd_reduce_mul_ordered(self, 1.) }
                 }
             }
@@ -84,6 +90,7 @@ macro_rules! impl_float_reductions {
             /// return either.  This function will not return `NaN` unless all lanes are `NaN`.
             #[inline]
             pub fn horizontal_max(self) -> $scalar {
+                // Safety: `self` is a float vector
                 unsafe { simd_reduce_max(self) }
             }
 
@@ -93,6 +100,7 @@ macro_rules! impl_float_reductions {
             /// return either.  This function will not return `NaN` unless all lanes are `NaN`.
             #[inline]
             pub fn horizontal_min(self) -> $scalar {
+                // Safety: `self` is a float vector
                 unsafe { simd_reduce_min(self) }
             }
         }
diff --git a/crates/core_simd/src/swizzle.rs b/crates/core_simd/src/swizzle.rs
@@ -95,6 +95,7 @@ pub trait Swizzle<const INPUT_LANES: usize, const OUTPUT_LANES: usize> {
         LaneCount<INPUT_LANES>: SupportedLaneCount,
         LaneCount<OUTPUT_LANES>: SupportedLaneCount,
     {
+        // Safety: `vector` is a vector, and `INDEX_IMPL` is a const array of u32.
         unsafe { intrinsics::simd_shuffle(vector, vector, Self::INDEX_IMPL) }
     }
 }
@@ -119,6 +120,7 @@ pub trait Swizzle2<const INPUT_LANES: usize, const OUTPUT_LANES: usize> {
         LaneCount<INPUT_LANES>: SupportedLaneCount,
         LaneCount<OUTPUT_LANES>: SupportedLaneCount,
     {
+        // Safety: `first` and `second` are vectors, and `INDEX_IMPL` is a const array of u32.
         unsafe { intrinsics::simd_shuffle(first, second, Self::INDEX_IMPL) }
     }
 }
diff --git a/crates/core_simd/src/to_bytes.rs b/crates/core_simd/src/to_bytes.rs
@@ -8,12 +8,14 @@ macro_rules! impl_to_bytes {
             /// Return the memory representation of this integer as a byte array in native byte
             /// order.
             pub fn to_ne_bytes(self) -> crate::simd::Simd<u8, {{ $size * LANES }}> {
+                // Safety: transmuting between vectors is safe
                 unsafe { core::mem::transmute_copy(&self) }
             }
 
             /// Create a native endian integer value from its memory representation as a byte array
             /// in native endianness.
             pub fn from_ne_bytes(bytes: crate::simd::Simd<u8, {{ $size * LANES }}>) -> Self {
+                // Safety: transmuting between vectors is safe
                 unsafe { core::mem::transmute_copy(&bytes) }
             }
         }
diff --git a/crates/core_simd/src/vector.rs b/crates/core_simd/src/vector.rs
@@ -206,7 +206,7 @@ where
         or: Self,
     ) -> Self {
         let enable: Mask<isize, LANES> = enable & idxs.lanes_lt(Simd::splat(slice.len()));
-        // SAFETY: We have masked-off out-of-bounds lanes.
+        // Safety: We have masked-off out-of-bounds lanes.
         unsafe { Self::gather_select_unchecked(slice, enable, idxs, or) }
     }
 
@@ -247,7 +247,7 @@ where
         let base_ptr = crate::simd::ptr::SimdConstPtr::splat(slice.as_ptr());
         // Ferris forgive me, I have done pointer arithmetic here.
         let ptrs = base_ptr.wrapping_add(idxs);
-        // SAFETY: The ptrs have been bounds-masked to prevent memory-unsafe reads insha'allah
+        // Safety: The ptrs have been bounds-masked to prevent memory-unsafe reads insha'allah
         unsafe { intrinsics::simd_gather(or, ptrs, enable.to_int()) }
     }
 
@@ -299,7 +299,7 @@ where
         idxs: Simd<usize, LANES>,
     ) {
         let enable: Mask<isize, LANES> = enable & idxs.lanes_lt(Simd::splat(slice.len()));
-        // SAFETY: We have masked-off out-of-bounds lanes.
+        // Safety: We have masked-off out-of-bounds lanes.
         unsafe { self.scatter_select_unchecked(slice, enable, idxs) }
     }
 
@@ -338,7 +338,7 @@ where
         enable: Mask<isize, LANES>,
         idxs: Simd<usize, LANES>,
     ) {
-        // SAFETY: This block works with *mut T derived from &mut 'a [T],
+        // Safety: This block works with *mut T derived from &mut 'a [T],
         // which means it is delicate in Rust's borrowing model, circa 2021:
         // &mut 'a [T] asserts uniqueness, so deriving &'a [T] invalidates live *mut Ts!
         // Even though this block is largely safe methods, it must be exactly this way
@@ -518,7 +518,9 @@ mod sealed {
 use sealed::Sealed;
 
 /// Marker trait for types that may be used as SIMD vector elements.
-/// SAFETY: This trait, when implemented, asserts the compiler can monomorphize
+///
+/// # Safety
+/// This trait, when implemented, asserts the compiler can monomorphize
 /// `#[repr(simd)]` structs with the marked type as an element.
 /// Strictly, it is valid to impl if the vector will not be miscompiled.
 /// Practically, it is user-unfriendly to impl it if the vector won't compile,
diff --git a/crates/core_simd/src/vector/ptr.rs b/crates/core_simd/src/vector/ptr.rs
@@ -21,6 +21,8 @@ where
     #[inline]
     #[must_use]
     pub fn wrapping_add(self, addend: Simd<usize, LANES>) -> Self {
+        // Safety: converting pointers to usize and vice-versa is safe
+        // (even if using that pointer is not)
         unsafe {
             let x: Simd<usize, LANES> = mem::transmute_copy(&self);
             mem::transmute_copy(&{ x + (addend * Simd::splat(mem::size_of::<T>())) })
@@ -47,6 +49,8 @@ where
     #[inline]
     #[must_use]
     pub fn wrapping_add(self, addend: Simd<usize, LANES>) -> Self {
+        // Safety: converting pointers to usize and vice-versa is safe
+        // (even if using that pointer is not)
         unsafe {
             let x: Simd<usize, LANES> = mem::transmute_copy(&self);
             mem::transmute_copy(&{ x + (addend * Simd::splat(mem::size_of::<T>())) })
diff --git a/crates/core_simd/src/vendor.rs b/crates/core_simd/src/vendor.rs
@@ -9,6 +9,8 @@ macro_rules! from_transmute {
         impl core::convert::From<$from> for $to {
             #[inline]
             fn from(value: $from) -> $to {
+                // Safety: transmuting between vectors is safe, but the caller of this macro
+                // checks the invariants
                 unsafe { core::mem::transmute(value) }
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -137,6 +137,7 @@ where`
`137`	`137`	`where`
`138`	`138`	`U: MaskElement,`
`139`	`139`	`{`
	`140`	`+ // Safety: bitmask layout does not depend on the element width`
`140`	`141`	`unsafe { core::mem::transmute_copy(&self) }`
`141`	`142`	`}`
`142`	`143`
Original file line number	Diff line number	Diff line change
`@@ -106,6 +106,7 @@ where`
`106`	`106`	`where`
`107`	`107`	`U: MaskElement,`
`108`	`108`	`{`
	`109`	`+ // Safety: masks are simply integer vectors of 0 and -1, and we can cast the element type.`
`109`	`110`	`unsafe { Mask(intrinsics::simd_cast(self.0)) }`
`110`	`111`	`}`
`111`	`112`
`@@ -155,12 +156,14 @@ where`
`155`	`156`	`#[inline]`
`156`	`157`	`#[must_use = "method returns a new bool and does not mutate the original value"]`
`157`	`158`	`pub fn any(self) -> bool {`
	`159`	+ // Safety: use `self` as an integer vector
`158`	`160`	`unsafe { intrinsics::simd_reduce_any(self.to_int()) }`
`159`	`161`	`}`
`160`	`162`
`161`	`163`	`#[inline]`
`162`	`164`	`#[must_use = "method returns a new vector and does not mutate the original value"]`
`163`	`165`	`pub fn all(self) -> bool {`
	`166`	+ // Safety: use `self` as an integer vector
`164`	`167`	`unsafe { intrinsics::simd_reduce_all(self.to_int()) }`
`165`	`168`	`}`
`166`	`169`	`}`
`@@ -184,6 +187,7 @@ where`
`184`	`187`	`#[inline]`
`185`	`188`	`#[must_use = "method returns a new mask and does not mutate the original value"]`
`186`	`189`	`fn bitand(self, rhs: Self) -> Self {`
	`190`	+ // Safety: `self` is an integer vector
`187`	`191`	`unsafe { Self(intrinsics::simd_and(self.0, rhs.0)) }`
`188`	`192`	`}`
`189`	`193`	`}`
`@@ -197,6 +201,7 @@ where`
`197`	`201`	`#[inline]`
`198`	`202`	`#[must_use = "method returns a new mask and does not mutate the original value"]`
`199`	`203`	`fn bitor(self, rhs: Self) -> Self {`
	`204`	+ // Safety: `self` is an integer vector
`200`	`205`	`unsafe { Self(intrinsics::simd_or(self.0, rhs.0)) }`
`201`	`206`	`}`
`202`	`207`	`}`
`@@ -210,6 +215,7 @@ where`
`210`	`215`	`#[inline]`
`211`	`216`	`#[must_use = "method returns a new mask and does not mutate the original value"]`
`212`	`217`	`fn bitxor(self, rhs: Self) -> Self {`
	`218`	+ // Safety: `self` is an integer vector
`213`	`219`	`unsafe { Self(intrinsics::simd_xor(self.0, rhs.0)) }`
`214`	`220`	`}`
`215`	`221`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,24 +14,28 @@ macro_rules! impl_integer_reductions {`
`14`	`14`	`/// Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.`
`15`	`15`	`#[inline]`
`16`	`16`	`pub fn horizontal_sum(self) -> $scalar {`
	`17`	+ // Safety: `self` is an integer vector
`17`	`18`	`unsafe { simd_reduce_add_ordered(self, 0) }`
`18`	`19`	`}`
`19`	`20`
`20`	`21`	`/// Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.`
`21`	`22`	`#[inline]`
`22`	`23`	`pub fn horizontal_product(self) -> $scalar {`
	`24`	+ // Safety: `self` is an integer vector
`23`	`25`	`unsafe { simd_reduce_mul_ordered(self, 1) }`
`24`	`26`	`}`
`25`	`27`
`26`	`28`	`/// Horizontal maximum. Returns the maximum lane in the vector.`
`27`	`29`	`#[inline]`
`28`	`30`	`pub fn horizontal_max(self) -> $scalar {`
	`31`	+ // Safety: `self` is an integer vector
`29`	`32`	`unsafe { simd_reduce_max(self) }`
`30`	`33`	`}`
`31`	`34`
`32`	`35`	`/// Horizontal minimum. Returns the minimum lane in the vector.`
`33`	`36`	`#[inline]`
`34`	`37`	`pub fn horizontal_min(self) -> $scalar {`
	`38`	+ // Safety: `self` is an integer vector
`35`	`39`	`unsafe { simd_reduce_min(self) }`
`36`	`40`	`}`
`37`	`41`	`}`
`@@ -63,6 +67,7 @@ macro_rules! impl_float_reductions {`
`63`	`67`	`if cfg!(all(target_arch = "x86", not(target_feature = "sse2"))) {`
`64`	`68`	`self.as_array().iter().sum()`
`65`	`69`	`} else {`
	`70`	+ // Safety: `self` is a float vector
`66`	`71`	`unsafe { simd_reduce_add_ordered(self, 0.) }`
`67`	`72`	`}`
`68`	`73`	`}`
`@@ -74,6 +79,7 @@ macro_rules! impl_float_reductions {`
`74`	`79`	`if cfg!(all(target_arch = "x86", not(target_feature = "sse2"))) {`
`75`	`80`	`self.as_array().iter().product()`
`76`	`81`	`} else {`
	`82`	+ // Safety: `self` is a float vector
`77`	`83`	`unsafe { simd_reduce_mul_ordered(self, 1.) }`
`78`	`84`	`}`
`79`	`85`	`}`
`@@ -84,6 +90,7 @@ macro_rules! impl_float_reductions {`
`84`	`90`	/// return either. This function will not return `NaN` unless all lanes are `NaN`.
`85`	`91`	`#[inline]`
`86`	`92`	`pub fn horizontal_max(self) -> $scalar {`
	`93`	+ // Safety: `self` is a float vector
`87`	`94`	`unsafe { simd_reduce_max(self) }`
`88`	`95`	`}`
`89`	`96`
`@@ -93,6 +100,7 @@ macro_rules! impl_float_reductions {`
`93`	`100`	/// return either. This function will not return `NaN` unless all lanes are `NaN`.
`94`	`101`	`#[inline]`
`95`	`102`	`pub fn horizontal_min(self) -> $scalar {`
	`103`	+ // Safety: `self` is a float vector
`96`	`104`	`unsafe { simd_reduce_min(self) }`
`97`	`105`	`}`
`98`	`106`	`}`
Original file line number	Diff line number	Diff line change
`@@ -95,6 +95,7 @@ pub trait Swizzle<const INPUT_LANES: usize, const OUTPUT_LANES: usize> {`
`95`	`95`	`LaneCount<INPUT_LANES>: SupportedLaneCount,`
`96`	`96`	`LaneCount<OUTPUT_LANES>: SupportedLaneCount,`
`97`	`97`	`{`
	`98`	+ // Safety: `vector` is a vector, and `INDEX_IMPL` is a const array of u32.
`98`	`99`	`unsafe { intrinsics::simd_shuffle(vector, vector, Self::INDEX_IMPL) }`
`99`	`100`	`}`
`100`	`101`	`}`
`@@ -119,6 +120,7 @@ pub trait Swizzle2<const INPUT_LANES: usize, const OUTPUT_LANES: usize> {`
`119`	`120`	`LaneCount<INPUT_LANES>: SupportedLaneCount,`
`120`	`121`	`LaneCount<OUTPUT_LANES>: SupportedLaneCount,`
`121`	`122`	`{`
	`123`	+ // Safety: `first` and `second` are vectors, and `INDEX_IMPL` is a const array of u32.
`122`	`124`	`unsafe { intrinsics::simd_shuffle(first, second, Self::INDEX_IMPL) }`
`123`	`125`	`}`
`124`	`126`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,12 +8,14 @@ macro_rules! impl_to_bytes {`
`8`	`8`	`/// Return the memory representation of this integer as a byte array in native byte`
`9`	`9`	`/// order.`
`10`	`10`	`pub fn to_ne_bytes(self) -> crate::simd::Simd<u8, {{ $size * LANES }}> {`
	`11`	`+ // Safety: transmuting between vectors is safe`
`11`	`12`	`unsafe { core::mem::transmute_copy(&self) }`
`12`	`13`	`}`
`13`	`14`
`14`	`15`	`/// Create a native endian integer value from its memory representation as a byte array`
`15`	`16`	`/// in native endianness.`
`16`	`17`	`pub fn from_ne_bytes(bytes: crate::simd::Simd<u8, {{ $size * LANES }}>) -> Self {`
	`18`	`+ // Safety: transmuting between vectors is safe`
`17`	`19`	`unsafe { core::mem::transmute_copy(&bytes) }`
`18`	`20`	`}`
`19`	`21`	`}`