Fix expected instructions for arm.

- vreinterpret* do not emit any instructions on arm.
- vst1* intrinsics actual emit vst1.* instructions.
- arm vext_s64/vext_u64 don't cause any instructions to be emitted.

Author: hkratz

crates/core_arch/src/arm/neon.rs

@@ -307,175 +307,175 @@ pub unsafe fn vld1q_f32(ptr: *const f32) -> float32x4_t {
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.8"))]
 pub unsafe fn vst1_s8(ptr: *mut i8, a: int8x8_t) {
     vst1_v8i8(ptr as *const i8, a, align_of::<i8>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.8"))]
 pub unsafe fn vst1q_s8(ptr: *mut i8, a: int8x16_t) {
     vst1q_v16i8(ptr as *const i8, a, align_of::<i8>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.16"))]
 pub unsafe fn vst1_s16(ptr: *mut i16, a: int16x4_t) {
     vst1_v4i16(ptr as *const i8, a, align_of::<i16>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.16"))]
 pub unsafe fn vst1q_s16(ptr: *mut i16, a: int16x8_t) {
     vst1q_v8i16(ptr as *const i8, a, align_of::<i16>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.32"))]
 pub unsafe fn vst1_s32(ptr: *mut i32, a: int32x2_t) {
     vst1_v2i32(ptr as *const i8, a, align_of::<i32>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.32"))]
 pub unsafe fn vst1q_s32(ptr: *mut i32, a: int32x4_t) {
     vst1q_v4i32(ptr as *const i8, a, align_of::<i32>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.64"))]
 pub unsafe fn vst1_s64(ptr: *mut i64, a: int64x1_t) {
     vst1_v1i64(ptr as *const i8, a, align_of::<i64>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.64"))]
 pub unsafe fn vst1q_s64(ptr: *mut i64, a: int64x2_t) {
     vst1q_v2i64(ptr as *const i8, a, align_of::<i64>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.8"))]
 pub unsafe fn vst1_u8(ptr: *mut u8, a: uint8x8_t) {
     vst1_v8i8(ptr as *const i8, transmute(a), align_of::<u8>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.8"))]
 pub unsafe fn vst1q_u8(ptr: *mut u8, a: uint8x16_t) {
     vst1q_v16i8(ptr as *const i8, transmute(a), align_of::<u8>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.16"))]
 pub unsafe fn vst1_u16(ptr: *mut u16, a: uint16x4_t) {
     vst1_v4i16(ptr as *const i8, transmute(a), align_of::<u16>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.16"))]
 pub unsafe fn vst1q_u16(ptr: *mut u16, a: uint16x8_t) {
     vst1q_v8i16(ptr as *const i8, transmute(a), align_of::<u16>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.32"))]
 pub unsafe fn vst1_u32(ptr: *mut u32, a: uint32x2_t) {
     vst1_v2i32(ptr as *const i8, transmute(a), align_of::<u32>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.32"))]
 pub unsafe fn vst1q_u32(ptr: *mut u32, a: uint32x4_t) {
     vst1q_v4i32(ptr as *const i8, transmute(a), align_of::<u32>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.64"))]
 pub unsafe fn vst1_u64(ptr: *mut u64, a: uint64x1_t) {
     vst1_v1i64(ptr as *const i8, transmute(a), align_of::<u64>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.64"))]
 pub unsafe fn vst1q_u64(ptr: *mut u64, a: uint64x2_t) {
     vst1q_v2i64(ptr as *const i8, transmute(a), align_of::<u64>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.8"))]
 pub unsafe fn vst1_p8(ptr: *mut p8, a: poly8x8_t) {
     vst1_v8i8(ptr as *const i8, transmute(a), align_of::<p8>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.8"))]
 pub unsafe fn vst1q_p8(ptr: *mut p8, a: poly8x16_t) {
     vst1q_v16i8(ptr as *const i8, transmute(a), align_of::<p8>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.16"))]
 pub unsafe fn vst1_p16(ptr: *mut p16, a: poly16x4_t) {
     vst1_v4i16(ptr as *const i8, transmute(a), align_of::<p16>() as i32)
 }
 
 /// Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.16"))]
 pub unsafe fn vst1q_p16(ptr: *mut p16, a: poly16x8_t) {
     vst1q_v8i16(ptr as *const i8, transmute(a), align_of::<p8>() as i32)
 }
 
 // Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.32"))]
 pub unsafe fn vst1_f32(ptr: *mut f32, a: float32x2_t) {
     vst1_v2f32(ptr as *const i8, a, align_of::<f32>() as i32)
 }
 
 // Store multiple single-element structures from one, two, three, or four registers.
 #[inline]
 #[target_feature(enable = "neon,v7")]
-#[cfg_attr(test, assert_instr(str))]
+#[cfg_attr(test, assert_instr("vst1.32"))]
 pub unsafe fn vst1q_f32(ptr: *mut f32, a: float32x4_t) {
     vst1q_v4f32(ptr as *const i8, a, align_of::<f32>() as i32)
 }