use stdarch-gen to generate instructions

Author: surechen

crates/core_arch/src/aarch64/neon/generated.rs

@@ -271,6 +271,22 @@ pub unsafe fn vceqzq_f64(a: float64x2_t) -> uint64x2_t {
     simd_eq(a, transmute(b))
 }
 
+/// Floating-point absolute value
+#[inline]
+#[target_feature(enable = "neon")]
+#[cfg_attr(test, assert_instr(fabs))]
+pub unsafe fn vabs_f64(a: float64x1_t) -> float64x1_t {
+    simd_fabs(a)
+}
+
+/// Floating-point absolute value
+#[inline]
+#[target_feature(enable = "neon")]
+#[cfg_attr(test, assert_instr(fabs))]
+pub unsafe fn vabsq_f64(a: float64x2_t) -> float64x2_t {
+    simd_fabs(a)
+}
+
 /// Compare signed greater than
 #[inline]
 #[target_feature(enable = "neon")]
@@ -838,6 +854,22 @@ mod test {
         assert_eq!(r, e);
     }
 
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vabs_f64() {
+        let a: f64 = -0.1;
+        let e: f64 = 0.1;
+        let r: f64 = transmute(vabs_f64(transmute(a)));
+        assert_eq!(r, e);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vabsq_f64() {
+        let a: f64x2 = f64x2::new(-0.1, -2.2);
+        let e: f64x2 = f64x2::new(0.1, 2.2);
+        let r: f64x2 = transmute(vabsq_f64(transmute(a)));
+        assert_eq!(r, e);
+    }
+
     #[simd_test(enable = "neon")]
     unsafe fn test_vcgt_s64() {
         let a: i64x1 = i64x1::new(1);

crates/core_arch/src/aarch64/neon/mod.rs

@@ -72,10 +72,6 @@ extern "C" {
     fn vabs_s64_(a: int64x1_t) -> int64x1_t;
     #[link_name = "llvm.aarch64.neon.abs.v2i64"]
     fn vabsq_s64_(a: int64x2_t) -> int64x2_t;
-    #[link_name = "llvm.fabs.v1f64"]
-    fn vabs_f64_(a: float64x1_t) -> float64x1_t;
-    #[link_name = "llvm.fabs.v2f64"]
-    fn vabsq_f64_(a: float64x2_t) -> float64x2_t;
 
     #[link_name = "llvm.aarch64.neon.suqadd.v8i8"]
     fn vuqadd_s8_(a: int8x8_t, b: uint8x8_t) -> int8x8_t;
@@ -708,21 +704,6 @@ pub unsafe fn vabsq_s64(a: int64x2_t) -> int64x2_t {
     vabsq_s64_(a)
 }
 
-/// Floating-point absolute value.
-#[inline]
-#[target_feature(enable = "neon")]
-#[cfg_attr(test, assert_instr(fabs))]
-pub unsafe fn vabs_f64(a: float64x1_t) -> float64x1_t {
-    vabs_f64_(a)
-}
-/// Floating-point absolute value.
-#[inline]
-#[target_feature(enable = "neon")]
-#[cfg_attr(test, assert_instr(fabs))]
-pub unsafe fn vabsq_f64(a: float64x2_t) -> float64x2_t {
-    vabsq_f64_(a)
-}
-
 /// Signed saturating Accumulate of Unsigned value.
 #[inline]
 #[target_feature(enable = "neon")]
@@ -3932,20 +3913,6 @@ mod tests {
         let e = i64x2::new(i64::MIN, i64::MAX);
         assert_eq!(r, e);
     }
-    #[simd_test(enable = "neon")]
-    unsafe fn test_vabs_f64() {
-        let a = f64x1::new(f64::MIN);
-        let r: f64x1 = transmute(vabs_f64(transmute(a)));
-        let e = f64x1::new(f64::MAX);
-        assert_eq!(r, e);
-    }
-    #[simd_test(enable = "neon")]
-    unsafe fn test_vabsq_f64() {
-        let a = f64x2::new(f64::MIN, -4.2);
-        let r: f64x2 = transmute(vabsq_f64(transmute(a)));
-        let e = f64x2::new(f64::MAX, 4.2);
-        assert_eq!(r, e);
-    }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vaddv_s16() {

crates/core_arch/src/arm/neon/generated.rs

@@ -629,6 +629,26 @@ pub unsafe fn vceqq_f32(a: float32x4_t, b: float32x4_t) -> uint32x4_t {
     simd_eq(a, b)
 }
 
+/// Floating-point absolute value
+#[inline]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vabs))]
+#[cfg_attr(all(test, target_arch = "aarch64"), assert_instr(fabs))]
+pub unsafe fn vabs_f32(a: float32x2_t) -> float32x2_t {
+    simd_fabs(a)
+}
+
+/// Floating-point absolute value
+#[inline]
+#[target_feature(enable = "neon")]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vabs))]
+#[cfg_attr(all(test, target_arch = "aarch64"), assert_instr(fabs))]
+pub unsafe fn vabsq_f32(a: float32x4_t) -> float32x4_t {
+    simd_fabs(a)
+}
+
 /// Compare signed greater than
 #[inline]
 #[target_feature(enable = "neon")]
@@ -3651,6 +3671,22 @@ mod test {
         assert_eq!(r, e);
     }
 
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vabs_f32() {
+        let a: f32x2 = f32x2::new(-0.1, -2.2);
+        let e: f32x2 = f32x2::new(0.1, 2.2);
+        let r: f32x2 = transmute(vabs_f32(transmute(a)));
+        assert_eq!(r, e);
+    }
+
+    #[simd_test(enable = "neon")]
+    unsafe fn test_vabsq_f32() {
+        let a: f32x4 = f32x4::new(-0.1, -2.2, -3.3, -6.6);
+        let e: f32x4 = f32x4::new(0.1, 2.2, 3.3, 6.6);
+        let r: f32x4 = transmute(vabsq_f32(transmute(a)));
+        assert_eq!(r, e);
+    }
+
     #[simd_test(enable = "neon")]
     unsafe fn test_vcgt_s8() {
         let a: i8x8 = i8x8::new(1, 2, 3, 4, 5, 6, 7, 8);

crates/core_arch/src/arm/neon/mod.rs

@@ -125,9 +125,6 @@ extern "C" {
     #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vabs.v2i32")]
     #[cfg_attr(target_arch = "aarch64", link_name = "llvm.aarch64.neon.abs.v2i32")]
     fn vabs_s32_(a: int32x2_t) -> int32x2_t;
-    #[cfg_attr(target_arch = "arm", link_name = "llvm.fabs.v2f32")]
-    #[cfg_attr(target_arch = "aarch64", link_name = "llvm.fabs.v2f32")]
-    fn vabs_f32_(a: float32x2_t) -> float32x2_t;
     // absolute value (128-bit)
     #[cfg_attr(target_arch = "arm", link_name = "llvm.arm.neon.vabs.v16i8")]
     #[cfg_attr(target_arch = "aarch64", link_name = "llvm.aarch64.neon.abs.v16i8")]
@@ -1153,24 +1150,6 @@ pub unsafe fn vabsq_s16(a: int16x8_t) -> int16x8_t {
 pub unsafe fn vabsq_s32(a: int32x4_t) -> int32x4_t {
     vabsq_s32_(a)
 }
-/// Floating-point absolute value.
-#[inline]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vabs))]
-#[cfg_attr(all(test, target_arch = "aarch64"), assert_instr(fabs))]
-pub unsafe fn vabs_f32(a: float32x2_t) -> float32x2_t {
-    vabs_f32_(a)
-}
-/// Floating-point absolute value.
-#[inline]
-#[target_feature(enable = "neon")]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vabs))]
-#[cfg_attr(all(test, target_arch = "aarch64"), assert_instr(fabs))]
-pub unsafe fn vabsq_f32(a: float32x4_t) -> float32x4_t {
-    vabsq_f32_(a)
-}
 
 /// Add pairwise.
 #[inline]
@@ -8588,20 +8567,7 @@ mod tests {
         let e = i32x4::new(i32::MIN, i32::MAX, 0, 1);
         assert_eq!(r, e);
     }
-    #[simd_test(enable = "neon")]
-    unsafe fn test_vabs_f32() {
-        let a = f32x2::new(f32::MIN, -1.0);
-        let r: f32x2 = transmute(vabs_f32(transmute(a)));
-        let e = f32x2::new(f32::MAX, 1.0);
-        assert_eq!(r, e);
-    }
-    #[simd_test(enable = "neon")]
-    unsafe fn test_vabsq_f32() {
-        let a = f32x4::new(f32::MIN, -1.32, -4.3, -6.8);
-        let r: f32x4 = transmute(vabsq_f32(transmute(a)));
-        let e = f32x4::new(f32::MAX, 1.32, 4.3, 6.8);
-        assert_eq!(r, e);
-    }
+
     #[simd_test(enable = "neon")]
     unsafe fn test_vpadd_s16() {
         let a = i16x4::new(1, 2, 3, 4);

crates/stdarch-gen/neon.spec

@@ -53,12 +53,12 @@
 // FALSE - 'false' all bits are set to 0
 // FF - same as 'true'
 // MIN - minimal value (either 0 or the lowest negative number)
-// MAX - maximal value propr to overflow
+// MAX - maximal value proper to overflow
 //
 // # validate <values>
 // Validates a and b aginst the expected result of the test.
 // The special values 'TRUE' and 'FALSE' can be used to
-// represent the corect NEON representation of true or
+// represent the correct NEON representation of true or
 // false values. It too gets scaled to the type.
 //
 // Validate needs to be called before generate as it sets
@@ -166,6 +166,29 @@ validate TRUE, FALSE, FALSE, FALSE
 aarch64 = fcmeq
 generate float32x2_t:uint32x2_t, float32x4_t:uint32x4_t, float64x1_t:uint64x1_t, float64x2_t:uint64x2_t
 
+////////////////////
+// Floating-point absolute value
+////////////////////
+
+/// Floating-point absolute value
+name = vabs
+fn = simd_fabs
+a =  -0.1, -2.2, -3.3, -6.6
+validate 0.1, 2.2, 3.3, 6.6
+
+arm = vabs
+aarch64 = fabs
+generate float32x2_t:float32x2_t, float32x4_t:float32x4_t
+
+/// Floating-point absolute value
+name = vabs
+fn = simd_fabs
+a =  -0.1, -2.2, -3.3, -6.6
+validate 0.1, 2.2, 3.3, 6.6
+
+aarch64 = fabs
+generate float64x1_t:float64x1_t, float64x2_t:float64x2_t
+
 ////////////////////
 // greater then
 ////////////////////