remove unnecessary transmutes in aarch64 neon

Author: gnzlbg

coresimd/aarch64/neon.rs

@@ -565,205 +565,205 @@ mod tests {
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxv_s8() {
-        let r = ::mem::transmute(vmaxv_s8(::mem::transmute(i8x8::new(1, 2, 3, 4, -8, 6, 7, 5))));
+        let r = vmaxv_s8(::mem::transmute(i8x8::new(1, 2, 3, 4, -8, 6, 7, 5)));
         assert_eq!(r, 7_i8);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxvq_s8() {
         #[cfg_attr(rustfmt, rustfmt_skip)]
-        let r = ::mem::transmute(vmaxvq_s8(::mem::transmute(i8x16::new(
+        let r = vmaxvq_s8(::mem::transmute(i8x16::new(
             1, 2, 3, 4,
             -16, 6, 7, 5,
             8, 1, 1, 1,
             1, 1, 1, 1,
-        ))));
+        )));
         assert_eq!(r, 8_i8);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxv_s16() {
-        let r = ::mem::transmute(vmaxv_s16(::mem::transmute(i16x4::new(1, 2, -4, 3))));
+        let r = vmaxv_s16(::mem::transmute(i16x4::new(1, 2, -4, 3)));
         assert_eq!(r, 3_i16);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxvq_s16() {
-        let r = ::mem::transmute(vmaxvq_s16(::mem::transmute(i16x8::new(1, 2, 7, 4, -16, 6, 7, 5))));
+        let r = vmaxvq_s16(::mem::transmute(i16x8::new(1, 2, 7, 4, -16, 6, 7, 5)));
         assert_eq!(r, 7_i16);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxv_s32() {
-        let r = ::mem::transmute(vmaxv_s32(::mem::transmute(i32x2::new(1, -4))));
+        let r = vmaxv_s32(::mem::transmute(i32x2::new(1, -4)));
         assert_eq!(r, 1_i32);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxvq_s32() {
-        let r = ::mem::transmute(vmaxvq_s32(::mem::transmute(i32x4::new(1, 2, -32, 4))));
+        let r = vmaxvq_s32(::mem::transmute(i32x4::new(1, 2, -32, 4)));
         assert_eq!(r, 4_i32);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxv_u8() {
-        let r = ::mem::transmute(vmaxv_u8(::mem::transmute(u8x8::new(1, 2, 3, 4, 8, 6, 7, 5))));
+        let r = vmaxv_u8(::mem::transmute(u8x8::new(1, 2, 3, 4, 8, 6, 7, 5)));
         assert_eq!(r, 8_u8);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxvq_u8() {
         #[cfg_attr(rustfmt, rustfmt_skip)]
-        let r = ::mem::transmute(vmaxvq_u8(::mem::transmute(u8x16::new(
+        let r = vmaxvq_u8(::mem::transmute(u8x16::new(
             1, 2, 3, 4,
             16, 6, 7, 5,
             8, 1, 1, 1,
             1, 1, 1, 1,
-        ))));
+        )));
         assert_eq!(r, 16_u8);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxv_u16() {
-        let r = ::mem::transmute(vmaxv_u16(::mem::transmute(u16x4::new(1, 2, 4, 3))));
+        let r = vmaxv_u16(::mem::transmute(u16x4::new(1, 2, 4, 3)));
         assert_eq!(r, 4_u16);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxvq_u16() {
-        let r = ::mem::transmute(vmaxvq_u16(::mem::transmute(u16x8::new(1, 2, 7, 4, 16, 6, 7, 5))));
+        let r = vmaxvq_u16(::mem::transmute(u16x8::new(1, 2, 7, 4, 16, 6, 7, 5)));
         assert_eq!(r, 16_u16);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxv_u32() {
-        let r = ::mem::transmute(vmaxv_u32(::mem::transmute(u32x2::new(1, 4))));
+        let r = vmaxv_u32(::mem::transmute(u32x2::new(1, 4)));
         assert_eq!(r, 4_u32);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxvq_u32() {
-        let r = ::mem::transmute(vmaxvq_u32(::mem::transmute(u32x4::new(1, 2, 32, 4))));
+        let r = vmaxvq_u32(::mem::transmute(u32x4::new(1, 2, 32, 4)));
         assert_eq!(r, 32_u32);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxv_f32() {
-        let r = ::mem::transmute(vmaxv_f32(::mem::transmute(f32x2::new(1., 4.))));
+        let r = vmaxv_f32(::mem::transmute(f32x2::new(1., 4.)));
         assert_eq!(r, 4_f32);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxvq_f32() {
-        let r = ::mem::transmute(vmaxvq_f32(::mem::transmute(f32x4::new(1., 2., 32., 4.))));
+        let r = vmaxvq_f32(::mem::transmute(f32x4::new(1., 2., 32., 4.)));
         assert_eq!(r, 32_f32);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vmaxvq_f64() {
-        let r = ::mem::transmute(vmaxvq_f64(::mem::transmute(f64x2::new(1., 4.))));
+        let r = vmaxvq_f64(::mem::transmute(f64x2::new(1., 4.)));
         assert_eq!(r, 4_f64);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminv_s8() {
-        let r = ::mem::transmute(vminv_s8(::mem::transmute(i8x8::new(1, 2, 3, 4, -8, 6, 7, 5))));
+        let r = vminv_s8(::mem::transmute(i8x8::new(1, 2, 3, 4, -8, 6, 7, 5)));
         assert_eq!(r, -8_i8);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminvq_s8() {
         #[cfg_attr(rustfmt, rustfmt_skip)]
-        let r = ::mem::transmute(vminvq_s8(::mem::transmute(::mem::transmute(i8x16::new(
+        let r = vminvq_s8(::mem::transmute(::mem::transmute(i8x16::new(
             1, 2, 3, 4,
             -16, 6, 7, 5,
             8, 1, 1, 1,
             1, 1, 1, 1,
-        )))));
+        ))));
         assert_eq!(r, -16_i8);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminv_s16() {
-        let r = ::mem::transmute(vminv_s16(::mem::transmute(i16x4::new(1, 2, -4, 3))));
+        let r = vminv_s16(::mem::transmute(i16x4::new(1, 2, -4, 3)));
         assert_eq!(r, -4_i16);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminvq_s16() {
-        let r = ::mem::transmute(vminvq_s16(::mem::transmute(i16x8::new(1, 2, 7, 4, -16, 6, 7, 5))));
+        let r = vminvq_s16(::mem::transmute(i16x8::new(1, 2, 7, 4, -16, 6, 7, 5)));
         assert_eq!(r, -16_i16);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminv_s32() {
-        let r = ::mem::transmute(vminv_s32(::mem::transmute(i32x2::new(1, -4))));
+        let r = vminv_s32(::mem::transmute(i32x2::new(1, -4)));
         assert_eq!(r, -4_i32);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminvq_s32() {
-        let r = ::mem::transmute(vminvq_s32(::mem::transmute(i32x4::new(1, 2, -32, 4))));
+        let r = vminvq_s32(::mem::transmute(i32x4::new(1, 2, -32, 4)));
         assert_eq!(r, -32_i32);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminv_u8() {
-        let r = ::mem::transmute(vminv_u8(::mem::transmute(u8x8::new(1, 2, 3, 4, 8, 6, 7, 5))));
+        let r = vminv_u8(::mem::transmute(u8x8::new(1, 2, 3, 4, 8, 6, 7, 5)));
         assert_eq!(r, 1_u8);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminvq_u8() {
         #[cfg_attr(rustfmt, rustfmt_skip)]
-        let r = ::mem::transmute(vminvq_u8(::mem::transmute(u8x16::new(
+        let r = vminvq_u8(::mem::transmute(u8x16::new(
             1, 2, 3, 4,
             16, 6, 7, 5,
             8, 1, 1, 1,
             1, 1, 1, 1,
-        ))));
+        )));
         assert_eq!(r, 1_u8);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminv_u16() {
-        let r = ::mem::transmute(vminv_u16(::mem::transmute(u16x4::new(1, 2, 4, 3))));
+        let r = vminv_u16(::mem::transmute(u16x4::new(1, 2, 4, 3)));
         assert_eq!(r, 1_u16);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminvq_u16() {
-        let r = ::mem::transmute(vminvq_u16(::mem::transmute(u16x8::new(1, 2, 7, 4, 16, 6, 7, 5))));
+        let r = vminvq_u16(::mem::transmute(u16x8::new(1, 2, 7, 4, 16, 6, 7, 5)));
         assert_eq!(r, 1_u16);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminv_u32() {
-        let r = ::mem::transmute(vminv_u32(::mem::transmute(u32x2::new(1, 4))));
+        let r = vminv_u32(::mem::transmute(u32x2::new(1, 4)));
         assert_eq!(r, 1_u32);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminvq_u32() {
-        let r = ::mem::transmute(vminvq_u32(::mem::transmute(u32x4::new(1, 2, 32, 4))));
+        let r = vminvq_u32(::mem::transmute(u32x4::new(1, 2, 32, 4)));
         assert_eq!(r, 1_u32);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminv_f32() {
-        let r = ::mem::transmute(vminv_f32(::mem::transmute(f32x2::new(1., 4.))));
+        let r = vminv_f32(::mem::transmute(f32x2::new(1., 4.)));
         assert_eq!(r, 1_f32);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminvq_f32() {
-        let r = ::mem::transmute(vminvq_f32(::mem::transmute(f32x4::new(1., 2., 32., 4.))));
+        let r = vminvq_f32(::mem::transmute(f32x4::new(1., 2., 32., 4.)));
         assert_eq!(r, 1_f32);
     }
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vminvq_f64() {
-        let r = ::mem::transmute(vminvq_f64(::mem::transmute(f64x2::new(1., 4.))));
+        let r = vminvq_f64(::mem::transmute(f64x2::new(1., 4.)));
         assert_eq!(r, 1_f64);
     }