library/stdarch/crates/core_arch/src/x86/test.rs

   1 //! Utilities used in testing the x86 intrinsics
   2
   3 use crate::core_arch::x86::*;
   4 use std::mem::transmute;
   5
   6 #[target_feature(enable = "sse2")]
   7 pub unsafe fn assert_eq_m128i(a: __m128i, b: __m128i) {
   8     assert_eq!(transmute::<_, [u64; 2]>(a), transmute::<_, [u64; 2]>(b))
   9 }
  10
  11 #[target_feature(enable = "sse2")]
  12 pub unsafe fn assert_eq_m128d(a: __m128d, b: __m128d) {
  13     if _mm_movemask_pd(_mm_cmpeq_pd(a, b)) != 0b11 {
  14         panic!("{:?} != {:?}", a, b);
  15     }
  16 }
  17
  18 #[target_feature(enable = "sse2")]
  19 pub unsafe fn get_m128d(a: __m128d, idx: usize) -> f64 {
  20     transmute::<_, [f64; 2]>(a)[idx]
  21 }
  22
  23 #[target_feature(enable = "sse")]
  24 pub unsafe fn assert_eq_m128(a: __m128, b: __m128) {
  25     let r = _mm_cmpeq_ps(a, b);
  26     if _mm_movemask_ps(r) != 0b1111 {
  27         panic!("{:?} != {:?}", a, b);
  28     }
  29 }
  30
  31 #[target_feature(enable = "sse")]
  32 pub unsafe fn get_m128(a: __m128, idx: usize) -> f32 {
  33     transmute::<_, [f32; 4]>(a)[idx]
  34 }
  35
  36 // not actually an intrinsic but useful in various tests as we proted from
  37 // `i64x2::new` which is backwards from `_mm_set_epi64x`
  38 #[target_feature(enable = "sse2")]
  39 pub unsafe fn _mm_setr_epi64x(a: i64, b: i64) -> __m128i {
  40     _mm_set_epi64x(b, a)
  41 }
  42
  43 #[target_feature(enable = "avx")]
  44 pub unsafe fn assert_eq_m256i(a: __m256i, b: __m256i) {
  45     assert_eq!(transmute::<_, [u64; 4]>(a), transmute::<_, [u64; 4]>(b))
  46 }
  47
  48 #[target_feature(enable = "avx")]
  49 pub unsafe fn assert_eq_m256d(a: __m256d, b: __m256d) {
  50     let cmp = _mm256_cmp_pd(a, b, _CMP_EQ_OQ);
  51     if _mm256_movemask_pd(cmp) != 0b1111 {
  52         panic!("{:?} != {:?}", a, b);
  53     }
  54 }
  55
  56 #[target_feature(enable = "avx")]
  57 pub unsafe fn get_m256d(a: __m256d, idx: usize) -> f64 {
  58     transmute::<_, [f64; 4]>(a)[idx]
  59 }
  60
  61 #[target_feature(enable = "avx")]
  62 pub unsafe fn assert_eq_m256(a: __m256, b: __m256) {
  63     let cmp = _mm256_cmp_ps(a, b, _CMP_EQ_OQ);
  64     if _mm256_movemask_ps(cmp) != 0b11111111 {
  65         panic!("{:?} != {:?}", a, b);
  66     }
  67 }
  68
  69 #[target_feature(enable = "avx")]
  70 pub unsafe fn get_m256(a: __m256, idx: usize) -> f32 {
  71     transmute::<_, [f32; 8]>(a)[idx]
  72 }
  73
  74 #[target_feature(enable = "avx512f")]
  75 pub unsafe fn get_m512(a: __m512, idx: usize) -> f32 {
  76     transmute::<_, [f32; 16]>(a)[idx]
  77 }
  78
  79 #[target_feature(enable = "avx512f")]
  80 pub unsafe fn get_m512d(a: __m512d, idx: usize) -> f64 {
  81     transmute::<_, [f64; 8]>(a)[idx]
  82 }
  83
  84 #[target_feature(enable = "avx512f")]
  85 pub unsafe fn get_m512i(a: __m512i, idx: usize) -> i64 {
  86     transmute::<_, [i64; 8]>(a)[idx]
  87 }
  88
  89 // These intrinsics doesn't exist on x86 b/c it requires a 64-bit register,
  90 // which doesn't exist on x86!
  91 #[cfg(target_arch = "x86")]
  92 mod x86_polyfill {
  93     use crate::core_arch::x86::*;
  94
  95     pub unsafe fn _mm_insert_epi64(a: __m128i, val: i64, idx: i32) -> __m128i {
  96         #[repr(C)]
  97         union A {
  98             a: __m128i,
  99             b: [i64; 2],
 100         }
 101         let mut a = A { a };
 102         a.b[idx as usize] = val;
 103         a.a
 104     }
 105
 106     #[target_feature(enable = "avx2")]
 107     pub unsafe fn _mm256_insert_epi64(a: __m256i, val: i64, idx: i32) -> __m256i {
 108         #[repr(C)]
 109         union A {
 110             a: __m256i,
 111             b: [i64; 4],
 112         }
 113         let mut a = A { a };
 114         a.b[idx as usize] = val;
 115         a.a
 116     }
 117 }
 118 #[cfg(target_arch = "x86_64")]
 119 mod x86_polyfill {
 120     pub use crate::core_arch::x86_64::{_mm256_insert_epi64, _mm_insert_epi64};
 121 }
 122 pub use self::x86_polyfill::*;
 123
 124 pub unsafe fn assert_eq_m512i(a: __m512i, b: __m512i) {
 125     assert_eq!(transmute::<_, [i32; 16]>(a), transmute::<_, [i32; 16]>(b))
 126 }
 127
 128 pub unsafe fn assert_eq_m512(a: __m512, b: __m512) {
 129     let cmp = _mm512_cmp_ps_mask(a, b, _CMP_EQ_OQ);
 130     if cmp != 0b11111111_11111111 {
 131         panic!("{:?} != {:?}", a, b);
 132     }
 133 }
 134
 135 pub unsafe fn assert_eq_m512d(a: __m512d, b: __m512d) {
 136     let cmp = _mm512_cmp_pd_mask(a, b, _CMP_EQ_OQ);
 137     if cmp != 0b11111111 {
 138         panic!("{:?} != {:?}", a, b);
 139     }
 140 }