Add checks for void pointer types to ensure consistency

Author: sayantn

crates/core_arch/src/x86/avx512f.rs

@@ -29696,7 +29696,7 @@ pub unsafe fn _mm512_stream_pd(mem_addr: *mut f64, a: __m512d) {
 #[unstable(feature = "stdarch_x86_avx512", issue = "111137")]
 #[cfg_attr(test, assert_instr(vmovntdq))]
 #[allow(clippy::cast_ptr_alignment)]
-pub unsafe fn _mm512_stream_si512(mem_addr: *mut i32, a: __m512i) {
+pub unsafe fn _mm512_stream_si512(mem_addr: *mut __m512i, a: __m512i) {
     crate::arch::asm!(
         vps!("vmovntdq", ",{a}"),
         p = in(reg) mem_addr,
@@ -34435,8 +34435,8 @@ pub unsafe fn _mm_storeu_epi64(mem_addr: *mut i64, a: __m128i) {
 #[target_feature(enable = "avx512f")]
 #[unstable(feature = "stdarch_x86_avx512", issue = "111137")]
 #[cfg_attr(test, assert_instr(vmovups))] //should be vmovdqu32
-pub unsafe fn _mm512_loadu_si512(mem_addr: *const i32) -> __m512i {
-    ptr::read_unaligned(mem_addr as *const __m512i)
+pub unsafe fn _mm512_loadu_si512(mem_addr: *const __m512i) -> __m512i {
+    ptr::read_unaligned(mem_addr)
 }
 
 /// Store 512-bits of integer data from a into memory. mem_addr does not need to be aligned on any particular boundary.
@@ -34459,8 +34459,8 @@ pub unsafe fn _mm512_storeu_si512(mem_addr: *mut __m512i, a: __m512i) {
 #[target_feature(enable = "avx512f")]
 #[unstable(feature = "stdarch_x86_avx512", issue = "111137")]
 #[cfg_attr(test, assert_instr(vmovups))]
-pub unsafe fn _mm512_loadu_pd(mem_addr: *const f64) -> __m512d {
-    ptr::read_unaligned(mem_addr as *const __m512d)
+pub unsafe fn _mm512_loadu_pd(mem_addr: *const __m512d) -> __m512d {
+    ptr::read_unaligned(mem_addr)
 }
 
 /// Stores 512-bits (composed of 8 packed double-precision (64-bit)
@@ -34472,8 +34472,8 @@ pub unsafe fn _mm512_loadu_pd(mem_addr: *const f64) -> __m512d {
 #[target_feature(enable = "avx512f")]
 #[unstable(feature = "stdarch_x86_avx512", issue = "111137")]
 #[cfg_attr(test, assert_instr(vmovups))]
-pub unsafe fn _mm512_storeu_pd(mem_addr: *mut f64, a: __m512d) {
-    ptr::write_unaligned(mem_addr as *mut __m512d, a);
+pub unsafe fn _mm512_storeu_pd(mem_addr: *mut __m512d, a: __m512d) {
+    ptr::write_unaligned(mem_addr, a);
 }
 
 /// Loads 512-bits (composed of 16 packed single-precision (32-bit)
@@ -34485,8 +34485,8 @@ pub unsafe fn _mm512_storeu_pd(mem_addr: *mut f64, a: __m512d) {
 #[target_feature(enable = "avx512f")]
 #[unstable(feature = "stdarch_x86_avx512", issue = "111137")]
 #[cfg_attr(test, assert_instr(vmovups))]
-pub unsafe fn _mm512_loadu_ps(mem_addr: *const f32) -> __m512 {
-    ptr::read_unaligned(mem_addr as *const __m512)
+pub unsafe fn _mm512_loadu_ps(mem_addr: *const __m512) -> __m512 {
+    ptr::read_unaligned(mem_addr)
 }
 
 /// Stores 512-bits (composed of 16 packed single-precision (32-bit)
@@ -34498,8 +34498,8 @@ pub unsafe fn _mm512_loadu_ps(mem_addr: *const f32) -> __m512 {
 #[target_feature(enable = "avx512f")]
 #[unstable(feature = "stdarch_x86_avx512", issue = "111137")]
 #[cfg_attr(test, assert_instr(vmovups))]
-pub unsafe fn _mm512_storeu_ps(mem_addr: *mut f32, a: __m512) {
-    ptr::write_unaligned(mem_addr as *mut __m512, a);
+pub unsafe fn _mm512_storeu_ps(mem_addr: *mut __m512, a: __m512) {
+    ptr::write_unaligned(mem_addr, a);
 }
 
 /// Load 512-bits of integer data from memory into dst. mem_addr must be aligned on a 64-byte boundary or a general-protection exception may be generated.
@@ -34509,8 +34509,8 @@ pub unsafe fn _mm512_storeu_ps(mem_addr: *mut f32, a: __m512) {
 #[target_feature(enable = "avx512f")]
 #[unstable(feature = "stdarch_x86_avx512", issue = "111137")]
 #[cfg_attr(test, assert_instr(vmovaps))] //should be vmovdqa32
-pub unsafe fn _mm512_load_si512(mem_addr: *const i32) -> __m512i {
-    ptr::read(mem_addr as *const __m512i)
+pub unsafe fn _mm512_load_si512(mem_addr: *const __m512i) -> __m512i {
+    ptr::read(mem_addr)
 }
 
 /// Store 512-bits of integer data from a into memory. mem_addr must be aligned on a 64-byte boundary or a general-protection exception may be generated.
@@ -34663,8 +34663,8 @@ pub unsafe fn _mm_store_epi64(mem_addr: *mut i64, a: __m128i) {
 #[target_feature(enable = "avx512f")]
 #[unstable(feature = "stdarch_x86_avx512", issue = "111137")]
 #[cfg_attr(test, assert_instr(vmovaps))]
-pub unsafe fn _mm512_load_ps(mem_addr: *const f32) -> __m512 {
-    ptr::read(mem_addr as *const __m512)
+pub unsafe fn _mm512_load_ps(mem_addr: *const __m512) -> __m512 {
+    ptr::read(mem_addr)
 }
 
 /// Store 512-bits of integer data from a into memory. mem_addr must be aligned on a 64-byte boundary or a general-protection exception may be generated.
@@ -34674,8 +34674,8 @@ pub unsafe fn _mm512_load_ps(mem_addr: *const f32) -> __m512 {
 #[target_feature(enable = "avx512f")]
 #[unstable(feature = "stdarch_x86_avx512", issue = "111137")]
 #[cfg_attr(test, assert_instr(vmovaps))]
-pub unsafe fn _mm512_store_ps(mem_addr: *mut f32, a: __m512) {
-    ptr::write(mem_addr as *mut __m512, a);
+pub unsafe fn _mm512_store_ps(mem_addr: *mut __m512, a: __m512) {
+    ptr::write(mem_addr, a);
 }
 
 /// Load 512-bits (composed of 8 packed double-precision (64-bit) floating-point elements) from memory into dst. mem_addr must be aligned on a 64-byte boundary or a general-protection exception may be generated.
@@ -34685,8 +34685,8 @@ pub unsafe fn _mm512_store_ps(mem_addr: *mut f32, a: __m512) {
 #[target_feature(enable = "avx512f")]
 #[unstable(feature = "stdarch_x86_avx512", issue = "111137")]
 #[cfg_attr(test, assert_instr(vmovaps))] //should be vmovapd
-pub unsafe fn _mm512_load_pd(mem_addr: *const f64) -> __m512d {
-    ptr::read(mem_addr as *const __m512d)
+pub unsafe fn _mm512_load_pd(mem_addr: *const __m512d) -> __m512d {
+    ptr::read(mem_addr)
 }
 
 /// Store 512-bits (composed of 8 packed double-precision (64-bit) floating-point elements) from a into memory. mem_addr must be aligned on a 64-byte boundary or a general-protection exception may be generated.
@@ -34696,8 +34696,8 @@ pub unsafe fn _mm512_load_pd(mem_addr: *const f64) -> __m512d {
 #[target_feature(enable = "avx512f")]
 #[unstable(feature = "stdarch_x86_avx512", issue = "111137")]
 #[cfg_attr(test, assert_instr(vmovaps))] //should be vmovapd
-pub unsafe fn _mm512_store_pd(mem_addr: *mut f64, a: __m512d) {
-    ptr::write(mem_addr as *mut __m512d, a);
+pub unsafe fn _mm512_store_pd(mem_addr: *mut __m512d, a: __m512d) {
+    ptr::write(mem_addr, a);
 }
 
 /// Load packed 32-bit integers from memory into dst using writemask k
@@ -51036,7 +51036,7 @@ mod tests {
     #[simd_test(enable = "avx512f")]
     unsafe fn test_mm512_loadu_pd() {
         let a = &[4., 3., 2., 5., 8., 9., 64., 50.];
-        let p = a.as_ptr();
+        let p = a.as_ptr().cast();
         let r = _mm512_loadu_pd(black_box(p));
         let e = _mm512_setr_pd(4., 3., 2., 5., 8., 9., 64., 50.);
         assert_eq_m512d(r, e);
@@ -51046,16 +51046,16 @@ mod tests {
     unsafe fn test_mm512_storeu_pd() {
         let a = _mm512_set1_pd(9.);
         let mut r = _mm512_undefined_pd();
-        _mm512_storeu_pd(&mut r as *mut _ as *mut f64, a);
+        _mm512_storeu_pd(&mut r as *mut _, a);
         assert_eq_m512d(r, a);
     }
 
     #[simd_test(enable = "avx512f")]
     unsafe fn test_mm512_loadu_ps() {
         let a = &[
-            4., 3., 2., 5., 8., 9., 64., 50., -4., -3., -2., -5., -8., -9., -64., -50.,
+            4.0_f32, 3., 2., 5., 8., 9., 64., 50., -4., -3., -2., -5., -8., -9., -64., -50.,
         ];
-        let p = a.as_ptr();
+        let p = a.as_ptr().cast();
         let r = _mm512_loadu_ps(black_box(p));
         let e = _mm512_setr_ps(
             4., 3., 2., 5., 8., 9., 64., 50., -4., -3., -2., -5., -8., -9., -64., -50.,
@@ -51067,7 +51067,7 @@ mod tests {
     unsafe fn test_mm512_storeu_ps() {
         let a = _mm512_set1_ps(9.);
         let mut r = _mm512_undefined_ps();
-        _mm512_storeu_ps(&mut r as *mut _ as *mut f32, a);
+        _mm512_storeu_ps(&mut r as *mut _, a);
         assert_eq_m512(r, a);
     }
 
@@ -51316,7 +51316,7 @@ mod tests {
             42.0, 2.0, 42.0, 4.0, 42.0, 42.0, 7.0, 8.0, 42.0, 42.0, 42.0, 12.0, 42.0, 14.0, 15.0,
             16.0,
         );
-        assert_eq_m512(_mm512_loadu_ps(r.as_ptr()), e);
+        assert_eq_m512(_mm512_loadu_ps(r.as_ptr().cast()), e);
     }
 
     #[simd_test(enable = "avx512f")]
@@ -51335,7 +51335,7 @@ mod tests {
             42.0, 2.0, 42.0, 4.0, 42.0, 42.0, 7.0, 8.0, 42.0, 42.0, 42.0, 12.0, 42.0, 14.0, 15.0,
             16.0,
         );
-        assert_eq_m512(_mm512_load_ps(r.data.as_ptr()), e);
+        assert_eq_m512(_mm512_load_ps(r.data.as_ptr().cast()), e);
     }
 
     #[simd_test(enable = "avx512f")]
@@ -51399,7 +51399,7 @@ mod tests {
         let m = 0b11001010;
         _mm512_mask_storeu_pd(r.as_mut_ptr(), m, a);
         let e = _mm512_setr_pd(42.0, 2.0, 42.0, 4.0, 42.0, 42.0, 7.0, 8.0);
-        assert_eq_m512d(_mm512_loadu_pd(r.as_ptr()), e);
+        assert_eq_m512d(_mm512_loadu_pd(r.as_ptr().cast()), e);
     }
 
     #[simd_test(enable = "avx512f")]
@@ -51413,7 +51413,7 @@ mod tests {
         let m = 0b11001010;
         _mm512_mask_store_pd(r.data.as_mut_ptr(), m, a);
         let e = _mm512_setr_pd(42.0, 2.0, 42.0, 4.0, 42.0, 42.0, 7.0, 8.0);
-        assert_eq_m512d(_mm512_load_pd(r.data.as_ptr()), e);
+        assert_eq_m512d(_mm512_load_pd(r.data.as_ptr().cast()), e);
     }
 
     #[simd_test(enable = "avx512f,avx512vl")]
@@ -57231,7 +57231,7 @@ mod tests {
     #[simd_test(enable = "avx512f")]
     unsafe fn test_mm512_loadu_si512() {
         let a = &[4, 3, 2, 5, 8, 9, 64, 50, -4, -3, -2, -5, -8, -9, -64, -50];
-        let p = a.as_ptr();
+        let p = a.as_ptr().cast();
         let r = _mm512_loadu_si512(black_box(p));
         let e = _mm512_setr_epi32(4, 3, 2, 5, 8, 9, 64, 50, -4, -3, -2, -5, -8, -9, -64, -50);
         assert_eq_m512i(r, e);
@@ -57254,7 +57254,7 @@ mod tests {
         let a = Align {
             data: [4, 3, 2, 5, 8, 9, 64, 50, -4, -3, -2, -5, -8, -9, -64, -50],
         };
-        let p = (a.data).as_ptr();
+        let p = (a.data).as_ptr().cast();
         let r = _mm512_load_si512(black_box(p));
         let e = _mm512_setr_epi32(4, 3, 2, 5, 8, 9, 64, 50, -4, -3, -2, -5, -8, -9, -64, -50);
         assert_eq_m512i(r, e);
@@ -57277,7 +57277,7 @@ mod tests {
         let a = Align {
             data: [4, 3, 2, 5, 8, 9, 64, 50, -4, -3, -2, -5, -8, -9, -64, -50],
         };
-        let p = (a.data).as_ptr();
+        let p = (a.data).as_ptr().cast();
         let r = _mm512_load_epi32(black_box(p));
         let e = _mm512_setr_epi32(4, 3, 2, 5, 8, 9, 64, 50, -4, -3, -2, -5, -8, -9, -64, -50);
         assert_eq_m512i(r, e);
@@ -57346,7 +57346,7 @@ mod tests {
                 4., 3., 2., 5., 8., 9., 64., 50., -4., -3., -2., -5., -8., -9., -64., -50.,
             ],
         };
-        let p = (a.data).as_ptr();
+        let p = (a.data).as_ptr().cast();
         let r = _mm512_load_ps(black_box(p));
         let e = _mm512_setr_ps(
             4., 3., 2., 5., 8., 9., 64., 50., -4., -3., -2., -5., -8., -9., -64., -50.,
@@ -57358,7 +57358,7 @@ mod tests {
     unsafe fn test_mm512_store_ps() {
         let a = _mm512_set1_ps(9.);
         let mut r = _mm512_undefined_ps();
-        _mm512_store_ps(&mut r as *mut _ as *mut f32, a);
+        _mm512_store_ps(&mut r as *mut _, a);
         assert_eq_m512(r, a);
     }