Migrate the x86_64 folder to vendor types (rust-lang#284)

Author: alexcrichton

coresimd/src/x86/x86_64/sse.rs

@@ -1,18 +1,18 @@
 //! `x86_64` Streaming SIMD Extensions (SSE)
 
-use v128::*;
+use x86::*;
 
 #[cfg(test)]
 use stdsimd_test::assert_instr;
 
 #[allow(improper_ctypes)]
 extern "C" {
     #[link_name = "llvm.x86.sse.cvtss2si64"]
-    fn cvtss2si64(a: f32x4) -> i64;
+    fn cvtss2si64(a: __m128) -> i64;
     #[link_name = "llvm.x86.sse.cvttss2si64"]
-    fn cvttss2si64(a: f32x4) -> i64;
+    fn cvttss2si64(a: __m128) -> i64;
     #[link_name = "llvm.x86.sse.cvtsi642ss"]
-    fn cvtsi642ss(a: f32x4, b: i64) -> f32x4;
+    fn cvtsi642ss(a: __m128, b: i64) -> __m128;
 }
 
 /// Convert the lowest 32 bit float in the input vector to a 64 bit integer.
@@ -27,7 +27,7 @@ extern "C" {
 #[inline(always)]
 #[target_feature(enable = "sse")]
 #[cfg_attr(test, assert_instr(cvtss2si))]
-pub unsafe fn _mm_cvtss_si64(a: f32x4) -> i64 {
+pub unsafe fn _mm_cvtss_si64(a: __m128) -> i64 {
     cvtss2si64(a)
 }
 
@@ -43,7 +43,7 @@ pub unsafe fn _mm_cvtss_si64(a: f32x4) -> i64 {
 #[inline(always)]
 #[target_feature(enable = "sse")]
 #[cfg_attr(test, assert_instr(cvttss2si))]
-pub unsafe fn _mm_cvttss_si64(a: f32x4) -> i64 {
+pub unsafe fn _mm_cvttss_si64(a: __m128) -> i64 {
     cvttss2si64(a)
 }
 
@@ -55,21 +55,21 @@ pub unsafe fn _mm_cvttss_si64(a: f32x4) -> i64 {
 #[inline(always)]
 #[target_feature(enable = "sse")]
 #[cfg_attr(test, assert_instr(cvtsi2ss))]
-pub unsafe fn _mm_cvtsi64_ss(a: f32x4, b: i64) -> f32x4 {
+pub unsafe fn _mm_cvtsi64_ss(a: __m128, b: i64) -> __m128 {
     cvtsi642ss(a, b)
 }
 
 #[cfg(test)]
 mod tests {
-    use v128::*;
-    use x86::x86_64::sse;
+    use std::f32::NAN;
+    use std::i64::MIN;
 
     use stdsimd_test::simd_test;
 
+    use x86::*;
+
     #[simd_test = "sse"]
-    unsafe fn _mm_cvtss_si64() {
-        use std::f32::NAN;
-        use std::i64::MIN;
+    unsafe fn test_mm_cvtss_si64() {
         let inputs = &[
             (42.0f32, 42i64),
             (-31.4, -31),
@@ -83,8 +83,8 @@ mod tests {
         ];
         for i in 0..inputs.len() {
             let (xi, e) = inputs[i];
-            let x = f32x4::new(xi, 1.0, 3.0, 4.0);
-            let r = sse::_mm_cvtss_si64(x);
+            let x = _mm_setr_ps(xi, 1.0, 3.0, 4.0);
+            let r = _mm_cvtss_si64(x);
             assert_eq!(
                 e,
                 r,
@@ -98,9 +98,7 @@ mod tests {
     }
 
     #[simd_test = "sse"]
-    unsafe fn _mm_cvttss_si64() {
-        use std::f32::NAN;
-        use std::i64::MIN;
+    unsafe fn test_mm_cvttss_si64() {
         let inputs = &[
             (42.0f32, 42i64),
             (-31.4, -31),
@@ -117,8 +115,8 @@ mod tests {
         ];
         for i in 0..inputs.len() {
             let (xi, e) = inputs[i];
-            let x = f32x4::new(xi, 1.0, 3.0, 4.0);
-            let r = sse::_mm_cvttss_si64(x);
+            let x = _mm_setr_ps(xi, 1.0, 3.0, 4.0);
+            let r = _mm_cvttss_si64(x);
             assert_eq!(
                 e,
                 r,
@@ -132,7 +130,7 @@ mod tests {
     }
 
     #[simd_test = "sse"]
-    pub unsafe fn _mm_cvtsi64_ss() {
+    pub unsafe fn test_mm_cvtsi64_ss() {
         let inputs = &[
             (4555i64, 4555.0f32),
             (322223333, 322223330.0),
@@ -144,19 +142,10 @@ mod tests {
 
         for i in 0..inputs.len() {
             let (x, f) = inputs[i];
-            let a = f32x4::new(5.0, 6.0, 7.0, 8.0);
-            let r = sse::_mm_cvtsi64_ss(a, x);
-            let e = a.replace(0, f);
-            assert_eq!(
-                e,
-                r,
-                "TestCase #{} _mm_cvtsi64_ss({:?}, {}) = {:?}, expected: {:?}",
-                i,
-                a,
-                x,
-                r,
-                e
-            );
+            let a = _mm_setr_ps(5.0, 6.0, 7.0, 8.0);
+            let r = _mm_cvtsi64_ss(a, x);
+            let e = _mm_setr_ps(f, 6.0, 7.0, 8.0);
+            assert_eq_m128(e, r);
         }
     }
 }

coresimd/src/x86/x86_64/sse2.rs

@@ -1,32 +1,33 @@
 //! `x86_64`'s Streaming SIMD Extensions 2 (SSE2)
 
-use v128::*;
+use x86::*;
+use simd_llvm::*;
 
 #[cfg(test)]
 use stdsimd_test::assert_instr;
 
 #[allow(improper_ctypes)]
 extern "C" {
     #[link_name = "llvm.x86.sse2.cvtsd2si64"]
-    fn cvtsd2si64(a: f64x2) -> i64;
+    fn cvtsd2si64(a: __m128d) -> i64;
     #[link_name = "llvm.x86.sse2.cvttsd2si64"]
-    fn cvttsd2si64(a: f64x2) -> i64;
+    fn cvttsd2si64(a: __m128d) -> i64;
 }
 
 /// Convert the lower double-precision (64-bit) floating-point element in a to
 /// a 64-bit integer.
 #[inline(always)]
 #[target_feature(enable = "sse2")]
 #[cfg_attr(test, assert_instr(cvtsd2si))]
-pub unsafe fn _mm_cvtsd_si64(a: f64x2) -> i64 {
+pub unsafe fn _mm_cvtsd_si64(a: __m128d) -> i64 {
     cvtsd2si64(a)
 }
 
 /// Alias for [`_mm_cvtsd_si64`](fn._mm_cvtsd_si64_ss.html).
 #[inline(always)]
 #[target_feature(enable = "sse2")]
 #[cfg_attr(test, assert_instr(cvtsd2si))]
-pub unsafe fn _mm_cvtsd_si64x(a: f64x2) -> i64 {
+pub unsafe fn _mm_cvtsd_si64x(a: __m128d) -> i64 {
     _mm_cvtsd_si64(a)
 }
 
@@ -35,15 +36,15 @@ pub unsafe fn _mm_cvtsd_si64x(a: f64x2) -> i64 {
 #[inline(always)]
 #[target_feature(enable = "sse2")]
 #[cfg_attr(test, assert_instr(cvttsd2si))]
-pub unsafe fn _mm_cvttsd_si64(a: f64x2) -> i64 {
+pub unsafe fn _mm_cvttsd_si64(a: __m128d) -> i64 {
     cvttsd2si64(a)
 }
 
 /// Alias for [`_mm_cvttsd_si64`](fn._mm_cvttsd_si64_ss.html).
 #[inline(always)]
 #[target_feature(enable = "sse2")]
 #[cfg_attr(test, assert_instr(cvttsd2si))]
-pub unsafe fn _mm_cvttsd_si64x(a: f64x2) -> i64 {
+pub unsafe fn _mm_cvttsd_si64x(a: __m128d) -> i64 {
     _mm_cvttsd_si64(a)
 }
 
@@ -63,32 +64,32 @@ pub unsafe fn _mm_stream_si64(mem_addr: *mut i64, a: i64) {
 #[inline(always)]
 #[target_feature(enable = "sse2")]
 #[cfg_attr(all(test, not(windows)), assert_instr(movq))]
-pub unsafe fn _mm_cvtsi64_si128(a: i64) -> i64x2 {
-    i64x2::new(a, 0)
+pub unsafe fn _mm_cvtsi64_si128(a: i64) -> __m128i {
+    _mm_set_epi64x(0, a)
 }
 
 /// Return a vector whose lowest element is `a` and all higher elements are
 /// `0`.
 #[inline(always)]
 #[target_feature(enable = "sse2")]
 #[cfg_attr(all(test, not(windows)), assert_instr(movq))]
-pub unsafe fn _mm_cvtsi64x_si128(a: i64) -> i64x2 {
+pub unsafe fn _mm_cvtsi64x_si128(a: i64) -> __m128i {
     _mm_cvtsi64_si128(a)
 }
 
 /// Return the lowest element of `a`.
 #[inline(always)]
 #[target_feature(enable = "sse2")]
 #[cfg_attr(all(test, not(windows)), assert_instr(movq))]
-pub unsafe fn _mm_cvtsi128_si64(a: i64x2) -> i64 {
-    a.extract(0)
+pub unsafe fn _mm_cvtsi128_si64(a: __m128i) -> i64 {
+    simd_extract(a, 0)
 }
 
 /// Return the lowest element of `a`.
 #[inline(always)]
 #[target_feature(enable = "sse2")]
 #[cfg_attr(all(test, not(windows)), assert_instr(movq))]
-pub unsafe fn _mm_cvtsi128_si64x(a: i64x2) -> i64 {
+pub unsafe fn _mm_cvtsi128_si64x(a: __m128i) -> i64 {
     _mm_cvtsi128_si64(a)
 }
 
@@ -97,85 +98,81 @@ pub unsafe fn _mm_cvtsi128_si64x(a: i64x2) -> i64 {
 #[inline(always)]
 #[target_feature(enable = "sse2")]
 #[cfg_attr(test, assert_instr(cvtsi2sd))]
-pub unsafe fn _mm_cvtsi64_sd(a: f64x2, b: i64) -> f64x2 {
-    a.replace(0, b as f64)
+pub unsafe fn _mm_cvtsi64_sd(a: __m128d, b: i64) -> __m128d {
+    simd_insert(a, 0, b as f64)
 }
 
 /// Return `a` with its lower element replaced by `b` after converting it to
 /// an `f64`.
 #[inline(always)]
 #[target_feature(enable = "sse2")]
 #[cfg_attr(test, assert_instr(cvtsi2sd))]
-pub unsafe fn _mm_cvtsi64x_sd(a: f64x2, b: i64) -> f64x2 {
+pub unsafe fn _mm_cvtsi64x_sd(a: __m128d, b: i64) -> __m128d {
     _mm_cvtsi64_sd(a, b)
 }
 
 #[cfg(test)]
 mod tests {
+    use std::{f64, i64};
+
     use stdsimd_test::simd_test;
 
-    use v128::*;
-    use x86::x86_64::sse2;
+    use x86::*;
 
     #[simd_test = "sse2"]
-    unsafe fn _mm_cvtsd_si64() {
-        use std::{f64, i64};
+    unsafe fn test_mm_cvtsd_si64() {
 
-        let r = sse2::_mm_cvtsd_si64(f64x2::new(-2.0, 5.0));
+        let r = _mm_cvtsd_si64(_mm_setr_pd(-2.0, 5.0));
         assert_eq!(r, -2_i64);
 
-        let r = sse2::_mm_cvtsd_si64(f64x2::new(f64::MAX, f64::MIN));
+        let r = _mm_cvtsd_si64(_mm_setr_pd(f64::MAX, f64::MIN));
         assert_eq!(r, i64::MIN);
     }
 
     #[simd_test = "sse2"]
-    unsafe fn _mm_cvtsd_si64x() {
-        use std::{f64, i64};
-
-        let r = sse2::_mm_cvtsd_si64x(f64x2::new(f64::NAN, f64::NAN));
+    unsafe fn test_mm_cvtsd_si64x() {
+        let r = _mm_cvtsd_si64x(_mm_setr_pd(f64::NAN, f64::NAN));
         assert_eq!(r, i64::MIN);
     }
 
     #[simd_test = "sse2"]
-    unsafe fn _mm_cvttsd_si64() {
-        let a = f64x2::new(-1.1, 2.2);
-        let r = sse2::_mm_cvttsd_si64(a);
+    unsafe fn test_mm_cvttsd_si64() {
+        let a = _mm_setr_pd(-1.1, 2.2);
+        let r = _mm_cvttsd_si64(a);
         assert_eq!(r, -1_i64);
     }
 
     #[simd_test = "sse2"]
-    unsafe fn _mm_cvttsd_si64x() {
-        use std::{f64, i64};
-
-        let a = f64x2::new(f64::NEG_INFINITY, f64::NAN);
-        let r = sse2::_mm_cvttsd_si64x(a);
+    unsafe fn test_mm_cvttsd_si64x() {
+        let a = _mm_setr_pd(f64::NEG_INFINITY, f64::NAN);
+        let r = _mm_cvttsd_si64x(a);
         assert_eq!(r, i64::MIN);
     }
 
     #[simd_test = "sse2"]
-    unsafe fn _mm_stream_si64() {
+    unsafe fn test_mm_stream_si64() {
         let a: i64 = 7;
         let mut mem = ::std::boxed::Box::<i64>::new(-1);
-        sse2::_mm_stream_si64(&mut *mem as *mut i64, a);
+        _mm_stream_si64(&mut *mem as *mut i64, a);
         assert_eq!(a, *mem);
     }
 
     #[simd_test = "sse2"]
-    unsafe fn _mm_cvtsi64_si128() {
-        let r = sse2::_mm_cvtsi64_si128(5);
-        assert_eq!(r, i64x2::new(5, 0));
+    unsafe fn test_mm_cvtsi64_si128() {
+        let r = _mm_cvtsi64_si128(5);
+        assert_eq!(r, _mm_setr_epi64x(5, 0));
     }
 
     #[simd_test = "sse2"]
-    unsafe fn _mm_cvtsi128_si64() {
-        let r = sse2::_mm_cvtsi128_si64(i64x2::new(5, 0));
+    unsafe fn test_mm_cvtsi128_si64() {
+        let r = _mm_cvtsi128_si64(_mm_setr_epi64x(5, 0));
         assert_eq!(r, 5);
     }
 
     #[simd_test = "sse2"]
-    unsafe fn _mm_cvtsi64_sd() {
-        let a = f64x2::splat(3.5);
-        let r = sse2::_mm_cvtsi64_sd(a, 5);
-        assert_eq!(r, f64x2::new(5.0, 3.5));
+    unsafe fn test_mm_cvtsi64_sd() {
+        let a = _mm_set1_pd(3.5);
+        let r = _mm_cvtsi64_sd(a, 5);
+        assert_eq_m128d(r, _mm_setr_pd(5.0, 3.5));
     }
 }