Replace copy_nonoverlapping() in vst1_* with write_unaligned()

Author: hkratz

crates/core_arch/src/aarch64/neon/mod.rs

@@ -12,8 +12,7 @@ pub use self::generated::*;
 use crate::{
     core_arch::{arm_shared::*, simd::*, simd_llvm::*},
     hint::unreachable_unchecked,
-    mem::{size_of, transmute, zeroed},
-    ptr::copy_nonoverlapping,
+    mem::{transmute, zeroed},
 };
 #[cfg(test)]
 use stdarch_test::assert_instr;
@@ -657,11 +656,7 @@ pub unsafe fn vld1q_f64(ptr: *const f64) -> float64x2_t {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1_s8(ptr: *mut i8, a: int8x8_t) {
-    copy_nonoverlapping(
-        &a as *const int8x8_t as *const i8,
-        ptr as *mut i8,
-        size_of::<int8x8_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -670,11 +665,7 @@ pub unsafe fn vst1_s8(ptr: *mut i8, a: int8x8_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1q_s8(ptr: *mut i8, a: int8x16_t) {
-    copy_nonoverlapping(
-        &a as *const int8x16_t as *const i8,
-        ptr as *mut i8,
-        size_of::<int8x16_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -683,11 +674,7 @@ pub unsafe fn vst1q_s8(ptr: *mut i8, a: int8x16_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1_s16(ptr: *mut i16, a: int16x4_t) {
-    copy_nonoverlapping(
-        &a as *const int16x4_t as *const i16,
-        ptr as *mut i16,
-        size_of::<int16x4_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -696,11 +683,7 @@ pub unsafe fn vst1_s16(ptr: *mut i16, a: int16x4_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1q_s16(ptr: *mut i16, a: int16x8_t) {
-    copy_nonoverlapping(
-        &a as *const int16x8_t as *const i16,
-        ptr as *mut i16,
-        size_of::<int16x8_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -709,11 +692,7 @@ pub unsafe fn vst1q_s16(ptr: *mut i16, a: int16x8_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1_s32(ptr: *mut i32, a: int32x2_t) {
-    copy_nonoverlapping(
-        &a as *const int32x2_t as *const i32,
-        ptr as *mut i32,
-        size_of::<int32x2_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -722,11 +701,7 @@ pub unsafe fn vst1_s32(ptr: *mut i32, a: int32x2_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1q_s32(ptr: *mut i32, a: int32x4_t) {
-    copy_nonoverlapping(
-        &a as *const int32x4_t as *const i32,
-        ptr as *mut i32,
-        size_of::<int32x4_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -735,11 +710,7 @@ pub unsafe fn vst1q_s32(ptr: *mut i32, a: int32x4_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1_s64(ptr: *mut i64, a: int64x1_t) {
-    copy_nonoverlapping(
-        &a as *const int64x1_t as *const i64,
-        ptr as *mut i64,
-        size_of::<int64x1_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -748,11 +719,7 @@ pub unsafe fn vst1_s64(ptr: *mut i64, a: int64x1_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1q_s64(ptr: *mut i64, a: int64x2_t) {
-    copy_nonoverlapping(
-        &a as *const int64x2_t as *const i64,
-        ptr as *mut i64,
-        size_of::<int64x2_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -761,11 +728,7 @@ pub unsafe fn vst1q_s64(ptr: *mut i64, a: int64x2_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1_u8(ptr: *mut u8, a: uint8x8_t) {
-    copy_nonoverlapping(
-        &a as *const uint8x8_t as *const u8,
-        ptr as *mut u8,
-        size_of::<uint8x8_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -774,11 +737,7 @@ pub unsafe fn vst1_u8(ptr: *mut u8, a: uint8x8_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1q_u8(ptr: *mut u8, a: uint8x16_t) {
-    copy_nonoverlapping(
-        &a as *const uint8x16_t as *const u8,
-        ptr as *mut u8,
-        size_of::<uint8x16_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -787,11 +746,7 @@ pub unsafe fn vst1q_u8(ptr: *mut u8, a: uint8x16_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1_u16(ptr: *mut u16, a: uint16x4_t) {
-    copy_nonoverlapping(
-        &a as *const uint16x4_t as *const u16,
-        ptr as *mut u16,
-        size_of::<uint16x4_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -800,11 +755,7 @@ pub unsafe fn vst1_u16(ptr: *mut u16, a: uint16x4_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1q_u16(ptr: *mut u16, a: uint16x8_t) {
-    copy_nonoverlapping(
-        &a as *const uint16x8_t as *const u16,
-        ptr as *mut u16,
-        size_of::<uint16x8_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -813,11 +764,7 @@ pub unsafe fn vst1q_u16(ptr: *mut u16, a: uint16x8_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1_u32(ptr: *mut u32, a: uint32x2_t) {
-    copy_nonoverlapping(
-        &a as *const uint32x2_t as *const u32,
-        ptr as *mut u32,
-        size_of::<uint32x2_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -826,11 +773,7 @@ pub unsafe fn vst1_u32(ptr: *mut u32, a: uint32x2_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1q_u32(ptr: *mut u32, a: uint32x4_t) {
-    copy_nonoverlapping(
-        &a as *const uint32x4_t as *const u32,
-        ptr as *mut u32,
-        size_of::<uint32x4_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -839,11 +782,7 @@ pub unsafe fn vst1q_u32(ptr: *mut u32, a: uint32x4_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1_u64(ptr: *mut u64, a: uint64x1_t) {
-    copy_nonoverlapping(
-        &a as *const uint64x1_t as *const u64,
-        ptr as *mut u64,
-        size_of::<uint64x1_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -852,11 +791,7 @@ pub unsafe fn vst1_u64(ptr: *mut u64, a: uint64x1_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1q_u64(ptr: *mut u64, a: uint64x2_t) {
-    copy_nonoverlapping(
-        &a as *const uint64x2_t as *const u64,
-        ptr as *mut u64,
-        size_of::<uint64x2_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -865,11 +800,7 @@ pub unsafe fn vst1q_u64(ptr: *mut u64, a: uint64x2_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1_p8(ptr: *mut p8, a: poly8x8_t) {
-    copy_nonoverlapping(
-        &a as *const poly8x8_t as *const p8,
-        ptr as *mut p8,
-        size_of::<poly8x8_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -878,11 +809,7 @@ pub unsafe fn vst1_p8(ptr: *mut p8, a: poly8x8_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1q_p8(ptr: *mut p8, a: poly8x16_t) {
-    copy_nonoverlapping(
-        &a as *const poly8x16_t as *const p8,
-        ptr as *mut p8,
-        size_of::<poly8x16_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -891,11 +818,7 @@ pub unsafe fn vst1q_p8(ptr: *mut p8, a: poly8x16_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1_p16(ptr: *mut p16, a: poly16x4_t) {
-    copy_nonoverlapping(
-        &a as *const poly16x4_t as *const p16,
-        ptr as *mut p16,
-        size_of::<poly16x4_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
@@ -904,11 +827,7 @@ pub unsafe fn vst1_p16(ptr: *mut p16, a: poly16x4_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1q_p16(ptr: *mut p16, a: poly16x8_t) {
-    copy_nonoverlapping(
-        &a as *const poly16x8_t as *const p16,
-        ptr as *mut p16,
-        size_of::<poly16x8_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 // Store multiple single-element structures from one, two, three, or four registers.
@@ -917,11 +836,7 @@ pub unsafe fn vst1q_p16(ptr: *mut p16, a: poly16x8_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1_p64(ptr: *mut p64, a: poly64x1_t) {
-    copy_nonoverlapping(
-        &a as *const poly64x1_t as *const p64,
-        ptr as *mut p64,
-        size_of::<poly64x1_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 // Store multiple single-element structures from one, two, three, or four registers.
@@ -930,11 +845,7 @@ pub unsafe fn vst1_p64(ptr: *mut p64, a: poly64x1_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1q_p64(ptr: *mut p64, a: poly64x2_t) {
-    copy_nonoverlapping(
-        &a as *const poly64x2_t as *const p64,
-        ptr as *mut p64,
-        size_of::<poly64x2_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 // Store multiple single-element structures from one, two, three, or four registers.
@@ -943,11 +854,7 @@ pub unsafe fn vst1q_p64(ptr: *mut p64, a: poly64x2_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1_f32(ptr: *mut f32, a: float32x2_t) {
-    copy_nonoverlapping(
-        &a as *const float32x2_t as *const f32,
-        ptr as *mut f32,
-        size_of::<float32x2_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 // Store multiple single-element structures from one, two, three, or four registers.
@@ -956,11 +863,7 @@ pub unsafe fn vst1_f32(ptr: *mut f32, a: float32x2_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1q_f32(ptr: *mut f32, a: float32x4_t) {
-    copy_nonoverlapping(
-        &a as *const float32x4_t as *const f32,
-        ptr as *mut f32,
-        size_of::<float32x4_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 // Store multiple single-element structures from one, two, three, or four registers.
@@ -969,11 +872,7 @@ pub unsafe fn vst1q_f32(ptr: *mut f32, a: float32x4_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1_f64(ptr: *mut f64, a: float64x1_t) {
-    copy_nonoverlapping(
-        &a as *const float64x1_t as *const f64,
-        ptr as *mut f64,
-        size_of::<float64x1_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 // Store multiple single-element structures from one, two, three, or four registers.
@@ -982,11 +881,7 @@ pub unsafe fn vst1_f64(ptr: *mut f64, a: float64x1_t) {
 #[cfg_attr(test, assert_instr(str))]
 #[allow(clippy::cast_ptr_alignment)]
 pub unsafe fn vst1q_f64(ptr: *mut f64, a: float64x2_t) {
-    copy_nonoverlapping(
-        &a as *const float64x2_t as *const f64,
-        ptr as *mut f64,
-        size_of::<float64x2_t>(),
-    )
+    core::ptr::write_unaligned(ptr.cast(), a);
 }
 
 /// Absolute Value (wrapping).