use transmute in vceqz instructions in aarch64/neon/generated.rs

SparrowLii · Amanieu · commit b1af76f55eb6 · 2021-03-05T00:18:04.000Z
diff --git a/crates/core_arch/src/aarch64/neon/generated.rs b/crates/core_arch/src/aarch64/neon/generated.rs
@@ -78,143 +78,143 @@ pub unsafe fn vceqq_f64(a: float64x2_t, b: float64x2_t) -> uint64x2_t {
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqz_s8(a: int8x8_t) -> uint8x8_t {
-    simd_eq(a, int8x8_t(0, 0, 0, 0, 0, 0, 0, 0))
+    simd_eq(a, transmute(i8x8::new(0, 0, 0, 0, 0, 0, 0, 0)))
 }
 
 /// Signed Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqzq_s8(a: int8x16_t) -> uint8x16_t {
-    simd_eq(a, int8x16_t(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    simd_eq(a, transmute(i8x16::new(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)))
 }
 
 /// Signed Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqz_s16(a: int16x4_t) -> uint16x4_t {
-    simd_eq(a, int16x4_t(0, 0, 0, 0))
+    simd_eq(a, transmute(i16x4::new(0, 0, 0, 0)))
 }
 
 /// Signed Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqzq_s16(a: int16x8_t) -> uint16x8_t {
-    simd_eq(a, int16x8_t(0, 0, 0, 0, 0, 0, 0, 0))
+    simd_eq(a, transmute(i16x8::new(0, 0, 0, 0, 0, 0, 0, 0)))
 }
 
 /// Signed Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqz_s32(a: int32x2_t) -> uint32x2_t {
-    simd_eq(a, int32x2_t(0, 0))
+    simd_eq(a, transmute(i32x2::new(0, 0)))
 }
 
 /// Signed Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqzq_s32(a: int32x4_t) -> uint32x4_t {
-    simd_eq(a, int32x4_t(0, 0, 0, 0))
+    simd_eq(a, transmute(i32x4::new(0, 0, 0, 0)))
 }
 
 /// Signed Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqz_s64(a: int64x1_t) -> uint64x1_t {
-    simd_eq(a, int64x1_t(0))
+    simd_eq(a, transmute(i64x1::new(0)))
 }
 
 /// Signed Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqzq_s64(a: int64x2_t) -> uint64x2_t {
-    simd_eq(a, int64x2_t(0, 0))
+    simd_eq(a, transmute(i64x2::new(0, 0)))
 }
 
 /// Signed Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqz_p64(a: poly64x1_t) -> uint64x1_t {
-    simd_eq(a, poly64x1_t(0))
+    simd_eq(a, transmute(i64x1::new(0)))
 }
 
 /// Signed Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqzq_p64(a: poly64x2_t) -> uint64x2_t {
-    simd_eq(a, poly64x2_t(0, 0))
+    simd_eq(a, transmute(i64x2::new(0, 0)))
 }
 
 /// Unsigned Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqz_u8(a: uint8x8_t) -> uint8x8_t {
-    simd_eq(a, uint8x8_t(0, 0, 0, 0, 0, 0, 0, 0))
+    simd_eq(a, transmute(u8x8::new(0, 0, 0, 0, 0, 0, 0, 0)))
 }
 
 /// Unsigned Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqzq_u8(a: uint8x16_t) -> uint8x16_t {
-    simd_eq(a, uint8x16_t(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
+    simd_eq(a, transmute(u8x16::new(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)))
 }
 
 /// Unsigned Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqz_u16(a: uint16x4_t) -> uint16x4_t {
-    simd_eq(a, uint16x4_t(0, 0, 0, 0))
+    simd_eq(a, transmute(u16x4::new(0, 0, 0, 0)))
 }
 
 /// Unsigned Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqzq_u16(a: uint16x8_t) -> uint16x8_t {
-    simd_eq(a, uint16x8_t(0, 0, 0, 0, 0, 0, 0, 0))
+    simd_eq(a, transmute(u16x8::new(0, 0, 0, 0, 0, 0, 0, 0)))
 }
 
 /// Unsigned Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqz_u32(a: uint32x2_t) -> uint32x2_t {
-    simd_eq(a, uint32x2_t(0, 0))
+    simd_eq(a, transmute(u32x2::new(0, 0)))
 }
 
 /// Unsigned Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqzq_u32(a: uint32x4_t) -> uint32x4_t {
-    simd_eq(a, uint32x4_t(0, 0, 0, 0))
+    simd_eq(a, transmute(u32x4::new(0, 0, 0, 0)))
 }
 
 /// Unsigned Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqz_u64(a: uint64x1_t) -> uint64x1_t {
-    simd_eq(a, uint64x1_t(0))
+    simd_eq(a, transmute(u64x1::new(0)))
 }
 
 /// Unsigned Compare bitwise equal to zero
 #[inline]
 #[target_feature(enable = "neon")]
 #[cfg_attr(test, assert_instr(vceqz))]
 pub unsafe fn vceqzq_u64(a: uint64x2_t) -> uint64x2_t {
-    simd_eq(a, uint64x2_t(0, 0))
+    simd_eq(a, transmute(u64x2::new(0, 0)))
 }
 
 /// Compare signed greater than
diff --git a/crates/core_arch/src/macros.rs b/crates/core_arch/src/macros.rs
@@ -426,13 +426,13 @@ macro_rules! constify_imm3 {
 macro_rules! types {
     ($(
         $(#[$doc:meta])*
-        pub struct $name:ident($field:ty$(, $fields:ty)*$(,)?);
+        pub struct $name:ident($($fields:tt)*);
     )*) => ($(
         $(#[$doc])*
         #[derive(Copy, Clone, Debug)]
         #[allow(non_camel_case_types)]
         #[repr(simd)]
         #[allow(clippy::missing_inline_in_public_items)]
-        pub struct $name(pub $field$(, pub $fields)*);
+        pub struct $name($($fields)*);
     )*)
 }
diff --git a/crates/stdarch-gen/src/main.rs b/crates/stdarch-gen/src/main.rs
@@ -299,7 +299,7 @@ fn gen_aarch64(
     in_t: &str,
     out_t: &str,
     current_tests: &[(Vec<String>, Vec<String>, Vec<String>)],
-    has_b: bool,
+    single_para: bool,
     fixed: &Option<String>,
 ) -> (String, String) {
     let _global_t = type_to_global_type(in_t);
@@ -335,7 +335,7 @@ fn gen_aarch64(
     } else {
         String::new()
     };
-    let call = if has_b {
+    let call = if !single_para {
         format!(
             r#"pub unsafe fn {}(a: {}, b: {}) -> {} {{
     {}{}(a, b)
@@ -350,9 +350,15 @@ fn gen_aarch64(
         }
         format!(
             r#"pub unsafe fn {}(a: {}) -> {} {{
-    {}{}(a, {}({}))
+    {}{}(a, transmute({}::new({})))
 }}"#,
-            name, in_t, out_t, ext_c, current_fn, in_t, fixed_vals,
+            name,
+            in_t,
+            out_t,
+            ext_c,
+            current_fn,
+            type_to_global_type(in_t),
+            fixed_vals,
         )
     } else {
         String::new()
@@ -368,7 +374,14 @@ fn gen_aarch64(
         current_comment, current_aarch64, call
     );
 
-    let test = gen_test(name, &in_t, &out_t, current_tests, type_len(in_t), has_b);
+    let test = gen_test(
+        name,
+        &in_t,
+        &out_t,
+        current_tests,
+        type_len(in_t),
+        single_para,
+    );
     (function, test)
 }
 
@@ -378,7 +391,7 @@ fn gen_test(
     out_t: &str,
     current_tests: &[(Vec<String>, Vec<String>, Vec<String>)],
     len: usize,
-    has_b: bool,
+    single_para: bool,
 ) -> String {
     let mut test = format!(
         r#"
@@ -390,7 +403,7 @@ fn gen_test(
         let a: Vec<String> = a.iter().take(len).cloned().collect();
         let b: Vec<String> = b.iter().take(len).cloned().collect();
         let e: Vec<String> = e.iter().take(len).cloned().collect();
-        let t = if has_b {
+        let t = if !single_para {
             format!(
                 r#"
         let a{};
@@ -437,7 +450,7 @@ fn gen_arm(
     in_t: &str,
     out_t: &str,
     current_tests: &[(Vec<String>, Vec<String>, Vec<String>)],
-    has_b: bool,
+    single_para: bool,
     fixed: &Option<String>,
 ) -> (String, String) {
     let _global_t = type_to_global_type(in_t);
@@ -486,7 +499,7 @@ fn gen_arm(
         } else {
             String::new()
         };
-    let call = if has_b {
+    let call = if !single_para {
         format!(
             r#"pub unsafe fn {}(a: {}, b: {}) -> {} {{
     {}{}(a, b)
@@ -501,9 +514,15 @@ fn gen_arm(
         }
         format!(
             r#"pub unsafe fn {}(a: {}) -> {} {{
-    {}{}(a, {}({}))
+    {}{}(a, transmute({}::new({})))
 }}"#,
-            name, in_t, out_t, ext_c, current_fn, in_t, fixed_vals,
+            name,
+            in_t,
+            out_t,
+            ext_c,
+            current_fn,
+            type_to_global_type(in_t),
+            fixed_vals,
         )
     } else {
         String::new()
@@ -523,7 +542,14 @@ fn gen_arm(
         expand_intrinsic(&current_aarch64, in_t),
         call,
     );
-    let test = gen_test(name, &in_t, &out_t, current_tests, type_len(in_t), has_b);
+    let test = gen_test(
+        name,
+        &in_t,
+        &out_t,
+        current_tests,
+        type_len(in_t),
+        single_para,
+    );
 
     (function, test)
 }
@@ -752,7 +778,7 @@ mod test {
                         &in_t,
                         &out_t,
                         &current_tests,
-                        b.len() > 0,
+                        b.len() == 0,
                         &fixed,
                     );
                     out_arm.push_str(&function);
@@ -767,7 +793,7 @@ mod test {
                         &in_t,
                         &out_t,
                         &current_tests,
-                        b.len() > 0,
+                        b.len() == 0,
                         &fixed,
                     );
                     out_aarch64.push_str(&function);
