Google GitGoogle Git
Sign in
rust/rust/b4ea05ef36b845f06f805ffffdfa1322a60c8505^!/.
commit
b4ea05ef36b845f06f805ffffdfa1322a60c8505
[log]
author
Folkert de Vries <folkert@folkertdev.nl>
Sun Aug 09 14:37:17 2026 +0200
committer
Folkert de Vries <folkert@folkertdev.nl>
Wed Aug 12 00:10:47 2026 +0200
tree
26afe4dd9ab7ad13911a5f08d6a24ae41dac46a3
parent
1745a93a864b371ab1e31317eb54a912de2b0fb6 [diff]
update aarch64/arm64ec assembly tests

I believe this is effectively equivalent, just a different spelling of the same semantics

diff --git a/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs b/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
index b371530..3a47ede 100644
--- a/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs
+++ b/library/stdarch/crates/core_arch/src/arm_shared/neon/generated.rs

@@ -15285,11 +15285,17 @@ pub fn vget_low_f16(a: float16x8_t) -> float16x4_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15307,11 +15313,17 @@ pub fn vget_high_f32(a: float32x4_t) -> float32x2_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15333,11 +15345,17 @@ pub fn vget_high_f32(a: float32x4_t) -> float32x2_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15355,11 +15373,17 @@ pub fn vget_high_p16(a: poly16x8_t) -> poly16x4_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15381,11 +15405,17 @@ pub fn vget_high_p16(a: poly16x8_t) -> poly16x4_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15403,11 +15433,17 @@ pub fn vget_high_p8(a: poly8x16_t) -> poly8x8_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15430,11 +15466,17 @@ pub fn vget_high_p8(a: poly8x16_t) -> poly8x8_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15452,11 +15494,17 @@ pub fn vget_high_s16(a: int16x8_t) -> int16x4_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15478,11 +15526,17 @@ pub fn vget_high_s16(a: int16x8_t) -> int16x4_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15500,11 +15554,17 @@ pub fn vget_high_s32(a: int32x4_t) -> int32x2_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15526,11 +15586,17 @@ pub fn vget_high_s32(a: int32x4_t) -> int32x2_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15548,11 +15614,17 @@ pub fn vget_high_s8(a: int8x16_t) -> int8x8_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15575,11 +15647,17 @@ pub fn vget_high_s8(a: int8x16_t) -> int8x8_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15597,11 +15675,17 @@ pub fn vget_high_u16(a: uint16x8_t) -> uint16x4_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15623,11 +15707,17 @@ pub fn vget_high_u16(a: uint16x8_t) -> uint16x4_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15645,11 +15735,17 @@ pub fn vget_high_u32(a: uint32x4_t) -> uint32x2_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15671,11 +15767,17 @@ pub fn vget_high_u32(a: uint32x4_t) -> uint32x2_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15693,11 +15795,17 @@ pub fn vget_high_u8(a: uint8x16_t) -> uint8x8_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15720,11 +15828,17 @@ pub fn vget_high_u8(a: uint8x16_t) -> uint8x8_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15742,11 +15856,17 @@ pub fn vget_high_p64(a: poly64x2_t) -> poly64x1_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15767,11 +15887,17 @@ pub fn vget_high_p64(a: poly64x2_t) -> poly64x1_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15789,11 +15915,17 @@ pub fn vget_high_s64(a: int64x2_t) -> int64x1_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15814,11 +15946,17 @@ pub fn vget_high_s64(a: int64x2_t) -> int64x1_t {
 #[cfg(target_endian = "little")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")
@@ -15836,11 +15974,17 @@ pub fn vget_high_u64(a: uint64x2_t) -> uint64x1_t {
 #[cfg(target_endian = "big")]
 #[target_feature(enable = "neon")]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "v7"))]
-#[cfg_attr(all(test, target_arch = "arm"), assert_instr("vmov"))]
+#[cfg_attr(all(test, target_arch = "arm"), assert_instr(vmov))]
 #[cfg_attr(
-    all(test, any(target_arch = "aarch64", target_arch = "arm64ec")),
+    all(test, target_arch = "aarch64", target_endian = "little", not(windows)),
+    assert_instr(mov)
+)]
+#[cfg_attr(
+    all(test, target_arch = "aarch64", target_endian = "big"),
     assert_instr(ext)
 )]
+#[cfg_attr(all(test, target_arch = "arm64ec"), assert_instr(dup))]
+#[cfg_attr(all(test, target_arch = "aarch64", windows), assert_instr(dup))]
 #[cfg_attr(
     not(target_arch = "arm"),
     stable(feature = "neon_intrinsics", since = "1.59.0")

diff --git a/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml b/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
index 7473742..7a7656e 100644
--- a/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml
+++ b/library/stdarch/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml

@@ -55,6 +55,18 @@
 neon-target-aarch64-arm64ec: &neon-target-aarch64-arm64ec
   FnCall: [all, [test, {FnCall: [any, ['target_arch = "aarch64"', 'target_arch = "arm64ec"']]}]]
 
+neon-target-aarch64-le: &neon-target-aarch64-le
+  FnCall: [all, [test, 'target_arch = "aarch64"', 'target_endian = "little"', {FnCall: [not, [windows]]}]]
+
+neon-target-aarch64-be: &neon-target-aarch64-be
+  FnCall: [all, [test, 'target_arch = "aarch64"', 'target_endian = "big"']]
+
+neon-target-arm64ec: &neon-target-arm64ec
+  FnCall: [all, [test, 'target_arch = "arm64ec"']]
+
+neon-target-aarch64-windows: &neon-target-aarch64-windows
+  FnCall: [all, [test, 'target_arch = "aarch64"', windows]]
+
 # #[cfg_attr(not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0"))]
 neon-not-arm-stable: &neon-not-arm-stable
   FnCall: [cfg_attr, [{ FnCall: [not, ['target_arch = "arm"']]}, {FnCall: [stable, ['feature = "neon_intrinsics"', 'since = "1.59.0"']]}]]
@@ -15076,18 +15088,21 @@
     return_type: "{neon_type[2]}"
     attr:
       - *neon-v7
-      - FnCall: [cfg_attr, [*test-is-arm, { FnCall: [assert_instr, ['"{type[3]}"']]}]]
-      - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, ['{type[4]}']]}]]
+      - FnCall: [cfg_attr, [*test-is-arm, { FnCall: [assert_instr, ['vmov']]}]]
+      - FnCall: [cfg_attr, [*neon-target-aarch64-le, {FnCall: [assert_instr, ['mov']]}]]
+      - FnCall: [cfg_attr, [*neon-target-aarch64-be, {FnCall: [assert_instr, ['ext']]}]]
+      - FnCall: [cfg_attr, [*neon-target-arm64ec, {FnCall: [assert_instr, ['dup']]}]]
+      - FnCall: [cfg_attr, [*neon-target-aarch64-windows, {FnCall: [assert_instr, ['dup']]}]]
       - *neon-not-arm-stable
       - *neon-cfg-arm-unstable
     safety: safe
     big_endian_inverse: true
     types:
-      - ['vget_high_s64', 'int64x2_t',   'int64x1_t',   'vmov', 'ext',  'int64x1_t([simd_extract!(a, 1)])']
-      - ['vget_high_u64', 'uint64x2_t',  'uint64x1_t',  'vmov', 'ext',  'uint64x1_t([simd_extract!(a, 1)])']
-      - ['vget_high_p64', 'poly64x2_t',  'poly64x1_t',  'vmov', 'ext',  'transmute(u64x1::new(simd_extract!(a, 1)))']
+      - ['vget_high_s64', 'int64x2_t',   'int64x1_t', 'int64x1_t([simd_extract!(a, 1)])']
+      - ['vget_high_u64', 'uint64x2_t',  'uint64x1_t', 'uint64x1_t([simd_extract!(a, 1)])']
+      - ['vget_high_p64', 'poly64x2_t',  'poly64x1_t', 'transmute(u64x1::new(simd_extract!(a, 1)))']
     compose:
-      - Identifier: ['{type[5]}', UnsafeSymbol]
+      - Identifier: ['{type[3]}', UnsafeSymbol]
 
   - name: "{type[0]}"
     doc: "Duplicate vector element to vector or scalar"
@@ -15113,24 +15128,27 @@
     return_type: "{neon_type[2]}"
     attr:
       - *neon-v7
-      - FnCall: [cfg_attr, [*test-is-arm, { FnCall: [assert_instr, ['"{type[3]}"']]}]]
-      - FnCall: [cfg_attr, [*neon-target-aarch64-arm64ec, {FnCall: [assert_instr, ['{type[4]}']]}]]
+      - FnCall: [cfg_attr, [*test-is-arm, { FnCall: [assert_instr, ['vmov']]}]]
+      - FnCall: [cfg_attr, [*neon-target-aarch64-le, {FnCall: [assert_instr, ['mov']]}]]
+      - FnCall: [cfg_attr, [*neon-target-aarch64-be, {FnCall: [assert_instr, ['ext']]}]]
+      - FnCall: [cfg_attr, [*neon-target-arm64ec, {FnCall: [assert_instr, ['dup']]}]]
+      - FnCall: [cfg_attr, [*neon-target-aarch64-windows, {FnCall: [assert_instr, ['dup']]}]]
       - *neon-not-arm-stable
       - *neon-cfg-arm-unstable
     safety: safe
     big_endian_inverse: true
     types:
-      - ['vget_high_s8', 'int8x16_t', 'int8x8_t', 'vmov', 'ext', '[8, 9, 10, 11, 12, 13, 14, 15]']
-      - ['vget_high_u8', 'uint8x16_t', 'uint8x8_t', 'vmov', 'ext', '[8, 9, 10, 11, 12, 13, 14, 15]']
-      - ['vget_high_p8', 'poly8x16_t', 'poly8x8_t', 'vmov', 'ext', '[8, 9, 10, 11, 12, 13, 14, 15]']
-      - ['vget_high_s16', 'int16x8_t', 'int16x4_t', 'vmov', 'ext', '[4, 5, 6, 7]']
-      - ['vget_high_u16', 'uint16x8_t', 'uint16x4_t', 'vmov', 'ext', '[4, 5, 6, 7]']
-      - ['vget_high_p16', 'poly16x8_t', 'poly16x4_t', 'vmov', 'ext', '[4, 5, 6, 7]']
-      - ['vget_high_s32', 'int32x4_t', 'int32x2_t', 'vmov', 'ext', '[2, 3]']
-      - ['vget_high_u32', 'uint32x4_t', 'uint32x2_t', 'vmov', 'ext', '[2, 3]']
-      - ['vget_high_f32', 'float32x4_t', 'float32x2_t', 'vmov', 'ext', '[2, 3]']
+      - ['vget_high_s8', 'int8x16_t', 'int8x8_t', '[8, 9, 10, 11, 12, 13, 14, 15]']
+      - ['vget_high_u8', 'uint8x16_t', 'uint8x8_t', '[8, 9, 10, 11, 12, 13, 14, 15]']
+      - ['vget_high_p8', 'poly8x16_t', 'poly8x8_t', '[8, 9, 10, 11, 12, 13, 14, 15]']
+      - ['vget_high_s16', 'int16x8_t', 'int16x4_t', '[4, 5, 6, 7]']
+      - ['vget_high_u16', 'uint16x8_t', 'uint16x4_t', '[4, 5, 6, 7]']
+      - ['vget_high_p16', 'poly16x8_t', 'poly16x4_t', '[4, 5, 6, 7]']
+      - ['vget_high_s32', 'int32x4_t', 'int32x2_t', '[2, 3]']
+      - ['vget_high_u32', 'uint32x4_t', 'uint32x2_t', '[2, 3]']
+      - ['vget_high_f32', 'float32x4_t', 'float32x2_t', '[2, 3]']
     compose:
-      - FnCall: ['simd_shuffle!', [a, a, '{type[5]}']]
+      - FnCall: ['simd_shuffle!', [a, a, '{type[3]}']]
 
   - name: "{type[0]}"
     doc: "Duplicate vector element to vector or scalar"