Add bitwise equality operations

Author: Licenser

crates/core_arch/src/aarch64/neon.rs

@@ -232,6 +232,49 @@ extern "C" {
     ) -> int8x16_t;
 }
 
+macro_rules! aarch64_simd_2 {
+    ($name:ident, $type:ty, $simd_fn:ident, $intr:ident) => {
+        #[inline]
+        #[target_feature(enable = "neon")]
+        #[cfg_attr(test, assert_instr($intr))]
+        pub unsafe fn $name(a: $type, b: $type) -> $type {
+            $simd_fn(a, b)
+        }
+    };
+}
+macro_rules! aarch64_simd_ceq {
+    ($name:ident, $type:ty) => {
+        /// Compare bitwise Equal (vector)
+        aarch64_simd_2!($name, $type, simd_eq, cmeq);
+    };
+}
+
+aarch64_simd_ceq!(vceq_s64, int64x1_t);
+aarch64_simd_ceq!(vceqq_s64, int64x2_t);
+aarch64_simd_ceq!(vceq_u64, uint64x1_t);
+aarch64_simd_ceq!(vceqq_u64, uint64x2_t);
+
+/// Compare bitwise Equal (vector)
+#[inline]
+#[target_feature(enable = "neon")]
+#[cfg_attr(test, assert_instr(fcmeq))]
+pub unsafe fn vceq_f64(a: float64x1_t, b: float64x1_t) -> uint64x1_t {
+    simd_eq(a, b)
+}
+
+/// Compare bitwise Equal (vector)
+#[inline]
+#[target_feature(enable = "neon")]
+#[cfg_attr(test, assert_instr(fcmeq))]
+pub unsafe fn vceqq_f64(a: float64x2_t, b: float64x2_t) -> uint64x2_t {
+    simd_eq(a, b)
+}
+
+aarch64_simd_ceq!(vceq_p64, uint64x1_t);
+aarch64_simd_ceq!(vceqq_p64, uint64x2_t);
+
+
+
 /// Vector add.
 #[inline]
 #[target_feature(enable = "neon")]
@@ -1584,6 +1627,55 @@ mod tests {
         assert_eq!(r, e);
     }
 
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceq_s64() {
+        let a = i64x1::new(0x0001020304050607);
+        let b = i64x1::new(-1);
+        let r: i64x1 = transmute(vceq_s64(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceqq_s64() {
+        let a = i64x2::new(0x0001020304050607, 0x08090A0B0C0D0E0F);
+        let b = i64x2::new(-1, -1);
+        let r: i64x2 = transmute(vceqq_s64(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceq_u64() {
+        let a = u64x1::new(0x0001020304050607);
+        let b = u64x1::new(0xFFFFFFFFFFFFFFFF);
+        let r: u64x1 = transmute(vceq_u64(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceqq_u64() {
+        let a = u64x2::new(0x0001020304050607, 0x08090A0B0C0D0E0F);
+        let b = u64x2::new(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);
+        let r: u64x2 = transmute(vceqq_u64(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceq_f64() {
+        let a: f64 = 1.2;
+        let b = u64x1::new(0xFFFFFFFFFFFFFFFF);
+        let r: u64x1 = transmute(vceq_f64(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceqq_f32() {
+        let a = f64x2::new(1.2, 3.4);
+        let b = u64x2::new(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);
+        let r: u64x2 = transmute(vceqq_f64(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxv_s8() {
         let r = vmaxv_s8(transmute(i8x8::new(1, 2, 3, 4, -8, 6, 7, 5)));

crates/core_arch/src/arm/neon.rs

@@ -784,7 +784,7 @@ arm_simd_eor!(veorq_u64, uint64x2_t);
 
 macro_rules! arm_simd_ceq {
     ($name:ident, $type:ty) => {
-        /// Vector bitwise exclusive or (vector).
+        /// Compare bitwise Equal (vector)
         arm_simd_2!($name, $type, simd_eq, cmeq, cmeq);
     };
 }
@@ -802,7 +802,6 @@ arm_simd_ceq!(vceqq_u16, uint16x8_t);
 arm_simd_ceq!(vceq_u32, uint32x2_t);
 arm_simd_ceq!(vceqq_u32, uint32x4_t);
 
-
 // arm_simd_ceq!(vceq_f32, float32x2_t); // we have a different return type
 #[inline]
 #[target_feature(enable = "neon")]
@@ -826,16 +825,6 @@ pub unsafe fn vceqq_f32(a: float32x4_t, b: float32x4_t) -> uint32x4_t {
 arm_simd_ceq!(vceq_p8, poly8x8_t);
 arm_simd_ceq!(vceqq_p8, poly8x16_t);
 
-// TODO: 
-// uint64x1_t vceq_s64 (int64x1_t a, int64x1_t b)Compare bitwise equal
-// uint64x2_t vceqq_s64 (int64x2_t a, int64x2_t b)Compare bitwise equal
-// uint64x1_t vceq_u64 (uint64x1_t a, uint64x1_t b)Compare bitwise equal
-// uint64x2_t vceqq_u64 (uint64x2_t a, uint64x2_t b)Compare bitwise equal
-// uint64x1_t vceq_p64 (poly64x1_t a, poly64x1_t b)Compare bitwise equal
-// uint64x2_t vceqq_p64 (poly64x2_t a, poly64x2_t b)Compare bitwise equal
-// ui nt64x1_t vceq_f64 (float64x1_t a, float64x1_t b)Floating-point compare equal
-// uint64x2_t vceqq_f64 (float64x2_t a, float64x2_t b)Floating-point compare equal
-
 /// Folding minimum of adjacent pairs
 #[inline]
 #[target_feature(enable = "neon")]
@@ -1842,7 +1831,7 @@ mod tests {
         assert_eq!(r, a);
     }
 
-        #[simd_test(enable = "neon")]
+    #[simd_test(enable = "neon")]
     unsafe fn test_veor_s8() {
         let a = i8x8::new(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
         let b = i8x8::new(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
@@ -1970,6 +1959,122 @@ mod tests {
         assert_eq!(r, b);
     }
 
+        #[simd_test(enable = "neon")]
+    unsafe fn test_vceq_s8() {
+        let a = i8x8::new(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
+        let b = i8x8::new(-1, -1, -1, -1, -1, -1, -1, -1);
+        let r: i8x8 = transmute(vceq_s8(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceqq_s8() {
+        let a = i8x16::new(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F);
+        let b = i8x16::new(-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+        let r: i8x16 = transmute(vceqq_s8(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceq_s16() {
+        let a = i16x4::new(0x0001, 0x0203, 0x0405, 0x0607);
+        let b = i16x4::new(-1, -1, -1, -1);
+        let r: i16x4 = transmute(vceq_s16(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceqq_s16() {
+        let a = i16x8::new(0x0001, 0x0203, 0x0405, 0x0607, 0x0809, 0x0A0B, 0x0C0D, 0x0E0F);
+        let b = i16x8::new(-1, -1, -1, -1, -1, -1, -1, -1);
+        let r: i16x8 = transmute(vceqq_s16(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceq_s32() {
+        let a = i32x2::new(0x00010203, 0x04050607);
+        let b = i32x2::new(-1, -1);
+        let r: i32x2 = transmute(vceq_s32(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceqq_s32() {
+        let a = i32x4::new(0x00010203, 0x04050607, 0x08090A0B, 0x0C0D0E0F);
+        let b = i32x4::new(-1, -1, -1, -1);
+        let r: i32x4 = transmute(vceqq_s32(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceq_u8() {
+        let a = u8x8::new(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
+        let b = u8x8::new(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
+        let r: u8x8 = transmute(vceq_u8(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceqq_u8() {
+        let a = u8x16::new(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F);
+        let b = u8x16::new(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
+        let r: u8x16 = transmute(vceqq_u8(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceq_u16() {
+        let a = u16x4::new(0x0001, 0x0203, 0x0405, 0x0607);
+        let b = u16x4::new(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
+        let r: u16x4 = transmute(vceq_u16(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceqq_u16() {
+        let a = u16x8::new(0x0001, 0x0203, 0x0405, 0x0607, 0x0809, 0x0A0B, 0x0C0D, 0x0E0F);
+        let b = u16x8::new(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
+        let r: u16x8 = transmute(vceqq_u16(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceq_u32() {
+        let a = u32x2::new(0x00010203, 0x04050607);
+        let b = u32x2::new(0xFFFFFFFF, 0xFFFFFFFF);
+        let r: u32x2 = transmute(vceq_u32(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceqq_u32() {
+        let a = u32x4::new(0x00010203, 0x04050607, 0x08090A0B, 0x0C0D0E0F);
+        let b = u32x4::new(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+        let r: u32x4 = transmute(vceqq_u32(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceq_f32() {
+        let a = f32x2::new(1.2, 2.3);
+        let b = u32x2::new(0xFFFFFFFF, 0xFFFFFFFF);
+        let r: u32x2 = transmute(vceq_f32(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vceqq_f32() {
+        let a = f32x4::new(1.2, 3.4, 5.6, 7.8);
+        let b = u32x4::new(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+        let r: u32x4 = transmute(vceqq_f32(transmute(a), transmute(a)));
+        assert_eq!(r, b);
+    }
+    
+
     #[simd_test(enable = "neon")]
     unsafe fn test_vmovn_s16() {
         let a = i16x8::new(1, 2, 3, 4, 5, 6, 7, 8);