1// This code is automatically generated. DO NOT MODIFY.2//3// Instead, modify `crates/stdarch-gen-arm/spec/sve` and run the following command to re-generate4// this file:5//6// ```7// cargo run --bin=stdarch-gen-arm -- crates/stdarch-gen-arm/spec8// ```9#![allow(unused)]10use super::*;11use std::boxed::Box;12use std::convert::{TryFrom, TryInto};13use std::sync::LazyLock;14use std::vec::Vec;15use stdarch_test::simd_test;16static F32_DATA: LazyLock<[f32; 64 * 5]> = LazyLock::new(|| {17    (0..64 * 5)18        .map(|i| i as f32)19        .collect::<Vec<_>>()20        .try_into()21        .expect("f32 data incorrectly initialised")22});23static F64_DATA: LazyLock<[f64; 32 * 5]> = LazyLock::new(|| {24    (0..32 * 5)25        .map(|i| i as f64)26        .collect::<Vec<_>>()27        .try_into()28        .expect("f64 data incorrectly initialised")29});30static I8_DATA: LazyLock<[i8; 256 * 5]> = LazyLock::new(|| {31    (0..256 * 5)32        .map(|i| ((i + 128) % 256 - 128) as i8)33        .collect::<Vec<_>>()34        .try_into()35        .expect("i8 data incorrectly initialised")36});37static I16_DATA: LazyLock<[i16; 128 * 5]> = LazyLock::new(|| {38    (0..128 * 5)39        .map(|i| i as i16)40        .collect::<Vec<_>>()41        .try_into()42        .expect("i16 data incorrectly initialised")43});44static I32_DATA: LazyLock<[i32; 64 * 5]> = LazyLock::new(|| {45    (0..64 * 5)46        .map(|i| i as i32)47        .collect::<Vec<_>>()48        .try_into()49        .expect("i32 data incorrectly initialised")50});51static I64_DATA: LazyLock<[i64; 32 * 5]> = LazyLock::new(|| {52    (0..32 * 5)53        .map(|i| i as i64)54        .collect::<Vec<_>>()55        .try_into()56        .expect("i64 data incorrectly initialised")57});58static U8_DATA: LazyLock<[u8; 256 * 5]> = LazyLock::new(|| {59    (0..256 * 5)60        .map(|i| i as u8)61        .collect::<Vec<_>>()62        .try_into()63        .expect("u8 data incorrectly initialised")64});65static U16_DATA: LazyLock<[u16; 128 * 5]> = LazyLock::new(|| {66    (0..128 * 5)67        .map(|i| i as u16)68        .collect::<Vec<_>>()69        .try_into()70        .expect("u16 data incorrectly initialised")71});72static U32_DATA: LazyLock<[u32; 64 * 5]> = LazyLock::new(|| {73    (0..64 * 5)74        .map(|i| i as u32)75        .collect::<Vec<_>>()76        .try_into()77        .expect("u32 data incorrectly initialised")78});79static U64_DATA: LazyLock<[u64; 32 * 5]> = LazyLock::new(|| {80    (0..32 * 5)81        .map(|i| i as u64)82        .collect::<Vec<_>>()83        .try_into()84        .expect("u64 data incorrectly initialised")85});86#[target_feature(enable = "sve")]87fn assert_vector_matches_f32(vector: svfloat32_t, expected: svfloat32_t, defined: svbool_t) {88    assert!(svptest_first(svptrue_b32(), defined));89    let cmp = svcmpne_f32(defined, vector, expected);90    assert!(!svptest_any(defined, cmp))91}92#[target_feature(enable = "sve")]93fn assert_vector_matches_f64(vector: svfloat64_t, expected: svfloat64_t, defined: svbool_t) {94    assert!(svptest_first(svptrue_b64(), defined));95    let cmp = svcmpne_f64(defined, vector, expected);96    assert!(!svptest_any(defined, cmp))97}98#[target_feature(enable = "sve")]99fn assert_vector_matches_i8(vector: svint8_t, expected: svint8_t, defined: svbool_t) {100    assert!(svptest_first(svptrue_b8(), defined));101    let cmp = svcmpne_s8(defined, vector, expected);102    assert!(!svptest_any(defined, cmp))103}104#[target_feature(enable = "sve")]105fn assert_vector_matches_i16(vector: svint16_t, expected: svint16_t, defined: svbool_t) {106    assert!(svptest_first(svptrue_b16(), defined));107    let cmp = svcmpne_s16(defined, vector, expected);108    assert!(!svptest_any(defined, cmp))109}110#[target_feature(enable = "sve")]111fn assert_vector_matches_i32(vector: svint32_t, expected: svint32_t, defined: svbool_t) {112    assert!(svptest_first(svptrue_b32(), defined));113    let cmp = svcmpne_s32(defined, vector, expected);114    assert!(!svptest_any(defined, cmp))115}116#[target_feature(enable = "sve")]117fn assert_vector_matches_i64(vector: svint64_t, expected: svint64_t, defined: svbool_t) {118    assert!(svptest_first(svptrue_b64(), defined));119    let cmp = svcmpne_s64(defined, vector, expected);120    assert!(!svptest_any(defined, cmp))121}122#[target_feature(enable = "sve")]123fn assert_vector_matches_u8(vector: svuint8_t, expected: svuint8_t, defined: svbool_t) {124    assert!(svptest_first(svptrue_b8(), defined));125    let cmp = svcmpne_u8(defined, vector, expected);126    assert!(!svptest_any(defined, cmp))127}128#[target_feature(enable = "sve")]129fn assert_vector_matches_u16(vector: svuint16_t, expected: svuint16_t, defined: svbool_t) {130    assert!(svptest_first(svptrue_b16(), defined));131    let cmp = svcmpne_u16(defined, vector, expected);132    assert!(!svptest_any(defined, cmp))133}134#[target_feature(enable = "sve")]135fn assert_vector_matches_u32(vector: svuint32_t, expected: svuint32_t, defined: svbool_t) {136    assert!(svptest_first(svptrue_b32(), defined));137    let cmp = svcmpne_u32(defined, vector, expected);138    assert!(!svptest_any(defined, cmp))139}140#[target_feature(enable = "sve")]141fn assert_vector_matches_u64(vector: svuint64_t, expected: svuint64_t, defined: svbool_t) {142    assert!(svptest_first(svptrue_b64(), defined));143    let cmp = svcmpne_u64(defined, vector, expected);144    assert!(!svptest_any(defined, cmp))145}146#[simd_test(enable = "sve")]147unsafe fn test_svld1_f32_with_svst1_f32() {148    let mut storage = [0 as f32; 320usize];149    let data = svcvt_f32_s32_x(150        svptrue_b32(),151        svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),152    );153    svst1_f32(svptrue_b32(), storage.as_mut_ptr(), data);154    for (i, &val) in storage.iter().enumerate() {155        assert!(val == 0 as f32 || val == i as f32);156    }157    svsetffr();158    let loaded = svld1_f32(svptrue_b32(), storage.as_ptr() as *const f32);159    let defined = svrdffr();160    assert_vector_matches_f32(161        loaded,162        svcvt_f32_s32_x(163            svptrue_b32(),164            svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),165        ),166        defined,167    );168}169#[simd_test(enable = "sve")]170unsafe fn test_svld1_f64_with_svst1_f64() {171    let mut storage = [0 as f64; 160usize];172    let data = svcvt_f64_s64_x(173        svptrue_b64(),174        svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),175    );176    svst1_f64(svptrue_b64(), storage.as_mut_ptr(), data);177    for (i, &val) in storage.iter().enumerate() {178        assert!(val == 0 as f64 || val == i as f64);179    }180    svsetffr();181    let loaded = svld1_f64(svptrue_b64(), storage.as_ptr() as *const f64);182    let defined = svrdffr();183    assert_vector_matches_f64(184        loaded,185        svcvt_f64_s64_x(186            svptrue_b64(),187            svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),188        ),189        defined,190    );191}192#[simd_test(enable = "sve")]193unsafe fn test_svld1_s8_with_svst1_s8() {194    let mut storage = [0 as i8; 1280usize];195    let data = svindex_s8((0usize).try_into().unwrap(), 1usize.try_into().unwrap());196    svst1_s8(svptrue_b8(), storage.as_mut_ptr(), data);197    for (i, &val) in storage.iter().enumerate() {198        assert!(val == 0 as i8 || val == i as i8);199    }200    svsetffr();201    let loaded = svld1_s8(svptrue_b8(), storage.as_ptr() as *const i8);202    let defined = svrdffr();203    assert_vector_matches_i8(204        loaded,205        svindex_s8((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),206        defined,207    );208}209#[simd_test(enable = "sve")]210unsafe fn test_svld1_s16_with_svst1_s16() {211    let mut storage = [0 as i16; 640usize];212    let data = svindex_s16((0usize).try_into().unwrap(), 1usize.try_into().unwrap());213    svst1_s16(svptrue_b16(), storage.as_mut_ptr(), data);214    for (i, &val) in storage.iter().enumerate() {215        assert!(val == 0 as i16 || val == i as i16);216    }217    svsetffr();218    let loaded = svld1_s16(svptrue_b16(), storage.as_ptr() as *const i16);219    let defined = svrdffr();220    assert_vector_matches_i16(221        loaded,222        svindex_s16((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),223        defined,224    );225}226#[simd_test(enable = "sve")]227unsafe fn test_svld1_s32_with_svst1_s32() {228    let mut storage = [0 as i32; 320usize];229    let data = svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap());230    svst1_s32(svptrue_b32(), storage.as_mut_ptr(), data);231    for (i, &val) in storage.iter().enumerate() {232        assert!(val == 0 as i32 || val == i as i32);233    }234    svsetffr();235    let loaded = svld1_s32(svptrue_b32(), storage.as_ptr() as *const i32);236    let defined = svrdffr();237    assert_vector_matches_i32(238        loaded,239        svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),240        defined,241    );242}243#[simd_test(enable = "sve")]244unsafe fn test_svld1_s64_with_svst1_s64() {245    let mut storage = [0 as i64; 160usize];246    let data = svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());247    svst1_s64(svptrue_b64(), storage.as_mut_ptr(), data);248    for (i, &val) in storage.iter().enumerate() {249        assert!(val == 0 as i64 || val == i as i64);250    }251    svsetffr();252    let loaded = svld1_s64(svptrue_b64(), storage.as_ptr() as *const i64);253    let defined = svrdffr();254    assert_vector_matches_i64(255        loaded,256        svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),257        defined,258    );259}260#[simd_test(enable = "sve")]261unsafe fn test_svld1_u8_with_svst1_u8() {262    let mut storage = [0 as u8; 1280usize];263    let data = svindex_u8((0usize).try_into().unwrap(), 1usize.try_into().unwrap());264    svst1_u8(svptrue_b8(), storage.as_mut_ptr(), data);265    for (i, &val) in storage.iter().enumerate() {266        assert!(val == 0 as u8 || val == i as u8);267    }268    svsetffr();269    let loaded = svld1_u8(svptrue_b8(), storage.as_ptr() as *const u8);270    let defined = svrdffr();271    assert_vector_matches_u8(272        loaded,273        svindex_u8((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),274        defined,275    );276}277#[simd_test(enable = "sve")]278unsafe fn test_svld1_u16_with_svst1_u16() {279    let mut storage = [0 as u16; 640usize];280    let data = svindex_u16((0usize).try_into().unwrap(), 1usize.try_into().unwrap());281    svst1_u16(svptrue_b16(), storage.as_mut_ptr(), data);282    for (i, &val) in storage.iter().enumerate() {283        assert!(val == 0 as u16 || val == i as u16);284    }285    svsetffr();286    let loaded = svld1_u16(svptrue_b16(), storage.as_ptr() as *const u16);287    let defined = svrdffr();288    assert_vector_matches_u16(289        loaded,290        svindex_u16((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),291        defined,292    );293}294#[simd_test(enable = "sve")]295unsafe fn test_svld1_u32_with_svst1_u32() {296    let mut storage = [0 as u32; 320usize];297    let data = svindex_u32((0usize).try_into().unwrap(), 1usize.try_into().unwrap());298    svst1_u32(svptrue_b32(), storage.as_mut_ptr(), data);299    for (i, &val) in storage.iter().enumerate() {300        assert!(val == 0 as u32 || val == i as u32);301    }302    svsetffr();303    let loaded = svld1_u32(svptrue_b32(), storage.as_ptr() as *const u32);304    let defined = svrdffr();305    assert_vector_matches_u32(306        loaded,307        svindex_u32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),308        defined,309    );310}311#[simd_test(enable = "sve")]312unsafe fn test_svld1_u64_with_svst1_u64() {313    let mut storage = [0 as u64; 160usize];314    let data = svindex_u64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());315    svst1_u64(svptrue_b64(), storage.as_mut_ptr(), data);316    for (i, &val) in storage.iter().enumerate() {317        assert!(val == 0 as u64 || val == i as u64);318    }319    svsetffr();320    let loaded = svld1_u64(svptrue_b64(), storage.as_ptr() as *const u64);321    let defined = svrdffr();322    assert_vector_matches_u64(323        loaded,324        svindex_u64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),325        defined,326    );327}328#[simd_test(enable = "sve")]329unsafe fn test_svld1_gather_s32index_f32_with_svst1_scatter_s32index_f32() {330    let mut storage = [0 as f32; 320usize];331    let data = svcvt_f32_s32_x(332        svptrue_b32(),333        svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),334    );335    let indices = svindex_s32(0, 1);336    svst1_scatter_s32index_f32(svptrue_b32(), storage.as_mut_ptr(), indices, data);337    for (i, &val) in storage.iter().enumerate() {338        assert!(val == 0 as f32 || val == i as f32);339    }340    svsetffr();341    let loaded = svld1_gather_s32index_f32(svptrue_b32(), storage.as_ptr() as *const f32, indices);342    let defined = svrdffr();343    assert_vector_matches_f32(344        loaded,345        svcvt_f32_s32_x(346            svptrue_b32(),347            svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),348        ),349        defined,350    );351}352#[simd_test(enable = "sve")]353unsafe fn test_svld1_gather_s32index_s32_with_svst1_scatter_s32index_s32() {354    let mut storage = [0 as i32; 320usize];355    let data = svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap());356    let indices = svindex_s32(0, 1);357    svst1_scatter_s32index_s32(svptrue_b32(), storage.as_mut_ptr(), indices, data);358    for (i, &val) in storage.iter().enumerate() {359        assert!(val == 0 as i32 || val == i as i32);360    }361    svsetffr();362    let loaded = svld1_gather_s32index_s32(svptrue_b32(), storage.as_ptr() as *const i32, indices);363    let defined = svrdffr();364    assert_vector_matches_i32(365        loaded,366        svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),367        defined,368    );369}370#[simd_test(enable = "sve")]371unsafe fn test_svld1_gather_s32index_u32_with_svst1_scatter_s32index_u32() {372    let mut storage = [0 as u32; 320usize];373    let data = svindex_u32((0usize).try_into().unwrap(), 1usize.try_into().unwrap());374    let indices = svindex_s32(0, 1);375    svst1_scatter_s32index_u32(svptrue_b32(), storage.as_mut_ptr(), indices, data);376    for (i, &val) in storage.iter().enumerate() {377        assert!(val == 0 as u32 || val == i as u32);378    }379    svsetffr();380    let loaded = svld1_gather_s32index_u32(svptrue_b32(), storage.as_ptr() as *const u32, indices);381    let defined = svrdffr();382    assert_vector_matches_u32(383        loaded,384        svindex_u32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),385        defined,386    );387}388#[simd_test(enable = "sve")]389unsafe fn test_svld1_gather_s64index_f64_with_svst1_scatter_s64index_f64() {390    let mut storage = [0 as f64; 160usize];391    let data = svcvt_f64_s64_x(392        svptrue_b64(),393        svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),394    );395    let indices = svindex_s64(0, 1);396    svst1_scatter_s64index_f64(svptrue_b64(), storage.as_mut_ptr(), indices, data);397    for (i, &val) in storage.iter().enumerate() {398        assert!(val == 0 as f64 || val == i as f64);399    }400    svsetffr();401    let loaded = svld1_gather_s64index_f64(svptrue_b64(), storage.as_ptr() as *const f64, indices);402    let defined = svrdffr();403    assert_vector_matches_f64(404        loaded,405        svcvt_f64_s64_x(406            svptrue_b64(),407            svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),408        ),409        defined,410    );411}412#[simd_test(enable = "sve")]413unsafe fn test_svld1_gather_s64index_s64_with_svst1_scatter_s64index_s64() {414    let mut storage = [0 as i64; 160usize];415    let data = svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());416    let indices = svindex_s64(0, 1);417    svst1_scatter_s64index_s64(svptrue_b64(), storage.as_mut_ptr(), indices, data);418    for (i, &val) in storage.iter().enumerate() {419        assert!(val == 0 as i64 || val == i as i64);420    }421    svsetffr();422    let loaded = svld1_gather_s64index_s64(svptrue_b64(), storage.as_ptr() as *const i64, indices);423    let defined = svrdffr();424    assert_vector_matches_i64(425        loaded,426        svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),427        defined,428    );429}430#[simd_test(enable = "sve")]431unsafe fn test_svld1_gather_s64index_u64_with_svst1_scatter_s64index_u64() {432    let mut storage = [0 as u64; 160usize];433    let data = svindex_u64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());434    let indices = svindex_s64(0, 1);435    svst1_scatter_s64index_u64(svptrue_b64(), storage.as_mut_ptr(), indices, data);436    for (i, &val) in storage.iter().enumerate() {437        assert!(val == 0 as u64 || val == i as u64);438    }439    svsetffr();440    let loaded = svld1_gather_s64index_u64(svptrue_b64(), storage.as_ptr() as *const u64, indices);441    let defined = svrdffr();442    assert_vector_matches_u64(443        loaded,444        svindex_u64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),445        defined,446    );447}448#[simd_test(enable = "sve")]449unsafe fn test_svld1_gather_u32index_f32_with_svst1_scatter_u32index_f32() {450    let mut storage = [0 as f32; 320usize];451    let data = svcvt_f32_s32_x(452        svptrue_b32(),453        svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),454    );455    let indices = svindex_u32(0, 1);456    svst1_scatter_u32index_f32(svptrue_b32(), storage.as_mut_ptr(), indices, data);457    for (i, &val) in storage.iter().enumerate() {458        assert!(val == 0 as f32 || val == i as f32);459    }460    svsetffr();461    let loaded = svld1_gather_u32index_f32(svptrue_b32(), storage.as_ptr() as *const f32, indices);462    let defined = svrdffr();463    assert_vector_matches_f32(464        loaded,465        svcvt_f32_s32_x(466            svptrue_b32(),467            svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),468        ),469        defined,470    );471}472#[simd_test(enable = "sve")]473unsafe fn test_svld1_gather_u32index_s32_with_svst1_scatter_u32index_s32() {474    let mut storage = [0 as i32; 320usize];475    let data = svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap());476    let indices = svindex_u32(0, 1);477    svst1_scatter_u32index_s32(svptrue_b32(), storage.as_mut_ptr(), indices, data);478    for (i, &val) in storage.iter().enumerate() {479        assert!(val == 0 as i32 || val == i as i32);480    }481    svsetffr();482    let loaded = svld1_gather_u32index_s32(svptrue_b32(), storage.as_ptr() as *const i32, indices);483    let defined = svrdffr();484    assert_vector_matches_i32(485        loaded,486        svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),487        defined,488    );489}490#[simd_test(enable = "sve")]491unsafe fn test_svld1_gather_u32index_u32_with_svst1_scatter_u32index_u32() {492    let mut storage = [0 as u32; 320usize];493    let data = svindex_u32((0usize).try_into().unwrap(), 1usize.try_into().unwrap());494    let indices = svindex_u32(0, 1);495    svst1_scatter_u32index_u32(svptrue_b32(), storage.as_mut_ptr(), indices, data);496    for (i, &val) in storage.iter().enumerate() {497        assert!(val == 0 as u32 || val == i as u32);498    }499    svsetffr();500    let loaded = svld1_gather_u32index_u32(svptrue_b32(), storage.as_ptr() as *const u32, indices);501    let defined = svrdffr();502    assert_vector_matches_u32(503        loaded,504        svindex_u32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),505        defined,506    );507}508#[simd_test(enable = "sve")]509unsafe fn test_svld1_gather_u64index_f64_with_svst1_scatter_u64index_f64() {510    let mut storage = [0 as f64; 160usize];511    let data = svcvt_f64_s64_x(512        svptrue_b64(),513        svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),514    );515    let indices = svindex_u64(0, 1);516    svst1_scatter_u64index_f64(svptrue_b64(), storage.as_mut_ptr(), indices, data);517    for (i, &val) in storage.iter().enumerate() {518        assert!(val == 0 as f64 || val == i as f64);519    }520    svsetffr();521    let loaded = svld1_gather_u64index_f64(svptrue_b64(), storage.as_ptr() as *const f64, indices);522    let defined = svrdffr();523    assert_vector_matches_f64(524        loaded,525        svcvt_f64_s64_x(526            svptrue_b64(),527            svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),528        ),529        defined,530    );531}532#[simd_test(enable = "sve")]533unsafe fn test_svld1_gather_u64index_s64_with_svst1_scatter_u64index_s64() {534    let mut storage = [0 as i64; 160usize];535    let data = svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());536    let indices = svindex_u64(0, 1);537    svst1_scatter_u64index_s64(svptrue_b64(), storage.as_mut_ptr(), indices, data);538    for (i, &val) in storage.iter().enumerate() {539        assert!(val == 0 as i64 || val == i as i64);540    }541    svsetffr();542    let loaded = svld1_gather_u64index_s64(svptrue_b64(), storage.as_ptr() as *const i64, indices);543    let defined = svrdffr();544    assert_vector_matches_i64(545        loaded,546        svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),547        defined,548    );549}550#[simd_test(enable = "sve")]551unsafe fn test_svld1_gather_u64index_u64_with_svst1_scatter_u64index_u64() {552    let mut storage = [0 as u64; 160usize];553    let data = svindex_u64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());554    let indices = svindex_u64(0, 1);555    svst1_scatter_u64index_u64(svptrue_b64(), storage.as_mut_ptr(), indices, data);556    for (i, &val) in storage.iter().enumerate() {557        assert!(val == 0 as u64 || val == i as u64);558    }559    svsetffr();560    let loaded = svld1_gather_u64index_u64(svptrue_b64(), storage.as_ptr() as *const u64, indices);561    let defined = svrdffr();562    assert_vector_matches_u64(563        loaded,564        svindex_u64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),565        defined,566    );567}568#[simd_test(enable = "sve")]569unsafe fn test_svld1_gather_s32offset_f32_with_svst1_scatter_s32offset_f32() {570    let mut storage = [0 as f32; 320usize];571    let data = svcvt_f32_s32_x(572        svptrue_b32(),573        svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),574    );575    let offsets = svindex_s32(0, 4u32.try_into().unwrap());576    svst1_scatter_s32offset_f32(svptrue_b32(), storage.as_mut_ptr(), offsets, data);577    for (i, &val) in storage.iter().enumerate() {578        assert!(val == 0 as f32 || val == i as f32);579    }580    svsetffr();581    let loaded = svld1_gather_s32offset_f32(svptrue_b32(), storage.as_ptr() as *const f32, offsets);582    let defined = svrdffr();583    assert_vector_matches_f32(584        loaded,585        svcvt_f32_s32_x(586            svptrue_b32(),587            svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),588        ),589        defined,590    );591}592#[simd_test(enable = "sve")]593unsafe fn test_svld1_gather_s32offset_s32_with_svst1_scatter_s32offset_s32() {594    let mut storage = [0 as i32; 320usize];595    let data = svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap());596    let offsets = svindex_s32(0, 4u32.try_into().unwrap());597    svst1_scatter_s32offset_s32(svptrue_b32(), storage.as_mut_ptr(), offsets, data);598    for (i, &val) in storage.iter().enumerate() {599        assert!(val == 0 as i32 || val == i as i32);600    }601    svsetffr();602    let loaded = svld1_gather_s32offset_s32(svptrue_b32(), storage.as_ptr() as *const i32, offsets);603    let defined = svrdffr();604    assert_vector_matches_i32(605        loaded,606        svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),607        defined,608    );609}610#[simd_test(enable = "sve")]611unsafe fn test_svld1_gather_s32offset_u32_with_svst1_scatter_s32offset_u32() {612    let mut storage = [0 as u32; 320usize];613    let data = svindex_u32((0usize).try_into().unwrap(), 1usize.try_into().unwrap());614    let offsets = svindex_s32(0, 4u32.try_into().unwrap());615    svst1_scatter_s32offset_u32(svptrue_b32(), storage.as_mut_ptr(), offsets, data);616    for (i, &val) in storage.iter().enumerate() {617        assert!(val == 0 as u32 || val == i as u32);618    }619    svsetffr();620    let loaded = svld1_gather_s32offset_u32(svptrue_b32(), storage.as_ptr() as *const u32, offsets);621    let defined = svrdffr();622    assert_vector_matches_u32(623        loaded,624        svindex_u32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),625        defined,626    );627}628#[simd_test(enable = "sve")]629unsafe fn test_svld1_gather_s64offset_f64_with_svst1_scatter_s64offset_f64() {630    let mut storage = [0 as f64; 160usize];631    let data = svcvt_f64_s64_x(632        svptrue_b64(),633        svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),634    );635    let offsets = svindex_s64(0, 8u32.try_into().unwrap());636    svst1_scatter_s64offset_f64(svptrue_b64(), storage.as_mut_ptr(), offsets, data);637    for (i, &val) in storage.iter().enumerate() {638        assert!(val == 0 as f64 || val == i as f64);639    }640    svsetffr();641    let loaded = svld1_gather_s64offset_f64(svptrue_b64(), storage.as_ptr() as *const f64, offsets);642    let defined = svrdffr();643    assert_vector_matches_f64(644        loaded,645        svcvt_f64_s64_x(646            svptrue_b64(),647            svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),648        ),649        defined,650    );651}652#[simd_test(enable = "sve")]653unsafe fn test_svld1_gather_s64offset_s64_with_svst1_scatter_s64offset_s64() {654    let mut storage = [0 as i64; 160usize];655    let data = svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());656    let offsets = svindex_s64(0, 8u32.try_into().unwrap());657    svst1_scatter_s64offset_s64(svptrue_b64(), storage.as_mut_ptr(), offsets, data);658    for (i, &val) in storage.iter().enumerate() {659        assert!(val == 0 as i64 || val == i as i64);660    }661    svsetffr();662    let loaded = svld1_gather_s64offset_s64(svptrue_b64(), storage.as_ptr() as *const i64, offsets);663    let defined = svrdffr();664    assert_vector_matches_i64(665        loaded,666        svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),667        defined,668    );669}670#[simd_test(enable = "sve")]671unsafe fn test_svld1_gather_s64offset_u64_with_svst1_scatter_s64offset_u64() {672    let mut storage = [0 as u64; 160usize];673    let data = svindex_u64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());674    let offsets = svindex_s64(0, 8u32.try_into().unwrap());675    svst1_scatter_s64offset_u64(svptrue_b64(), storage.as_mut_ptr(), offsets, data);676    for (i, &val) in storage.iter().enumerate() {677        assert!(val == 0 as u64 || val == i as u64);678    }679    svsetffr();680    let loaded = svld1_gather_s64offset_u64(svptrue_b64(), storage.as_ptr() as *const u64, offsets);681    let defined = svrdffr();682    assert_vector_matches_u64(683        loaded,684        svindex_u64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),685        defined,686    );687}688#[simd_test(enable = "sve")]689unsafe fn test_svld1_gather_u32offset_f32_with_svst1_scatter_u32offset_f32() {690    let mut storage = [0 as f32; 320usize];691    let data = svcvt_f32_s32_x(692        svptrue_b32(),693        svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),694    );695    let offsets = svindex_u32(0, 4u32.try_into().unwrap());696    svst1_scatter_u32offset_f32(svptrue_b32(), storage.as_mut_ptr(), offsets, data);697    for (i, &val) in storage.iter().enumerate() {698        assert!(val == 0 as f32 || val == i as f32);699    }700    svsetffr();701    let loaded = svld1_gather_u32offset_f32(svptrue_b32(), storage.as_ptr() as *const f32, offsets);702    let defined = svrdffr();703    assert_vector_matches_f32(704        loaded,705        svcvt_f32_s32_x(706            svptrue_b32(),707            svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),708        ),709        defined,710    );711}712#[simd_test(enable = "sve")]713unsafe fn test_svld1_gather_u32offset_s32_with_svst1_scatter_u32offset_s32() {714    let mut storage = [0 as i32; 320usize];715    let data = svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap());716    let offsets = svindex_u32(0, 4u32.try_into().unwrap());717    svst1_scatter_u32offset_s32(svptrue_b32(), storage.as_mut_ptr(), offsets, data);718    for (i, &val) in storage.iter().enumerate() {719        assert!(val == 0 as i32 || val == i as i32);720    }721    svsetffr();722    let loaded = svld1_gather_u32offset_s32(svptrue_b32(), storage.as_ptr() as *const i32, offsets);723    let defined = svrdffr();724    assert_vector_matches_i32(725        loaded,726        svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),727        defined,728    );729}730#[simd_test(enable = "sve")]731unsafe fn test_svld1_gather_u32offset_u32_with_svst1_scatter_u32offset_u32() {732    let mut storage = [0 as u32; 320usize];733    let data = svindex_u32((0usize).try_into().unwrap(), 1usize.try_into().unwrap());734    let offsets = svindex_u32(0, 4u32.try_into().unwrap());735    svst1_scatter_u32offset_u32(svptrue_b32(), storage.as_mut_ptr(), offsets, data);736    for (i, &val) in storage.iter().enumerate() {737        assert!(val == 0 as u32 || val == i as u32);738    }739    svsetffr();740    let loaded = svld1_gather_u32offset_u32(svptrue_b32(), storage.as_ptr() as *const u32, offsets);741    let defined = svrdffr();742    assert_vector_matches_u32(743        loaded,744        svindex_u32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),745        defined,746    );747}748#[simd_test(enable = "sve")]749unsafe fn test_svld1_gather_u64offset_f64_with_svst1_scatter_u64offset_f64() {750    let mut storage = [0 as f64; 160usize];751    let data = svcvt_f64_s64_x(752        svptrue_b64(),753        svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),754    );755    let offsets = svindex_u64(0, 8u32.try_into().unwrap());756    svst1_scatter_u64offset_f64(svptrue_b64(), storage.as_mut_ptr(), offsets, data);757    for (i, &val) in storage.iter().enumerate() {758        assert!(val == 0 as f64 || val == i as f64);759    }760    svsetffr();761    let loaded = svld1_gather_u64offset_f64(svptrue_b64(), storage.as_ptr() as *const f64, offsets);762    let defined = svrdffr();763    assert_vector_matches_f64(764        loaded,765        svcvt_f64_s64_x(766            svptrue_b64(),767            svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),768        ),769        defined,770    );771}772#[simd_test(enable = "sve")]773unsafe fn test_svld1_gather_u64offset_s64_with_svst1_scatter_u64offset_s64() {774    let mut storage = [0 as i64; 160usize];775    let data = svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());776    let offsets = svindex_u64(0, 8u32.try_into().unwrap());777    svst1_scatter_u64offset_s64(svptrue_b64(), storage.as_mut_ptr(), offsets, data);778    for (i, &val) in storage.iter().enumerate() {779        assert!(val == 0 as i64 || val == i as i64);780    }781    svsetffr();782    let loaded = svld1_gather_u64offset_s64(svptrue_b64(), storage.as_ptr() as *const i64, offsets);783    let defined = svrdffr();784    assert_vector_matches_i64(785        loaded,786        svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),787        defined,788    );789}790#[simd_test(enable = "sve")]791unsafe fn test_svld1_gather_u64offset_u64_with_svst1_scatter_u64offset_u64() {792    let mut storage = [0 as u64; 160usize];793    let data = svindex_u64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());794    let offsets = svindex_u64(0, 8u32.try_into().unwrap());795    svst1_scatter_u64offset_u64(svptrue_b64(), storage.as_mut_ptr(), offsets, data);796    for (i, &val) in storage.iter().enumerate() {797        assert!(val == 0 as u64 || val == i as u64);798    }799    svsetffr();800    let loaded = svld1_gather_u64offset_u64(svptrue_b64(), storage.as_ptr() as *const u64, offsets);801    let defined = svrdffr();802    assert_vector_matches_u64(803        loaded,804        svindex_u64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),805        defined,806    );807}808#[simd_test(enable = "sve")]809unsafe fn test_svld1_gather_u64base_f64_with_svst1_scatter_u64base_f64() {810    let mut storage = [0 as f64; 160usize];811    let data = svcvt_f64_s64_x(812        svptrue_b64(),813        svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),814    );815    let bases = svdup_n_u64(storage.as_ptr() as u64);816    let offsets = svindex_u64(0, 8u32.try_into().unwrap());817    let bases = svadd_u64_x(svptrue_b64(), bases, offsets);818    svst1_scatter_u64base_f64(svptrue_b64(), bases, data);819    for (i, &val) in storage.iter().enumerate() {820        assert!(val == 0 as f64 || val == i as f64);821    }822    svsetffr();823    let loaded = svld1_gather_u64base_f64(svptrue_b64(), bases);824    let defined = svrdffr();825    assert_vector_matches_f64(826        loaded,827        svcvt_f64_s64_x(828            svptrue_b64(),829            svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),830        ),831        defined,832    );833}834#[simd_test(enable = "sve")]835unsafe fn test_svld1_gather_u64base_s64_with_svst1_scatter_u64base_s64() {836    let mut storage = [0 as i64; 160usize];837    let data = svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());838    let bases = svdup_n_u64(storage.as_ptr() as u64);839    let offsets = svindex_u64(0, 8u32.try_into().unwrap());840    let bases = svadd_u64_x(svptrue_b64(), bases, offsets);841    svst1_scatter_u64base_s64(svptrue_b64(), bases, data);842    for (i, &val) in storage.iter().enumerate() {843        assert!(val == 0 as i64 || val == i as i64);844    }845    svsetffr();846    let loaded = svld1_gather_u64base_s64(svptrue_b64(), bases);847    let defined = svrdffr();848    assert_vector_matches_i64(849        loaded,850        svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),851        defined,852    );853}854#[simd_test(enable = "sve")]855unsafe fn test_svld1_gather_u64base_u64_with_svst1_scatter_u64base_u64() {856    let mut storage = [0 as u64; 160usize];857    let data = svindex_u64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());858    let bases = svdup_n_u64(storage.as_ptr() as u64);859    let offsets = svindex_u64(0, 8u32.try_into().unwrap());860    let bases = svadd_u64_x(svptrue_b64(), bases, offsets);861    svst1_scatter_u64base_u64(svptrue_b64(), bases, data);862    for (i, &val) in storage.iter().enumerate() {863        assert!(val == 0 as u64 || val == i as u64);864    }865    svsetffr();866    let loaded = svld1_gather_u64base_u64(svptrue_b64(), bases);867    let defined = svrdffr();868    assert_vector_matches_u64(869        loaded,870        svindex_u64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),871        defined,872    );873}874#[simd_test(enable = "sve")]875unsafe fn test_svld1_gather_u32base_index_f32_with_svst1_scatter_u32base_index_f32() {876    let mut storage = [0 as f32; 320usize];877    let data = svcvt_f32_s32_x(878        svptrue_b32(),879        svindex_s32((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),880    );881    let bases = svindex_u32(0, 4u32.try_into().unwrap());882    svst1_scatter_u32base_index_f32(883        svptrue_b32(),884        bases,885        storage.as_ptr() as i64 / (4u32 as i64) + 1,886        data,887    );888    for (i, &val) in storage.iter().enumerate() {889        assert!(val == 0 as f32 || val == i as f32);890    }891    svsetffr();892    let loaded = svld1_gather_u32base_index_f32(893        svptrue_b32(),894        bases,895        storage.as_ptr() as i64 / (4u32 as i64) + 1,896    );897    let defined = svrdffr();898    assert_vector_matches_f32(899        loaded,900        svcvt_f32_s32_x(901            svptrue_b32(),902            svindex_s32((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),903        ),904        defined,905    );906}907#[simd_test(enable = "sve")]908unsafe fn test_svld1_gather_u32base_index_s32_with_svst1_scatter_u32base_index_s32() {909    let mut storage = [0 as i32; 320usize];910    let data = svindex_s32((1usize).try_into().unwrap(), 1usize.try_into().unwrap());911    let bases = svindex_u32(0, 4u32.try_into().unwrap());912    svst1_scatter_u32base_index_s32(913        svptrue_b32(),914        bases,915        storage.as_ptr() as i64 / (4u32 as i64) + 1,916        data,917    );918    for (i, &val) in storage.iter().enumerate() {919        assert!(val == 0 as i32 || val == i as i32);920    }921    svsetffr();922    let loaded = svld1_gather_u32base_index_s32(923        svptrue_b32(),924        bases,925        storage.as_ptr() as i64 / (4u32 as i64) + 1,926    );927    let defined = svrdffr();928    assert_vector_matches_i32(929        loaded,930        svindex_s32((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),931        defined,932    );933}934#[simd_test(enable = "sve")]935unsafe fn test_svld1_gather_u32base_index_u32_with_svst1_scatter_u32base_index_u32() {936    let mut storage = [0 as u32; 320usize];937    let data = svindex_u32((1usize).try_into().unwrap(), 1usize.try_into().unwrap());938    let bases = svindex_u32(0, 4u32.try_into().unwrap());939    svst1_scatter_u32base_index_u32(940        svptrue_b32(),941        bases,942        storage.as_ptr() as i64 / (4u32 as i64) + 1,943        data,944    );945    for (i, &val) in storage.iter().enumerate() {946        assert!(val == 0 as u32 || val == i as u32);947    }948    svsetffr();949    let loaded = svld1_gather_u32base_index_u32(950        svptrue_b32(),951        bases,952        storage.as_ptr() as i64 / (4u32 as i64) + 1,953    );954    let defined = svrdffr();955    assert_vector_matches_u32(956        loaded,957        svindex_u32((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),958        defined,959    );960}961#[simd_test(enable = "sve")]962unsafe fn test_svld1_gather_u64base_index_f64_with_svst1_scatter_u64base_index_f64() {963    let mut storage = [0 as f64; 160usize];964    let data = svcvt_f64_s64_x(965        svptrue_b64(),966        svindex_s64((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),967    );968    let bases = svdup_n_u64(storage.as_ptr() as u64);969    let offsets = svindex_u64(0, 8u32.try_into().unwrap());970    let bases = svadd_u64_x(svptrue_b64(), bases, offsets);971    svst1_scatter_u64base_index_f64(svptrue_b64(), bases, 1.try_into().unwrap(), data);972    for (i, &val) in storage.iter().enumerate() {973        assert!(val == 0 as f64 || val == i as f64);974    }975    svsetffr();976    let loaded = svld1_gather_u64base_index_f64(svptrue_b64(), bases, 1.try_into().unwrap());977    let defined = svrdffr();978    assert_vector_matches_f64(979        loaded,980        svcvt_f64_s64_x(981            svptrue_b64(),982            svindex_s64((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),983        ),984        defined,985    );986}987#[simd_test(enable = "sve")]988unsafe fn test_svld1_gather_u64base_index_s64_with_svst1_scatter_u64base_index_s64() {989    let mut storage = [0 as i64; 160usize];990    let data = svindex_s64((1usize).try_into().unwrap(), 1usize.try_into().unwrap());991    let bases = svdup_n_u64(storage.as_ptr() as u64);992    let offsets = svindex_u64(0, 8u32.try_into().unwrap());993    let bases = svadd_u64_x(svptrue_b64(), bases, offsets);994    svst1_scatter_u64base_index_s64(svptrue_b64(), bases, 1.try_into().unwrap(), data);995    for (i, &val) in storage.iter().enumerate() {996        assert!(val == 0 as i64 || val == i as i64);997    }998    svsetffr();999    let loaded = svld1_gather_u64base_index_s64(svptrue_b64(), bases, 1.try_into().unwrap());1000    let defined = svrdffr();1001    assert_vector_matches_i64(1002        loaded,1003        svindex_s64((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),1004        defined,1005    );1006}1007#[simd_test(enable = "sve")]1008unsafe fn test_svld1_gather_u64base_index_u64_with_svst1_scatter_u64base_index_u64() {1009    let mut storage = [0 as u64; 160usize];1010    let data = svindex_u64((1usize).try_into().unwrap(), 1usize.try_into().unwrap());1011    let bases = svdup_n_u64(storage.as_ptr() as u64);1012    let offsets = svindex_u64(0, 8u32.try_into().unwrap());1013    let bases = svadd_u64_x(svptrue_b64(), bases, offsets);1014    svst1_scatter_u64base_index_u64(svptrue_b64(), bases, 1.try_into().unwrap(), data);1015    for (i, &val) in storage.iter().enumerate() {1016        assert!(val == 0 as u64 || val == i as u64);1017    }1018    svsetffr();1019    let loaded = svld1_gather_u64base_index_u64(svptrue_b64(), bases, 1.try_into().unwrap());1020    let defined = svrdffr();1021    assert_vector_matches_u64(1022        loaded,1023        svindex_u64((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),1024        defined,1025    );1026}1027#[simd_test(enable = "sve")]1028unsafe fn test_svld1_gather_u32base_offset_f32_with_svst1_scatter_u32base_offset_f32() {1029    let mut storage = [0 as f32; 320usize];1030    let data = svcvt_f32_s32_x(1031        svptrue_b32(),1032        svindex_s32((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),1033    );1034    let bases = svindex_u32(0, 4u32.try_into().unwrap());1035    svst1_scatter_u32base_offset_f32(1036        svptrue_b32(),1037        bases,1038        storage.as_ptr() as i64 + 4u32 as i64,1039        data,1040    );1041    for (i, &val) in storage.iter().enumerate() {1042        assert!(val == 0 as f32 || val == i as f32);1043    }1044    svsetffr();1045    let loaded = svld1_gather_u32base_offset_f32(1046        svptrue_b32(),1047        bases,1048        storage.as_ptr() as i64 + 4u32 as i64,1049    );1050    let defined = svrdffr();1051    assert_vector_matches_f32(1052        loaded,1053        svcvt_f32_s32_x(1054            svptrue_b32(),1055            svindex_s32((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),1056        ),1057        defined,1058    );1059}1060#[simd_test(enable = "sve")]1061unsafe fn test_svld1_gather_u32base_offset_s32_with_svst1_scatter_u32base_offset_s32() {1062    let mut storage = [0 as i32; 320usize];1063    let data = svindex_s32((1usize).try_into().unwrap(), 1usize.try_into().unwrap());1064    let bases = svindex_u32(0, 4u32.try_into().unwrap());1065    svst1_scatter_u32base_offset_s32(1066        svptrue_b32(),1067        bases,1068        storage.as_ptr() as i64 + 4u32 as i64,1069        data,1070    );1071    for (i, &val) in storage.iter().enumerate() {1072        assert!(val == 0 as i32 || val == i as i32);1073    }1074    svsetffr();1075    let loaded = svld1_gather_u32base_offset_s32(1076        svptrue_b32(),1077        bases,1078        storage.as_ptr() as i64 + 4u32 as i64,1079    );1080    let defined = svrdffr();1081    assert_vector_matches_i32(1082        loaded,1083        svindex_s32((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),1084        defined,1085    );1086}1087#[simd_test(enable = "sve")]1088unsafe fn test_svld1_gather_u32base_offset_u32_with_svst1_scatter_u32base_offset_u32() {1089    let mut storage = [0 as u32; 320usize];1090    let data = svindex_u32((1usize).try_into().unwrap(), 1usize.try_into().unwrap());1091    let bases = svindex_u32(0, 4u32.try_into().unwrap());1092    svst1_scatter_u32base_offset_u32(1093        svptrue_b32(),1094        bases,1095        storage.as_ptr() as i64 + 4u32 as i64,1096        data,1097    );1098    for (i, &val) in storage.iter().enumerate() {1099        assert!(val == 0 as u32 || val == i as u32);1100    }1101    svsetffr();1102    let loaded = svld1_gather_u32base_offset_u32(1103        svptrue_b32(),1104        bases,1105        storage.as_ptr() as i64 + 4u32 as i64,1106    );1107    let defined = svrdffr();1108    assert_vector_matches_u32(1109        loaded,1110        svindex_u32((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),1111        defined,1112    );1113}1114#[simd_test(enable = "sve")]1115unsafe fn test_svld1_gather_u64base_offset_f64_with_svst1_scatter_u64base_offset_f64() {1116    let mut storage = [0 as f64; 160usize];1117    let data = svcvt_f64_s64_x(1118        svptrue_b64(),1119        svindex_s64((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),1120    );1121    let bases = svdup_n_u64(storage.as_ptr() as u64);1122    let offsets = svindex_u64(0, 8u32.try_into().unwrap());1123    let bases = svadd_u64_x(svptrue_b64(), bases, offsets);1124    svst1_scatter_u64base_offset_f64(svptrue_b64(), bases, 8u32.try_into().unwrap(), data);1125    for (i, &val) in storage.iter().enumerate() {1126        assert!(val == 0 as f64 || val == i as f64);1127    }1128    svsetffr();1129    let loaded = svld1_gather_u64base_offset_f64(svptrue_b64(), bases, 8u32.try_into().unwrap());1130    let defined = svrdffr();1131    assert_vector_matches_f64(1132        loaded,1133        svcvt_f64_s64_x(1134            svptrue_b64(),1135            svindex_s64((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),1136        ),1137        defined,1138    );1139}1140#[simd_test(enable = "sve")]1141unsafe fn test_svld1_gather_u64base_offset_s64_with_svst1_scatter_u64base_offset_s64() {1142    let mut storage = [0 as i64; 160usize];1143    let data = svindex_s64((1usize).try_into().unwrap(), 1usize.try_into().unwrap());1144    let bases = svdup_n_u64(storage.as_ptr() as u64);1145    let offsets = svindex_u64(0, 8u32.try_into().unwrap());1146    let bases = svadd_u64_x(svptrue_b64(), bases, offsets);1147    svst1_scatter_u64base_offset_s64(svptrue_b64(), bases, 8u32.try_into().unwrap(), data);1148    for (i, &val) in storage.iter().enumerate() {1149        assert!(val == 0 as i64 || val == i as i64);1150    }1151    svsetffr();1152    let loaded = svld1_gather_u64base_offset_s64(svptrue_b64(), bases, 8u32.try_into().unwrap());1153    let defined = svrdffr();1154    assert_vector_matches_i64(1155        loaded,1156        svindex_s64((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),1157        defined,1158    );1159}1160#[simd_test(enable = "sve")]1161unsafe fn test_svld1_gather_u64base_offset_u64_with_svst1_scatter_u64base_offset_u64() {1162    let mut storage = [0 as u64; 160usize];1163    let data = svindex_u64((1usize).try_into().unwrap(), 1usize.try_into().unwrap());1164    let bases = svdup_n_u64(storage.as_ptr() as u64);1165    let offsets = svindex_u64(0, 8u32.try_into().unwrap());1166    let bases = svadd_u64_x(svptrue_b64(), bases, offsets);1167    svst1_scatter_u64base_offset_u64(svptrue_b64(), bases, 8u32.try_into().unwrap(), data);1168    for (i, &val) in storage.iter().enumerate() {1169        assert!(val == 0 as u64 || val == i as u64);1170    }1171    svsetffr();1172    let loaded = svld1_gather_u64base_offset_u64(svptrue_b64(), bases, 8u32.try_into().unwrap());1173    let defined = svrdffr();1174    assert_vector_matches_u64(1175        loaded,1176        svindex_u64((1usize).try_into().unwrap(), 1usize.try_into().unwrap()),1177        defined,1178    );1179}1180#[simd_test(enable = "sve")]1181unsafe fn test_svld1_vnum_f32_with_svst1_vnum_f32() {1182    let len = svcntw() as usize;1183    let mut storage = [0 as f32; 320usize];1184    let data = svcvt_f32_s32_x(1185        svptrue_b32(),1186        svindex_s32(1187            (len + 0usize).try_into().unwrap(),1188            1usize.try_into().unwrap(),1189        ),1190    );1191    svst1_vnum_f32(svptrue_b32(), storage.as_mut_ptr(), 1, data);1192    for (i, &val) in storage.iter().enumerate() {1193        assert!(val == 0 as f32 || val == i as f32);1194    }1195    svsetffr();1196    let loaded = svld1_vnum_f32(svptrue_b32(), storage.as_ptr() as *const f32, 1);1197    let defined = svrdffr();1198    assert_vector_matches_f32(1199        loaded,1200        svcvt_f32_s32_x(1201            svptrue_b32(),1202            svindex_s32(1203                (len + 0usize).try_into().unwrap(),1204                1usize.try_into().unwrap(),1205            ),1206        ),1207        defined,1208    );1209}1210#[simd_test(enable = "sve")]1211unsafe fn test_svld1_vnum_f64_with_svst1_vnum_f64() {1212    let len = svcntd() as usize;1213    let mut storage = [0 as f64; 160usize];1214    let data = svcvt_f64_s64_x(1215        svptrue_b64(),1216        svindex_s64(1217            (len + 0usize).try_into().unwrap(),1218            1usize.try_into().unwrap(),1219        ),1220    );1221    svst1_vnum_f64(svptrue_b64(), storage.as_mut_ptr(), 1, data);1222    for (i, &val) in storage.iter().enumerate() {1223        assert!(val == 0 as f64 || val == i as f64);1224    }1225    svsetffr();1226    let loaded = svld1_vnum_f64(svptrue_b64(), storage.as_ptr() as *const f64, 1);1227    let defined = svrdffr();1228    assert_vector_matches_f64(1229        loaded,1230        svcvt_f64_s64_x(1231            svptrue_b64(),1232            svindex_s64(1233                (len + 0usize).try_into().unwrap(),1234                1usize.try_into().unwrap(),1235            ),1236        ),1237        defined,1238    );1239}1240#[simd_test(enable = "sve")]1241unsafe fn test_svld1_vnum_s8_with_svst1_vnum_s8() {1242    let len = svcntb() as usize;1243    let mut storage = [0 as i8; 1280usize];1244    let data = svindex_s8(1245        (len + 0usize).try_into().unwrap(),1246        1usize.try_into().unwrap(),1247    );1248    svst1_vnum_s8(svptrue_b8(), storage.as_mut_ptr(), 1, data);1249    for (i, &val) in storage.iter().enumerate() {1250        assert!(val == 0 as i8 || val == i as i8);1251    }1252    svsetffr();1253    let loaded = svld1_vnum_s8(svptrue_b8(), storage.as_ptr() as *const i8, 1);1254    let defined = svrdffr();1255    assert_vector_matches_i8(1256        loaded,1257        svindex_s8(1258            (len + 0usize).try_into().unwrap(),1259            1usize.try_into().unwrap(),1260        ),1261        defined,1262    );1263}1264#[simd_test(enable = "sve")]1265unsafe fn test_svld1_vnum_s16_with_svst1_vnum_s16() {1266    let len = svcnth() as usize;1267    let mut storage = [0 as i16; 640usize];1268    let data = svindex_s16(1269        (len + 0usize).try_into().unwrap(),1270        1usize.try_into().unwrap(),1271    );1272    svst1_vnum_s16(svptrue_b16(), storage.as_mut_ptr(), 1, data);1273    for (i, &val) in storage.iter().enumerate() {1274        assert!(val == 0 as i16 || val == i as i16);1275    }1276    svsetffr();1277    let loaded = svld1_vnum_s16(svptrue_b16(), storage.as_ptr() as *const i16, 1);1278    let defined = svrdffr();1279    assert_vector_matches_i16(1280        loaded,1281        svindex_s16(1282            (len + 0usize).try_into().unwrap(),1283            1usize.try_into().unwrap(),1284        ),1285        defined,1286    );1287}1288#[simd_test(enable = "sve")]1289unsafe fn test_svld1_vnum_s32_with_svst1_vnum_s32() {1290    let len = svcntw() as usize;1291    let mut storage = [0 as i32; 320usize];1292    let data = svindex_s32(1293        (len + 0usize).try_into().unwrap(),1294        1usize.try_into().unwrap(),1295    );1296    svst1_vnum_s32(svptrue_b32(), storage.as_mut_ptr(), 1, data);1297    for (i, &val) in storage.iter().enumerate() {1298        assert!(val == 0 as i32 || val == i as i32);1299    }1300    svsetffr();1301    let loaded = svld1_vnum_s32(svptrue_b32(), storage.as_ptr() as *const i32, 1);1302    let defined = svrdffr();1303    assert_vector_matches_i32(1304        loaded,1305        svindex_s32(1306            (len + 0usize).try_into().unwrap(),1307            1usize.try_into().unwrap(),1308        ),1309        defined,1310    );1311}1312#[simd_test(enable = "sve")]1313unsafe fn test_svld1_vnum_s64_with_svst1_vnum_s64() {1314    let len = svcntd() as usize;1315    let mut storage = [0 as i64; 160usize];1316    let data = svindex_s64(1317        (len + 0usize).try_into().unwrap(),1318        1usize.try_into().unwrap(),1319    );1320    svst1_vnum_s64(svptrue_b64(), storage.as_mut_ptr(), 1, data);1321    for (i, &val) in storage.iter().enumerate() {1322        assert!(val == 0 as i64 || val == i as i64);1323    }1324    svsetffr();1325    let loaded = svld1_vnum_s64(svptrue_b64(), storage.as_ptr() as *const i64, 1);1326    let defined = svrdffr();1327    assert_vector_matches_i64(1328        loaded,1329        svindex_s64(1330            (len + 0usize).try_into().unwrap(),1331            1usize.try_into().unwrap(),1332        ),1333        defined,1334    );1335}1336#[simd_test(enable = "sve")]1337unsafe fn test_svld1_vnum_u8_with_svst1_vnum_u8() {1338    let len = svcntb() as usize;1339    let mut storage = [0 as u8; 1280usize];1340    let data = svindex_u8(1341        (len + 0usize).try_into().unwrap(),1342        1usize.try_into().unwrap(),1343    );1344    svst1_vnum_u8(svptrue_b8(), storage.as_mut_ptr(), 1, data);1345    for (i, &val) in storage.iter().enumerate() {1346        assert!(val == 0 as u8 || val == i as u8);1347    }1348    svsetffr();1349    let loaded = svld1_vnum_u8(svptrue_b8(), storage.as_ptr() as *const u8, 1);1350    let defined = svrdffr();1351    assert_vector_matches_u8(1352        loaded,1353        svindex_u8(1354            (len + 0usize).try_into().unwrap(),1355            1usize.try_into().unwrap(),1356        ),1357        defined,1358    );1359}1360#[simd_test(enable = "sve")]1361unsafe fn test_svld1_vnum_u16_with_svst1_vnum_u16() {1362    let len = svcnth() as usize;1363    let mut storage = [0 as u16; 640usize];1364    let data = svindex_u16(1365        (len + 0usize).try_into().unwrap(),1366        1usize.try_into().unwrap(),1367    );1368    svst1_vnum_u16(svptrue_b16(), storage.as_mut_ptr(), 1, data);1369    for (i, &val) in storage.iter().enumerate() {1370        assert!(val == 0 as u16 || val == i as u16);1371    }1372    svsetffr();1373    let loaded = svld1_vnum_u16(svptrue_b16(), storage.as_ptr() as *const u16, 1);1374    let defined = svrdffr();1375    assert_vector_matches_u16(1376        loaded,1377        svindex_u16(1378            (len + 0usize).try_into().unwrap(),1379            1usize.try_into().unwrap(),1380        ),1381        defined,1382    );1383}1384#[simd_test(enable = "sve")]1385unsafe fn test_svld1_vnum_u32_with_svst1_vnum_u32() {1386    let len = svcntw() as usize;1387    let mut storage = [0 as u32; 320usize];1388    let data = svindex_u32(1389        (len + 0usize).try_into().unwrap(),1390        1usize.try_into().unwrap(),1391    );1392    svst1_vnum_u32(svptrue_b32(), storage.as_mut_ptr(), 1, data);1393    for (i, &val) in storage.iter().enumerate() {1394        assert!(val == 0 as u32 || val == i as u32);1395    }1396    svsetffr();1397    let loaded = svld1_vnum_u32(svptrue_b32(), storage.as_ptr() as *const u32, 1);1398    let defined = svrdffr();1399    assert_vector_matches_u32(1400        loaded,1401        svindex_u32(1402            (len + 0usize).try_into().unwrap(),1403            1usize.try_into().unwrap(),1404        ),1405        defined,1406    );1407}1408#[simd_test(enable = "sve")]1409unsafe fn test_svld1_vnum_u64_with_svst1_vnum_u64() {1410    let len = svcntd() as usize;1411    let mut storage = [0 as u64; 160usize];1412    let data = svindex_u64(1413        (len + 0usize).try_into().unwrap(),1414        1usize.try_into().unwrap(),1415    );1416    svst1_vnum_u64(svptrue_b64(), storage.as_mut_ptr(), 1, data);1417    for (i, &val) in storage.iter().enumerate() {1418        assert!(val == 0 as u64 || val == i as u64);1419    }1420    svsetffr();1421    let loaded = svld1_vnum_u64(svptrue_b64(), storage.as_ptr() as *const u64, 1);1422    let defined = svrdffr();1423    assert_vector_matches_u64(1424        loaded,1425        svindex_u64(1426            (len + 0usize).try_into().unwrap(),1427            1usize.try_into().unwrap(),1428        ),1429        defined,1430    );1431}1432#[simd_test(enable = "sve,f64mm")]1433unsafe fn test_svld1ro_f32() {1434    if svcntb() < 32 {1435        println!("Skipping test_svld1ro_f32 due to SVE vector length");1436        return;1437    }1438    let ptr = F32_DATA.as_ptr();1439    svsetffr();1440    let loaded = svld1ro_f32(svptrue_b32(), ptr);1441    let defined = svrdffr();1442    assert_vector_matches_f32(1443        loaded,1444        svtrn1q_f32(1445            svdupq_n_f32(0usize as f32, 1usize as f32, 2usize as f32, 3usize as f32),1446            svdupq_n_f32(4usize as f32, 5usize as f32, 6usize as f32, 7usize as f32),1447        ),1448        defined,1449    );1450}1451#[simd_test(enable = "sve,f64mm")]1452unsafe fn test_svld1ro_f64() {1453    if svcntb() < 32 {1454        println!("Skipping test_svld1ro_f64 due to SVE vector length");1455        return;1456    }1457    let ptr = F64_DATA.as_ptr();1458    svsetffr();1459    let loaded = svld1ro_f64(svptrue_b64(), ptr);1460    let defined = svrdffr();1461    assert_vector_matches_f64(1462        loaded,1463        svtrn1q_f64(1464            svdupq_n_f64(0usize as f64, 1usize as f64),1465            svdupq_n_f64(2usize as f64, 3usize as f64),1466        ),1467        defined,1468    );1469}1470#[simd_test(enable = "sve,f64mm")]1471unsafe fn test_svld1ro_s8() {1472    if svcntb() < 32 {1473        println!("Skipping test_svld1ro_s8 due to SVE vector length");1474        return;1475    }1476    let ptr = I8_DATA.as_ptr();1477    svsetffr();1478    let loaded = svld1ro_s8(svptrue_b8(), ptr);1479    let defined = svrdffr();1480    assert_vector_matches_i8(1481        loaded,1482        svtrn1q_s8(1483            svdupq_n_s8(1484                0usize as i8,1485                1usize as i8,1486                2usize as i8,1487                3usize as i8,1488                4usize as i8,1489                5usize as i8,1490                6usize as i8,1491                7usize as i8,1492                8usize as i8,1493                9usize as i8,1494                10usize as i8,1495                11usize as i8,1496                12usize as i8,1497                13usize as i8,1498                14usize as i8,1499                15usize as i8,1500            ),1501            svdupq_n_s8(1502                16usize as i8,1503                17usize as i8,1504                18usize as i8,1505                19usize as i8,1506                20usize as i8,1507                21usize as i8,1508                22usize as i8,1509                23usize as i8,1510                24usize as i8,1511                25usize as i8,1512                26usize as i8,1513                27usize as i8,1514                28usize as i8,1515                29usize as i8,1516                30usize as i8,1517                31usize as i8,1518            ),1519        ),1520        defined,1521    );1522}1523#[simd_test(enable = "sve,f64mm")]1524unsafe fn test_svld1ro_s16() {1525    if svcntb() < 32 {1526        println!("Skipping test_svld1ro_s16 due to SVE vector length");1527        return;1528    }1529    let ptr = I16_DATA.as_ptr();1530    svsetffr();1531    let loaded = svld1ro_s16(svptrue_b16(), ptr);1532    let defined = svrdffr();1533    assert_vector_matches_i16(1534        loaded,1535        svtrn1q_s16(1536            svdupq_n_s16(1537                0usize as i16,1538                1usize as i16,1539                2usize as i16,1540                3usize as i16,1541                4usize as i16,1542                5usize as i16,1543                6usize as i16,1544                7usize as i16,1545            ),1546            svdupq_n_s16(1547                8usize as i16,1548                9usize as i16,1549                10usize as i16,1550                11usize as i16,1551                12usize as i16,1552                13usize as i16,1553                14usize as i16,1554                15usize as i16,1555            ),1556        ),1557        defined,1558    );1559}1560#[simd_test(enable = "sve,f64mm")]1561unsafe fn test_svld1ro_s32() {1562    if svcntb() < 32 {1563        println!("Skipping test_svld1ro_s32 due to SVE vector length");1564        return;1565    }1566    let ptr = I32_DATA.as_ptr();1567    svsetffr();1568    let loaded = svld1ro_s32(svptrue_b32(), ptr);1569    let defined = svrdffr();1570    assert_vector_matches_i32(1571        loaded,1572        svtrn1q_s32(1573            svdupq_n_s32(0usize as i32, 1usize as i32, 2usize as i32, 3usize as i32),1574            svdupq_n_s32(4usize as i32, 5usize as i32, 6usize as i32, 7usize as i32),1575        ),1576        defined,1577    );1578}1579#[simd_test(enable = "sve,f64mm")]1580unsafe fn test_svld1ro_s64() {1581    if svcntb() < 32 {1582        println!("Skipping test_svld1ro_s64 due to SVE vector length");1583        return;1584    }1585    let ptr = I64_DATA.as_ptr();1586    svsetffr();1587    let loaded = svld1ro_s64(svptrue_b64(), ptr);1588    let defined = svrdffr();1589    assert_vector_matches_i64(1590        loaded,1591        svtrn1q_s64(1592            svdupq_n_s64(0usize as i64, 1usize as i64),1593            svdupq_n_s64(2usize as i64, 3usize as i64),1594        ),1595        defined,1596    );1597}1598#[simd_test(enable = "sve,f64mm")]1599unsafe fn test_svld1ro_u8() {1600    if svcntb() < 32 {1601        println!("Skipping test_svld1ro_u8 due to SVE vector length");1602        return;1603    }1604    let ptr = U8_DATA.as_ptr();1605    svsetffr();1606    let loaded = svld1ro_u8(svptrue_b8(), ptr);1607    let defined = svrdffr();1608    assert_vector_matches_u8(1609        loaded,1610        svtrn1q_u8(1611            svdupq_n_u8(1612                0usize as u8,1613                1usize as u8,1614                2usize as u8,1615                3usize as u8,1616                4usize as u8,1617                5usize as u8,1618                6usize as u8,1619                7usize as u8,1620                8usize as u8,1621                9usize as u8,1622                10usize as u8,1623                11usize as u8,1624                12usize as u8,1625                13usize as u8,1626                14usize as u8,1627                15usize as u8,1628            ),1629            svdupq_n_u8(1630                16usize as u8,1631                17usize as u8,1632                18usize as u8,1633                19usize as u8,1634                20usize as u8,1635                21usize as u8,1636                22usize as u8,1637                23usize as u8,1638                24usize as u8,1639                25usize as u8,1640                26usize as u8,1641                27usize as u8,1642                28usize as u8,1643                29usize as u8,1644                30usize as u8,1645                31usize as u8,1646            ),1647        ),1648        defined,1649    );1650}1651#[simd_test(enable = "sve,f64mm")]1652unsafe fn test_svld1ro_u16() {1653    if svcntb() < 32 {1654        println!("Skipping test_svld1ro_u16 due to SVE vector length");1655        return;1656    }1657    let ptr = U16_DATA.as_ptr();1658    svsetffr();1659    let loaded = svld1ro_u16(svptrue_b16(), ptr);1660    let defined = svrdffr();1661    assert_vector_matches_u16(1662        loaded,1663        svtrn1q_u16(1664            svdupq_n_u16(1665                0usize as u16,1666                1usize as u16,1667                2usize as u16,1668                3usize as u16,1669                4usize as u16,1670                5usize as u16,1671                6usize as u16,1672                7usize as u16,1673            ),1674            svdupq_n_u16(1675                8usize as u16,1676                9usize as u16,1677                10usize as u16,1678                11usize as u16,1679                12usize as u16,1680                13usize as u16,1681                14usize as u16,1682                15usize as u16,1683            ),1684        ),1685        defined,1686    );1687}1688#[simd_test(enable = "sve,f64mm")]1689unsafe fn test_svld1ro_u32() {1690    if svcntb() < 32 {1691        println!("Skipping test_svld1ro_u32 due to SVE vector length");1692        return;1693    }1694    let ptr = U32_DATA.as_ptr();1695    svsetffr();1696    let loaded = svld1ro_u32(svptrue_b32(), ptr);1697    let defined = svrdffr();1698    assert_vector_matches_u32(1699        loaded,1700        svtrn1q_u32(1701            svdupq_n_u32(0usize as u32, 1usize as u32, 2usize as u32, 3usize as u32),1702            svdupq_n_u32(4usize as u32, 5usize as u32, 6usize as u32, 7usize as u32),1703        ),1704        defined,1705    );1706}1707#[simd_test(enable = "sve,f64mm")]1708unsafe fn test_svld1ro_u64() {1709    if svcntb() < 32 {1710        println!("Skipping test_svld1ro_u64 due to SVE vector length");1711        return;1712    }1713    let ptr = U64_DATA.as_ptr();1714    svsetffr();1715    let loaded = svld1ro_u64(svptrue_b64(), ptr);1716    let defined = svrdffr();1717    assert_vector_matches_u64(1718        loaded,1719        svtrn1q_u64(1720            svdupq_n_u64(0usize as u64, 1usize as u64),1721            svdupq_n_u64(2usize as u64, 3usize as u64),1722        ),1723        defined,1724    );1725}1726#[simd_test(enable = "sve")]1727unsafe fn test_svld1rq_f32() {1728    let ptr = F32_DATA.as_ptr();1729    svsetffr();1730    let loaded = svld1rq_f32(svptrue_b32(), ptr);1731    let defined = svrdffr();1732    assert_vector_matches_f32(1733        loaded,1734        svdupq_n_f32(0usize as f32, 1usize as f32, 2usize as f32, 3usize as f32),1735        defined,1736    );1737}1738#[simd_test(enable = "sve")]1739unsafe fn test_svld1rq_f64() {1740    let ptr = F64_DATA.as_ptr();1741    svsetffr();1742    let loaded = svld1rq_f64(svptrue_b64(), ptr);1743    let defined = svrdffr();1744    assert_vector_matches_f64(loaded, svdupq_n_f64(0usize as f64, 1usize as f64), defined);1745}1746#[simd_test(enable = "sve")]1747unsafe fn test_svld1rq_s8() {1748    let ptr = I8_DATA.as_ptr();1749    svsetffr();1750    let loaded = svld1rq_s8(svptrue_b8(), ptr);1751    let defined = svrdffr();1752    assert_vector_matches_i8(1753        loaded,1754        svdupq_n_s8(1755            0usize as i8,1756            1usize as i8,1757            2usize as i8,1758            3usize as i8,1759            4usize as i8,1760            5usize as i8,1761            6usize as i8,1762            7usize as i8,1763            8usize as i8,1764            9usize as i8,1765            10usize as i8,1766            11usize as i8,1767            12usize as i8,1768            13usize as i8,1769            14usize as i8,1770            15usize as i8,1771        ),1772        defined,1773    );1774}1775#[simd_test(enable = "sve")]1776unsafe fn test_svld1rq_s16() {1777    let ptr = I16_DATA.as_ptr();1778    svsetffr();1779    let loaded = svld1rq_s16(svptrue_b16(), ptr);1780    let defined = svrdffr();1781    assert_vector_matches_i16(1782        loaded,1783        svdupq_n_s16(1784            0usize as i16,1785            1usize as i16,1786            2usize as i16,1787            3usize as i16,1788            4usize as i16,1789            5usize as i16,1790            6usize as i16,1791            7usize as i16,1792        ),1793        defined,1794    );1795}1796#[simd_test(enable = "sve")]1797unsafe fn test_svld1rq_s32() {1798    let ptr = I32_DATA.as_ptr();1799    svsetffr();1800    let loaded = svld1rq_s32(svptrue_b32(), ptr);1801    let defined = svrdffr();1802    assert_vector_matches_i32(1803        loaded,1804        svdupq_n_s32(0usize as i32, 1usize as i32, 2usize as i32, 3usize as i32),1805        defined,1806    );1807}1808#[simd_test(enable = "sve")]1809unsafe fn test_svld1rq_s64() {1810    let ptr = I64_DATA.as_ptr();1811    svsetffr();1812    let loaded = svld1rq_s64(svptrue_b64(), ptr);1813    let defined = svrdffr();1814    assert_vector_matches_i64(loaded, svdupq_n_s64(0usize as i64, 1usize as i64), defined);1815}1816#[simd_test(enable = "sve")]1817unsafe fn test_svld1rq_u8() {1818    let ptr = U8_DATA.as_ptr();1819    svsetffr();1820    let loaded = svld1rq_u8(svptrue_b8(), ptr);1821    let defined = svrdffr();1822    assert_vector_matches_u8(1823        loaded,1824        svdupq_n_u8(1825            0usize as u8,1826            1usize as u8,1827            2usize as u8,1828            3usize as u8,1829            4usize as u8,1830            5usize as u8,1831            6usize as u8,1832            7usize as u8,1833            8usize as u8,1834            9usize as u8,1835            10usize as u8,1836            11usize as u8,1837            12usize as u8,1838            13usize as u8,1839            14usize as u8,1840            15usize as u8,1841        ),1842        defined,1843    );1844}1845#[simd_test(enable = "sve")]1846unsafe fn test_svld1rq_u16() {1847    let ptr = U16_DATA.as_ptr();1848    svsetffr();1849    let loaded = svld1rq_u16(svptrue_b16(), ptr);1850    let defined = svrdffr();1851    assert_vector_matches_u16(1852        loaded,1853        svdupq_n_u16(1854            0usize as u16,1855            1usize as u16,1856            2usize as u16,1857            3usize as u16,1858            4usize as u16,1859            5usize as u16,1860            6usize as u16,1861            7usize as u16,1862        ),1863        defined,1864    );1865}1866#[simd_test(enable = "sve")]1867unsafe fn test_svld1rq_u32() {1868    let ptr = U32_DATA.as_ptr();1869    svsetffr();1870    let loaded = svld1rq_u32(svptrue_b32(), ptr);1871    let defined = svrdffr();1872    assert_vector_matches_u32(1873        loaded,1874        svdupq_n_u32(0usize as u32, 1usize as u32, 2usize as u32, 3usize as u32),1875        defined,1876    );1877}1878#[simd_test(enable = "sve")]1879unsafe fn test_svld1rq_u64() {1880    let ptr = U64_DATA.as_ptr();1881    svsetffr();1882    let loaded = svld1rq_u64(svptrue_b64(), ptr);1883    let defined = svrdffr();1884    assert_vector_matches_u64(loaded, svdupq_n_u64(0usize as u64, 1usize as u64), defined);1885}1886#[simd_test(enable = "sve")]1887unsafe fn test_svld1sb_gather_s32offset_s32_with_svst1b_scatter_s32offset_s32() {1888    let mut storage = [0 as i8; 1280usize];1889    let data = svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap());1890    let offsets = svindex_s32(0, 1u32.try_into().unwrap());1891    svst1b_scatter_s32offset_s32(svptrue_b8(), storage.as_mut_ptr(), offsets, data);1892    for (i, &val) in storage.iter().enumerate() {1893        assert!(val == 0 as i8 || val == i as i8);1894    }1895    svsetffr();1896    let loaded = svld1sb_gather_s32offset_s32(svptrue_b8(), storage.as_ptr() as *const i8, offsets);1897    let defined = svrdffr();1898    assert_vector_matches_i32(1899        loaded,1900        svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),1901        defined,1902    );1903}1904#[simd_test(enable = "sve")]1905unsafe fn test_svld1sh_gather_s32offset_s32_with_svst1h_scatter_s32offset_s32() {1906    let mut storage = [0 as i16; 640usize];1907    let data = svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap());1908    let offsets = svindex_s32(0, 2u32.try_into().unwrap());1909    svst1h_scatter_s32offset_s32(svptrue_b16(), storage.as_mut_ptr(), offsets, data);1910    for (i, &val) in storage.iter().enumerate() {1911        assert!(val == 0 as i16 || val == i as i16);1912    }1913    svsetffr();1914    let loaded =1915        svld1sh_gather_s32offset_s32(svptrue_b16(), storage.as_ptr() as *const i16, offsets);1916    let defined = svrdffr();1917    assert_vector_matches_i32(1918        loaded,1919        svindex_s32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),1920        defined,1921    );1922}1923#[simd_test(enable = "sve")]1924unsafe fn test_svld1sb_gather_s32offset_u32_with_svst1b_scatter_s32offset_u32() {1925    let mut storage = [0 as u8; 1280usize];1926    let data = svindex_u32((0usize).try_into().unwrap(), 1usize.try_into().unwrap());1927    let offsets = svindex_s32(0, 1u32.try_into().unwrap());1928    svst1b_scatter_s32offset_u32(svptrue_b8(), storage.as_mut_ptr(), offsets, data);1929    for (i, &val) in storage.iter().enumerate() {1930        assert!(val == 0 as u8 || val == i as u8);1931    }1932    svsetffr();1933    let loaded = svld1sb_gather_s32offset_u32(svptrue_b8(), storage.as_ptr() as *const i8, offsets);1934    let defined = svrdffr();1935    assert_vector_matches_u32(1936        loaded,1937        svindex_u32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),1938        defined,1939    );1940}1941#[simd_test(enable = "sve")]1942unsafe fn test_svld1sh_gather_s32offset_u32_with_svst1h_scatter_s32offset_u32() {1943    let mut storage = [0 as u16; 640usize];1944    let data = svindex_u32((0usize).try_into().unwrap(), 1usize.try_into().unwrap());1945    let offsets = svindex_s32(0, 2u32.try_into().unwrap());1946    svst1h_scatter_s32offset_u32(svptrue_b16(), storage.as_mut_ptr(), offsets, data);1947    for (i, &val) in storage.iter().enumerate() {1948        assert!(val == 0 as u16 || val == i as u16);1949    }1950    svsetffr();1951    let loaded =1952        svld1sh_gather_s32offset_u32(svptrue_b16(), storage.as_ptr() as *const i16, offsets);1953    let defined = svrdffr();1954    assert_vector_matches_u32(1955        loaded,1956        svindex_u32((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),1957        defined,1958    );1959}1960#[simd_test(enable = "sve")]1961unsafe fn test_svld1sb_gather_s64offset_s64_with_svst1b_scatter_s64offset_s64() {1962    let mut storage = [0 as i8; 1280usize];1963    let data = svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());1964    let offsets = svindex_s64(0, 1u32.try_into().unwrap());1965    svst1b_scatter_s64offset_s64(svptrue_b8(), storage.as_mut_ptr(), offsets, data);1966    for (i, &val) in storage.iter().enumerate() {1967        assert!(val == 0 as i8 || val == i as i8);1968    }1969    svsetffr();1970    let loaded = svld1sb_gather_s64offset_s64(svptrue_b8(), storage.as_ptr() as *const i8, offsets);1971    let defined = svrdffr();1972    assert_vector_matches_i64(1973        loaded,1974        svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),1975        defined,1976    );1977}1978#[simd_test(enable = "sve")]1979unsafe fn test_svld1sh_gather_s64offset_s64_with_svst1h_scatter_s64offset_s64() {1980    let mut storage = [0 as i16; 640usize];1981    let data = svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());1982    let offsets = svindex_s64(0, 2u32.try_into().unwrap());1983    svst1h_scatter_s64offset_s64(svptrue_b16(), storage.as_mut_ptr(), offsets, data);1984    for (i, &val) in storage.iter().enumerate() {1985        assert!(val == 0 as i16 || val == i as i16);1986    }1987    svsetffr();1988    let loaded =1989        svld1sh_gather_s64offset_s64(svptrue_b16(), storage.as_ptr() as *const i16, offsets);1990    let defined = svrdffr();1991    assert_vector_matches_i64(1992        loaded,1993        svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap()),1994        defined,1995    );1996}1997#[simd_test(enable = "sve")]1998unsafe fn test_svld1sw_gather_s64offset_s64_with_svst1w_scatter_s64offset_s64() {1999    let mut storage = [0 as i32; 320usize];2000    let data = svindex_s64((0usize).try_into().unwrap(), 1usize.try_into().unwrap());