Fix ARM vbsl* NEON intrinsics (#1191) (#1307)

2 files changed, 206 insertions, 114 deletions

diff --git a/library/stdarch/crates/core_arch/src/aarch64/neon/mod.rs b/library/stdarch/crates/core_arch/src/aarch64/neon/mod.rs
index 65ba527ee07..d3d00d2d796 100644
--- a/library/stdarch/crates/core_arch/src/aarch64/neon/mod.rs
+++ b/library/stdarch/crates/core_arch/src/aarch64/neon/mod.rs
@@ -1045,7 +1045,11 @@ pub unsafe fn vabsq_s64(a: int64x2_t) -> int64x2_t {
 #[cfg_attr(test, assert_instr(bsl))]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 pub unsafe fn vbsl_f64(a: uint64x1_t, b: float64x1_t, c: float64x1_t) -> float64x1_t {
-    simd_select(transmute::<_, int64x1_t>(a), b, c)
+    let not = int64x1_t(-1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 /// Bitwise Select.
 #[inline]
@@ -1053,7 +1057,11 @@ pub unsafe fn vbsl_f64(a: uint64x1_t, b: float64x1_t, c: float64x1_t) -> float64
 #[cfg_attr(test, assert_instr(bsl))]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 pub unsafe fn vbsl_p64(a: poly64x1_t, b: poly64x1_t, c: poly64x1_t) -> poly64x1_t {
-    simd_select(transmute::<_, int64x1_t>(a), b, c)
+    let not = int64x1_t(-1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 /// Bitwise Select. (128-bit)
 #[inline]
@@ -1061,7 +1069,11 @@ pub unsafe fn vbsl_p64(a: poly64x1_t, b: poly64x1_t, c: poly64x1_t) -> poly64x1_
 #[cfg_attr(test, assert_instr(bsl))]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 pub unsafe fn vbslq_f64(a: uint64x2_t, b: float64x2_t, c: float64x2_t) -> float64x2_t {
-    simd_select(transmute::<_, int64x2_t>(a), b, c)
+    let not = int64x2_t(-1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 /// Bitwise Select. (128-bit)
 #[inline]
@@ -1069,7 +1081,11 @@ pub unsafe fn vbslq_f64(a: uint64x2_t, b: float64x2_t, c: float64x2_t) -> float6
 #[cfg_attr(test, assert_instr(bsl))]
 #[stable(feature = "neon_intrinsics", since = "1.59.0")]
 pub unsafe fn vbslq_p64(a: poly64x2_t, b: poly64x2_t, c: poly64x2_t) -> poly64x2_t {
-    simd_select(transmute::<_, int64x2_t>(a), b, c)
+    let not = int64x2_t(-1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Signed saturating Accumulate of Unsigned value.
@@ -5136,37 +5152,37 @@ mod tests {
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vbsl_f64() {
-        let a = u64x1::new(u64::MAX);
-        let b = f64x1::new(f64::MAX);
-        let c = f64x1::new(f64::MIN);
-        let e = f64x1::new(f64::MAX);
+        let a = u64x1::new(0x8000000000000000);
+        let b = f64x1::new(-1.23f64);
+        let c = f64x1::new(2.34f64);
+        let e = f64x1::new(-2.34f64);
         let r: f64x1 = transmute(vbsl_f64(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbsl_p64() {
-        let a = u64x1::new(u64::MAX);
+        let a = u64x1::new(1);
         let b = u64x1::new(u64::MAX);
         let c = u64x1::new(u64::MIN);
-        let e = u64x1::new(u64::MAX);
+        let e = u64x1::new(1);
         let r: u64x1 = transmute(vbsl_p64(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbslq_f64() {
-        let a = u64x2::new(u64::MAX, 0);
-        let b = f64x2::new(f64::MAX, f64::MAX);
-        let c = f64x2::new(f64::MIN, f64::MIN);
-        let e = f64x2::new(f64::MAX, f64::MIN);
+        let a = u64x2::new(1, 0x8000000000000000);
+        let b = f64x2::new(f64::MAX, -1.23f64);
+        let c = f64x2::new(f64::MIN, 2.34f64);
+        let e = f64x2::new(f64::MIN, -2.34f64);
         let r: f64x2 = transmute(vbslq_f64(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbslq_p64() {
-        let a = u64x2::new(u64::MAX, 0);
+        let a = u64x2::new(u64::MAX, 1);
         let b = u64x2::new(u64::MAX, u64::MAX);
         let c = u64x2::new(u64::MIN, u64::MIN);
-        let e = u64x2::new(u64::MAX, u64::MIN);
+        let e = u64x2::new(u64::MAX, 1);
         let r: u64x2 = transmute(vbslq_p64(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
diff --git a/library/stdarch/crates/core_arch/src/arm_shared/neon/mod.rs b/library/stdarch/crates/core_arch/src/arm_shared/neon/mod.rs
index 952d1ca2e35..76eba3a2f67 100644
--- a/library/stdarch/crates/core_arch/src/arm_shared/neon/mod.rs
+++ b/library/stdarch/crates/core_arch/src/arm_shared/neon/mod.rs
@@ -3733,7 +3733,11 @@ pub unsafe fn vbicq_u64(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbsl_s8(a: uint8x8_t, b: int8x8_t, c: int8x8_t) -> int8x8_t {
-    simd_select(transmute::<_, int8x8_t>(a), b, c)
+    let not = int8x8_t(-1, -1, -1, -1, -1, -1, -1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select.
@@ -3747,7 +3751,11 @@ pub unsafe fn vbsl_s8(a: uint8x8_t, b: int8x8_t, c: int8x8_t) -> int8x8_t {
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbsl_s16(a: uint16x4_t, b: int16x4_t, c: int16x4_t) -> int16x4_t {
-    simd_select(transmute::<_, int16x4_t>(a), b, c)
+    let not = int16x4_t(-1, -1, -1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select.
@@ -3761,7 +3769,11 @@ pub unsafe fn vbsl_s16(a: uint16x4_t, b: int16x4_t, c: int16x4_t) -> int16x4_t {
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbsl_s32(a: uint32x2_t, b: int32x2_t, c: int32x2_t) -> int32x2_t {
-    simd_select(transmute::<_, int32x2_t>(a), b, c)
+    let not = int32x2_t(-1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select.
@@ -3775,7 +3787,11 @@ pub unsafe fn vbsl_s32(a: uint32x2_t, b: int32x2_t, c: int32x2_t) -> int32x2_t {
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbsl_s64(a: uint64x1_t, b: int64x1_t, c: int64x1_t) -> int64x1_t {
-    simd_select(transmute::<_, int64x1_t>(a), b, c)
+    let not = int64x1_t(-1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select.
@@ -3789,7 +3805,11 @@ pub unsafe fn vbsl_s64(a: uint64x1_t, b: int64x1_t, c: int64x1_t) -> int64x1_t {
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbsl_u8(a: uint8x8_t, b: uint8x8_t, c: uint8x8_t) -> uint8x8_t {
-    simd_select(transmute::<_, int8x8_t>(a), b, c)
+    let not = int8x8_t(-1, -1, -1, -1, -1, -1, -1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select.
@@ -3803,7 +3823,11 @@ pub unsafe fn vbsl_u8(a: uint8x8_t, b: uint8x8_t, c: uint8x8_t) -> uint8x8_t {
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbsl_u16(a: uint16x4_t, b: uint16x4_t, c: uint16x4_t) -> uint16x4_t {
-    simd_select(transmute::<_, int16x4_t>(a), b, c)
+    let not = int16x4_t(-1, -1, -1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select.
@@ -3817,7 +3841,11 @@ pub unsafe fn vbsl_u16(a: uint16x4_t, b: uint16x4_t, c: uint16x4_t) -> uint16x4_
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbsl_u32(a: uint32x2_t, b: uint32x2_t, c: uint32x2_t) -> uint32x2_t {
-    simd_select(transmute::<_, int32x2_t>(a), b, c)
+    let not = int32x2_t(-1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select.
@@ -3831,7 +3859,11 @@ pub unsafe fn vbsl_u32(a: uint32x2_t, b: uint32x2_t, c: uint32x2_t) -> uint32x2_
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbsl_u64(a: uint64x1_t, b: uint64x1_t, c: uint64x1_t) -> uint64x1_t {
-    simd_select(transmute::<_, int64x1_t>(a), b, c)
+    let not = int64x1_t(-1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select.
@@ -3845,7 +3877,11 @@ pub unsafe fn vbsl_u64(a: uint64x1_t, b: uint64x1_t, c: uint64x1_t) -> uint64x1_
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbsl_f32(a: uint32x2_t, b: float32x2_t, c: float32x2_t) -> float32x2_t {
-    simd_select(transmute::<_, int32x2_t>(a), b, c)
+    let not = int32x2_t(-1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select.
@@ -3859,7 +3895,11 @@ pub unsafe fn vbsl_f32(a: uint32x2_t, b: float32x2_t, c: float32x2_t) -> float32
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbsl_p8(a: uint8x8_t, b: poly8x8_t, c: poly8x8_t) -> poly8x8_t {
-    simd_select(transmute::<_, int8x8_t>(a), b, c)
+    let not = int8x8_t(-1, -1, -1, -1, -1, -1, -1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select.
@@ -3873,7 +3913,11 @@ pub unsafe fn vbsl_p8(a: uint8x8_t, b: poly8x8_t, c: poly8x8_t) -> poly8x8_t {
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbsl_p16(a: uint16x4_t, b: poly16x4_t, c: poly16x4_t) -> poly16x4_t {
-    simd_select(transmute::<_, int16x4_t>(a), b, c)
+    let not = int16x4_t(-1, -1, -1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select. (128-bit)
@@ -3887,7 +3931,13 @@ pub unsafe fn vbsl_p16(a: uint16x4_t, b: poly16x4_t, c: poly16x4_t) -> poly16x4_
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbslq_s8(a: uint8x16_t, b: int8x16_t, c: int8x16_t) -> int8x16_t {
-    simd_select(transmute::<_, int8x16_t>(a), b, c)
+    let not = int8x16_t(
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    );
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select. (128-bit)
@@ -3901,7 +3951,11 @@ pub unsafe fn vbslq_s8(a: uint8x16_t, b: int8x16_t, c: int8x16_t) -> int8x16_t {
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbslq_s16(a: uint16x8_t, b: int16x8_t, c: int16x8_t) -> int16x8_t {
-    simd_select(transmute::<_, int16x8_t>(a), b, c)
+    let not = int16x8_t(-1, -1, -1, -1, -1, -1, -1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select. (128-bit)
@@ -3915,7 +3969,11 @@ pub unsafe fn vbslq_s16(a: uint16x8_t, b: int16x8_t, c: int16x8_t) -> int16x8_t
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbslq_s32(a: uint32x4_t, b: int32x4_t, c: int32x4_t) -> int32x4_t {
-    simd_select(transmute::<_, int32x4_t>(a), b, c)
+    let not = int32x4_t(-1, -1, -1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select. (128-bit)
@@ -3929,7 +3987,11 @@ pub unsafe fn vbslq_s32(a: uint32x4_t, b: int32x4_t, c: int32x4_t) -> int32x4_t
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbslq_s64(a: uint64x2_t, b: int64x2_t, c: int64x2_t) -> int64x2_t {
-    simd_select(transmute::<_, int64x2_t>(a), b, c)
+    let not = int64x2_t(-1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select. (128-bit)
@@ -3943,7 +4005,13 @@ pub unsafe fn vbslq_s64(a: uint64x2_t, b: int64x2_t, c: int64x2_t) -> int64x2_t
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbslq_u8(a: uint8x16_t, b: uint8x16_t, c: uint8x16_t) -> uint8x16_t {
-    simd_select(transmute::<_, int8x16_t>(a), b, c)
+    let not = int8x16_t(
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    );
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select. (128-bit)
@@ -3957,7 +4025,11 @@ pub unsafe fn vbslq_u8(a: uint8x16_t, b: uint8x16_t, c: uint8x16_t) -> uint8x16_
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbslq_u16(a: uint16x8_t, b: uint16x8_t, c: uint16x8_t) -> uint16x8_t {
-    simd_select(transmute::<_, int16x8_t>(a), b, c)
+    let not = int16x8_t(-1, -1, -1, -1, -1, -1, -1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select. (128-bit)
@@ -3971,7 +4043,11 @@ pub unsafe fn vbslq_u16(a: uint16x8_t, b: uint16x8_t, c: uint16x8_t) -> uint16x8
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbslq_u32(a: uint32x4_t, b: uint32x4_t, c: uint32x4_t) -> uint32x4_t {
-    simd_select(transmute::<_, int32x4_t>(a), b, c)
+    let not = int32x4_t(-1, -1, -1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select. (128-bit)
@@ -3985,7 +4061,11 @@ pub unsafe fn vbslq_u32(a: uint32x4_t, b: uint32x4_t, c: uint32x4_t) -> uint32x4
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbslq_u64(a: uint64x2_t, b: uint64x2_t, c: uint64x2_t) -> uint64x2_t {
-    simd_select(transmute::<_, int64x2_t>(a), b, c)
+    let not = int64x2_t(-1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select. (128-bit)
@@ -3999,7 +4079,13 @@ pub unsafe fn vbslq_u64(a: uint64x2_t, b: uint64x2_t, c: uint64x2_t) -> uint64x2
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbslq_p8(a: uint8x16_t, b: poly8x16_t, c: poly8x16_t) -> poly8x16_t {
-    simd_select(transmute::<_, int8x16_t>(a), b, c)
+    let not = int8x16_t(
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    );
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select. (128-bit)
@@ -4013,7 +4099,11 @@ pub unsafe fn vbslq_p8(a: uint8x16_t, b: poly8x16_t, c: poly8x16_t) -> poly8x16_
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbslq_p16(a: uint16x8_t, b: poly16x8_t, c: poly16x8_t) -> poly16x8_t {
-    simd_select(transmute::<_, int16x8_t>(a), b, c)
+    let not = int16x8_t(-1, -1, -1, -1, -1, -1, -1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Bitwise Select. (128-bit)
@@ -4027,7 +4117,11 @@ pub unsafe fn vbslq_p16(a: uint16x8_t, b: poly16x8_t, c: poly16x8_t) -> poly16x8
     stable(feature = "neon_intrinsics", since = "1.59.0")
 )]
 pub unsafe fn vbslq_f32(a: uint32x4_t, b: float32x4_t, c: float32x4_t) -> float32x4_t {
-    simd_select(transmute::<_, int32x4_t>(a), b, c)
+    let not = int32x4_t(-1, -1, -1, -1);
+    transmute(simd_or(
+        simd_and(a, transmute(b)),
+        simd_and(simd_xor(a, transmute(not)), transmute(c)),
+    ))
 }
 
 /// Vector bitwise inclusive OR NOT
@@ -9206,7 +9300,7 @@ mod tests {
 
     #[simd_test(enable = "neon")]
     unsafe fn test_vbsl_s8() {
-        let a = u8x8::new(u8::MAX, 0, u8::MAX, 0, u8::MAX, 0, u8::MAX, 0);
+        let a = u8x8::new(u8::MAX, 1, u8::MAX, 2, u8::MAX, 0, u8::MAX, 0);
         let b = i8x8::new(
             i8::MAX,
             i8::MAX,
@@ -9229,9 +9323,9 @@ mod tests {
         );
         let e = i8x8::new(
             i8::MAX,
-            i8::MIN,
+            i8::MIN | 1,
             i8::MAX,
-            i8::MIN,
+            i8::MIN | 2,
             i8::MAX,
             i8::MIN,
             i8::MAX,
@@ -9242,34 +9336,34 @@ mod tests {
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbsl_s16() {
-        let a = u16x4::new(u16::MAX, 0, u16::MAX, 0);
+        let a = u16x4::new(u16::MAX, 0, 1, 2);
         let b = i16x4::new(i16::MAX, i16::MAX, i16::MAX, i16::MAX);
         let c = i16x4::new(i16::MIN, i16::MIN, i16::MIN, i16::MIN);
-        let e = i16x4::new(i16::MAX, i16::MIN, i16::MAX, i16::MIN);
+        let e = i16x4::new(i16::MAX, i16::MIN, i16::MIN | 1, i16::MIN | 2);
         let r: i16x4 = transmute(vbsl_s16(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbsl_s32() {
-        let a = u32x2::new(u32::MAX, u32::MIN);
+        let a = u32x2::new(u32::MAX, 1);
         let b = i32x2::new(i32::MAX, i32::MAX);
         let c = i32x2::new(i32::MIN, i32::MIN);
-        let e = i32x2::new(i32::MAX, i32::MIN);
+        let e = i32x2::new(i32::MAX, i32::MIN | 1);
         let r: i32x2 = transmute(vbsl_s32(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbsl_s64() {
-        let a = u64x1::new(u64::MAX);
+        let a = u64x1::new(1);
         let b = i64x1::new(i64::MAX);
         let c = i64x1::new(i64::MIN);
-        let e = i64x1::new(i64::MAX);
+        let e = i64x1::new(i64::MIN | 1);
         let r: i64x1 = transmute(vbsl_s64(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbsl_u8() {
-        let a = u8x8::new(u8::MAX, 0, u8::MAX, 0, u8::MAX, 0, u8::MAX, 0);
+        let a = u8x8::new(u8::MAX, 1, u8::MAX, 2, u8::MAX, 0, u8::MAX, 0);
         let b = u8x8::new(
             u8::MAX,
             u8::MAX,
@@ -9290,58 +9384,49 @@ mod tests {
             u8::MIN,
             u8::MIN,
         );
-        let e = u8x8::new(
-            u8::MAX,
-            u8::MIN,
-            u8::MAX,
-            u8::MIN,
-            u8::MAX,
-            u8::MIN,
-            u8::MAX,
-            u8::MIN,
-        );
+        let e = u8x8::new(u8::MAX, 1, u8::MAX, 2, u8::MAX, u8::MIN, u8::MAX, u8::MIN);
         let r: u8x8 = transmute(vbsl_u8(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbsl_u16() {
-        let a = u16x4::new(u16::MAX, 0, u16::MAX, 0);
+        let a = u16x4::new(u16::MAX, 0, 1, 2);
         let b = u16x4::new(u16::MAX, u16::MAX, u16::MAX, u16::MAX);
         let c = u16x4::new(u16::MIN, u16::MIN, u16::MIN, u16::MIN);
-        let e = u16x4::new(u16::MAX, u16::MIN, u16::MAX, u16::MIN);
+        let e = u16x4::new(u16::MAX, 0, 1, 2);
         let r: u16x4 = transmute(vbsl_u16(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbsl_u32() {
-        let a = u32x2::new(u32::MAX, 0);
+        let a = u32x2::new(u32::MAX, 2);
         let b = u32x2::new(u32::MAX, u32::MAX);
         let c = u32x2::new(u32::MIN, u32::MIN);
-        let e = u32x2::new(u32::MAX, u32::MIN);
+        let e = u32x2::new(u32::MAX, 2);
         let r: u32x2 = transmute(vbsl_u32(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbsl_u64() {
-        let a = u64x1::new(u64::MAX);
+        let a = u64x1::new(2);
         let b = u64x1::new(u64::MAX);
         let c = u64x1::new(u64::MIN);
-        let e = u64x1::new(u64::MAX);
+        let e = u64x1::new(2);
         let r: u64x1 = transmute(vbsl_u64(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbsl_f32() {
-        let a = u32x2::new(u32::MAX, 0);
-        let b = f32x2::new(f32::MAX, f32::MAX);
-        let c = f32x2::new(f32::MIN, f32::MIN);
-        let e = f32x2::new(f32::MAX, f32::MIN);
+        let a = u32x2::new(1, 0x80000000);
+        let b = f32x2::new(8388609f32, -1.23f32);
+        let c = f32x2::new(2097152f32, 2.34f32);
+        let e = f32x2::new(2097152.25f32, -2.34f32);
         let r: f32x2 = transmute(vbsl_f32(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbsl_p8() {
-        let a = u8x8::new(u8::MAX, 0, u8::MAX, 0, u8::MAX, 0, u8::MAX, 0);
+        let a = u8x8::new(u8::MAX, 1, u8::MAX, 2, u8::MAX, 0, u8::MAX, 0);
         let b = u8x8::new(
             u8::MAX,
             u8::MAX,
@@ -9362,25 +9447,16 @@ mod tests {
             u8::MIN,
             u8::MIN,
         );
-        let e = u8x8::new(
-            u8::MAX,
-            u8::MIN,
-            u8::MAX,
-            u8::MIN,
-            u8::MAX,
-            u8::MIN,
-            u8::MAX,
-            u8::MIN,
-        );
+        let e = u8x8::new(u8::MAX, 1, u8::MAX, 2, u8::MAX, u8::MIN, u8::MAX, u8::MIN);
         let r: u8x8 = transmute(vbsl_p8(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbsl_p16() {
-        let a = u16x4::new(u16::MAX, 0, u16::MAX, 0);
+        let a = u16x4::new(u16::MAX, 0, 1, 2);
         let b = u16x4::new(u16::MAX, u16::MAX, u16::MAX, u16::MAX);
         let c = u16x4::new(u16::MIN, u16::MIN, u16::MIN, u16::MIN);
-        let e = u16x4::new(u16::MAX, u16::MIN, u16::MAX, u16::MIN);
+        let e = u16x4::new(u16::MAX, 0, 1, 2);
         let r: u16x4 = transmute(vbsl_p16(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
@@ -9388,9 +9464,9 @@ mod tests {
     unsafe fn test_vbslq_s8() {
         let a = u8x16::new(
             u8::MAX,
-            0,
+            1,
             u8::MAX,
-            0,
+            2,
             u8::MAX,
             0,
             u8::MAX,
@@ -9442,9 +9518,9 @@ mod tests {
         );
         let e = i8x16::new(
             i8::MAX,
-            i8::MIN,
+            i8::MIN | 1,
             i8::MAX,
-            i8::MIN,
+            i8::MIN | 2,
             i8::MAX,
             i8::MIN,
             i8::MAX,
@@ -9463,7 +9539,7 @@ mod tests {
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbslq_s16() {
-        let a = u16x8::new(u16::MAX, 0, u16::MAX, 0, u16::MAX, 0, u16::MAX, 0);
+        let a = u16x8::new(u16::MAX, 1, u16::MAX, 2, u16::MAX, 0, u16::MAX, 0);
         let b = i16x8::new(
             i16::MAX,
             i16::MAX,
@@ -9486,9 +9562,9 @@ mod tests {
         );
         let e = i16x8::new(
             i16::MAX,
-            i16::MIN,
+            i16::MIN | 1,
             i16::MAX,
-            i16::MIN,
+            i16::MIN | 2,
             i16::MAX,
             i16::MIN,
             i16::MAX,
@@ -9499,19 +9575,19 @@ mod tests {
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbslq_s32() {
-        let a = u32x4::new(u32::MAX, 0, u32::MAX, 0);
+        let a = u32x4::new(u32::MAX, 1, u32::MAX, 2);
         let b = i32x4::new(i32::MAX, i32::MAX, i32::MAX, i32::MAX);
         let c = i32x4::new(i32::MIN, i32::MIN, i32::MIN, i32::MIN);
-        let e = i32x4::new(i32::MAX, i32::MIN, i32::MAX, i32::MIN);
+        let e = i32x4::new(i32::MAX, i32::MIN | 1, i32::MAX, i32::MIN | 2);
         let r: i32x4 = transmute(vbslq_s32(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbslq_s64() {
-        let a = u64x2::new(u64::MAX, 0);
+        let a = u64x2::new(u64::MAX, 1);
         let b = i64x2::new(i64::MAX, i64::MAX);
         let c = i64x2::new(i64::MIN, i64::MIN);
-        let e = i64x2::new(i64::MAX, i64::MIN);
+        let e = i64x2::new(i64::MAX, i64::MIN | 1);
         let r: i64x2 = transmute(vbslq_s64(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
@@ -9519,9 +9595,9 @@ mod tests {
     unsafe fn test_vbslq_u8() {
         let a = u8x16::new(
             u8::MAX,
-            0,
+            1,
             u8::MAX,
-            0,
+            2,
             u8::MAX,
             0,
             u8::MAX,
@@ -9573,9 +9649,9 @@ mod tests {
         );
         let e = u8x16::new(
             u8::MAX,
-            u8::MIN,
+            1,
             u8::MAX,
-            u8::MIN,
+            2,
             u8::MAX,
             u8::MIN,
             u8::MAX,
@@ -9594,7 +9670,7 @@ mod tests {
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbslq_u16() {
-        let a = u16x8::new(u16::MAX, 0, u16::MAX, 0, u16::MAX, 0, u16::MAX, 0);
+        let a = u16x8::new(u16::MAX, 1, u16::MAX, 2, u16::MAX, 0, u16::MAX, 0);
         let b = u16x8::new(
             u16::MAX,
             u16::MAX,
@@ -9617,9 +9693,9 @@ mod tests {
         );
         let e = u16x8::new(
             u16::MAX,
-            u16::MIN,
+            1,
             u16::MAX,
-            u16::MIN,
+            2,
             u16::MAX,
             u16::MIN,
             u16::MAX,
@@ -9630,28 +9706,28 @@ mod tests {
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbslq_u32() {
-        let a = u32x4::new(u32::MAX, 0, u32::MAX, 0);
+        let a = u32x4::new(u32::MAX, 1, u32::MAX, 2);
         let b = u32x4::new(u32::MAX, u32::MAX, u32::MAX, u32::MAX);
         let c = u32x4::new(u32::MIN, u32::MIN, u32::MIN, u32::MIN);
-        let e = u32x4::new(u32::MAX, u32::MIN, u32::MAX, u32::MIN);
+        let e = u32x4::new(u32::MAX, 1, u32::MAX, 2);
         let r: u32x4 = transmute(vbslq_u32(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbslq_u64() {
-        let a = u64x2::new(u64::MAX, 0);
+        let a = u64x2::new(u64::MAX, 1);
         let b = u64x2::new(u64::MAX, u64::MAX);
         let c = u64x2::new(u64::MIN, u64::MIN);
-        let e = u64x2::new(u64::MAX, u64::MIN);
+        let e = u64x2::new(u64::MAX, 1);
         let r: u64x2 = transmute(vbslq_u64(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbslq_f32() {
-        let a = u32x4::new(u32::MAX, 0, u32::MAX, 0);
-        let b = f32x4::new(f32::MAX, f32::MAX, f32::MAX, f32::MAX);
-        let c = f32x4::new(f32::MIN, f32::MIN, f32::MIN, f32::MIN);
-        let e = f32x4::new(f32::MAX, f32::MIN, f32::MAX, f32::MIN);
+        let a = u32x4::new(u32::MAX, 0, 1, 0x80000000);
+        let b = f32x4::new(-1.23f32, -1.23f32, 8388609f32, -1.23f32);
+        let c = f32x4::new(2.34f32, 2.34f32, 2097152f32, 2.34f32);
+        let e = f32x4::new(-1.23f32, 2.34f32, 2097152.25f32, -2.34f32);
         let r: f32x4 = transmute(vbslq_f32(transmute(a), transmute(b), transmute(c)));
         assert_eq!(r, e);
     }
@@ -9659,9 +9735,9 @@ mod tests {
     unsafe fn test_vbslq_p8() {
         let a = u8x16::new(
             u8::MAX,
-            0,
+            1,
             u8::MAX,
-            0,
+            2,
             u8::MAX,
             0,
             u8::MAX,
@@ -9713,9 +9789,9 @@ mod tests {
         );
         let e = u8x16::new(
             u8::MAX,
-            u8::MIN,
+            1,
             u8::MAX,
-            u8::MIN,
+            2,
             u8::MAX,
             u8::MIN,
             u8::MAX,
@@ -9734,7 +9810,7 @@ mod tests {
     }
     #[simd_test(enable = "neon")]
     unsafe fn test_vbslq_p16() {
-        let a = u16x8::new(u16::MAX, 0, u16::MAX, 0, u16::MAX, 0, u16::MAX, 0);
+        let a = u16x8::new(u16::MAX, 1, u16::MAX, 2, u16::MAX, 0, u16::MAX, 0);
         let b = u16x8::new(
             u16::MAX,
             u16::MAX,
@@ -9757,9 +9833,9 @@ mod tests {
         );
         let e = u16x8::new(
             u16::MAX,
-            u16::MIN,
+            1,
             u16::MAX,
-            u16::MIN,
+            2,
             u16::MAX,
             u16::MIN,
             u16::MAX,