Implement all addition MMX intrinsics (rust-lang#266)

* Implement `_mm_add_pi16`

* Implement `_mm_add_pi8`

* Implement `_mm_add_pi32`

* Implement `_mm_adds_pi16`

* Implement `_mm_adds_pi8`

* Implement `_mm_adds_pu8`

* Implement `_mm_adds_pu16`

Author: TSPMP

coresimd/src/x86/i686/mmx.rs

@@ -24,6 +24,62 @@ pub unsafe fn _mm_setzero_si64() -> __m64 {
     mem::transmute(0_i64)
 }
 
+/// Add packed 8-bit integers in `a` and `b`.
+#[inline(always)]
+#[target_feature = "+mmx"]
+#[cfg_attr(test, assert_instr(paddb))]
+pub unsafe fn _mm_add_pi8(a: __m64, b: __m64) -> __m64 {
+    paddb(a, b)
+}
+
+/// Add packed 16-bit integers in `a` and `b`.
+#[inline(always)]
+#[target_feature = "+mmx"]
+#[cfg_attr(test, assert_instr(paddw))]
+pub unsafe fn _mm_add_pi16(a: __m64, b: __m64) -> __m64 {
+    paddw(a, b)
+}
+
+/// Add packed 32-bit integers in `a` and `b`.
+#[inline(always)]
+#[target_feature = "+mmx"]
+#[cfg_attr(test, assert_instr(paddd))]
+pub unsafe fn _mm_add_pi32(a: __m64, b: __m64) -> __m64 {
+    paddd(a, b)
+}
+
+/// Add packed 8-bit integers in `a` and `b` using saturation.
+#[inline(always)]
+#[target_feature = "+mmx"]
+#[cfg_attr(test, assert_instr(paddsb))]
+pub unsafe fn _mm_adds_pi8(a: __m64, b: __m64) -> __m64 {
+    paddsb(a, b)
+}
+
+/// Add packed 16-bit integers in `a` and `b` using saturation.
+#[inline(always)]
+#[target_feature = "+mmx"]
+#[cfg_attr(test, assert_instr(paddsw))]
+pub unsafe fn _mm_adds_pi16(a: __m64, b: __m64) -> __m64 {
+    paddsw(a, b)
+}
+
+/// Add packed unsigned 8-bit integers in `a` and `b` using saturation.
+#[inline(always)]
+#[target_feature = "+mmx"]
+#[cfg_attr(test, assert_instr(paddusb))]
+pub unsafe fn _mm_adds_pu8(a: __m64, b: __m64) -> __m64 {
+    paddusb(a, b)
+}
+
+/// Add packed unsigned 16-bit integers in `a` and `b` using saturation.
+#[inline(always)]
+#[target_feature = "+mmx"]
+#[cfg_attr(test, assert_instr(paddusw))]
+pub unsafe fn _mm_adds_pu16(a: __m64, b: __m64) -> __m64 {
+    paddusw(a, b)
+}
+
 /// Convert packed 16-bit integers from `a` and `b` to packed 8-bit integers
 /// using signed saturation.
 ///
@@ -131,6 +187,20 @@ pub unsafe fn _mm_unpacklo_pi32(a: __m64, b: __m64) -> __m64 {
 
 #[allow(improper_ctypes)]
 extern "C" {
+    #[link_name = "llvm.x86.mmx.padd.b"]
+    fn paddb(a: __m64, b: __m64) -> __m64;
+    #[link_name = "llvm.x86.mmx.padd.w"]
+    fn paddw(a: __m64, b: __m64) -> __m64;
+    #[link_name = "llvm.x86.mmx.padd.d"]
+    fn paddd(a: __m64, b: __m64) -> __m64;
+    #[link_name = "llvm.x86.mmx.padds.b"]
+    fn paddsb(a: __m64, b: __m64) -> __m64;
+    #[link_name = "llvm.x86.mmx.padds.w"]
+    fn paddsw(a: __m64, b: __m64) -> __m64;
+    #[link_name = "llvm.x86.mmx.paddus.b"]
+    fn paddusb(a: __m64, b: __m64) -> __m64;
+    #[link_name = "llvm.x86.mmx.paddus.w"]
+    fn paddusw(a: __m64, b: __m64) -> __m64;
     #[link_name = "llvm.x86.mmx.packsswb"]
     fn packsswb(a: __m64, b: __m64) -> __m64;
     #[link_name = "llvm.x86.mmx.packssdw"]
@@ -157,7 +227,7 @@ extern "C" {
 
 #[cfg(test)]
 mod tests {
-    use v64::{__m64, i16x4, i32x2, i8x8};
+    use v64::{__m64, i16x4, i32x2, i8x8, u16x4, u8x8};
     use x86::i686::mmx;
     use stdsimd_test::simd_test;
 
@@ -167,6 +237,75 @@ mod tests {
         assert_eq!(r, mmx::_mm_setzero_si64());
     }
 
+    #[simd_test = "mmx"]
+    unsafe fn _mm_add_pi8() {
+        let a = i8x8::new(-1, -1, 1, 1, -1, 0, 1, 0);
+        let b = i8x8::new(-127, 101, 99, 126, 0, -1, 0, 1);
+        let r = i8x8::from(mmx::_mm_add_pi8(a.into(), b.into()));
+        let e = i8x8::new(-128, 100, 100, 127, -1, -1, 1, 1);
+        assert_eq!(r, e);
+    }
+
+    #[simd_test = "mmx"]
+    unsafe fn _mm_add_pi16() {
+        let a = i16x4::new(-1, -1, 1, 1);
+        let b = i16x4::new(
+            i16::min_value() + 1,
+            30001,
+            -30001,
+            i16::max_value() - 1,
+        );
+        let r = i16x4::from(mmx::_mm_add_pi16(a.into(), b.into()));
+        let e = i16x4::new(i16::min_value(), 30000, -30000, i16::max_value());
+        assert_eq!(r, e);
+    }
+
+    #[simd_test = "mmx"]
+    unsafe fn _mm_add_pi32() {
+        let a = i32x2::new(1, -1);
+        let b = i32x2::new(i32::max_value() - 1, i32::min_value() + 1);
+        let r = i32x2::from(mmx::_mm_add_pi32(a.into(), b.into()));
+        let e = i32x2::new(i32::max_value(), i32::min_value());
+        assert_eq!(r, e);
+    }
+
+    #[simd_test = "mmx"]
+    unsafe fn _mm_adds_pi8() {
+        let a = i8x8::new(-100, -1, 1, 100, -1, 0, 1, 0);
+        let b = i8x8::new(-100, 1, -1, 100, 0, -1, 0, 1);
+        let r = i8x8::from(mmx::_mm_adds_pi8(a.into(), b.into()));
+        let e =
+            i8x8::new(i8::min_value(), 0, 0, i8::max_value(), -1, -1, 1, 1);
+        assert_eq!(r, e);
+    }
+
+    #[simd_test = "mmx"]
+    unsafe fn _mm_adds_pi16() {
+        let a = i16x4::new(-32000, 32000, 4, 0);
+        let b = i16x4::new(-32000, 32000, -5, 1);
+        let r = i16x4::from(mmx::_mm_adds_pi16(a.into(), b.into()));
+        let e = i16x4::new(i16::min_value(), i16::max_value(), -1, 1);
+        assert_eq!(r, e);
+    }
+
+    #[simd_test = "mmx"]
+    unsafe fn _mm_adds_pu8() {
+        let a = u8x8::new(0, 1, 2, 3, 4, 5, 6, 200);
+        let b = u8x8::new(0, 10, 20, 30, 40, 50, 60, 200);
+        let r = u8x8::from(mmx::_mm_adds_pu8(a.into(), b.into()));
+        let e = u8x8::new(0, 11, 22, 33, 44, 55, 66, u8::max_value());
+        assert_eq!(r, e);
+    }
+
+    #[simd_test = "mmx"]
+    unsafe fn _mm_adds_pu16() {
+        let a = u16x4::new(0, 1, 2, 60000);
+        let b = u16x4::new(0, 10, 20, 60000);
+        let r = u16x4::from(mmx::_mm_adds_pu16(a.into(), b.into()));
+        let e = u16x4::new(0, 11, 22, u16::max_value());
+        assert_eq!(r, e);
+    }
+
     #[simd_test = "mmx"]
     unsafe fn _mm_packs_pi16() {
         let a = i16x4::new(-1, 2, -3, 4);