scratch

library/stdarch/.gitignore

@@ -0,0 +1,3 @@
+Cargo.lock
+.*.swp
+/target

library/stdarch/Cargo.toml

@@ -9,3 +9,6 @@ repository = "https://github.com/BurntSushi/stdsimd"
 readme = "README.md"
 keywords = ["std", "simd", "intrinsics", "sse", "avx"]
 license = "MIT"
+
+[profile.release]
+debug = true

library/stdarch/examples/play.rs

@@ -0,0 +1,28 @@
+extern crate stdsimd;
+
+use std::env;
+use std::io::Write;
+
+use stdsimd as s;
+
+fn main() {
+    let arg1: f64 = env::args().nth(1).unwrap().parse().unwrap();
+    let arg2: f64 = env::args().nth(2).unwrap().parse().unwrap();
+    let arg3: f64 = env::args().nth(3).unwrap().parse().unwrap();
+    let arg4: f64 = env::args().nth(4).unwrap().parse().unwrap();
+    unsafe {
+        let a1 = s::_mm_load_pd(&(arg1, arg2) as *const _ as *const f64);
+        let b1 = s::_mm_load_pd(&(arg3, arg4) as *const _ as *const f64);
+        // println!("{:?}, {:?}", a, b);
+        let r1 = s::_mm_add_sd(a1, b1);
+        // println!("{:?}", r1);
+        let mut r2: (f64, f64) = (0.0, 0.0);
+        s::_mm_store_pd(&mut r2 as *mut _ as *mut f64, r1);
+        if r2 == (4.0, 2.0) {
+            ::std::io::stdout().write_all(b"yes\n").unwrap();
+        } else {
+            ::std::io::stdout().write_all(b"NO\n").unwrap();
+        }
+        // println!("{:?}", r2);
+    }
+}

library/stdarch/src/lib.rs

@@ -0,0 +1,36 @@
+#![allow(dead_code)]
+#![feature(platform_intrinsics, repr_simd)]
+
+pub use x86::*;
+
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+mod x86;
+
+extern "platform-intrinsic" {
+    fn simd_eq<T, U>(x: T, y: T) -> U;
+    fn simd_ne<T, U>(x: T, y: T) -> U;
+    fn simd_lt<T, U>(x: T, y: T) -> U;
+    fn simd_le<T, U>(x: T, y: T) -> U;
+    fn simd_gt<T, U>(x: T, y: T) -> U;
+    fn simd_ge<T, U>(x: T, y: T) -> U;
+
+    fn simd_shuffle2<T, U>(x: T, y: T, idx: [u32; 2]) -> U;
+    fn simd_shuffle4<T, U>(x: T, y: T, idx: [u32; 4]) -> U;
+    fn simd_shuffle8<T, U>(x: T, y: T, idx: [u32; 8]) -> U;
+    fn simd_shuffle16<T, U>(x: T, y: T, idx: [u32; 16]) -> U;
+
+    fn simd_insert<T, U>(x: T, idx: u32, val: U) -> T;
+    fn simd_extract<T, U>(x: T, idx: u32) -> U;
+
+    fn simd_cast<T, U>(x: T) -> U;
+
+    fn simd_add<T>(x: T, y: T) -> T;
+    fn simd_sub<T>(x: T, y: T) -> T;
+    fn simd_mul<T>(x: T, y: T) -> T;
+    fn simd_div<T>(x: T, y: T) -> T;
+    fn simd_shl<T>(x: T, y: T) -> T;
+    fn simd_shr<T>(x: T, y: T) -> T;
+    fn simd_and<T>(x: T, y: T) -> T;
+    fn simd_or<T>(x: T, y: T) -> T;
+    fn simd_xor<T>(x: T, y: T) -> T;
+}

library/stdarch/src/x86/mod.rs

@@ -0,0 +1,29 @@
+pub use self::sse2::*;
+
+mod sse;
+mod sse2;
+
+#[repr(simd)]
+#[derive(Clone, Copy, Debug)]
+#[allow(non_camel_case_types)]
+pub struct __m128(f32, f32, f32, f32);
+
+#[repr(simd)]
+#[derive(Clone, Copy, Debug)]
+#[allow(non_camel_case_types)]
+pub struct __m128d(f64, f64);
+
+#[repr(simd)]
+#[derive(Clone, Copy, Debug)]
+#[allow(non_camel_case_types)]
+pub struct __m128i(u64, u64);
+
+#[repr(simd)]
+#[derive(Clone, Copy, Debug)]
+#[allow(non_camel_case_types)]
+pub struct f64x2(f64, f64);
+
+#[repr(simd)]
+#[derive(Clone, Copy, Debug)]
+#[allow(non_camel_case_types)]
+struct u8x16(u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8);

library/stdarch/src/x86/sse2.rs

@@ -0,0 +1,26 @@
+use std::mem::transmute;
+
+use super::{__m128d, __m128i, f64x2, u8x16};
+use {simd_add, simd_extract, simd_insert};
+
+pub unsafe fn _mm_add_epi8(a: __m128i, b: __m128i) -> __m128i {
+    transmute(simd_add::<u8x16>(transmute(a), transmute(b)))
+}
+
+pub unsafe fn _mm_add_sd(a: __m128d, b: __m128d) -> __m128d {
+    let alow = simd_extract::<f64x2, f64>(transmute(a), 0);
+    let blow = simd_extract::<f64x2, f64>(transmute(b), 0);
+    transmute(simd_insert::<f64x2, f64>(transmute(a), 0, alow + blow))
+}
+
+pub unsafe fn _mm_add_pd(a: __m128d, b: __m128d) -> __m128d {
+    transmute(simd_add::<f64x2>(transmute(a), transmute(b)))
+}
+
+pub unsafe fn _mm_load_pd(mem_addr: *const f64) -> __m128d {
+    *(mem_addr as *const __m128d)
+}
+
+pub unsafe fn _mm_store_pd(mem_addr: *mut f64, a: __m128d) {
+    *(mem_addr as *mut __m128d) = a;
+}