From 2c2abdd1e674728b4b44ac72441f96bbbb4c765b Mon Sep 17 00:00:00 2001 From: Folkert de Vries Date: Thu, 6 Aug 2026 20:49:44 +0200 Subject: [PATCH 01/12] remove derives from SVE macros they projected into a scalable vector, which hits assertions --- crates/core_arch/src/aarch64/sve/mod.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/crates/core_arch/src/aarch64/sve/mod.rs b/crates/core_arch/src/aarch64/sve/mod.rs index f11ca660b1..41fd12d351 100644 --- a/crates/core_arch/src/aarch64/sve/mod.rs +++ b/crates/core_arch/src/aarch64/sve/mod.rs @@ -39,7 +39,7 @@ impl SveInto for T { macro_rules! impl_sve_type { ($(($v:vis, $elem_type:ty, $name:ident, $elt:literal))*) => ($( #[doc = concat!("Scalable vector of type ", stringify!($elem_type))] - #[derive(Clone, Copy, Debug)] + #[derive(Clone, Copy)] #[rustc_scalable_vector($elt)] #[unstable(feature = "stdarch_aarch64_sve", issue = "145052")] $v struct $name($elem_type); @@ -52,21 +52,21 @@ macro_rules! impl_sve_tuple_type { )*); (@ ($v:vis, $vec_type:ty, 2, $name:ident)) => ( #[doc = concat!("Two-element tuple of scalable vectors of type ", stringify!($vec_type))] - #[derive(Clone, Copy, Debug)] + #[derive(Clone, Copy)] #[rustc_scalable_vector] #[unstable(feature = "stdarch_aarch64_sve", issue = "145052")] $v struct $name($vec_type, $vec_type); ); (@ ($v:vis, $vec_type:ty, 3, $name:ident)) => ( #[doc = concat!("Three-element tuple of scalable vectors of type ", stringify!($vec_type))] - #[derive(Clone, Copy, Debug)] + #[derive(Clone, Copy)] #[rustc_scalable_vector] #[unstable(feature = "stdarch_aarch64_sve", issue = "145052")] $v struct $name($vec_type, $vec_type, $vec_type); ); (@ ($v:vis, $vec_type:ty, 4, $name:ident)) => ( #[doc = concat!("Four-element tuple of scalable vectors of type ", stringify!($vec_type))] - #[derive(Clone, Copy, Debug)] + #[derive(Clone, Copy)] #[rustc_scalable_vector] #[unstable(feature = "stdarch_aarch64_sve", issue = "145052")] $v struct $name($vec_type, $vec_type, $vec_type, $vec_type); From c4562820aa64a5fc5b90b379a3f8e855c1d8445c Mon Sep 17 00:00:00 2001 From: Folkert de Vries Date: Wed, 5 Aug 2026 12:29:26 +0200 Subject: [PATCH 02/12] forward rustflags to rustdoc --- ci/dox.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/ci/dox.sh b/ci/dox.sh index 9803f7e371..d65192688f 100755 --- a/ci/dox.sh +++ b/ci/dox.sh @@ -22,6 +22,7 @@ dox() { export CARGO_UNSTABLE_BUILD_STD=core # amdgpu needs a target-cpu, any is fine export RUSTFLAGS="${RUSTFLAGS} -Ctarget-cpu=gfx900" + export RUSTDOCFLAGS="${RUSTDOCFLAGS} -Ctarget-cpu=gfx900" fi cargo build --verbose --target "${1}" --manifest-path crates/core_arch/Cargo.toml From c971e0b4d73545bc0d8a130971298a754cf25f85 Mon Sep 17 00:00:00 2001 From: Adam Gemmell Date: Thu, 6 Aug 2026 14:14:00 +0100 Subject: [PATCH 03/12] Fix wasm CI --- crates/core_arch/src/wasm32/simd128.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/core_arch/src/wasm32/simd128.rs b/crates/core_arch/src/wasm32/simd128.rs index e1a3754965..b52702f44e 100644 --- a/crates/core_arch/src/wasm32/simd128.rs +++ b/crates/core_arch/src/wasm32/simd128.rs @@ -4323,7 +4323,7 @@ mod tests { let vec = i64x2_load_extend_i32x2(arr.as_ptr()); compare_bytes(vec, i64x2(-1, 1)); let vec = i64x2_load_extend_u32x2(arr.as_ptr() as *const u32); - compare_bytes(vec, i64x2(u32::max_value().into(), 1)); + compare_bytes(vec, i64x2(u32::MAX.into(), 1)); } } From f8e38a1b66093addd66a0b5010a4766570940a58 Mon Sep 17 00:00:00 2001 From: Adam Gemmell Date: Thu, 6 Aug 2026 15:25:17 +0100 Subject: [PATCH 04/12] Point wasmtime into the new build-dir layout --- ci/run.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ci/run.sh b/ci/run.sh index ea012b42f9..8c75df6afb 100755 --- a/ci/run.sh +++ b/ci/run.sh @@ -82,7 +82,7 @@ cargo_test() { else dir="debug" fi - export CARGO_TARGET_WASM32_WASIP1_RUNNER="wasmtime -Wexceptions --dir /checkout/target/wasm32-wasip1/$dir/deps::." + export CARGO_TARGET_WASM32_WASIP1_RUNNER="wasmtime -Wexceptions --dir /checkout/target/wasm32-wasip1/$dir/build::." cmd="$cmd --nocapture" ;; esac From 02538dd6261504ce6d638414c6edb5baca89e66a Mon Sep 17 00:00:00 2001 From: Adam Gemmell Date: Thu, 6 Aug 2026 16:35:15 +0100 Subject: [PATCH 05/12] Fix stdarch-test wasm disassembly for the new deps layout --- crates/stdarch-test/src/wasm.rs | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/crates/stdarch-test/src/wasm.rs b/crates/stdarch-test/src/wasm.rs index bf411c1214..feadaa1215 100644 --- a/crates/stdarch-test/src/wasm.rs +++ b/crates/stdarch-test/src/wasm.rs @@ -2,6 +2,7 @@ use crate::Function; use std::collections::HashSet; +use std::path::Path; pub(crate) fn disassemble_myself() -> HashSet { // Use `std::env::args` to find the path to our executable. Assume the @@ -11,6 +12,27 @@ pub(crate) fn disassemble_myself() -> HashSet { let me = std::env::args() .next() .expect("failed to find current wasm file"); + let me = Path::new(&me); + let me = if me.exists() { + // Old build-dir layout + me.to_path_buf() + } else { + // Cargo's build-dir layout stores an artifact named + // `-.wasm` at `//out/-.wasm`. + // The build directory is mounted as the WASI working directory, so + // reconstruct that guest-visible path from the executable name. + let file_name = me + .file_name() + .and_then(|name| name.to_str()) + .expect("current wasm file has a file name"); + let stem = file_name + .strip_suffix(".wasm") + .expect("current wasm file does not have a .wasm extension"); + let (crate_name, hash) = stem + .rsplit_once('-') + .expect("current wasm file name does not contain an artifact hash"); + Path::new(crate_name).join(hash).join("out").join(file_name) + }; let output = wasmprinter::print_file(&me).unwrap(); let mut ret: HashSet = HashSet::new(); From c9246aabbe558e912073d34e0b978b7120bd73a1 Mon Sep 17 00:00:00 2001 From: Adam Gemmell Date: Thu, 6 Aug 2026 15:44:30 +0100 Subject: [PATCH 06/12] Speculative x86_64-pc-windows-msvc fix --- crates/core_arch/src/x86/sse2.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/core_arch/src/x86/sse2.rs b/crates/core_arch/src/x86/sse2.rs index 5e8fe959c3..66ebec22e1 100644 --- a/crates/core_arch/src/x86/sse2.rs +++ b/crates/core_arch/src/x86/sse2.rs @@ -3332,7 +3332,7 @@ mod tests { core_arch::{simd::*, x86::*}, hint::black_box, }; - use std::{boxed, f32, f64, mem, ptr}; + use std::{boxed, mem, ptr}; use stdarch_test::simd_test; const NAN: f64 = f64::NAN; From 6815b0c1807d851fc25289bcb6bf7206effe957b Mon Sep 17 00:00:00 2001 From: Folkert de Vries Date: Fri, 7 Aug 2026 13:17:14 +0200 Subject: [PATCH 07/12] amdgpu doc comment fix --- crates/core_arch/src/amdgpu/mod.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/crates/core_arch/src/amdgpu/mod.rs b/crates/core_arch/src/amdgpu/mod.rs index 374f582696..264240c505 100644 --- a/crates/core_arch/src/amdgpu/mod.rs +++ b/crates/core_arch/src/amdgpu/mod.rs @@ -360,6 +360,7 @@ pub unsafe fn sched_barrier() { /// sched_group_barrier::<8, 5, 0>() /// ``` /// +#[doc(cfg(target_arch = "amdgpu"))] #[doc = include_str!("intrinsic_is_convergent.md")] #[inline] #[unstable(feature = "stdarch_amdgpu", issue = "149988")] From c988d5facffe4df0ad940944361ca0fc1d6dcabe Mon Sep 17 00:00:00 2001 From: Folkert de Vries Date: Fri, 7 Aug 2026 13:26:05 +0200 Subject: [PATCH 08/12] use doc(cfg) on some x86 types with examples --- crates/core_arch/src/x86/mod.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/crates/core_arch/src/x86/mod.rs b/crates/core_arch/src/x86/mod.rs index fbf1002eab..fb6ecd3616 100644 --- a/crates/core_arch/src/x86/mod.rs +++ b/crates/core_arch/src/x86/mod.rs @@ -40,6 +40,7 @@ types! { /// # Examples /// /// ``` + /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))] /// #[cfg(target_arch = "x86")] /// use std::arch::x86::*; /// #[cfg(target_arch = "x86_64")] @@ -56,6 +57,7 @@ types! { /// # if is_x86_feature_detected!("sse2") { unsafe { foo() } } /// # } /// ``` + #[doc(cfg(any(target_arch = "x86", target_arch = "x86_64")))] pub struct __m128i(2 x i64); /// 128-bit wide set of four `f32` types, x86-specific @@ -83,6 +85,7 @@ types! { /// # Examples /// /// ``` + /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))] /// #[cfg(target_arch = "x86")] /// use std::arch::x86::*; /// #[cfg(target_arch = "x86_64")] @@ -99,6 +102,7 @@ types! { /// # if is_x86_feature_detected!("sse") { unsafe { foo() } } /// # } /// ``` + #[doc(cfg(any(target_arch = "x86", target_arch = "x86_64")))] pub struct __m128(4 x f32); /// 128-bit wide set of two `f64` types, x86-specific @@ -126,6 +130,7 @@ types! { /// # Examples /// /// ``` + /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))] /// #[cfg(target_arch = "x86")] /// use std::arch::x86::*; /// #[cfg(target_arch = "x86_64")] @@ -142,6 +147,7 @@ types! { /// # if is_x86_feature_detected!("sse2") { unsafe { foo() } } /// # } /// ``` + #[doc(cfg(any(target_arch = "x86", target_arch = "x86_64")))] pub struct __m128d(2 x f64); /// 256-bit wide integer vector type, x86-specific @@ -173,6 +179,7 @@ types! { /// # Examples /// /// ``` + /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))] /// #[cfg(target_arch = "x86")] /// use std::arch::x86::*; /// #[cfg(target_arch = "x86_64")] @@ -189,6 +196,7 @@ types! { /// # if is_x86_feature_detected!("avx") { unsafe { foo() } } /// # } /// ``` + #[doc(cfg(any(target_arch = "x86", target_arch = "x86_64")))] pub struct __m256i(4 x i64); /// 256-bit wide set of eight `f32` types, x86-specific @@ -216,6 +224,7 @@ types! { /// # Examples /// /// ``` + /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))] /// #[cfg(target_arch = "x86")] /// use std::arch::x86::*; /// #[cfg(target_arch = "x86_64")] @@ -232,6 +241,7 @@ types! { /// # if is_x86_feature_detected!("avx") { unsafe { foo() } } /// # } /// ``` + #[doc(cfg(any(target_arch = "x86", target_arch = "x86_64")))] pub struct __m256(8 x f32); /// 256-bit wide set of four `f64` types, x86-specific @@ -259,6 +269,7 @@ types! { /// # Examples /// /// ``` + /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))] /// #[cfg(target_arch = "x86")] /// use std::arch::x86::*; /// #[cfg(target_arch = "x86_64")] @@ -275,6 +286,7 @@ types! { /// # if is_x86_feature_detected!("avx") { unsafe { foo() } } /// # } /// ``` + #[doc(cfg(any(target_arch = "x86", target_arch = "x86_64")))] pub struct __m256d(4 x f64); } From 4ecc87b20c52444b78f7209c4682059dcb52b653 Mon Sep 17 00:00:00 2001 From: Folkert de Vries Date: Sun, 9 Aug 2026 14:08:59 +0200 Subject: [PATCH 09/12] ignore example code blocks on nvptx and amdgpu --- crates/core_arch/src/amdgpu/mod.rs | 8 ++++---- crates/core_arch/src/nvptx/mod.rs | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/crates/core_arch/src/amdgpu/mod.rs b/crates/core_arch/src/amdgpu/mod.rs index 264240c505..856fb840aa 100644 --- a/crates/core_arch/src/amdgpu/mod.rs +++ b/crates/core_arch/src/amdgpu/mod.rs @@ -351,13 +351,13 @@ pub unsafe fn sched_barrier() { /// Combining multiple `sched_group_barrier` intrinsics enables an ordering of specific instruction types during instruction scheduling. /// For example, the following enforces a sequence of 1 VMEM read, followed by 1 VALU instruction, followed by 5 MFMA instructions. /// -/// ```rust +/// ```ignore /// // 1 VMEM read -/// sched_group_barrier::<32, 1, 0>() +/// sched_group_barrier::<32, 1, 0>(); /// // 1 VALU -/// sched_group_barrier::<2, 1, 0>() +/// sched_group_barrier::<2, 1, 0>(); /// // 5 MFMA -/// sched_group_barrier::<8, 5, 0>() +/// sched_group_barrier::<8, 5, 0>(); /// ``` /// #[doc(cfg(target_arch = "amdgpu"))] diff --git a/crates/core_arch/src/nvptx/mod.rs b/crates/core_arch/src/nvptx/mod.rs index d22f3a25bf..df682b6c6e 100644 --- a/crates/core_arch/src/nvptx/mod.rs +++ b/crates/core_arch/src/nvptx/mod.rs @@ -157,7 +157,7 @@ unsafe extern "C" { /// * `format`: A pointer to the format specifier input (uses common `printf` format). /// * `valist`: A pointer to the valist input. /// - /// ``` + /// ```ignore /// #[repr(C)] /// struct PrintArgs(f32, f32, f32, i32); /// From 3a9ad23e2935d320535ac56fa33a704db79054ea Mon Sep 17 00:00:00 2001 From: Folkert de Vries Date: Sun, 9 Aug 2026 14:14:13 +0200 Subject: [PATCH 10/12] use cfg to only compile/run x86 examples on x86 --- crates/core_arch/src/x86/mod.rs | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/crates/core_arch/src/x86/mod.rs b/crates/core_arch/src/x86/mod.rs index fb6ecd3616..e6875a628f 100644 --- a/crates/core_arch/src/x86/mod.rs +++ b/crates/core_arch/src/x86/mod.rs @@ -40,13 +40,12 @@ types! { /// # Examples /// /// ``` - /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))] + /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] { /// #[cfg(target_arch = "x86")] /// use std::arch::x86::*; /// #[cfg(target_arch = "x86_64")] /// use std::arch::x86_64::*; /// - /// # fn main() { /// # #[target_feature(enable = "sse2")] /// # #[allow(unused_unsafe)] // temporary, to unstick CI /// # unsafe fn foo() { unsafe { @@ -85,13 +84,12 @@ types! { /// # Examples /// /// ``` - /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))] + /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] { /// #[cfg(target_arch = "x86")] /// use std::arch::x86::*; /// #[cfg(target_arch = "x86_64")] /// use std::arch::x86_64::*; /// - /// # fn main() { /// # #[target_feature(enable = "sse")] /// # #[allow(unused_unsafe)] // temporary, to unstick CI /// # unsafe fn foo() { unsafe { @@ -130,13 +128,12 @@ types! { /// # Examples /// /// ``` - /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))] + /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] { /// #[cfg(target_arch = "x86")] /// use std::arch::x86::*; /// #[cfg(target_arch = "x86_64")] /// use std::arch::x86_64::*; /// - /// # fn main() { /// # #[target_feature(enable = "sse2")] /// # #[allow(unused_unsafe)] // temporary, to unstick CI /// # unsafe fn foo() { unsafe { @@ -179,13 +176,12 @@ types! { /// # Examples /// /// ``` - /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))] + /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] { /// #[cfg(target_arch = "x86")] /// use std::arch::x86::*; /// #[cfg(target_arch = "x86_64")] /// use std::arch::x86_64::*; /// - /// # fn main() { /// # #[target_feature(enable = "avx")] /// # #[allow(unused_unsafe)] // temporary, to unstick CI /// # unsafe fn foo() { unsafe { @@ -224,13 +220,12 @@ types! { /// # Examples /// /// ``` - /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))] + /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] { /// #[cfg(target_arch = "x86")] /// use std::arch::x86::*; /// #[cfg(target_arch = "x86_64")] /// use std::arch::x86_64::*; /// - /// # fn main() { /// # #[target_feature(enable = "avx")] /// # #[allow(unused_unsafe)] // temporary, to unstick CI /// # unsafe fn foo() { unsafe { @@ -269,13 +264,12 @@ types! { /// # Examples /// /// ``` - /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))] + /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] { /// #[cfg(target_arch = "x86")] /// use std::arch::x86::*; /// #[cfg(target_arch = "x86_64")] /// use std::arch::x86_64::*; /// - /// # fn main() { /// # #[target_feature(enable = "avx")] /// # #[allow(unused_unsafe)] // temporary, to unstick CI /// # unsafe fn foo() { unsafe { From 7126cc5bb6b79146ad21ba19447f7347bb15c70b Mon Sep 17 00:00:00 2001 From: Folkert de Vries Date: Sun, 9 Aug 2026 14:37:17 +0200 Subject: [PATCH 11/12] update aarch64/arm64ec assembly tests I believe this is effectively equivalent, just a different spelling of the same semantics --- .../src/arm_shared/neon/generated.rs | 216 ++++++++++++++---- .../spec/neon/arm_shared.spec.yml | 51 +++-- 2 files changed, 200 insertions(+), 67 deletions(-) diff --git a/crates/core_arch/src/arm_shared/neon/generated.rs b/crates/core_arch/src/arm_shared/neon/generated.rs index b3715308c9..a2717459b8 100644 --- a/crates/core_arch/src/arm_shared/neon/generated.rs +++ b/crates/core_arch/src/arm_shared/neon/generated.rs @@ -15285,11 +15285,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15307,11 +15312,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15333,11 +15343,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15355,11 +15370,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15381,11 +15401,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15403,11 +15428,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15430,11 +15460,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15452,11 +15487,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15478,11 +15518,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15500,11 +15545,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15526,11 +15576,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15548,11 +15603,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15575,11 +15635,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15597,11 +15662,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15623,11 +15693,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15645,11 +15720,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15671,11 +15751,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15693,11 +15778,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15720,11 +15810,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15742,11 +15837,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15767,11 +15867,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15789,11 +15894,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15814,11 +15924,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") @@ -15836,11 +15951,16 @@ 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"), + 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( not(target_arch = "arm"), stable(feature = "neon_intrinsics", since = "1.59.0") diff --git a/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml b/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml index 7473742a96..f46c24cd8b 100644 --- a/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml +++ b/crates/stdarch-gen-arm/spec/neon/arm_shared.spec.yml @@ -55,6 +55,15 @@ not-arm: ¬-arm 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"']] + +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"']] + # #[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 +15085,20 @@ intrinsics: 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']]}]] - *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 +15124,26 @@ intrinsics: 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']]}]] - *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]'] - compose: - - FnCall: ['simd_shuffle!', [a, a, '{type[5]}']] + - ['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[3]}']] - name: "{type[0]}" doc: "Duplicate vector element to vector or scalar" From d18ecee09915dcfe7f5e68e40c439f613e808561 Mon Sep 17 00:00:00 2001 From: Folkert de Vries Date: Sun, 9 Aug 2026 14:56:33 +0200 Subject: [PATCH 12/12] do not fail fast --- .github/workflows/main.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index b5b45f5f0d..a91622f612 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -40,6 +40,7 @@ jobs: name: Test runs-on: ${{ matrix.target.os }} strategy: + fail-fast: false matrix: profile: - dev