Add const tests for avx512cd

Author: sayantn

crates/core_arch/src/x86/avx512cd.rs

@@ -581,52 +581,53 @@ unsafe extern "C" {
 
 #[cfg(test)]
 mod tests {
+    use crate::core_arch::assert_eq_const as assert_eq;
 
     use crate::core_arch::x86::*;
     use stdarch_test::simd_test;
 
     #[simd_test(enable = "avx512cd")]
-    unsafe fn test_mm512_broadcastmw_epi32() {
+    const unsafe fn test_mm512_broadcastmw_epi32() {
         let a: __mmask16 = 2;
         let r = _mm512_broadcastmw_epi32(a);
         let e = _mm512_set1_epi32(2);
         assert_eq_m512i(r, e);
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm256_broadcastmw_epi32() {
+    const unsafe fn test_mm256_broadcastmw_epi32() {
         let a: __mmask16 = 2;
         let r = _mm256_broadcastmw_epi32(a);
         let e = _mm256_set1_epi32(2);
         assert_eq_m256i(r, e);
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm_broadcastmw_epi32() {
+    const unsafe fn test_mm_broadcastmw_epi32() {
         let a: __mmask16 = 2;
         let r = _mm_broadcastmw_epi32(a);
         let e = _mm_set1_epi32(2);
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "avx512cd")]
-    unsafe fn test_mm512_broadcastmb_epi64() {
+    const unsafe fn test_mm512_broadcastmb_epi64() {
         let a: __mmask8 = 2;
         let r = _mm512_broadcastmb_epi64(a);
         let e = _mm512_set1_epi64(2);
         assert_eq_m512i(r, e);
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm256_broadcastmb_epi64() {
+    const unsafe fn test_mm256_broadcastmb_epi64() {
         let a: __mmask8 = 2;
         let r = _mm256_broadcastmb_epi64(a);
         let e = _mm256_set1_epi64x(2);
         assert_eq_m256i(r, e);
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm_broadcastmb_epi64() {
+    const unsafe fn test_mm_broadcastmb_epi64() {
         let a: __mmask8 = 2;
         let r = _mm_broadcastmb_epi64(a);
         let e = _mm_set1_epi64x(2);
@@ -1087,15 +1088,15 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    unsafe fn test_mm512_lzcnt_epi32() {
+    const unsafe fn test_mm512_lzcnt_epi32() {
         let a = _mm512_set1_epi32(1);
         let r = _mm512_lzcnt_epi32(a);
         let e = _mm512_set1_epi32(31);
         assert_eq_m512i(r, e);
     }
 
     #[simd_test(enable = "avx512cd")]
-    unsafe fn test_mm512_mask_lzcnt_epi32() {
+    const unsafe fn test_mm512_mask_lzcnt_epi32() {
         let a = _mm512_set1_epi32(1);
         let r = _mm512_mask_lzcnt_epi32(a, 0, a);
         assert_eq_m512i(r, a);
@@ -1105,7 +1106,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    unsafe fn test_mm512_maskz_lzcnt_epi32() {
+    const unsafe fn test_mm512_maskz_lzcnt_epi32() {
         let a = _mm512_set1_epi32(2);
         let r = _mm512_maskz_lzcnt_epi32(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -1115,15 +1116,15 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm256_lzcnt_epi32() {
+    const unsafe fn test_mm256_lzcnt_epi32() {
         let a = _mm256_set1_epi32(1);
         let r = _mm256_lzcnt_epi32(a);
         let e = _mm256_set1_epi32(31);
         assert_eq_m256i(r, e);
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm256_mask_lzcnt_epi32() {
+    const unsafe fn test_mm256_mask_lzcnt_epi32() {
         let a = _mm256_set1_epi32(1);
         let r = _mm256_mask_lzcnt_epi32(a, 0, a);
         assert_eq_m256i(r, a);
@@ -1133,7 +1134,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm256_maskz_lzcnt_epi32() {
+    const unsafe fn test_mm256_maskz_lzcnt_epi32() {
         let a = _mm256_set1_epi32(1);
         let r = _mm256_maskz_lzcnt_epi32(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -1143,15 +1144,15 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm_lzcnt_epi32() {
+    const unsafe fn test_mm_lzcnt_epi32() {
         let a = _mm_set1_epi32(1);
         let r = _mm_lzcnt_epi32(a);
         let e = _mm_set1_epi32(31);
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm_mask_lzcnt_epi32() {
+    const unsafe fn test_mm_mask_lzcnt_epi32() {
         let a = _mm_set1_epi32(1);
         let r = _mm_mask_lzcnt_epi32(a, 0, a);
         assert_eq_m128i(r, a);
@@ -1161,7 +1162,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm_maskz_lzcnt_epi32() {
+    const unsafe fn test_mm_maskz_lzcnt_epi32() {
         let a = _mm_set1_epi32(1);
         let r = _mm_maskz_lzcnt_epi32(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());
@@ -1171,15 +1172,15 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    unsafe fn test_mm512_lzcnt_epi64() {
+    const unsafe fn test_mm512_lzcnt_epi64() {
         let a = _mm512_set1_epi64(1);
         let r = _mm512_lzcnt_epi64(a);
         let e = _mm512_set1_epi64(63);
         assert_eq_m512i(r, e);
     }
 
     #[simd_test(enable = "avx512cd")]
-    unsafe fn test_mm512_mask_lzcnt_epi64() {
+    const unsafe fn test_mm512_mask_lzcnt_epi64() {
         let a = _mm512_set1_epi64(1);
         let r = _mm512_mask_lzcnt_epi64(a, 0, a);
         assert_eq_m512i(r, a);
@@ -1189,7 +1190,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd")]
-    unsafe fn test_mm512_maskz_lzcnt_epi64() {
+    const unsafe fn test_mm512_maskz_lzcnt_epi64() {
         let a = _mm512_set1_epi64(2);
         let r = _mm512_maskz_lzcnt_epi64(0, a);
         assert_eq_m512i(r, _mm512_setzero_si512());
@@ -1199,15 +1200,15 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm256_lzcnt_epi64() {
+    const unsafe fn test_mm256_lzcnt_epi64() {
         let a = _mm256_set1_epi64x(1);
         let r = _mm256_lzcnt_epi64(a);
         let e = _mm256_set1_epi64x(63);
         assert_eq_m256i(r, e);
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm256_mask_lzcnt_epi64() {
+    const unsafe fn test_mm256_mask_lzcnt_epi64() {
         let a = _mm256_set1_epi64x(1);
         let r = _mm256_mask_lzcnt_epi64(a, 0, a);
         assert_eq_m256i(r, a);
@@ -1217,7 +1218,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm256_maskz_lzcnt_epi64() {
+    const unsafe fn test_mm256_maskz_lzcnt_epi64() {
         let a = _mm256_set1_epi64x(1);
         let r = _mm256_maskz_lzcnt_epi64(0, a);
         assert_eq_m256i(r, _mm256_setzero_si256());
@@ -1227,15 +1228,15 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm_lzcnt_epi64() {
+    const unsafe fn test_mm_lzcnt_epi64() {
         let a = _mm_set1_epi64x(1);
         let r = _mm_lzcnt_epi64(a);
         let e = _mm_set1_epi64x(63);
         assert_eq_m128i(r, e);
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm_mask_lzcnt_epi64() {
+    const unsafe fn test_mm_mask_lzcnt_epi64() {
         let a = _mm_set1_epi64x(1);
         let r = _mm_mask_lzcnt_epi64(a, 0, a);
         assert_eq_m128i(r, a);
@@ -1245,7 +1246,7 @@ mod tests {
     }
 
     #[simd_test(enable = "avx512cd,avx512vl")]
-    unsafe fn test_mm_maskz_lzcnt_epi64() {
+    const unsafe fn test_mm_maskz_lzcnt_epi64() {
         let a = _mm_set1_epi64x(1);
         let r = _mm_maskz_lzcnt_epi64(0, a);
         assert_eq_m128i(r, _mm_setzero_si128());