| #![allow(unused)] |
| |
| use std::collections::HashMap; |
| |
| use serde::Deserialize; |
| |
| struct Function { |
| name: &'static str, |
| arguments: &'static [&'static Type], |
| ret: Option<&'static Type>, |
| target_feature: Option<&'static str>, |
| instrs: &'static [&'static str], |
| file: &'static str, |
| required_const: &'static [usize], |
| has_test: bool, |
| doc: &'static str, |
| } |
| |
| static BOOL: Type = Type::PrimBool; |
| static F16: Type = Type::PrimFloat(16); |
| static F32: Type = Type::PrimFloat(32); |
| static F64: Type = Type::PrimFloat(64); |
| static I16: Type = Type::PrimSigned(16); |
| static I32: Type = Type::PrimSigned(32); |
| static I64: Type = Type::PrimSigned(64); |
| static I8: Type = Type::PrimSigned(8); |
| static U16: Type = Type::PrimUnsigned(16); |
| static U32: Type = Type::PrimUnsigned(32); |
| static U64: Type = Type::PrimUnsigned(64); |
| static U8: Type = Type::PrimUnsigned(8); |
| static NEVER: Type = Type::Never; |
| static VOID: Type = Type::Void; |
| static GENERICT: Type = Type::GenericParam("T"); |
| static GENERICU: Type = Type::GenericParam("U"); |
| |
| static F16X4: Type = Type::F(16, 4, 1); |
| static F16X4X2: Type = Type::F(16, 4, 2); |
| static F16X4X3: Type = Type::F(16, 4, 3); |
| static F16X4X4: Type = Type::F(16, 4, 4); |
| static F16X8: Type = Type::F(16, 8, 1); |
| static F16X8X2: Type = Type::F(16, 8, 2); |
| static F16X8X3: Type = Type::F(16, 8, 3); |
| static F16X8X4: Type = Type::F(16, 8, 4); |
| static F32X2: Type = Type::F(32, 2, 1); |
| static F32X2X2: Type = Type::F(32, 2, 2); |
| static F32X2X3: Type = Type::F(32, 2, 3); |
| static F32X2X4: Type = Type::F(32, 2, 4); |
| static F32X4: Type = Type::F(32, 4, 1); |
| static F32X4X2: Type = Type::F(32, 4, 2); |
| static F32X4X3: Type = Type::F(32, 4, 3); |
| static F32X4X4: Type = Type::F(32, 4, 4); |
| static F64X1: Type = Type::F(64, 1, 1); |
| static F64X1X2: Type = Type::F(64, 1, 2); |
| static F64X1X3: Type = Type::F(64, 1, 3); |
| static F64X1X4: Type = Type::F(64, 1, 4); |
| static F64X2: Type = Type::F(64, 2, 1); |
| static F64X2X2: Type = Type::F(64, 2, 2); |
| static F64X2X3: Type = Type::F(64, 2, 3); |
| static F64X2X4: Type = Type::F(64, 2, 4); |
| static I16X2: Type = Type::I(16, 2, 1); |
| static I16X4: Type = Type::I(16, 4, 1); |
| static I16X4X2: Type = Type::I(16, 4, 2); |
| static I16X4X3: Type = Type::I(16, 4, 3); |
| static I16X4X4: Type = Type::I(16, 4, 4); |
| static I16X8: Type = Type::I(16, 8, 1); |
| static I16X8X2: Type = Type::I(16, 8, 2); |
| static I16X8X3: Type = Type::I(16, 8, 3); |
| static I16X8X4: Type = Type::I(16, 8, 4); |
| static I32X2: Type = Type::I(32, 2, 1); |
| static I32X2X2: Type = Type::I(32, 2, 2); |
| static I32X2X3: Type = Type::I(32, 2, 3); |
| static I32X2X4: Type = Type::I(32, 2, 4); |
| static I32X4: Type = Type::I(32, 4, 1); |
| static I32X4X2: Type = Type::I(32, 4, 2); |
| static I32X4X3: Type = Type::I(32, 4, 3); |
| static I32X4X4: Type = Type::I(32, 4, 4); |
| static I64X1: Type = Type::I(64, 1, 1); |
| static I64X1X2: Type = Type::I(64, 1, 2); |
| static I64X1X3: Type = Type::I(64, 1, 3); |
| static I64X1X4: Type = Type::I(64, 1, 4); |
| static I64X2: Type = Type::I(64, 2, 1); |
| static I64X2X2: Type = Type::I(64, 2, 2); |
| static I64X2X3: Type = Type::I(64, 2, 3); |
| static I64X2X4: Type = Type::I(64, 2, 4); |
| static I8X16: Type = Type::I(8, 16, 1); |
| static I8X16X2: Type = Type::I(8, 16, 2); |
| static I8X16X3: Type = Type::I(8, 16, 3); |
| static I8X16X4: Type = Type::I(8, 16, 4); |
| static I8X4: Type = Type::I(8, 4, 1); |
| static I8X8: Type = Type::I(8, 8, 1); |
| static I8X8X2: Type = Type::I(8, 8, 2); |
| static I8X8X3: Type = Type::I(8, 8, 3); |
| static I8X8X4: Type = Type::I(8, 8, 4); |
| static P128: Type = Type::PrimPoly(128); |
| static P16: Type = Type::PrimPoly(16); |
| static P16X4X2: Type = Type::P(16, 4, 2); |
| static P16X4X3: Type = Type::P(16, 4, 3); |
| static P16X4X4: Type = Type::P(16, 4, 4); |
| static P16X8X2: Type = Type::P(16, 8, 2); |
| static P16X8X3: Type = Type::P(16, 8, 3); |
| static P16X8X4: Type = Type::P(16, 8, 4); |
| static P64: Type = Type::PrimPoly(64); |
| static P64X1X2: Type = Type::P(64, 1, 2); |
| static P64X1X3: Type = Type::P(64, 1, 3); |
| static P64X1X4: Type = Type::P(64, 1, 4); |
| static P64X2X2: Type = Type::P(64, 2, 2); |
| static P64X2X3: Type = Type::P(64, 2, 3); |
| static P64X2X4: Type = Type::P(64, 2, 4); |
| static P8: Type = Type::PrimPoly(8); |
| static POLY16X4: Type = Type::P(16, 4, 1); |
| static POLY16X8: Type = Type::P(16, 8, 1); |
| static POLY64X1: Type = Type::P(64, 1, 1); |
| static POLY64X2: Type = Type::P(64, 2, 1); |
| static POLY8X16: Type = Type::P(8, 16, 1); |
| static POLY8X16X2: Type = Type::P(8, 16, 2); |
| static POLY8X16X3: Type = Type::P(8, 16, 3); |
| static POLY8X16X4: Type = Type::P(8, 16, 4); |
| static POLY8X8: Type = Type::P(8, 8, 1); |
| static POLY8X8X2: Type = Type::P(8, 8, 2); |
| static POLY8X8X3: Type = Type::P(8, 8, 3); |
| static POLY8X8X4: Type = Type::P(8, 8, 4); |
| static U16X4: Type = Type::U(16, 4, 1); |
| static U16X4X2: Type = Type::U(16, 4, 2); |
| static U16X4X3: Type = Type::U(16, 4, 3); |
| static U16X4X4: Type = Type::U(16, 4, 4); |
| static U16X8: Type = Type::U(16, 8, 1); |
| static U16X8X2: Type = Type::U(16, 8, 2); |
| static U16X8X3: Type = Type::U(16, 8, 3); |
| static U16X8X4: Type = Type::U(16, 8, 4); |
| static U32X2: Type = Type::U(32, 2, 1); |
| static U32X2X2: Type = Type::U(32, 2, 2); |
| static U32X2X3: Type = Type::U(32, 2, 3); |
| static U32X2X4: Type = Type::U(32, 2, 4); |
| static U32X4: Type = Type::U(32, 4, 1); |
| static U32X4X2: Type = Type::U(32, 4, 2); |
| static U32X4X3: Type = Type::U(32, 4, 3); |
| static U32X4X4: Type = Type::U(32, 4, 4); |
| static U64X1: Type = Type::U(64, 1, 1); |
| static U64X1X2: Type = Type::U(64, 1, 2); |
| static U64X1X3: Type = Type::U(64, 1, 3); |
| static U64X1X4: Type = Type::U(64, 1, 4); |
| static U64X2: Type = Type::U(64, 2, 1); |
| static U64X2X2: Type = Type::U(64, 2, 2); |
| static U64X2X3: Type = Type::U(64, 2, 3); |
| static U64X2X4: Type = Type::U(64, 2, 4); |
| static U8X16: Type = Type::U(8, 16, 1); |
| static U8X16X2: Type = Type::U(8, 16, 2); |
| static U8X16X3: Type = Type::U(8, 16, 3); |
| static U8X16X4: Type = Type::U(8, 16, 4); |
| static U8X8: Type = Type::U(8, 8, 1); |
| static U8X4: Type = Type::U(8, 4, 1); |
| static U8X8X2: Type = Type::U(8, 8, 2); |
| static U8X8X3: Type = Type::U(8, 8, 3); |
| static U8X8X4: Type = Type::U(8, 8, 4); |
| |
| static SVBOOL: Type = Type::Pred(1); |
| static SVBOOLX2: Type = Type::Pred(2); |
| static SVBOOLX3: Type = Type::Pred(3); |
| static SVBOOLX4: Type = Type::Pred(4); |
| static SVCOUNT: Type = Type::Pred(1); |
| static SVF16: Type = Type::SVF(16, 1); |
| static SVF16X2: Type = Type::SVF(16, 2); |
| static SVF16X3: Type = Type::SVF(16, 3); |
| static SVF16X4: Type = Type::SVF(16, 4); |
| static SVF32: Type = Type::SVF(32, 1); |
| static SVF32X2: Type = Type::SVF(32, 2); |
| static SVF32X3: Type = Type::SVF(32, 3); |
| static SVF32X4: Type = Type::SVF(32, 4); |
| static SVF64: Type = Type::SVF(64, 1); |
| static SVF64X2: Type = Type::SVF(64, 2); |
| static SVF64X3: Type = Type::SVF(64, 3); |
| static SVF64X4: Type = Type::SVF(64, 4); |
| static SVI8: Type = Type::SVI(8, 1); |
| static SVI8X2: Type = Type::SVI(8, 2); |
| static SVI8X3: Type = Type::SVI(8, 3); |
| static SVI8X4: Type = Type::SVI(8, 4); |
| static SVI16: Type = Type::SVI(16, 1); |
| static SVI16X2: Type = Type::SVI(16, 2); |
| static SVI16X3: Type = Type::SVI(16, 3); |
| static SVI16X4: Type = Type::SVI(16, 4); |
| static SVI32: Type = Type::SVI(32, 1); |
| static SVI32X2: Type = Type::SVI(32, 2); |
| static SVI32X3: Type = Type::SVI(32, 3); |
| static SVI32X4: Type = Type::SVI(32, 4); |
| static SVI64: Type = Type::SVI(64, 1); |
| static SVI64X2: Type = Type::SVI(64, 2); |
| static SVI64X3: Type = Type::SVI(64, 3); |
| static SVI64X4: Type = Type::SVI(64, 4); |
| static SVU8: Type = Type::SVU(8, 1); |
| static SVU8X2: Type = Type::SVU(8, 2); |
| static SVU8X3: Type = Type::SVU(8, 3); |
| static SVU8X4: Type = Type::SVU(8, 4); |
| static SVU16: Type = Type::SVU(16, 1); |
| static SVU16X2: Type = Type::SVU(16, 2); |
| static SVU16X3: Type = Type::SVU(16, 3); |
| static SVU16X4: Type = Type::SVU(16, 4); |
| static SVU32: Type = Type::SVU(32, 1); |
| static SVU32X2: Type = Type::SVU(32, 2); |
| static SVU32X3: Type = Type::SVU(32, 3); |
| static SVU32X4: Type = Type::SVU(32, 4); |
| static SVU64: Type = Type::SVU(64, 1); |
| static SVU64X2: Type = Type::SVU(64, 2); |
| static SVU64X3: Type = Type::SVU(64, 3); |
| static SVU64X4: Type = Type::SVU(64, 4); |
| static SVPRFOP: Type = Type::Enum("svprfop"); |
| static SVPATTERN: Type = Type::Enum("svpattern"); |
| |
| #[derive(Debug, Copy, Clone, PartialEq)] |
| enum Type { |
| Void, |
| PrimBool, |
| PrimFloat(u8), |
| PrimSigned(u8), |
| PrimUnsigned(u8), |
| PrimPoly(u8), |
| MutPtr(&'static Type), |
| ConstPtr(&'static Type), |
| Enum(&'static str), |
| GenericParam(&'static str), |
| I(u8, u8, u8), |
| U(u8, u8, u8), |
| P(u8, u8, u8), |
| F(u8, u8, u8), |
| Pred(u8), |
| SVI(u8, u8), |
| SVU(u8, u8), |
| SVF(u8, u8), |
| Never, |
| } |
| |
| stdarch_verify::arm_functions!(static FUNCTIONS); |
| |
| macro_rules! bail { |
| ($($t:tt)*) => (return Err(format!($($t)*))) |
| } |
| |
| #[test] |
| fn verify_all_signatures() { |
| // Reference: https://developer.arm.com/architectures/instruction-sets/intrinsics |
| let json = include_bytes!("../../../intrinsics_data/arm_intrinsics.json"); |
| let intrinsics: Vec<JsonIntrinsic> = serde_json::from_slice(json).unwrap(); |
| let map = parse_intrinsics(intrinsics); |
| |
| let mut all_valid = true; |
| for rust in FUNCTIONS { |
| // Most SVE intrinsics just rely on the intrinsics test tool for validation |
| if !rust.has_test { |
| if !SKIP_RUNTIME_TESTS.contains(&rust.name) |
| // Most run-time tests are handled by the intrinsic-test tool, except for |
| // load/stores (which have generated tests) |
| && (!rust.name.starts_with("sv") || rust.name.starts_with("svld") |
| || rust.name.starts_with("svst")) |
| // The load/store test generator can't handle these cases yet |
| && (!rust.name.contains("_u32base_") || rust.name.contains("index") || rust.name.contains("offset")) |
| && !(rust.name.starts_with("svldff1") && rust.name.contains("gather")) |
| { |
| println!("missing run-time test for `{}`", rust.name); |
| all_valid = false; |
| } |
| } |
| |
| // Skip some intrinsics that aren't NEON and are located in different |
| // places than the whitelists below. |
| match rust.name { |
| "brk" | "__breakpoint" | "udf" | "_prefetch" => continue, |
| _ => {} |
| } |
| // Skip some intrinsics that are present in GCC and Clang but |
| // are missing from the official documentation. |
| let skip_intrinsic_verify = [ |
| "vmov_n_p64", |
| "vmovq_n_p64", |
| "vreinterpret_p64_s64", |
| "vreinterpret_f32_p64", |
| "vreinterpretq_f32_p64", |
| "vreinterpretq_p64_p128", |
| "vreinterpretq_p128_p64", |
| "vreinterpretq_f32_p128", |
| "vtst_p16", |
| "vtstq_p16", |
| "__dbg", |
| ]; |
| let arm = match map.get(rust.name) { |
| Some(i) => i, |
| None => { |
| // Skip all these intrinsics as they're not listed in NEON |
| // descriptions online. |
| // |
| // TODO: we still need to verify these intrinsics or find a |
| // reference for them, need to figure out where though! |
| if !rust.file.ends_with("dsp.rs\"") |
| && !rust.file.ends_with("sat.rs\"") |
| && !rust.file.ends_with("simd32.rs\"") |
| && !rust.file.ends_with("v6.rs\"") |
| && !rust.file.ends_with("v7.rs\"") |
| && !rust.file.ends_with("v8.rs\"") |
| && !rust.file.ends_with("mte.rs\"") |
| && !rust.file.ends_with("rand.rs\"") |
| && !rust.file.ends_with("ex.rs\"") |
| && !skip_intrinsic_verify.contains(&rust.name) |
| { |
| println!( |
| "missing arm definition for {:?} in {}", |
| rust.name, rust.file |
| ); |
| all_valid = false; |
| } |
| continue; |
| } |
| }; |
| |
| if let Err(e) = matches(rust, arm) { |
| println!("failed to verify `{}`", rust.name); |
| println!(" * {e}"); |
| all_valid = false; |
| } |
| } |
| assert!(all_valid); |
| } |
| |
| fn matches(rust: &Function, arm: &Intrinsic) -> Result<(), String> { |
| if rust.ret != arm.ret.as_ref() { |
| bail!("mismatched return value") |
| } |
| if rust.arguments.len() != arm.arguments.len() { |
| bail!("mismatched argument lengths"); |
| } |
| |
| let mut nconst = 0; |
| let iter = rust.arguments.iter().zip(&arm.arguments).enumerate(); |
| for (i, (rust_ty, (arm, arm_const))) in iter { |
| match (*rust_ty, arm) { |
| // SVE uses generic type parameters to handle void pointers |
| (Type::ConstPtr(Type::GenericParam("T")), Type::ConstPtr(Type::Void)) => (), |
| // SVE const generics use i32 over u64 for usability reasons |
| (Type::PrimSigned(32), Type::PrimUnsigned(64)) if rust.required_const.contains(&i) => { |
| () |
| } |
| // svset doesn't have its const argument last as we assumed when building the Function |
| _ if rust.name.starts_with("svset") => (), |
| (x, y) if x == y => (), |
| _ => bail!("mismatched arguments: {rust_ty:?} != {arm:?}"), |
| } |
| if *arm_const { |
| nconst += 1; |
| if !rust.required_const.contains(&i) && !rust.name.starts_with("svset") { |
| bail!("argument const mismatch"); |
| } |
| } |
| } |
| if nconst != rust.required_const.len() { |
| bail!("wrong number of const arguments"); |
| } |
| |
| if rust.instrs.is_empty() |
| && arm.instruction != "" |
| && !SKIP_ASSERT_INSTR_TESTS.contains(&rust.name) |
| { |
| bail!( |
| "instruction not listed for `{}`, but arm lists {:?}", |
| rust.name, |
| arm.instruction |
| ); |
| } else if false |
| // TODO: This instruction checking logic needs work to handle multiple instructions and to only |
| // look at aarch64 insructions. |
| // The ACLE's listed instructions are a guideline only and compilers have the freedom to use |
| // different instructions in dfferent cases which makes this an unreliable testing method. It |
| // is of questionable value given the intrinsic test tool. |
| { |
| for instr in rust.instrs { |
| if arm.instruction.starts_with(instr) { |
| continue; |
| } |
| // sometimes arm says `foo` and disassemblers say `vfoo`, or |
| // sometimes disassemblers say `vfoo` and arm says `sfoo` or `ffoo` |
| if instr.starts_with('v') |
| && (arm.instruction.starts_with(&instr[1..]) |
| || arm.instruction[1..].starts_with(&instr[1..])) |
| { |
| continue; |
| } |
| bail!( |
| "arm failed to list `{}` as an instruction for `{}` in {:?}", |
| instr, |
| rust.name, |
| arm.instruction, |
| ); |
| } |
| } |
| |
| // TODO: verify `target_feature`. |
| |
| Ok(()) |
| } |
| |
| #[derive(Debug, PartialEq)] |
| struct Intrinsic { |
| name: String, |
| ret: Option<Type>, |
| arguments: Vec<(Type, bool)>, |
| instruction: String, |
| } |
| |
| // These structures are similar to those in json_parser.rs in intrinsics-test |
| #[derive(Deserialize, Debug)] |
| struct JsonIntrinsic { |
| name: String, |
| arguments: Vec<String>, |
| return_type: ReturnType, |
| #[serde(default)] |
| instructions: Option<Vec<Vec<String>>>, |
| } |
| |
| #[derive(Deserialize, Debug)] |
| struct ReturnType { |
| value: String, |
| } |
| |
| fn parse_intrinsics(intrinsics: Vec<JsonIntrinsic>) -> HashMap<String, Intrinsic> { |
| let mut ret = HashMap::new(); |
| for intr in intrinsics.into_iter() { |
| let f = parse_intrinsic(intr); |
| ret.insert(f.name.clone(), f); |
| } |
| ret |
| } |
| |
| fn parse_intrinsic(mut intr: JsonIntrinsic) -> Intrinsic { |
| let name = intr.name; |
| // Remove '[' and ']' so that intrinsics of the form `svwhilerw[_s16]` becomes `svwhilerw_s16`. |
| let name = name.replace('[', "").replace(']', ""); |
| let ret = if intr.return_type.value == "void" { |
| None |
| } else { |
| Some(parse_ty(&intr.return_type.value)) |
| }; |
| |
| // This ignores multiple instructions and different optional sequences for now to mimic |
| // the old HTML scraping behaviour |
| let instruction = intr |
| .instructions |
| .map_or(String::new(), |mut i| i.swap_remove(0).swap_remove(0)); |
| |
| let arguments = intr |
| .arguments |
| .iter() |
| .map(|s| { |
| let ty = if let Some(i) = s.find('*') { |
| &s[..i + 1] |
| } else { |
| s.rsplit_once(' ').unwrap().0.trim_start_matches("const ") |
| }; |
| let ty = parse_ty(ty); |
| let konst = s.contains("const") && !matches!(ty, Type::ConstPtr(_)) |
| || s.starts_with("enum") |
| || s.rsplit_once(" ").unwrap().1.starts_with("imm"); |
| (ty, konst) |
| }) |
| .collect::<Vec<_>>(); |
| |
| Intrinsic { |
| name, |
| ret, |
| instruction, |
| arguments, |
| } |
| } |
| |
| fn parse_ty(s: &str) -> Type { |
| if let Some(ty) = s.strip_suffix("*") { |
| let ty = ty.trim(); |
| if let Some(ty) = ty.strip_prefix("const") { |
| // SVE intrinsics are west-const (`const int8_t *`) |
| Type::ConstPtr(parse_ty_base(ty)) |
| } else if let Some(ty) = ty.strip_suffix("const") { |
| // Neon intrinsics are east-const (`int8_t const *`) |
| Type::ConstPtr(parse_ty_base(ty)) |
| } else { |
| Type::MutPtr(parse_ty_base(ty)) |
| } |
| } else { |
| *parse_ty_base(s) |
| } |
| } |
| |
| fn parse_ty_base(s: &str) -> &'static Type { |
| let s = s.trim(); |
| match s { |
| "bool" => &BOOL, |
| "void" => &VOID, |
| "float16_t" => &F16, |
| "float16x4_t" => &F16X4, |
| "float16x4x2_t" => &F16X4X2, |
| "float16x4x3_t" => &F16X4X3, |
| "float16x4x4_t" => &F16X4X4, |
| "float16x8_t" => &F16X8, |
| "float16x8x2_t" => &F16X8X2, |
| "float16x8x3_t" => &F16X8X3, |
| "float16x8x4_t" => &F16X8X4, |
| "float32_t" => &F32, |
| "float32x2_t" => &F32X2, |
| "float32x2x2_t" => &F32X2X2, |
| "float32x2x3_t" => &F32X2X3, |
| "float32x2x4_t" => &F32X2X4, |
| "float32x4_t" => &F32X4, |
| "float32x4x2_t" => &F32X4X2, |
| "float32x4x3_t" => &F32X4X3, |
| "float32x4x4_t" => &F32X4X4, |
| "float64_t" => &F64, |
| "float64x1_t" => &F64X1, |
| "float64x1x2_t" => &F64X1X2, |
| "float64x1x3_t" => &F64X1X3, |
| "float64x1x4_t" => &F64X1X4, |
| "float64x2_t" => &F64X2, |
| "float64x2x2_t" => &F64X2X2, |
| "float64x2x3_t" => &F64X2X3, |
| "float64x2x4_t" => &F64X2X4, |
| "int16_t" => &I16, |
| "int16x2_t" => &I16X2, |
| "int16x4_t" => &I16X4, |
| "int16x4x2_t" => &I16X4X2, |
| "int16x4x3_t" => &I16X4X3, |
| "int16x4x4_t" => &I16X4X4, |
| "int16x8_t" => &I16X8, |
| "int16x8x2_t" => &I16X8X2, |
| "int16x8x3_t" => &I16X8X3, |
| "int16x8x4_t" => &I16X8X4, |
| "int32_t" | "int" => &I32, |
| "int32x2_t" => &I32X2, |
| "int32x2x2_t" => &I32X2X2, |
| "int32x2x3_t" => &I32X2X3, |
| "int32x2x4_t" => &I32X2X4, |
| "int32x4_t" => &I32X4, |
| "int32x4x2_t" => &I32X4X2, |
| "int32x4x3_t" => &I32X4X3, |
| "int32x4x4_t" => &I32X4X4, |
| "int64_t" => &I64, |
| "int64x1_t" => &I64X1, |
| "int64x1x2_t" => &I64X1X2, |
| "int64x1x3_t" => &I64X1X3, |
| "int64x1x4_t" => &I64X1X4, |
| "int64x2_t" => &I64X2, |
| "int64x2x2_t" => &I64X2X2, |
| "int64x2x3_t" => &I64X2X3, |
| "int64x2x4_t" => &I64X2X4, |
| "int8_t" => &I8, |
| "int8x16_t" => &I8X16, |
| "int8x16x2_t" => &I8X16X2, |
| "int8x16x3_t" => &I8X16X3, |
| "int8x16x4_t" => &I8X16X4, |
| "int8x4_t" => &I8X4, |
| "int8x8_t" => &I8X8, |
| "int8x8x2_t" => &I8X8X2, |
| "int8x8x3_t" => &I8X8X3, |
| "int8x8x4_t" => &I8X8X4, |
| "poly128_t" => &P128, |
| "poly16_t" => &P16, |
| "poly16x4_t" => &POLY16X4, |
| "poly16x4x2_t" => &P16X4X2, |
| "poly16x4x3_t" => &P16X4X3, |
| "poly16x4x4_t" => &P16X4X4, |
| "poly16x8_t" => &POLY16X8, |
| "poly16x8x2_t" => &P16X8X2, |
| "poly16x8x3_t" => &P16X8X3, |
| "poly16x8x4_t" => &P16X8X4, |
| "poly64_t" => &P64, |
| "poly64x1_t" => &POLY64X1, |
| "poly64x1x2_t" => &P64X1X2, |
| "poly64x1x3_t" => &P64X1X3, |
| "poly64x1x4_t" => &P64X1X4, |
| "poly64x2_t" => &POLY64X2, |
| "poly64x2x2_t" => &P64X2X2, |
| "poly64x2x3_t" => &P64X2X3, |
| "poly64x2x4_t" => &P64X2X4, |
| "poly8_t" => &P8, |
| "poly8x16_t" => &POLY8X16, |
| "poly8x16x2_t" => &POLY8X16X2, |
| "poly8x16x3_t" => &POLY8X16X3, |
| "poly8x16x4_t" => &POLY8X16X4, |
| "poly8x8_t" => &POLY8X8, |
| "poly8x8x2_t" => &POLY8X8X2, |
| "poly8x8x3_t" => &POLY8X8X3, |
| "poly8x8x4_t" => &POLY8X8X4, |
| "uint16_t" => &U16, |
| "uint16x4_t" => &U16X4, |
| "uint16x4x2_t" => &U16X4X2, |
| "uint16x4x3_t" => &U16X4X3, |
| "uint16x4x4_t" => &U16X4X4, |
| "uint16x8_t" => &U16X8, |
| "uint16x8x2_t" => &U16X8X2, |
| "uint16x8x3_t" => &U16X8X3, |
| "uint16x8x4_t" => &U16X8X4, |
| "uint32_t" => &U32, |
| "uint32x2_t" => &U32X2, |
| "uint32x2x2_t" => &U32X2X2, |
| "uint32x2x3_t" => &U32X2X3, |
| "uint32x2x4_t" => &U32X2X4, |
| "uint32x4_t" => &U32X4, |
| "uint32x4x2_t" => &U32X4X2, |
| "uint32x4x3_t" => &U32X4X3, |
| "uint32x4x4_t" => &U32X4X4, |
| "uint64_t" => &U64, |
| "uint64x1_t" => &U64X1, |
| "uint64x1x2_t" => &U64X1X2, |
| "uint64x1x3_t" => &U64X1X3, |
| "uint64x1x4_t" => &U64X1X4, |
| "uint64x2_t" => &U64X2, |
| "uint64x2x2_t" => &U64X2X2, |
| "uint64x2x3_t" => &U64X2X3, |
| "uint64x2x4_t" => &U64X2X4, |
| "uint8_t" => &U8, |
| "uint8x16_t" => &U8X16, |
| "uint8x16x2_t" => &U8X16X2, |
| "uint8x16x3_t" => &U8X16X3, |
| "uint8x16x4_t" => &U8X16X4, |
| "uint8x8_t" => &U8X8, |
| "uint8x8x2_t" => &U8X8X2, |
| "uint8x8x3_t" => &U8X8X3, |
| "uint8x8x4_t" => &U8X8X4, |
| "svbool_t" => &SVBOOL, |
| "svboolx2_t" => &SVBOOLX2, |
| "svboolx3_t" => &SVBOOLX3, |
| "svboolx4_t" => &SVBOOLX4, |
| "svcount_t" => &SVCOUNT, |
| "svfloat16_t" => &SVF16, |
| "svfloat16x2_t" => &SVF16X2, |
| "svfloat16x3_t" => &SVF16X3, |
| "svfloat16x4_t" => &SVF16X4, |
| "svfloat32_t" => &SVF32, |
| "svfloat32x2_t" => &SVF32X2, |
| "svfloat32x3_t" => &SVF32X3, |
| "svfloat32x4_t" => &SVF32X4, |
| "svfloat64_t" => &SVF64, |
| "svfloat64x2_t" => &SVF64X2, |
| "svfloat64x3_t" => &SVF64X3, |
| "svfloat64x4_t" => &SVF64X4, |
| "svint8_t" => &SVI8, |
| "svint8x2_t" => &SVI8X2, |
| "svint8x3_t" => &SVI8X3, |
| "svint8x4_t" => &SVI8X4, |
| "svint16_t" => &SVI16, |
| "svint16x2_t" => &SVI16X2, |
| "svint16x3_t" => &SVI16X3, |
| "svint16x4_t" => &SVI16X4, |
| "svint32_t" => &SVI32, |
| "svint32x2_t" => &SVI32X2, |
| "svint32x3_t" => &SVI32X3, |
| "svint32x4_t" => &SVI32X4, |
| "svint64_t" => &SVI64, |
| "svint64x2_t" => &SVI64X2, |
| "svint64x3_t" => &SVI64X3, |
| "svint64x4_t" => &SVI64X4, |
| "svuint8_t" => &SVU8, |
| "svuint8x2_t" => &SVU8X2, |
| "svuint8x3_t" => &SVU8X3, |
| "svuint8x4_t" => &SVU8X4, |
| "svuint16_t" => &SVU16, |
| "svuint16x2_t" => &SVU16X2, |
| "svuint16x3_t" => &SVU16X3, |
| "svuint16x4_t" => &SVU16X4, |
| "svuint32_t" => &SVU32, |
| "svuint32x2_t" => &SVU32X2, |
| "svuint32x3_t" => &SVU32X3, |
| "svuint32x4_t" => &SVU32X4, |
| "svuint64_t" => &SVU64, |
| "svuint64x2_t" => &SVU64X2, |
| "svuint64x3_t" => &SVU64X3, |
| "svuint64x4_t" => &SVU64X4, |
| "enum svprfop" => &SVPRFOP, |
| "enum svpattern" => &SVPATTERN, |
| |
| _ => panic!("failed to parse json type {s:?}"), |
| } |
| } |
| |
| // FIXME(arm-maintainers): Some tests require new rustc intrinsics in order to generate |
| // the appropriate instruction, though they do have the correct behaviour - these will be fixed |
| // but are disabled for now. |
| static SKIP_ASSERT_INSTR_TESTS: &'static [&'static str] = &["svpfalse_b"]; |
| |
| // FIXME(arm-maintainers): With the advent of the `intrinsic-test` tool, new tests of this kind |
| // are no longer being added and just adding to this list indefinitely isn't the best solution for |
| // dealing with that. |
| static SKIP_RUNTIME_TESTS: &'static [&'static str] = &[ |
| "vaddq_s64", |
| "vaddq_u64", |
| "vrsqrte_f32", |
| "vtbl1_s8", |
| "vtbl1_u8", |
| "vtbl1_p8", |
| "vtbl2_s8", |
| "vtbl2_u8", |
| "vtbl2_p8", |
| "vtbl3_s8", |
| "vtbl3_u8", |
| "vtbl3_p8", |
| "vtbl4_s8", |
| "vtbl4_u8", |
| "vtbl4_p8", |
| "vtbx1_s8", |
| "vtbx1_u8", |
| "vtbx1_p8", |
| "vtbx2_s8", |
| "vtbx2_u8", |
| "vtbx2_p8", |
| "vtbx3_s8", |
| "vtbx3_u8", |
| "vtbx3_p8", |
| "vtbx4_s8", |
| "vtbx4_u8", |
| "vtbx4_p8", |
| "udf", |
| "_clz_u8", |
| "_clz_u16", |
| "_clz_u32", |
| "_rbit_u32", |
| "_rev_u16", |
| "_rev_u32", |
| "__breakpoint", |
| "vpminq_f32", |
| "vpminq_f64", |
| "vpmaxq_f32", |
| "vpmaxq_f64", |
| "vcombine_s8", |
| "vcombine_s16", |
| "vcombine_s32", |
| "vcombine_s64", |
| "vcombine_u8", |
| "vcombine_u16", |
| "vcombine_u32", |
| "vcombine_u64", |
| "vcombine_p64", |
| "vcombine_f32", |
| "vcombine_p8", |
| "vcombine_p16", |
| "vcombine_f64", |
| "vtbl1_s8", |
| "vtbl1_u8", |
| "vtbl1_p8", |
| "vtbl2_s8", |
| "vtbl2_u8", |
| "vtbl2_p8", |
| "vtbl3_s8", |
| "vtbl3_u8", |
| "vtbl3_p8", |
| "vtbl4_s8", |
| "vtbl4_u8", |
| "vtbl4_p8", |
| "vtbx1_s8", |
| "vtbx1_u8", |
| "vtbx1_p8", |
| "vtbx2_s8", |
| "vtbx2_u8", |
| "vtbx2_p8", |
| "vtbx3_s8", |
| "vtbx3_u8", |
| "vtbx3_p8", |
| "vtbx4_s8", |
| "vtbx4_u8", |
| "vtbx4_p8", |
| "vqtbl1_s8", |
| "vqtbl1q_s8", |
| "vqtbl1_u8", |
| "vqtbl1q_u8", |
| "vqtbl1_p8", |
| "vqtbl1q_p8", |
| "vqtbx1_s8", |
| "vqtbx1q_s8", |
| "vqtbx1_u8", |
| "vqtbx1q_u8", |
| "vqtbx1_p8", |
| "vqtbx1q_p8", |
| "vqtbl2_s8", |
| "vqtbl2q_s8", |
| "vqtbl2_u8", |
| "vqtbl2q_u8", |
| "vqtbl2_p8", |
| "vqtbl2q_p8", |
| "vqtbx2_s8", |
| "vqtbx2q_s8", |
| "vqtbx2_u8", |
| "vqtbx2q_u8", |
| "vqtbx2_p8", |
| "vqtbx2q_p8", |
| "vqtbl3_s8", |
| "vqtbl3q_s8", |
| "vqtbl3_u8", |
| "vqtbl3q_u8", |
| "vqtbl3_p8", |
| "vqtbl3q_p8", |
| "vqtbx3_s8", |
| "vqtbx3q_s8", |
| "vqtbx3_u8", |
| "vqtbx3q_u8", |
| "vqtbx3_p8", |
| "vqtbx3q_p8", |
| "vqtbl4_s8", |
| "vqtbl4q_s8", |
| "vqtbl4_u8", |
| "vqtbl4q_u8", |
| "vqtbl4_p8", |
| "vqtbl4q_p8", |
| "vqtbx4_s8", |
| "vqtbx4q_s8", |
| "vqtbx4_u8", |
| "vqtbx4q_u8", |
| "vqtbx4_p8", |
| "vqtbx4q_p8", |
| "brk", |
| "_rev_u64", |
| "_clz_u64", |
| "_rbit_u64", |
| "_cls_u32", |
| "_cls_u64", |
| "_prefetch", |
| "vsli_n_s8", |
| "vsliq_n_s8", |
| "vsli_n_s16", |
| "vsliq_n_s16", |
| "vsli_n_s32", |
| "vsliq_n_s32", |
| "vsli_n_s64", |
| "vsliq_n_s64", |
| "vsli_n_u8", |
| "vsliq_n_u8", |
| "vsli_n_u16", |
| "vsliq_n_u16", |
| "vsli_n_u32", |
| "vsliq_n_u32", |
| "vsli_n_u64", |
| "vsliq_n_u64", |
| "vsli_n_p8", |
| "vsliq_n_p8", |
| "vsli_n_p16", |
| "vsliq_n_p16", |
| "vsli_n_p64", |
| "vsliq_n_p64", |
| "vsri_n_s8", |
| "vsriq_n_s8", |
| "vsri_n_s16", |
| "vsriq_n_s16", |
| "vsri_n_s32", |
| "vsriq_n_s32", |
| "vsri_n_s64", |
| "vsriq_n_s64", |
| "vsri_n_u8", |
| "vsriq_n_u8", |
| "vsri_n_u16", |
| "vsriq_n_u16", |
| "vsri_n_u32", |
| "vsriq_n_u32", |
| "vsri_n_u64", |
| "vsriq_n_u64", |
| "vsri_n_p8", |
| "vsriq_n_p8", |
| "vsri_n_p16", |
| "vsriq_n_p16", |
| "vsri_n_p64", |
| "vsriq_n_p64", |
| "__smulbb", |
| "__smultb", |
| "__smulbt", |
| "__smultt", |
| "__smulwb", |
| "__smulwt", |
| "__qadd", |
| "__qsub", |
| "__qdbl", |
| "__smlabb", |
| "__smlabt", |
| "__smlatb", |
| "__smlatt", |
| "__smlawb", |
| "__smlawt", |
| "__qadd8", |
| "__qsub8", |
| "__qsub16", |
| "__qadd16", |
| "__qasx", |
| "__qsax", |
| "__sadd16", |
| "__sadd8", |
| "__smlad", |
| "__smlsd", |
| "__sasx", |
| "__sel", |
| "__shadd8", |
| "__shadd16", |
| "__shsub8", |
| "__usub8", |
| "__ssub8", |
| "__shsub16", |
| "__smuad", |
| "__smuadx", |
| "__smusd", |
| "__smusdx", |
| "__usad8", |
| "__usada8", |
| "__ldrex", |
| "__strex", |
| "__ldrexb", |
| "__strexb", |
| "__ldrexh", |
| "__strexh", |
| "__clrex", |
| "__dbg", |
| "__crc32cd", |
| "__crc32d", |
| "__jcvt", |
| "vabal_high_s8", |
| "vabal_high_s16", |
| "vabal_high_s32", |
| "vabal_high_u8", |
| "vabal_high_u16", |
| "vabal_high_u32", |
| "vabd_f64", |
| "vabdq_f64", |
| "vabdd_f64", |
| "vabds_f32", |
| "vabdh_f16", |
| "vabdl_high_s16", |
| "vabdl_high_s32", |
| "vabdl_high_s8", |
| "vabdl_high_u8", |
| "vabdl_high_u16", |
| "vabdl_high_u32", |
| "vabs_f64", |
| "vabsq_f64", |
| "vabs_s64", |
| "vabsq_s64", |
| "vabsd_s64", |
| "vaddlv_s16", |
| "vaddlvq_s16", |
| "vaddlvq_s32", |
| "vaddlv_s32", |
| "vaddlv_s8", |
| "vaddlvq_s8", |
| "vaddlv_u16", |
| "vaddlvq_u16", |
| "vaddlvq_u32", |
| "vaddlv_u32", |
| "vaddlv_u8", |
| "vaddlvq_u8", |
| "vaddv_f32", |
| "vaddvq_f32", |
| "vaddvq_f64", |
| "vaddv_s32", |
| "vaddv_s8", |
| "vaddvq_s8", |
| "vaddv_s16", |
| "vaddvq_s16", |
| "vaddvq_s32", |
| "vaddv_u32", |
| "vaddv_u8", |
| "vaddvq_u8", |
| "vaddv_u16", |
| "vaddvq_u16", |
| "vaddvq_u32", |
| "vaddvq_s64", |
| "vaddvq_u64", |
| "vamax_f16", |
| "vamaxq_f16", |
| "vamax_f32", |
| "vamaxq_f32", |
| "vamaxq_f64", |
| "vamin_f16", |
| "vaminq_f16", |
| "vamin_f32", |
| "vaminq_f32", |
| "vaminq_f64", |
| "vbcaxq_s8", |
| "vbcaxq_s16", |
| "vbcaxq_s32", |
| "vbcaxq_s64", |
| "vbcaxq_u8", |
| "vbcaxq_u16", |
| "vbcaxq_u32", |
| "vbcaxq_u64", |
| "vcadd_rot270_f16", |
| "vcaddq_rot270_f16", |
| "vcadd_rot270_f32", |
| "vcaddq_rot270_f32", |
| "vcaddq_rot270_f64", |
| "vcadd_rot90_f16", |
| "vcaddq_rot90_f16", |
| "vcadd_rot90_f32", |
| "vcaddq_rot90_f32", |
| "vcaddq_rot90_f64", |
| "vcage_f64", |
| "vcageq_f64", |
| "vcaged_f64", |
| "vcages_f32", |
| "vcageh_f16", |
| "vcagt_f64", |
| "vcagtq_f64", |
| "vcagtd_f64", |
| "vcagts_f32", |
| "vcagth_f16", |
| "vcale_f64", |
| "vcaleq_f64", |
| "vcaled_f64", |
| "vcales_f32", |
| "vcaleh_f16", |
| "vcalt_f64", |
| "vcaltq_f64", |
| "vcaltd_f64", |
| "vcalts_f32", |
| "vcalth_f16", |
| "vceq_f64", |
| "vceqq_f64", |
| "vceq_s64", |
| "vceqq_s64", |
| "vceq_u64", |
| "vceqq_u64", |
| "vceq_p64", |
| "vceqq_p64", |
| "vceqd_f64", |
| "vceqs_f32", |
| "vceqd_s64", |
| "vceqd_u64", |
| "vceqh_f16", |
| "vceqz_f16", |
| "vceqzq_f16", |
| "vceqz_f32", |
| "vceqzq_f32", |
| "vceqz_f64", |
| "vceqzq_f64", |
| "vceqz_s8", |
| "vceqzq_s8", |
| "vceqz_s16", |
| "vceqzq_s16", |
| "vceqz_s32", |
| "vceqzq_s32", |
| "vceqz_s64", |
| "vceqzq_s64", |
| "vceqz_p8", |
| "vceqzq_p8", |
| "vceqz_p64", |
| "vceqzq_p64", |
| "vceqz_u8", |
| "vceqzq_u8", |
| "vceqz_u16", |
| "vceqzq_u16", |
| "vceqz_u32", |
| "vceqzq_u32", |
| "vceqz_u64", |
| "vceqzq_u64", |
| "vceqzd_s64", |
| "vceqzd_u64", |
| "vceqzh_f16", |
| "vceqzs_f32", |
| "vceqzd_f64", |
| "vcge_f64", |
| "vcgeq_f64", |
| "vcge_s64", |
| "vcgeq_s64", |
| "vcge_u64", |
| "vcgeq_u64", |
| "vcged_f64", |
| "vcges_f32", |
| "vcged_s64", |
| "vcged_u64", |
| "vcgeh_f16", |
| "vcgez_f32", |
| "vcgezq_f32", |
| "vcgez_f64", |
| "vcgezq_f64", |
| "vcgez_s8", |
| "vcgezq_s8", |
| "vcgez_s16", |
| "vcgezq_s16", |
| "vcgez_s32", |
| "vcgezq_s32", |
| "vcgez_s64", |
| "vcgezq_s64", |
| "vcgezd_f64", |
| "vcgezs_f32", |
| "vcgezd_s64", |
| "vcgezh_f16", |
| "vcgt_f64", |
| "vcgtq_f64", |
| "vcgt_s64", |
| "vcgtq_s64", |
| "vcgt_u64", |
| "vcgtq_u64", |
| "vcgtd_f64", |
| "vcgts_f32", |
| "vcgtd_s64", |
| "vcgtd_u64", |
| "vcgth_f16", |
| "vcgtz_f32", |
| "vcgtzq_f32", |
| "vcgtz_f64", |
| "vcgtzq_f64", |
| "vcgtz_s8", |
| "vcgtzq_s8", |
| "vcgtz_s16", |
| "vcgtzq_s16", |
| "vcgtz_s32", |
| "vcgtzq_s32", |
| "vcgtz_s64", |
| "vcgtzq_s64", |
| "vcgtzd_f64", |
| "vcgtzs_f32", |
| "vcgtzd_s64", |
| "vcgtzh_f16", |
| "vcle_f64", |
| "vcleq_f64", |
| "vcle_s64", |
| "vcleq_s64", |
| "vcle_u64", |
| "vcleq_u64", |
| "vcled_f64", |
| "vcles_f32", |
| "vcled_u64", |
| "vcled_s64", |
| "vcleh_f16", |
| "vclez_f32", |
| "vclezq_f32", |
| "vclez_f64", |
| "vclezq_f64", |
| "vclez_s8", |
| "vclezq_s8", |
| "vclez_s16", |
| "vclezq_s16", |
| "vclez_s32", |
| "vclezq_s32", |
| "vclez_s64", |
| "vclezq_s64", |
| "vclezd_f64", |
| "vclezs_f32", |
| "vclezd_s64", |
| "vclezh_f16", |
| "vclt_f64", |
| "vcltq_f64", |
| "vclt_s64", |
| "vcltq_s64", |
| "vclt_u64", |
| "vcltq_u64", |
| "vcltd_u64", |
| "vcltd_s64", |
| "vclth_f16", |
| "vclts_f32", |
| "vcltd_f64", |
| "vcltz_f32", |
| "vcltzq_f32", |
| "vcltz_f64", |
| "vcltzq_f64", |
| "vcltz_s8", |
| "vcltzq_s8", |
| "vcltz_s16", |
| "vcltzq_s16", |
| "vcltz_s32", |
| "vcltzq_s32", |
| "vcltz_s64", |
| "vcltzq_s64", |
| "vcltzd_f64", |
| "vcltzs_f32", |
| "vcltzd_s64", |
| "vcltzh_f16", |
| "vcmla_f16", |
| "vcmlaq_f16", |
| "vcmla_f32", |
| "vcmlaq_f32", |
| "vcmlaq_f64", |
| "vcmla_lane_f16", |
| "vcmlaq_lane_f16", |
| "vcmla_lane_f32", |
| "vcmlaq_lane_f32", |
| "vcmla_laneq_f16", |
| "vcmlaq_laneq_f16", |
| "vcmla_laneq_f32", |
| "vcmlaq_laneq_f32", |
| "vcmla_rot180_f16", |
| "vcmlaq_rot180_f16", |
| "vcmla_rot180_f32", |
| "vcmlaq_rot180_f32", |
| "vcmlaq_rot180_f64", |
| "vcmla_rot180_lane_f16", |
| "vcmlaq_rot180_lane_f16", |
| "vcmla_rot180_lane_f32", |
| "vcmlaq_rot180_lane_f32", |
| "vcmla_rot180_laneq_f16", |
| "vcmlaq_rot180_laneq_f16", |
| "vcmla_rot180_laneq_f32", |
| "vcmlaq_rot180_laneq_f32", |
| "vcmla_rot270_f16", |
| "vcmlaq_rot270_f16", |
| "vcmla_rot270_f32", |
| "vcmlaq_rot270_f32", |
| "vcmlaq_rot270_f64", |
| "vcmla_rot270_lane_f16", |
| "vcmlaq_rot270_lane_f16", |
| "vcmla_rot270_lane_f32", |
| "vcmlaq_rot270_lane_f32", |
| "vcmla_rot270_laneq_f16", |
| "vcmlaq_rot270_laneq_f16", |
| "vcmla_rot270_laneq_f32", |
| "vcmlaq_rot270_laneq_f32", |
| "vcmla_rot90_f16", |
| "vcmlaq_rot90_f16", |
| "vcmla_rot90_f32", |
| "vcmlaq_rot90_f32", |
| "vcmlaq_rot90_f64", |
| "vcmla_rot90_lane_f16", |
| "vcmlaq_rot90_lane_f16", |
| "vcmla_rot90_lane_f32", |
| "vcmlaq_rot90_lane_f32", |
| "vcmla_rot90_laneq_f16", |
| "vcmlaq_rot90_laneq_f16", |
| "vcmla_rot90_laneq_f32", |
| "vcmlaq_rot90_laneq_f32", |
| "vcopy_lane_f32", |
| "vcopy_lane_s8", |
| "vcopy_lane_s16", |
| "vcopy_lane_s32", |
| "vcopy_lane_u8", |
| "vcopy_lane_u16", |
| "vcopy_lane_u32", |
| "vcopy_lane_p8", |
| "vcopy_lane_p16", |
| "vcopy_laneq_f32", |
| "vcopy_laneq_s8", |
| "vcopy_laneq_s16", |
| "vcopy_laneq_s32", |
| "vcopy_laneq_u8", |
| "vcopy_laneq_u16", |
| "vcopy_laneq_u32", |
| "vcopy_laneq_p8", |
| "vcopy_laneq_p16", |
| "vcopyq_lane_f32", |
| "vcopyq_lane_f64", |
| "vcopyq_lane_s64", |
| "vcopyq_lane_u64", |
| "vcopyq_lane_p64", |
| "vcopyq_lane_s8", |
| "vcopyq_lane_s16", |
| "vcopyq_lane_s32", |
| "vcopyq_lane_u8", |
| "vcopyq_lane_u16", |
| "vcopyq_lane_u32", |
| "vcopyq_lane_p8", |
| "vcopyq_lane_p16", |
| "vcopyq_laneq_f32", |
| "vcopyq_laneq_f64", |
| "vcopyq_laneq_s8", |
| "vcopyq_laneq_s16", |
| "vcopyq_laneq_s32", |
| "vcopyq_laneq_s64", |
| "vcopyq_laneq_u8", |
| "vcopyq_laneq_u16", |
| "vcopyq_laneq_u32", |
| "vcopyq_laneq_u64", |
| "vcopyq_laneq_p8", |
| "vcopyq_laneq_p16", |
| "vcopyq_laneq_p64", |
| "vcreate_f64", |
| "vcvt_f32_f64", |
| "vcvt_f64_f32", |
| "vcvt_f64_s64", |
| "vcvtq_f64_s64", |
| "vcvt_f64_u64", |
| "vcvtq_f64_u64", |
| "vcvt_high_f16_f32", |
| "vcvt_high_f32_f16", |
| "vcvt_high_f32_f64", |
| "vcvt_high_f64_f32", |
| "vcvt_n_f64_s64", |
| "vcvtq_n_f64_s64", |
| "vcvt_n_f64_u64", |
| "vcvtq_n_f64_u64", |
| "vcvt_n_s64_f64", |
| "vcvtq_n_s64_f64", |
| "vcvt_n_u64_f64", |
| "vcvtq_n_u64_f64", |
| "vcvt_s64_f64", |
| "vcvtq_s64_f64", |
| "vcvt_u64_f64", |
| "vcvtq_u64_f64", |
| "vcvta_s16_f16", |
| "vcvtaq_s16_f16", |
| "vcvta_s32_f32", |
| "vcvtaq_s32_f32", |
| "vcvta_s64_f64", |
| "vcvtaq_s64_f64", |
| "vcvta_u16_f16", |
| "vcvtaq_u16_f16", |
| "vcvta_u32_f32", |
| "vcvtaq_u32_f32", |
| "vcvta_u64_f64", |
| "vcvtaq_u64_f64", |
| "vcvtah_s16_f16", |
| "vcvtah_s32_f16", |
| "vcvtah_s64_f16", |
| "vcvtah_u16_f16", |
| "vcvtah_u32_f16", |
| "vcvtah_u64_f16", |
| "vcvtas_s32_f32", |
| "vcvtad_s64_f64", |
| "vcvtas_u32_f32", |
| "vcvtad_u64_f64", |
| "vcvtd_f64_s64", |
| "vcvts_f32_s32", |
| "vcvth_f16_s16", |
| "vcvth_f16_s32", |
| "vcvth_f16_s64", |
| "vcvth_f16_u16", |
| "vcvth_f16_u32", |
| "vcvth_f16_u64", |
| "vcvth_n_f16_s16", |
| "vcvth_n_f16_s32", |
| "vcvth_n_f16_s64", |
| "vcvth_n_f16_u16", |
| "vcvth_n_f16_u32", |
| "vcvth_n_f16_u64", |
| "vcvth_n_s16_f16", |
| "vcvth_n_s32_f16", |
| "vcvth_n_s64_f16", |
| "vcvth_n_u16_f16", |
| "vcvth_n_u32_f16", |
| "vcvth_n_u64_f16", |
| "vcvth_s16_f16", |
| "vcvth_s32_f16", |
| "vcvth_s64_f16", |
| "vcvth_u16_f16", |
| "vcvth_u32_f16", |
| "vcvth_u64_f16", |
| "vcvtm_s16_f16", |
| "vcvtmq_s16_f16", |
| "vcvtm_s32_f32", |
| "vcvtmq_s32_f32", |
| "vcvtm_s64_f64", |
| "vcvtmq_s64_f64", |
| "vcvtm_u16_f16", |
| "vcvtmq_u16_f16", |
| "vcvtm_u32_f32", |
| "vcvtmq_u32_f32", |
| "vcvtm_u64_f64", |
| "vcvtmq_u64_f64", |
| "vcvtmh_s16_f16", |
| "vcvtmh_s32_f16", |
| "vcvtmh_s64_f16", |
| "vcvtmh_u16_f16", |
| "vcvtmh_u32_f16", |
| "vcvtmh_u64_f16", |
| "vcvtms_s32_f32", |
| "vcvtmd_s64_f64", |
| "vcvtms_u32_f32", |
| "vcvtmd_u64_f64", |
| "vcvtn_s16_f16", |
| "vcvtnq_s16_f16", |
| "vcvtn_s32_f32", |
| "vcvtnq_s32_f32", |
| "vcvtn_s64_f64", |
| "vcvtnq_s64_f64", |
| "vcvtn_u16_f16", |
| "vcvtnq_u16_f16", |
| "vcvtn_u32_f32", |
| "vcvtnq_u32_f32", |
| "vcvtn_u64_f64", |
| "vcvtnq_u64_f64", |
| "vcvtnh_s16_f16", |
| "vcvtnh_s32_f16", |
| "vcvtnh_s64_f16", |
| "vcvtnh_u16_f16", |
| "vcvtnh_u32_f16", |
| "vcvtnh_u64_f16", |
| "vcvtns_s32_f32", |
| "vcvtnd_s64_f64", |
| "vcvtns_u32_f32", |
| "vcvtnd_u64_f64", |
| "vcvtp_s16_f16", |
| "vcvtpq_s16_f16", |
| "vcvtp_s32_f32", |
| "vcvtpq_s32_f32", |
| "vcvtp_s64_f64", |
| "vcvtpq_s64_f64", |
| "vcvtp_u16_f16", |
| "vcvtpq_u16_f16", |
| "vcvtp_u32_f32", |
| "vcvtpq_u32_f32", |
| "vcvtp_u64_f64", |
| "vcvtpq_u64_f64", |
| "vcvtph_s16_f16", |
| "vcvtph_s32_f16", |
| "vcvtph_s64_f16", |
| "vcvtph_u16_f16", |
| "vcvtph_u32_f16", |
| "vcvtph_u64_f16", |
| "vcvtps_s32_f32", |
| "vcvtpd_s64_f64", |
| "vcvtps_u32_f32", |
| "vcvtpd_u64_f64", |
| "vcvts_f32_u32", |
| "vcvtd_f64_u64", |
| "vcvts_n_f32_s32", |
| "vcvtd_n_f64_s64", |
| "vcvts_n_f32_u32", |
| "vcvtd_n_f64_u64", |
| "vcvts_n_s32_f32", |
| "vcvtd_n_s64_f64", |
| "vcvts_n_u32_f32", |
| "vcvtd_n_u64_f64", |
| "vcvts_s32_f32", |
| "vcvtd_s64_f64", |
| "vcvts_u32_f32", |
| "vcvtd_u64_f64", |
| "vcvtx_f32_f64", |
| "vcvtx_high_f32_f64", |
| "vcvtxd_f32_f64", |
| "vdiv_f16", |
| "vdivq_f16", |
| "vdiv_f32", |
| "vdivq_f32", |
| "vdiv_f64", |
| "vdivq_f64", |
| "vdivh_f16", |
| "vdup_lane_f64", |
| "vdup_lane_p64", |
| "vdup_laneq_f64", |
| "vdup_laneq_p64", |
| "vdupb_lane_s8", |
| "vduph_laneq_s16", |
| "vdupb_lane_u8", |
| "vduph_laneq_u16", |
| "vdupb_lane_p8", |
| "vduph_laneq_p16", |
| "vdupb_laneq_s8", |
| "vdupb_laneq_u8", |
| "vdupb_laneq_p8", |
| "vdupd_lane_f64", |
| "vdupd_lane_s64", |
| "vdupd_lane_u64", |
| "vduph_lane_f16", |
| "vduph_laneq_f16", |
| "vdupq_lane_f64", |
| "vdupq_lane_p64", |
| "vdupq_laneq_f64", |
| "vdupq_laneq_p64", |
| "vdups_lane_f32", |
| "vdupd_laneq_f64", |
| "vdups_lane_s32", |
| "vdupd_laneq_s64", |
| "vdups_lane_u32", |
| "vdupd_laneq_u64", |
| "vdups_laneq_f32", |
| "vduph_lane_s16", |
| "vdups_laneq_s32", |
| "vduph_lane_u16", |
| "vdups_laneq_u32", |
| "vduph_lane_p16", |
| "veor3q_s8", |
| "veor3q_s16", |
| "veor3q_s32", |
| "veor3q_s64", |
| "veor3q_u8", |
| "veor3q_u16", |
| "veor3q_u32", |
| "veor3q_u64", |
| "vextq_f64", |
| "vextq_p64", |
| "vfma_f64", |
| "vfma_lane_f16", |
| "vfma_laneq_f16", |
| "vfmaq_lane_f16", |
| "vfmaq_laneq_f16", |
| "vfma_lane_f32", |
| "vfma_laneq_f32", |
| "vfmaq_lane_f32", |
| "vfmaq_laneq_f32", |
| "vfmaq_laneq_f64", |
| "vfma_lane_f64", |
| "vfma_laneq_f64", |
| "vfma_n_f16", |
| "vfmaq_n_f16", |
| "vfma_n_f64", |
| "vfmad_lane_f64", |
| "vfmah_f16", |
| "vfmah_lane_f16", |
| "vfmah_laneq_f16", |
| "vfmaq_f64", |
| "vfmaq_lane_f64", |
| "vfmaq_n_f64", |
| "vfmas_lane_f32", |
| "vfmas_laneq_f32", |
| "vfmad_laneq_f64", |
| "vfmlal_high_f16", |
| "vfmlalq_high_f16", |
| "vfmlal_lane_high_f16", |
| "vfmlal_laneq_high_f16", |
| "vfmlalq_lane_high_f16", |
| "vfmlalq_laneq_high_f16", |
| "vfmlal_lane_low_f16", |
| "vfmlal_laneq_low_f16", |
| "vfmlalq_lane_low_f16", |
| "vfmlalq_laneq_low_f16", |
| "vfmlal_low_f16", |
| "vfmlalq_low_f16", |
| "vfmlsl_high_f16", |
| "vfmlslq_high_f16", |
| "vfmlsl_lane_high_f16", |
| "vfmlsl_laneq_high_f16", |
| "vfmlslq_lane_high_f16", |
| "vfmlslq_laneq_high_f16", |
| "vfmlsl_lane_low_f16", |
| "vfmlsl_laneq_low_f16", |
| "vfmlslq_lane_low_f16", |
| "vfmlslq_laneq_low_f16", |
| "vfmlsl_low_f16", |
| "vfmlslq_low_f16", |
| "vfms_f64", |
| "vfms_lane_f16", |
| "vfms_laneq_f16", |
| "vfmsq_lane_f16", |
| "vfmsq_laneq_f16", |
| "vfms_lane_f32", |
| "vfms_laneq_f32", |
| "vfmsq_lane_f32", |
| "vfmsq_laneq_f32", |
| "vfmsq_laneq_f64", |
| "vfms_lane_f64", |
| "vfms_laneq_f64", |
| "vfms_n_f16", |
| "vfmsq_n_f16", |
| "vfms_n_f64", |
| "vfmsh_f16", |
| "vfmsh_lane_f16", |
| "vfmsh_laneq_f16", |
| "vfmsq_f64", |
| "vfmsq_lane_f64", |
| "vfmsq_n_f64", |
| "vfmss_lane_f32", |
| "vfmss_laneq_f32", |
| "vfmsd_lane_f64", |
| "vfmsd_laneq_f64", |
| "vld1_f16", |
| "vld1q_f16", |
| "vld1_f64_x2", |
| "vld1_f64_x3", |
| "vld1_f64_x4", |
| "vld1q_f64_x2", |
| "vld1q_f64_x3", |
| "vld1q_f64_x4", |
| "vld2_dup_f64", |
| "vld2q_dup_f64", |
| "vld2q_dup_s64", |
| "vld2_f64", |
| "vld2_lane_f64", |
| "vld2_lane_s64", |
| "vld2_lane_p64", |
| "vld2_lane_u64", |
| "vld2q_dup_p64", |
| "vld2q_dup_p64", |
| "vld2q_dup_u64", |
| "vld2q_dup_u64", |
| "vld2q_f64", |
| "vld2q_s64", |
| "vld2q_lane_f64", |
| "vld2q_lane_s8", |
| "vld2q_lane_s64", |
| "vld2q_lane_p64", |
| "vld2q_lane_u8", |
| "vld2q_lane_u64", |
| "vld2q_lane_p8", |
| "vld2q_p64", |
| "vld2q_p64", |
| "vld2q_u64", |
| "vld3_dup_f64", |
| "vld3q_dup_f64", |
| "vld3q_dup_s64", |
| "vld3_f64", |
| "vld3_lane_f64", |
| "vld3_lane_p64", |
| "vld3_lane_s64", |
| "vld3_lane_u64", |
| "vld3q_dup_p64", |
| "vld3q_dup_p64", |
| "vld3q_dup_u64", |
| "vld3q_dup_u64", |
| "vld3q_f64", |
| "vld3q_s64", |
| "vld3q_lane_f64", |
| "vld3q_lane_p64", |
| "vld3q_lane_s8", |
| "vld3q_lane_s64", |
| "vld3q_lane_u8", |
| "vld3q_lane_u64", |
| "vld3q_lane_p8", |
| "vld3q_p64", |
| "vld3q_p64", |
| "vld3q_u64", |
| "vld4_dup_f64", |
| "vld4q_dup_f64", |
| "vld4q_dup_s64", |
| "vld4_f64", |
| "vld4_lane_f64", |
| "vld4_lane_s64", |
| "vld4_lane_p64", |
| "vld4_lane_u64", |
| "vld4q_dup_p64", |
| "vld4q_dup_p64", |
| "vld4q_dup_u64", |
| "vld4q_dup_u64", |
| "vld4q_f64", |
| "vld4q_s64", |
| "vld4q_lane_f64", |
| "vld4q_lane_s8", |
| "vld4q_lane_s64", |
| "vld4q_lane_p64", |
| "vld4q_lane_u8", |
| "vld4q_lane_u64", |
| "vld4q_lane_p8", |
| "vld4q_p64", |
| "vld4q_p64", |
| "vld4q_u64", |
| "vldap1_lane_s64", |
| "vldap1q_lane_s64", |
| "vldap1q_lane_f64", |
| "vldap1_lane_u64", |
| "vldap1q_lane_u64", |
| "vldap1_lane_p64", |
| "vldap1q_lane_p64", |
| "vluti2_lane_f16", |
| "vluti2q_lane_f16", |
| "vluti2_lane_u8", |
| "vluti2q_lane_u8", |
| "vluti2_lane_u16", |
| "vluti2q_lane_u16", |
| "vluti2_lane_p8", |
| "vluti2q_lane_p8", |
| "vluti2_lane_p16", |
| "vluti2q_lane_p16", |
| "vluti2_lane_s8", |
| "vluti2q_lane_s8", |
| "vluti2_lane_s16", |
| "vluti2q_lane_s16", |
| "vluti2_laneq_f16", |
| "vluti2q_laneq_f16", |
| "vluti2_laneq_u8", |
| "vluti2q_laneq_u8", |
| "vluti2_laneq_u16", |
| "vluti2q_laneq_u16", |
| "vluti2_laneq_p8", |
| "vluti2q_laneq_p8", |
| "vluti2_laneq_p16", |
| "vluti2q_laneq_p16", |
| "vluti2_laneq_s8", |
| "vluti2q_laneq_s8", |
| "vluti2_laneq_s16", |
| "vluti2q_laneq_s16", |
| "vluti4q_lane_f16_x2", |
| "vluti4q_lane_u16_x2", |
| "vluti4q_lane_p16_x2", |
| "vluti4q_lane_s16_x2", |
| "vluti4q_lane_s8", |
| "vluti4q_lane_u8", |
| "vluti4q_lane_p8", |
| "vluti4q_laneq_f16_x2", |
| "vluti4q_laneq_u16_x2", |
| "vluti4q_laneq_p16_x2", |
| "vluti4q_laneq_s16_x2", |
| "vluti4q_laneq_s8", |
| "vluti4q_laneq_u8", |
| "vluti4q_laneq_p8", |
| "vmax_f64", |
| "vmaxq_f64", |
| "vmaxh_f16", |
| "vmaxnm_f64", |
| "vmaxnmq_f64", |
| "vmaxnmh_f16", |
| "vmaxnmv_f16", |
| "vmaxnmvq_f16", |
| "vmaxnmv_f32", |
| "vmaxnmvq_f64", |
| "vmaxnmvq_f32", |
| "vmaxv_f16", |
| "vmaxvq_f16", |
| "vmaxv_f32", |
| "vmaxvq_f32", |
| "vmaxvq_f64", |
| "vmaxv_s8", |
| "vmaxvq_s8", |
| "vmaxv_s16", |
| "vmaxvq_s16", |
| "vmaxv_s32", |
| "vmaxvq_s32", |
| "vmaxv_u8", |
| "vmaxvq_u8", |
| "vmaxv_u16", |
| "vmaxvq_u16", |
| "vmaxv_u32", |
| "vmaxvq_u32", |
| "vmin_f64", |
| "vminq_f64", |
| "vminh_f16", |
| "vminnm_f64", |
| "vminnmq_f64", |
| "vminnmh_f16", |
| "vminnmv_f16", |
| "vminnmvq_f16", |
| "vminnmv_f32", |
| "vminnmvq_f64", |
| "vminnmvq_f32", |
| "vminv_f16", |
| "vminvq_f16", |
| "vminv_f32", |
| "vminvq_f32", |
| "vminvq_f64", |
| "vminv_s8", |
| "vminvq_s8", |
| "vminv_s16", |
| "vminvq_s16", |
| "vminv_s32", |
| "vminvq_s32", |
| "vminv_u8", |
| "vminvq_u8", |
| "vminv_u16", |
| "vminvq_u16", |
| "vminv_u32", |
| "vminvq_u32", |
| "vmla_f64", |
| "vmlaq_f64", |
| "vmlal_high_lane_s16", |
| "vmlal_high_laneq_s16", |
| "vmlal_high_lane_s32", |
| "vmlal_high_laneq_s32", |
| "vmlal_high_lane_u16", |
| "vmlal_high_laneq_u16", |
| "vmlal_high_lane_u32", |
| "vmlal_high_laneq_u32", |
| "vmlal_high_n_s16", |
| "vmlal_high_n_s32", |
| "vmlal_high_n_u16", |
| "vmlal_high_n_u32", |
| "vmlal_high_s8", |
| "vmlal_high_s16", |
| "vmlal_high_s32", |
| "vmlal_high_u8", |
| "vmlal_high_u16", |
| "vmlal_high_u32", |
| "vmls_f64", |
| "vmlsq_f64", |
| "vmlsl_high_lane_s16", |
| "vmlsl_high_laneq_s16", |
| "vmlsl_high_lane_s32", |
| "vmlsl_high_laneq_s32", |
| "vmlsl_high_lane_u16", |
| "vmlsl_high_laneq_u16", |
| "vmlsl_high_lane_u32", |
| "vmlsl_high_laneq_u32", |
| "vmlsl_high_n_s16", |
| "vmlsl_high_n_s32", |
| "vmlsl_high_n_u16", |
| "vmlsl_high_n_u32", |
| "vmlsl_high_s8", |
| "vmlsl_high_s16", |
| "vmlsl_high_s32", |
| "vmlsl_high_u8", |
| "vmlsl_high_u16", |
| "vmlsl_high_u32", |
| "vmovl_high_s8", |
| "vmovl_high_s16", |
| "vmovl_high_s32", |
| "vmovl_high_u8", |
| "vmovl_high_u16", |
| "vmovl_high_u32", |
| "vmovn_high_s16", |
| "vmovn_high_s32", |
| "vmovn_high_s64", |
| "vmovn_high_u16", |
| "vmovn_high_u32", |
| "vmovn_high_u64", |
| "vmul_f64", |
| "vmulq_f64", |
| "vmul_lane_f64", |
| "vmul_laneq_f16", |
| "vmulq_laneq_f16", |
| "vmul_laneq_f64", |
| "vmul_n_f64", |
| "vmulq_n_f64", |
| "vmuld_lane_f64", |
| "vmulh_f16", |
| "vmulh_lane_f16", |
| "vmulh_laneq_f16", |
| "vmull_high_lane_s16", |
| "vmull_high_laneq_s16", |
| "vmull_high_lane_s32", |
| "vmull_high_laneq_s32", |
| "vmull_high_lane_u16", |
| "vmull_high_laneq_u16", |
| "vmull_high_lane_u32", |
| "vmull_high_laneq_u32", |
| "vmull_high_n_s16", |
| "vmull_high_n_s32", |
| "vmull_high_n_u16", |
| "vmull_high_n_u32", |
| "vmull_high_p64", |
| "vmull_high_p8", |
| "vmull_high_s8", |
| "vmull_high_s16", |
| "vmull_high_s32", |
| "vmull_high_u8", |
| "vmull_high_u16", |
| "vmull_high_u32", |
| "vmull_p64", |
| "vmulq_lane_f64", |
| "vmulq_laneq_f64", |
| "vmuls_lane_f32", |
| "vmuls_laneq_f32", |
| "vmuld_laneq_f64", |
| "vmulx_f16", |
| "vmulxq_f16", |
| "vmulx_f32", |
| "vmulxq_f32", |
| "vmulx_f64", |
| "vmulxq_f64", |
| "vmulx_lane_f16", |
| "vmulx_laneq_f16", |
| "vmulxq_lane_f16", |
| "vmulxq_laneq_f16", |
| "vmulx_lane_f32", |
| "vmulx_laneq_f32", |
| "vmulxq_lane_f32", |
| "vmulxq_laneq_f32", |
| "vmulxq_laneq_f64", |
| "vmulx_lane_f64", |
| "vmulx_laneq_f64", |
| "vmulx_n_f16", |
| "vmulxq_n_f16", |
| "vmulxd_f64", |
| "vmulxs_f32", |
| "vmulxd_lane_f64", |
| "vmulxd_laneq_f64", |
| "vmulxs_lane_f32", |
| "vmulxs_laneq_f32", |
| "vmulxh_f16", |
| "vmulxh_lane_f16", |
| "vmulxh_laneq_f16", |
| "vmulxq_lane_f64", |
| "vneg_f64", |
| "vnegq_f64", |
| "vneg_s64", |
| "vnegq_s64", |
| "vnegd_s64", |
| "vnegh_f16", |
| "vpaddd_f64", |
| "vpadds_f32", |
| "vpaddd_s64", |
| "vpaddd_u64", |
| "vpaddq_f16", |
| "vpaddq_f32", |
| "vpaddq_f64", |
| "vpaddq_s8", |
| "vpaddq_s16", |
| "vpaddq_s32", |
| "vpaddq_s64", |
| "vpaddq_u8", |
| "vpaddq_u16", |
| "vpaddq_u32", |
| "vpaddq_u64", |
| "vpmax_f16", |
| "vpmaxq_f16", |
| "vpmaxnm_f16", |
| "vpmaxnmq_f16", |
| "vpmaxnm_f32", |
| "vpmaxnmq_f32", |
| "vpmaxnmq_f64", |
| "vpmaxnmqd_f64", |
| "vpmaxnms_f32", |
| "vpmaxq_s8", |
| "vpmaxq_s16", |
| "vpmaxq_s32", |
| "vpmaxq_u8", |
| "vpmaxq_u16", |
| "vpmaxq_u32", |
| "vpmaxqd_f64", |
| "vpmaxs_f32", |
| "vpmin_f16", |
| "vpminq_f16", |
| "vpminnm_f16", |
| "vpminnmq_f16", |
| "vpminnm_f32", |
| "vpminnmq_f32", |
| "vpminnmq_f64", |
| "vpminnmqd_f64", |
| "vpminnms_f32", |
| "vpminq_s8", |
| "vpminq_s16", |
| "vpminq_s32", |
| "vpminq_u8", |
| "vpminq_u16", |
| "vpminq_u32", |
| "vpminqd_f64", |
| "vpmins_f32", |
| "vqabs_s64", |
| "vqabsq_s64", |
| "vqabsb_s8", |
| "vqabsh_s16", |
| "vqabss_s32", |
| "vqabsd_s64", |
| "vqaddb_s8", |
| "vqaddh_s16", |
| "vqaddb_u8", |
| "vqaddh_u16", |
| "vqadds_s32", |
| "vqaddd_s64", |
| "vqadds_u32", |
| "vqaddd_u64", |
| "vqdmlal_high_lane_s16", |
| "vqdmlal_high_laneq_s16", |
| "vqdmlal_high_lane_s32", |
| "vqdmlal_high_laneq_s32", |
| "vqdmlal_high_n_s16", |
| "vqdmlal_high_s16", |
| "vqdmlal_high_n_s32", |
| "vqdmlal_high_s32", |
| "vqdmlal_laneq_s16", |
| "vqdmlal_laneq_s32", |
| "vqdmlalh_lane_s16", |
| "vqdmlalh_laneq_s16", |
| "vqdmlals_lane_s32", |
| "vqdmlals_laneq_s32", |
| "vqdmlalh_s16", |
| "vqdmlals_s32", |
| "vqdmlsl_high_lane_s16", |
| "vqdmlsl_high_laneq_s16", |
| "vqdmlsl_high_lane_s32", |
| "vqdmlsl_high_laneq_s32", |
| "vqdmlsl_high_n_s16", |
| "vqdmlsl_high_s16", |
| "vqdmlsl_high_n_s32", |
| "vqdmlsl_high_s32", |
| "vqdmlsl_laneq_s16", |
| "vqdmlsl_laneq_s32", |
| "vqdmlslh_lane_s16", |
| "vqdmlslh_laneq_s16", |
| "vqdmlsls_lane_s32", |
| "vqdmlsls_laneq_s32", |
| "vqdmlslh_s16", |
| "vqdmlsls_s32", |
| "vqdmulh_lane_s16", |
| "vqdmulhq_lane_s16", |
| "vqdmulh_lane_s32", |
| "vqdmulhq_lane_s32", |
| "vqdmulhh_lane_s16", |
| "vqdmulhh_laneq_s16", |
| "vqdmulhh_s16", |
| "vqdmulhs_s32", |
| "vqdmulhs_lane_s32", |
| "vqdmulhs_laneq_s32", |
| "vqdmull_high_lane_s16", |
| "vqdmull_high_laneq_s32", |
| "vqdmull_high_lane_s32", |
| "vqdmull_high_laneq_s16", |
| "vqdmull_high_n_s16", |
| "vqdmull_high_n_s32", |
| "vqdmull_high_s16", |
| "vqdmull_high_s32", |
| "vqdmull_laneq_s16", |
| "vqdmull_laneq_s32", |
| "vqdmullh_lane_s16", |
| "vqdmulls_laneq_s32", |
| "vqdmullh_laneq_s16", |
| "vqdmullh_s16", |
| "vqdmulls_lane_s32", |
| "vqdmulls_s32", |
| "vqmovn_high_s16", |
| "vqmovn_high_s32", |
| "vqmovn_high_s64", |
| "vqmovn_high_u16", |
| "vqmovn_high_u32", |
| "vqmovn_high_u64", |
| "vqmovnd_s64", |
| "vqmovnd_u64", |
| "vqmovnh_s16", |
| "vqmovns_s32", |
| "vqmovnh_u16", |
| "vqmovns_u32", |
| "vqmovun_high_s16", |
| "vqmovun_high_s32", |
| "vqmovun_high_s64", |
| "vqmovunh_s16", |
| "vqmovuns_s32", |
| "vqmovund_s64", |
| "vqneg_s64", |
| "vqnegq_s64", |
| "vqnegb_s8", |
| "vqnegh_s16", |
| "vqnegs_s32", |
| "vqnegd_s64", |
| "vqrdmlah_lane_s16", |
| "vqrdmlah_lane_s32", |
| "vqrdmlah_laneq_s16", |
| "vqrdmlah_laneq_s32", |
| "vqrdmlahq_lane_s16", |
| "vqrdmlahq_lane_s32", |
| "vqrdmlahq_laneq_s16", |
| "vqrdmlahq_laneq_s32", |
| "vqrdmlah_s16", |
| "vqrdmlahq_s16", |
| "vqrdmlah_s32", |
| "vqrdmlahq_s32", |
| "vqrdmlahh_lane_s16", |
| "vqrdmlahh_laneq_s16", |
| "vqrdmlahs_lane_s32", |
| "vqrdmlahs_laneq_s32", |
| "vqrdmlahh_s16", |
| "vqrdmlahs_s32", |
| "vqrdmlsh_lane_s16", |
| "vqrdmlsh_lane_s32", |
| "vqrdmlsh_laneq_s16", |
| "vqrdmlsh_laneq_s32", |
| "vqrdmlshq_lane_s16", |
| "vqrdmlshq_lane_s32", |
| "vqrdmlshq_laneq_s16", |
| "vqrdmlshq_laneq_s32", |
| "vqrdmlsh_s16", |
| "vqrdmlshq_s16", |
| "vqrdmlsh_s32", |
| "vqrdmlshq_s32", |
| "vqrdmlshh_lane_s16", |
| "vqrdmlshh_laneq_s16", |
| "vqrdmlshs_lane_s32", |
| "vqrdmlshs_laneq_s32", |
| "vqrdmlshh_s16", |
| "vqrdmlshs_s32", |
| "vqrdmulhh_lane_s16", |
| "vqrdmulhh_laneq_s16", |
| "vqrdmulhs_lane_s32", |
| "vqrdmulhs_laneq_s32", |
| "vqrdmulhh_s16", |
| "vqrdmulhs_s32", |
| "vqrshlb_s8", |
| "vqrshlh_s16", |
| "vqrshlb_u8", |
| "vqrshlh_u16", |
| "vqrshld_s64", |
| "vqrshls_s32", |
| "vqrshls_u32", |
| "vqrshld_u64", |
| "vqrshrn_high_n_s16", |
| "vqrshrn_high_n_s32", |
| "vqrshrn_high_n_s64", |
| "vqrshrn_high_n_u16", |
| "vqrshrn_high_n_u32", |
| "vqrshrn_high_n_u64", |
| "vqrshrnd_n_u64", |
| "vqrshrnh_n_u16", |
| "vqrshrns_n_u32", |
| "vqrshrnh_n_s16", |
| "vqrshrns_n_s32", |
| "vqrshrnd_n_s64", |
| "vqrshrun_high_n_s16", |
| "vqrshrun_high_n_s32", |
| "vqrshrun_high_n_s64", |
| "vqrshrund_n_s64", |
| "vqrshrunh_n_s16", |
| "vqrshruns_n_s32", |
| "vqshlb_n_s8", |
| "vqshld_n_s64", |
| "vqshlh_n_s16", |
| "vqshls_n_s32", |
| "vqshlb_n_u8", |
| "vqshld_n_u64", |
| "vqshlh_n_u16", |
| "vqshls_n_u32", |
| "vqshlb_s8", |
| "vqshlh_s16", |
| "vqshls_s32", |
| "vqshlb_u8", |
| "vqshlh_u16", |
| "vqshls_u32", |
| "vqshld_s64", |
| "vqshld_u64", |
| "vqshlub_n_s8", |
| "vqshlud_n_s64", |
| "vqshluh_n_s16", |
| "vqshlus_n_s32", |
| "vqshrn_high_n_s16", |
| "vqshrn_high_n_s32", |
| "vqshrn_high_n_s64", |
| "vqshrn_high_n_u16", |
| "vqshrn_high_n_u32", |
| "vqshrn_high_n_u64", |
| "vqshrnd_n_s64", |
| "vqshrnd_n_u64", |
| "vqshrnh_n_s16", |
| "vqshrns_n_s32", |
| "vqshrnh_n_u16", |
| "vqshrns_n_u32", |
| "vqshrun_high_n_s16", |
| "vqshrun_high_n_s32", |
| "vqshrun_high_n_s64", |
| "vqshrund_n_s64", |
| "vqshrunh_n_s16", |
| "vqshruns_n_s32", |
| "vqsubb_s8", |
| "vqsubh_s16", |
| "vqsubb_u8", |
| "vqsubh_u16", |
| "vqsubs_s32", |
| "vqsubd_s64", |
| "vqsubs_u32", |
| "vqsubd_u64", |
| "vrax1q_u64", |
| "vrbit_s8", |
| "vrbitq_s8", |
| "vrbit_u8", |
| "vrbit_u8", |
| "vrbitq_u8", |
| "vrbitq_u8", |
| "vrbit_p8", |
| "vrbit_p8", |
| "vrbitq_p8", |
| "vrbitq_p8", |
| "vrecpe_f64", |
| "vrecpeq_f64", |
| "vrecped_f64", |
| "vrecpes_f32", |
| "vrecpeh_f16", |
| "vrecps_f64", |
| "vrecpsq_f64", |
| "vrecpsd_f64", |
| "vrecpss_f32", |
| "vrecpsh_f16", |
| "vrecpxd_f64", |
| "vrecpxs_f32", |
| "vrecpxh_f16", |
| "vreinterpret_f64_f16", |
| "vreinterpret_f64_f16", |
| "vreinterpretq_f64_f16", |
| "vreinterpretq_f64_f16", |
| "vreinterpret_f16_f64", |
| "vreinterpret_f16_f64", |
| "vreinterpretq_f16_f64", |
| "vreinterpretq_f16_f64", |
| "vreinterpretq_f64_p128", |
| "vreinterpretq_f64_p128", |
| "vreinterpret_f64_f32", |
| "vreinterpret_f64_f32", |
| "vreinterpret_p64_f32", |
| "vreinterpret_p64_f32", |
| "vreinterpretq_f64_f32", |
| "vreinterpretq_f64_f32", |
| "vreinterpretq_p64_f32", |
| "vreinterpretq_p64_f32", |
| "vreinterpret_f32_f64", |
| "vreinterpret_f32_f64", |
| "vreinterpret_s8_f64", |
| "vreinterpret_s8_f64", |
| "vreinterpret_s16_f64", |
| "vreinterpret_s16_f64", |
| "vreinterpret_s32_f64", |
| "vreinterpret_s32_f64", |
| "vreinterpret_s64_f64", |
| "vreinterpret_u8_f64", |
| "vreinterpret_u8_f64", |
| "vreinterpret_u16_f64", |
| "vreinterpret_u16_f64", |
| "vreinterpret_u32_f64", |
| "vreinterpret_u32_f64", |
| "vreinterpret_u64_f64", |
| "vreinterpret_p8_f64", |
| "vreinterpret_p8_f64", |
| "vreinterpret_p16_f64", |
| "vreinterpret_p16_f64", |
| "vreinterpret_p64_f64", |
| "vreinterpretq_p128_f64", |
| "vreinterpretq_p128_f64", |
| "vreinterpretq_f32_f64", |
| "vreinterpretq_f32_f64", |
| "vreinterpretq_s8_f64", |
| "vreinterpretq_s8_f64", |
| "vreinterpretq_s16_f64", |
| "vreinterpretq_s16_f64", |
| "vreinterpretq_s32_f64", |
| "vreinterpretq_s32_f64", |
| "vreinterpretq_s64_f64", |
| "vreinterpretq_s64_f64", |
| "vreinterpretq_u8_f64", |
| "vreinterpretq_u8_f64", |
| "vreinterpretq_u16_f64", |
| "vreinterpretq_u16_f64", |
| "vreinterpretq_u32_f64", |
| "vreinterpretq_u32_f64", |
| "vreinterpretq_u64_f64", |
| "vreinterpretq_u64_f64", |
| "vreinterpretq_p8_f64", |
| "vreinterpretq_p8_f64", |
| "vreinterpretq_p16_f64", |
| "vreinterpretq_p16_f64", |
| "vreinterpretq_p64_f64", |
| "vreinterpretq_p64_f64", |
| "vreinterpret_f64_s8", |
| "vreinterpret_f64_s8", |
| "vreinterpretq_f64_s8", |
| "vreinterpretq_f64_s8", |
| "vreinterpret_f64_s16", |
| "vreinterpret_f64_s16", |
| "vreinterpretq_f64_s16", |
| "vreinterpretq_f64_s16", |
| "vreinterpret_f64_s32", |
| "vreinterpret_f64_s32", |
| "vreinterpretq_f64_s32", |
| "vreinterpretq_f64_s32", |
| "vreinterpret_f64_s64", |
| "vreinterpret_p64_s64", |
| "vreinterpretq_f64_s64", |
| "vreinterpretq_f64_s64", |
| "vreinterpretq_p64_s64", |
| "vreinterpretq_p64_s64", |
| "vreinterpret_f64_u8", |
| "vreinterpret_f64_u8", |
| "vreinterpretq_f64_u8", |
| "vreinterpretq_f64_u8", |
| "vreinterpret_f64_u16", |
| "vreinterpret_f64_u16", |
| "vreinterpretq_f64_u16", |
| "vreinterpretq_f64_u16", |
| "vreinterpret_f64_u32", |
| "vreinterpret_f64_u32", |
| "vreinterpretq_f64_u32", |
| "vreinterpretq_f64_u32", |
| "vreinterpret_f64_u64", |
| "vreinterpret_p64_u64", |
| "vreinterpretq_f64_u64", |
| "vreinterpretq_f64_u64", |
| "vreinterpretq_p64_u64", |
| "vreinterpretq_p64_u64", |
| "vreinterpret_f64_p8", |
| "vreinterpret_f64_p8", |
| "vreinterpretq_f64_p8", |
| "vreinterpretq_f64_p8", |
| "vreinterpret_f64_p16", |
| "vreinterpret_f64_p16", |
| "vreinterpretq_f64_p16", |
| "vreinterpretq_f64_p16", |
| "vreinterpret_f32_p64", |
| "vreinterpret_f32_p64", |
| "vreinterpret_f64_p64", |
| "vreinterpret_s64_p64", |
| "vreinterpret_u64_p64", |
| "vreinterpretq_f32_p64", |
| "vreinterpretq_f32_p64", |
| "vreinterpretq_f64_p64", |
| "vreinterpretq_f64_p64", |
| "vreinterpretq_s64_p64", |
| "vreinterpretq_s64_p64", |
| "vreinterpretq_u64_p64", |
| "vreinterpretq_u64_p64", |
| "vrnd32x_f32", |
| "vrnd32xq_f32", |
| "vrnd32xq_f64", |
| "vrnd32x_f64", |
| "vrnd32z_f32", |
| "vrnd32zq_f32", |
| "vrnd32zq_f64", |
| "vrnd32z_f64", |
| "vrnd64x_f32", |
| "vrnd64xq_f32", |
| "vrnd64xq_f64", |
| "vrnd64x_f64", |
| "vrnd64z_f32", |
| "vrnd64zq_f32", |
| "vrnd64zq_f64", |
| "vrnd64z_f64", |
| "vrnd_f16", |
| "vrndq_f16", |
| "vrnd_f32", |
| "vrndq_f32", |
| "vrnd_f64", |
| "vrndq_f64", |
| "vrnda_f16", |
| "vrndaq_f16", |
| "vrnda_f32", |
| "vrndaq_f32", |
| "vrnda_f64", |
| "vrndaq_f64", |
| "vrndah_f16", |
| "vrndh_f16", |
| "vrndi_f16", |
| "vrndiq_f16", |
| "vrndi_f32", |
| "vrndiq_f32", |
| "vrndi_f64", |
| "vrndiq_f64", |
| "vrndih_f16", |
| "vrndm_f16", |
| "vrndmq_f16", |
| "vrndm_f32", |
| "vrndmq_f32", |
| "vrndm_f64", |
| "vrndmq_f64", |
| "vrndmh_f16", |
| "vrndn_f64", |
| "vrndnq_f64", |
| "vrndnh_f16", |
| "vrndns_f32", |
| "vrndp_f16", |
| "vrndpq_f16", |
| "vrndp_f32", |
| "vrndpq_f32", |
| "vrndp_f64", |
| "vrndpq_f64", |
| "vrndph_f16", |
| "vrndx_f16", |
| "vrndxq_f16", |
| "vrndx_f32", |
| "vrndxq_f32", |
| "vrndx_f64", |
| "vrndxq_f64", |
| "vrndxh_f16", |
| "vrshld_s64", |
| "vrshld_u64", |
| "vrshrd_n_s64", |
| "vrshrd_n_u64", |
| "vrshrn_high_n_s16", |
| "vrshrn_high_n_s32", |
| "vrshrn_high_n_s64", |
| "vrshrn_high_n_u16", |
| "vrshrn_high_n_u32", |
| "vrshrn_high_n_u64", |
| "vrsqrte_f64", |
| "vrsqrteq_f64", |
| "vrsqrted_f64", |
| "vrsqrtes_f32", |
| "vrsqrteh_f16", |
| "vrsqrts_f64", |
| "vrsqrtsq_f64", |
| "vrsqrtsd_f64", |
| "vrsqrtss_f32", |
| "vrsqrtsh_f16", |
| "vrsrad_n_s64", |
| "vrsrad_n_u64", |
| "vrsubhn_high_s16", |
| "vrsubhn_high_s32", |
| "vrsubhn_high_s64", |
| "vrsubhn_high_u16", |
| "vrsubhn_high_u32", |
| "vrsubhn_high_u64", |
| "vrsubhn_high_s16", |
| "vrsubhn_high_s32", |
| "vrsubhn_high_s64", |
| "vrsubhn_high_u16", |
| "vrsubhn_high_u32", |
| "vrsubhn_high_u64", |
| "vscale_f16", |
| "vscaleq_f16", |
| "vscale_f32", |
| "vscaleq_f32", |
| "vscaleq_f64", |
| "vset_lane_f64", |
| "vsetq_lane_f64", |
| "vsha512h2q_u64", |
| "vsha512hq_u64", |
| "vsha512su0q_u64", |
| "vsha512su1q_u64", |
| "vshld_s64", |
| "vshld_u64", |
| "vshll_high_n_s8", |
| "vshll_high_n_s16", |
| "vshll_high_n_s32", |
| "vshll_high_n_u8", |
| "vshll_high_n_u16", |
| "vshll_high_n_u32", |
| "vshrn_high_n_s16", |
| "vshrn_high_n_s32", |
| "vshrn_high_n_s64", |
| "vshrn_high_n_u16", |
| "vshrn_high_n_u32", |
| "vshrn_high_n_u64", |
| "vslid_n_s64", |
| "vslid_n_u64", |
| "vsm3partw1q_u32", |
| "vsm3partw2q_u32", |
| "vsm3ss1q_u32", |
| "vsm3tt1aq_u32", |
| "vsm3tt1bq_u32", |
| "vsm3tt2aq_u32", |
| "vsm3tt2bq_u32", |
| "vsm4ekeyq_u32", |
| "vsm4eq_u32", |
| "vsqadd_u8", |
| "vsqaddq_u8", |
| "vsqadd_u16", |
| "vsqaddq_u16", |
| "vsqadd_u32", |
| "vsqaddq_u32", |
| "vsqadd_u64", |
| "vsqaddq_u64", |
| "vsqaddb_u8", |
| "vsqaddh_u16", |
| "vsqaddd_u64", |
| "vsqadds_u32", |
| "vsqrt_f16", |
| "vsqrtq_f16", |
| "vsqrt_f32", |
| "vsqrtq_f32", |
| "vsqrt_f64", |
| "vsqrtq_f64", |
| "vsqrth_f16", |
| "vsrid_n_s64", |
| "vsrid_n_u64", |
| "vst1_f16", |
| "vst1q_f16", |
| "vst1_f64_x2", |
| "vst1q_f64_x2", |
| "vst1_f64_x3", |
| "vst1q_f64_x3", |
| "vst1_f64_x4", |
| "vst1q_f64_x4", |
| "vst1_lane_f64", |
| "vst1q_lane_f64", |
| "vst2_f64", |
| "vst2_lane_f64", |
| "vst2_lane_s64", |
| "vst2_lane_p64", |
| "vst2_lane_u64", |
| "vst2q_f64", |
| "vst2q_s64", |
| "vst2q_lane_f64", |
| "vst2q_lane_s8", |
| "vst2q_lane_s64", |
| "vst2q_lane_p64", |
| "vst2q_lane_u8", |
| "vst2q_lane_u64", |
| "vst2q_lane_p8", |
| "vst2q_p64", |
| "vst2q_u64", |
| "vst3_f64", |
| "vst3_lane_f64", |
| "vst3_lane_s64", |
| "vst3_lane_p64", |
| "vst3_lane_u64", |
| "vst3q_f64", |
| "vst3q_s64", |
| "vst3q_lane_f64", |
| "vst3q_lane_s8", |
| "vst3q_lane_s64", |
| "vst3q_lane_p64", |
| "vst3q_lane_u8", |
| "vst3q_lane_u64", |
| "vst3q_lane_p8", |
| "vst3q_p64", |
| "vst3q_u64", |
| "vst4_f64", |
| "vst4_lane_f64", |
| "vst4_lane_s64", |
| "vst4_lane_p64", |
| "vst4_lane_u64", |
| "vst4q_f64", |
| "vst4q_s64", |
| "vst4q_lane_f64", |
| "vst4q_lane_s8", |
| "vst4q_lane_s64", |
| "vst4q_lane_p64", |
| "vst4q_lane_u8", |
| "vst4q_lane_u64", |
| "vst4q_lane_p8", |
| "vst4q_p64", |
| "vst4q_u64", |
| "vstl1_lane_f64", |
| "vstl1q_lane_f64", |
| "vstl1_lane_u64", |
| "vstl1q_lane_u64", |
| "vstl1_lane_p64", |
| "vstl1q_lane_p64", |
| "vstl1_lane_s64", |
| "vstl1q_lane_s64", |
| "vsub_f64", |
| "vsubq_f64", |
| "vsubd_s64", |
| "vsubd_u64", |
| "vsubh_f16", |
| "vsubl_high_s8", |
| "vsubl_high_s16", |
| "vsubl_high_s32", |
| "vsubl_high_u8", |
| "vsubl_high_u16", |
| "vsubl_high_u32", |
| "vsubw_high_s8", |
| "vsubw_high_s16", |
| "vsubw_high_s32", |
| "vsubw_high_u8", |
| "vsubw_high_u16", |
| "vsubw_high_u32", |
| "vtrn1_f16", |
| "vtrn1q_f16", |
| "vtrn1_f32", |
| "vtrn1q_f64", |
| "vtrn1_s32", |
| "vtrn1q_s64", |
| "vtrn1_u32", |
| "vtrn1q_u64", |
| "vtrn1q_p64", |
| "vtrn1q_f32", |
| "vtrn1_s8", |
| "vtrn1q_s8", |
| "vtrn1_s16", |
| "vtrn1q_s16", |
| "vtrn1q_s32", |
| "vtrn1_u8", |
| "vtrn1q_u8", |
| "vtrn1_u16", |
| "vtrn1q_u16", |
| "vtrn1q_u32", |
| "vtrn1_p8", |
| "vtrn1q_p8", |
| "vtrn1_p16", |
| "vtrn1q_p16", |
| "vtrn2_f16", |
| "vtrn2q_f16", |
| "vtrn2_f32", |
| "vtrn2q_f64", |
| "vtrn2_s32", |
| "vtrn2q_s64", |
| "vtrn2_u32", |
| "vtrn2q_u64", |
| "vtrn2q_p64", |
| "vtrn2q_f32", |
| "vtrn2_s8", |
| "vtrn2q_s8", |
| "vtrn2_s16", |
| "vtrn2q_s16", |
| "vtrn2q_s32", |
| "vtrn2_u8", |
| "vtrn2q_u8", |
| "vtrn2_u16", |
| "vtrn2q_u16", |
| "vtrn2q_u32", |
| "vtrn2_p8", |
| "vtrn2q_p8", |
| "vtrn2_p16", |
| "vtrn2q_p16", |
| "vtst_s64", |
| "vtstq_s64", |
| "vtst_p64", |
| "vtstq_p64", |
| "vtst_u64", |
| "vtstq_u64", |
| "vtstd_s64", |
| "vtstd_u64", |
| "vuqadd_s8", |
| "vuqaddq_s8", |
| "vuqadd_s16", |
| "vuqaddq_s16", |
| "vuqadd_s32", |
| "vuqaddq_s32", |
| "vuqadd_s64", |
| "vuqaddq_s64", |
| "vuqaddb_s8", |
| "vuqaddh_s16", |
| "vuqaddd_s64", |
| "vuqadds_s32", |
| "vuzp1_f16", |
| "vuzp1q_f16", |
| "vuzp1_f32", |
| "vuzp1q_f64", |
| "vuzp1_s32", |
| "vuzp1q_s64", |
| "vuzp1_u32", |
| "vuzp1q_u64", |
| "vuzp1q_p64", |
| "vuzp1q_f32", |
| "vuzp1_s8", |
| "vuzp1q_s8", |
| "vuzp1_s16", |
| "vuzp1q_s16", |
| "vuzp1q_s32", |
| "vuzp1_u8", |
| "vuzp1q_u8", |
| "vuzp1_u16", |
| "vuzp1q_u16", |
| "vuzp1q_u32", |
| "vuzp1_p8", |
| "vuzp1q_p8", |
| "vuzp1_p16", |
| "vuzp1q_p16", |
| "vuzp2_f16", |
| "vuzp2q_f16", |
| "vuzp2_f32", |
| "vuzp2q_f64", |
| "vuzp2_s32", |
| "vuzp2q_s64", |
| "vuzp2_u32", |
| "vuzp2q_u64", |
| "vuzp2q_p64", |
| "vuzp2q_f32", |
| "vuzp2_s8", |
| "vuzp2q_s8", |
| "vuzp2_s16", |
| "vuzp2q_s16", |
| "vuzp2q_s32", |
| "vuzp2_u8", |
| "vuzp2q_u8", |
| "vuzp2_u16", |
| "vuzp2q_u16", |
| "vuzp2q_u32", |
| "vuzp2_p8", |
| "vuzp2q_p8", |
| "vuzp2_p16", |
| "vuzp2q_p16", |
| "vxarq_u64", |
| "vzip1_f16", |
| "vzip1q_f16", |
| "vzip1_f32", |
| "vzip1q_f32", |
| "vzip1q_f64", |
| "vzip1_s8", |
| "vzip1q_s8", |
| "vzip1_s16", |
| "vzip1q_s16", |
| "vzip1_s32", |
| "vzip1q_s32", |
| "vzip1q_s64", |
| "vzip1_u8", |
| "vzip1q_u8", |
| "vzip1_u16", |
| "vzip1q_u16", |
| "vzip1_u32", |
| "vzip1q_u32", |
| "vzip1q_u64", |
| "vzip1_p8", |
| "vzip1q_p8", |
| "vzip1_p16", |
| "vzip1q_p16", |
| "vzip1q_p64", |
| "vzip2_f16", |
| "vzip2q_f16", |
| "vzip2_f32", |
| "vzip2q_f32", |
| "vzip2q_f64", |
| "vzip2_s8", |
| "vzip2q_s8", |
| "vzip2_s16", |
| "vzip2q_s16", |
| "vzip2_s32", |
| "vzip2q_s32", |
| "vzip2q_s64", |
| "vzip2_u8", |
| "vzip2q_u8", |
| "vzip2_u16", |
| "vzip2q_u16", |
| "vzip2_u32", |
| "vzip2q_u32", |
| "vzip2q_u64", |
| "vzip2_p8", |
| "vzip2q_p8", |
| "vzip2_p16", |
| "vzip2q_p16", |
| "vzip2q_p64", |
| "__crc32b", |
| "__crc32cb", |
| "__crc32cd", |
| "__crc32ch", |
| "__crc32cw", |
| "__crc32d", |
| "__crc32h", |
| "__crc32w", |
| "vabal_s8", |
| "vabal_s16", |
| "vabal_s32", |
| "vabal_u8", |
| "vabal_u16", |
| "vabal_u32", |
| "vabd_f16", |
| "vabdq_f16", |
| "vabd_f32", |
| "vabdq_f32", |
| "vabd_s8", |
| "vabdq_s8", |
| "vabd_s16", |
| "vabdq_s16", |
| "vabd_s32", |
| "vabdq_s32", |
| "vabd_u8", |
| "vabdq_u8", |
| "vabd_u16", |
| "vabdq_u16", |
| "vabd_u32", |
| "vabdq_u32", |
| "vabdl_s8", |
| "vabdl_s16", |
| "vabdl_s32", |
| "vabdl_u8", |
| "vabdl_u16", |
| "vabdl_u32", |
| "vabs_f16", |
| "vabsq_f16", |
| "vabs_f32", |
| "vabsq_f32", |
| "vabs_s8", |
| "vabsq_s8", |
| "vabs_s16", |
| "vabsq_s16", |
| "vabs_s32", |
| "vabsq_s32", |
| "vabsh_f16", |
| "vadd_f16", |
| "vaddq_f16", |
| "vadd_p8", |
| "vaddq_p8", |
| "vadd_p16", |
| "vaddq_p16", |
| "vadd_p64", |
| "vaddq_p64", |
| "vaddh_f16", |
| "vaddhn_high_s16", |
| "vaddhn_high_s32", |
| "vaddhn_high_s64", |
| "vaddhn_high_u16", |
| "vaddhn_high_u32", |
| "vaddhn_high_u64", |
| "vaddhn_s16", |
| "vaddhn_s32", |
| "vaddhn_s64", |
| "vaddhn_u16", |
| "vaddhn_u32", |
| "vaddhn_u64", |
| "vaddq_p128", |
| "vaesdq_u8", |
| "vaeseq_u8", |
| "vaesimcq_u8", |
| "vaesmcq_u8", |
| "vbsl_f16", |
| "vbslq_f16", |
| "vcage_f16", |
| "vcageq_f16", |
| "vcage_f32", |
| "vcageq_f32", |
| "vcagt_f16", |
| "vcagtq_f16", |
| "vcagt_f32", |
| "vcagtq_f32", |
| "vcale_f16", |
| "vcaleq_f16", |
| "vcale_f32", |
| "vcaleq_f32", |
| "vcalt_f16", |
| "vcaltq_f16", |
| "vcalt_f32", |
| "vcaltq_f32", |
| "vceq_f16", |
| "vceqq_f16", |
| "vceq_p8", |
| "vceqq_p8", |
| "vcge_f16", |
| "vcgeq_f16", |
| "vcgez_f16", |
| "vcgezq_f16", |
| "vcgt_f16", |
| "vcgtq_f16", |
| "vcgtz_f16", |
| "vcgtzq_f16", |
| "vcle_f16", |
| "vcleq_f16", |
| "vclez_f16", |
| "vclezq_f16", |
| "vcls_s8", |
| "vclsq_s8", |
| "vcls_s16", |
| "vclsq_s16", |
| "vcls_s32", |
| "vclsq_s32", |
| "vcls_u8", |
| "vclsq_u8", |
| "vcls_u16", |
| "vclsq_u16", |
| "vcls_u32", |
| "vclsq_u32", |
| "vclt_f16", |
| "vcltq_f16", |
| "vcltz_f16", |
| "vcltzq_f16", |
| "vclz_s8", |
| "vclzq_s8", |
| "vclz_s16", |
| "vclzq_s16", |
| "vclz_s32", |
| "vclzq_s32", |
| "vclz_u16", |
| "vclz_u16", |
| "vclzq_u16", |
| "vclzq_u16", |
| "vclz_u32", |
| "vclz_u32", |
| "vclzq_u32", |
| "vclzq_u32", |
| "vclz_u8", |
| "vclz_u8", |
| "vclzq_u8", |
| "vclzq_u8", |
| "vcnt_s8", |
| "vcntq_s8", |
| "vcnt_u8", |
| "vcnt_u8", |
| "vcntq_u8", |
| "vcntq_u8", |
| "vcnt_p8", |
| "vcnt_p8", |
| "vcntq_p8", |
| "vcntq_p8", |
| "vcombine_f16", |
| "vcreate_f16", |
| "vcreate_f16", |
| "vcreate_f32", |
| "vcreate_f32", |
| "vcreate_s8", |
| "vcreate_s8", |
| "vcreate_s16", |
| "vcreate_s16", |
| "vcreate_s32", |
| "vcreate_s32", |
| "vcreate_s64", |
| "vcreate_u8", |
| "vcreate_u8", |
| "vcreate_u16", |
| "vcreate_u16", |
| "vcreate_u32", |
| "vcreate_u32", |
| "vcreate_u64", |
| "vcreate_p8", |
| "vcreate_p8", |
| "vcreate_p16", |
| "vcreate_p16", |
| "vcreate_p64", |
| "vcvt_f16_f32", |
| "vcvt_f16_s16", |
| "vcvtq_f16_s16", |
| "vcvt_f16_u16", |
| "vcvtq_f16_u16", |
| "vcvt_f32_f16", |
| "vcvt_f32_s32", |
| "vcvtq_f32_s32", |
| "vcvt_f32_u32", |
| "vcvtq_f32_u32", |
| "vcvt_n_f16_s16", |
| "vcvtq_n_f16_s16", |
| "vcvt_n_f16_u16", |
| "vcvtq_n_f16_u16", |
| "vcvt_n_f32_s32", |
| "vcvtq_n_f32_s32", |
| "vcvt_n_f32_s32", |
| "vcvtq_n_f32_s32", |
| "vcvt_n_f32_u32", |
| "vcvtq_n_f32_u32", |
| "vcvt_n_f32_u32", |
| "vcvtq_n_f32_u32", |
| "vcvt_n_s16_f16", |
| "vcvtq_n_s16_f16", |
| "vcvt_n_s32_f32", |
| "vcvtq_n_s32_f32", |
| "vcvt_n_s32_f32", |
| "vcvtq_n_s32_f32", |
| "vcvt_n_u16_f16", |
| "vcvtq_n_u16_f16", |
| "vcvt_n_u32_f32", |
| "vcvtq_n_u32_f32", |
| "vcvt_n_u32_f32", |
| "vcvtq_n_u32_f32", |
| "vcvt_s16_f16", |
| "vcvtq_s16_f16", |
| "vcvt_s32_f32", |
| "vcvtq_s32_f32", |
| "vcvt_u16_f16", |
| "vcvtq_u16_f16", |
| "vcvt_u32_f32", |
| "vcvtq_u32_f32", |
| "vdot_lane_s32", |
| "vdot_lane_s32", |
| "vdotq_lane_s32", |
| "vdotq_lane_s32", |
| "vdot_lane_u32", |
| "vdot_lane_u32", |
| "vdotq_lane_u32", |
| "vdotq_lane_u32", |
| "vdot_laneq_s32", |
| "vdot_laneq_s32", |
| "vdotq_laneq_s32", |
| "vdotq_laneq_s32", |
| "vdot_laneq_u32", |
| "vdot_laneq_u32", |
| "vdotq_laneq_u32", |
| "vdotq_laneq_u32", |
| "vdot_s32", |
| "vdotq_s32", |
| "vdot_u32", |
| "vdotq_u32", |
| "vdup_lane_f16", |
| "vdupq_lane_f16", |
| "vdup_lane_f32", |
| "vdup_lane_s32", |
| "vdup_lane_u32", |
| "vdupq_lane_f32", |
| "vdupq_lane_s32", |
| "vdupq_lane_u32", |
| "vdup_lane_p16", |
| "vdup_lane_s16", |
| "vdup_lane_u16", |
| "vdupq_lane_p16", |
| "vdupq_lane_s16", |
| "vdupq_lane_u16", |
| "vdup_lane_p8", |
| "vdup_lane_s8", |
| "vdup_lane_u8", |
| "vdupq_lane_p8", |
| "vdupq_lane_s8", |
| "vdupq_lane_u8", |
| "vdup_lane_s64", |
| "vdup_lane_u64", |
| "vdup_laneq_f16", |
| "vdupq_laneq_f16", |
| "vdup_laneq_f32", |
| "vdup_laneq_s32", |
| "vdup_laneq_u32", |
| "vdupq_laneq_f32", |
| "vdupq_laneq_s32", |
| "vdupq_laneq_u32", |
| "vdup_laneq_p16", |
| "vdup_laneq_s16", |
| "vdup_laneq_u16", |
| "vdupq_laneq_p16", |
| "vdupq_laneq_s16", |
| "vdupq_laneq_u16", |
| "vdup_laneq_p8", |
| "vdup_laneq_s8", |
| "vdup_laneq_u8", |
| "vdupq_laneq_p8", |
| "vdupq_laneq_s8", |
| "vdupq_laneq_u8", |
| "vdup_laneq_s64", |
| "vdup_laneq_u64", |
| "vdup_n_f16", |
| "vdupq_n_f16", |
| "vdupq_lane_s64", |
| "vdupq_lane_u64", |
| "vdupq_laneq_s64", |
| "vdupq_laneq_u64", |
| "vext_f16", |
| "vext_f32", |
| "vext_s32", |
| "vext_u32", |
| "vext_s8", |
| "vextq_s16", |
| "vext_u8", |
| "vextq_u16", |
| "vext_p8", |
| "vextq_p16", |
| "vextq_f16", |
| "vextq_f32", |
| "vext_s16", |
| "vextq_s32", |
| "vext_u16", |
| "vextq_u32", |
| "vext_p16", |
| "vextq_s64", |
| "vextq_u64", |
| "vextq_s8", |
| "vextq_u8", |
| "vextq_p8", |
| "vfma_f16", |
| "vfmaq_f16", |
| "vfma_f32", |
| "vfmaq_f32", |
| "vfma_n_f32", |
| "vfmaq_n_f32", |
| "vfms_f16", |
| "vfmsq_f16", |
| "vfms_f32", |
| "vfmsq_f32", |
| "vfms_n_f32", |
| "vfmsq_n_f32", |
| "vget_high_f16", |
| "vget_low_f16", |
| "vget_lane_f16", |
| "vgetq_lane_f16", |
| "vld1_dup_f16", |
| "vld1q_dup_f16", |
| "vld1_f16", |
| "vld1_f16", |
| "vld1q_f16", |
| "vld1q_f16", |
| "vld1_f16_x2", |
| "vld1_f16_x3", |
| "vld1_f16_x4", |
| "vld1q_f16_x2", |
| "vld1q_f16_x3", |
| "vld1q_f16_x4", |
| "vld1_f32_x2", |
| "vld1_f32_x3", |
| "vld1_f32_x4", |
| "vld1q_f32_x2", |
| "vld1q_f32_x3", |
| "vld1q_f32_x4", |
| "vld1_lane_f16", |
| "vld1q_lane_f16", |
| "vld1_p64_x2", |
| "vld1_p64_x3", |
| "vld1_p64_x4", |
| "vld1q_p64_x2", |
| "vld1q_p64_x3", |
| "vld1q_p64_x4", |
| "vld1_s8_x2", |
| "vld1_s8_x3", |
| "vld1_s8_x4", |
| "vld1q_s8_x2", |
| "vld1q_s8_x3", |
| "vld1q_s8_x4", |
| "vld1_s16_x2", |
| "vld1_s16_x3", |
| "vld1_s16_x4", |
| "vld1q_s16_x2", |
| "vld1q_s16_x3", |
| "vld1q_s16_x4", |
| "vld1_s32_x2", |
| "vld1_s32_x3", |
| "vld1_s32_x4", |
| "vld1q_s32_x2", |
| "vld1q_s32_x3", |
| "vld1q_s32_x4", |
| "vld1_s64_x2", |
| "vld1_s64_x3", |
| "vld1_s64_x4", |
| "vld1q_s64_x2", |
| "vld1q_s64_x3", |
| "vld1q_s64_x4", |
| "vld1_u8_x2", |
| "vld1_u8_x3", |
| "vld1_u8_x4", |
| "vld1q_u8_x2", |
| "vld1q_u8_x3", |
| "vld1q_u8_x4", |
| "vld1_u16_x2", |
| "vld1_u16_x3", |
| "vld1_u16_x4", |
| "vld1q_u16_x2", |
| "vld1q_u16_x3", |
| "vld1q_u16_x4", |
| "vld1_u32_x2", |
| "vld1_u32_x3", |
| "vld1_u32_x4", |
| "vld1q_u32_x2", |
| "vld1q_u32_x3", |
| "vld1q_u32_x4", |
| "vld1_u64_x2", |
| "vld1_u64_x3", |
| "vld1_u64_x4", |
| "vld1q_u64_x2", |
| "vld1q_u64_x3", |
| "vld1q_u64_x4", |
| "vld1_p8_x2", |
| "vld1_p8_x3", |
| "vld1_p8_x4", |
| "vld1q_p8_x2", |
| "vld1q_p8_x3", |
| "vld1q_p8_x4", |
| "vld1_p16_x2", |
| "vld1_p16_x3", |
| "vld1_p16_x4", |
| "vld1q_p16_x2", |
| "vld1q_p16_x3", |
| "vld1q_p16_x4", |
| "vld2_dup_f16", |
| "vld2q_dup_f16", |
| "vld2_dup_f16", |
| "vld2q_dup_f16", |
| "vld2_dup_f32", |
| "vld2q_dup_f32", |
| "vld2_dup_s8", |
| "vld2q_dup_s8", |
| "vld2_dup_s16", |
| "vld2q_dup_s16", |
| "vld2_dup_s32", |
| "vld2q_dup_s32", |
| "vld2_dup_f32", |
| "vld2q_dup_f32", |
| "vld2_dup_s8", |
| "vld2q_dup_s8", |
| "vld2_dup_s16", |
| "vld2q_dup_s16", |
| "vld2_dup_s32", |
| "vld2q_dup_s32", |
| "vld2_dup_p64", |
| "vld2_dup_s64", |
| "vld2_dup_s64", |
| "vld2_dup_u64", |
| "vld2_dup_u8", |
| "vld2_dup_u8", |
| "vld2q_dup_u8", |
| "vld2q_dup_u8", |
| "vld2_dup_u16", |
| "vld2_dup_u16", |
| "vld2q_dup_u16", |
| "vld2q_dup_u16", |
| "vld2_dup_u32", |
| "vld2_dup_u32", |
| "vld2q_dup_u32", |
| "vld2q_dup_u32", |
| "vld2_dup_p8", |
| "vld2_dup_p8", |
| "vld2q_dup_p8", |
| "vld2q_dup_p8", |
| "vld2_dup_p16", |
| "vld2_dup_p16", |
| "vld2q_dup_p16", |
| "vld2q_dup_p16", |
| "vld2_f16", |
| "vld2q_f16", |
| "vld2_f16", |
| "vld2q_f16", |
| "vld2_f32", |
| "vld2q_f32", |
| "vld2_s8", |
| "vld2q_s8", |
| "vld2_s16", |
| "vld2q_s16", |
| "vld2_s32", |
| "vld2q_s32", |
| "vld2_f32", |
| "vld2q_f32", |
| "vld2_s8", |
| "vld2q_s8", |
| "vld2_s16", |
| "vld2q_s16", |
| "vld2_s32", |
| "vld2q_s32", |
| "vld2_lane_f16", |
| "vld2q_lane_f16", |
| "vld2_lane_f16", |
| "vld2q_lane_f16", |
| "vld2_lane_f32", |
| "vld2q_lane_f32", |
| "vld2_lane_s8", |
| "vld2_lane_s16", |
| "vld2q_lane_s16", |
| "vld2_lane_s32", |
| "vld2q_lane_s32", |
| "vld2_lane_f32", |
| "vld2q_lane_f32", |
| "vld2q_lane_s16", |
| "vld2q_lane_s32", |
| "vld2_lane_s8", |
| "vld2_lane_s16", |
| "vld2_lane_s32", |
| "vld2_lane_u8", |
| "vld2_lane_u16", |
| "vld2q_lane_u16", |
| "vld2_lane_u32", |
| "vld2q_lane_u32", |
| "vld2_lane_p8", |
| "vld2_lane_p16", |
| "vld2q_lane_p16", |
| "vld2_p64", |
| "vld2_s64", |
| "vld2_s64", |
| "vld2_u64", |
| "vld2_u8", |
| "vld2q_u8", |
| "vld2_u16", |
| "vld2q_u16", |
| "vld2_u32", |
| "vld2q_u32", |
| "vld2_p8", |
| "vld2q_p8", |
| "vld2_p16", |
| "vld2q_p16", |
| "vld3_dup_f16", |
| "vld3q_dup_f16", |
| "vld3_dup_f16", |
| "vld3q_dup_f16", |
| "vld3_dup_f32", |
| "vld3q_dup_f32", |
| "vld3_dup_s8", |
| "vld3q_dup_s8", |
| "vld3_dup_s16", |
| "vld3q_dup_s16", |
| "vld3_dup_s32", |
| "vld3q_dup_s32", |
| "vld3_dup_s64", |
| "vld3_dup_f32", |
| "vld3q_dup_f32", |
| "vld3_dup_s8", |
| "vld3q_dup_s8", |
| "vld3_dup_s16", |
| "vld3q_dup_s16", |
| "vld3_dup_s32", |
| "vld3q_dup_s32", |
| "vld3_dup_p64", |
| "vld3_dup_s64", |
| "vld3_dup_u64", |
| "vld3_dup_u8", |
| "vld3_dup_u8", |
| "vld3q_dup_u8", |
| "vld3q_dup_u8", |
| "vld3_dup_u16", |
| "vld3_dup_u16", |
| "vld3q_dup_u16", |
| "vld3q_dup_u16", |
| "vld3_dup_u32", |
| "vld3_dup_u32", |
| "vld3q_dup_u32", |
| "vld3q_dup_u32", |
| "vld3_dup_p8", |
| "vld3_dup_p8", |
| "vld3q_dup_p8", |
| "vld3q_dup_p8", |
| "vld3_dup_p16", |
| "vld3_dup_p16", |
| "vld3q_dup_p16", |
| "vld3q_dup_p16", |
| "vld3_f16", |
| "vld3q_f16", |
| "vld3_f16", |
| "vld3q_f16", |
| "vld3_f32", |
| "vld3q_f32", |
| "vld3_s8", |
| "vld3q_s8", |
| "vld3_s16", |
| "vld3q_s16", |
| "vld3_s32", |
| "vld3q_s32", |
| "vld3_f32", |
| "vld3q_f32", |
| "vld3_s8", |
| "vld3q_s8", |
| "vld3_s16", |
| "vld3q_s16", |
| "vld3_s32", |
| "vld3q_s32", |
| "vld3_lane_f16", |
| "vld3q_lane_f16", |
| "vld3_lane_f16", |
| "vld3q_lane_f16", |
| "vld3_lane_f32", |
| "vld3q_lane_f32", |
| "vld3_lane_f32", |
| "vld3_lane_s8", |
| "vld3_lane_s16", |
| "vld3q_lane_s16", |
| "vld3_lane_s32", |
| "vld3q_lane_s32", |
| "vld3_lane_s8", |
| "vld3_lane_s16", |
| "vld3q_lane_s16", |
| "vld3_lane_s32", |
| "vld3q_lane_s32", |
| "vld3_lane_u8", |
| "vld3_lane_u16", |
| "vld3q_lane_u16", |
| "vld3_lane_u32", |
| "vld3q_lane_u32", |
| "vld3_lane_p8", |
| "vld3_lane_p16", |
| "vld3q_lane_p16", |
| "vld3_p64", |
| "vld3_s64", |
| "vld3_s64", |
| "vld3_u64", |
| "vld3_u8", |
| "vld3q_u8", |
| "vld3_u16", |
| "vld3q_u16", |
| "vld3_u32", |
| "vld3q_u32", |
| "vld3_p8", |
| "vld3q_p8", |
| "vld3_p16", |
| "vld3q_p16", |
| "vld3q_lane_f32", |
| "vld4_dup_f16", |
| "vld4q_dup_f16", |
| "vld4_dup_f16", |
| "vld4q_dup_f16", |
| "vld4_dup_f32", |
| "vld4q_dup_f32", |
| "vld4_dup_s8", |
| "vld4q_dup_s8", |
| "vld4_dup_s16", |
| "vld4q_dup_s16", |
| "vld4_dup_s32", |
| "vld4q_dup_s32", |
| "vld4_dup_f32", |
| "vld4q_dup_f32", |
| "vld4_dup_s8", |
| "vld4q_dup_s8", |
| "vld4_dup_s16", |
| "vld4q_dup_s16", |
| "vld4_dup_s32", |
| "vld4q_dup_s32", |
| "vld4_dup_s64", |
| "vld4_dup_p64", |
| "vld4_dup_s64", |
| "vld4_dup_u64", |
| "vld4_dup_u8", |
| "vld4_dup_u8", |
| "vld4q_dup_u8", |
| "vld4q_dup_u8", |
| "vld4_dup_u16", |
| "vld4_dup_u16", |
| "vld4q_dup_u16", |
| "vld4q_dup_u16", |
| "vld4_dup_u32", |
| "vld4_dup_u32", |
| "vld4q_dup_u32", |
| "vld4q_dup_u32", |
| "vld4_dup_p8", |
| "vld4_dup_p8", |
| "vld4q_dup_p8", |
| "vld4q_dup_p8", |
| "vld4_dup_p16", |
| "vld4_dup_p16", |
| "vld4q_dup_p16", |
| "vld4q_dup_p16", |
| "vld4_f16", |
| "vld4q_f16", |
| "vld4_f16", |
| "vld4q_f16", |
| "vld4_f32", |
| "vld4q_f32", |
| "vld4_s8", |
| "vld4q_s8", |
| "vld4_s16", |
| "vld4q_s16", |
| "vld4_s32", |
| "vld4q_s32", |
| "vld4_f32", |
| "vld4q_f32", |
| "vld4_s8", |
| "vld4q_s8", |
| "vld4_s16", |
| "vld4q_s16", |
| "vld4_s32", |
| "vld4q_s32", |
| "vld4_lane_f16", |
| "vld4q_lane_f16", |
| "vld4_lane_f16", |
| "vld4q_lane_f16", |
| "vld4_lane_f32", |
| "vld4q_lane_f32", |
| "vld4_lane_s8", |
| "vld4_lane_s16", |
| "vld4q_lane_s16", |
| "vld4_lane_s32", |
| "vld4q_lane_s32", |
| "vld4_lane_f32", |
| "vld4q_lane_f32", |
| "vld4_lane_s8", |
| "vld4_lane_s16", |
| "vld4q_lane_s16", |
| "vld4_lane_s32", |
| "vld4q_lane_s32", |
| "vld4_lane_u8", |
| "vld4_lane_u16", |
| "vld4q_lane_u16", |
| "vld4_lane_u32", |
| "vld4q_lane_u32", |
| "vld4_lane_p8", |
| "vld4_lane_p16", |
| "vld4q_lane_p16", |
| "vld4_p64", |
| "vld4_s64", |
| "vld4_s64", |
| "vld4_u64", |
| "vld4_u8", |
| "vld4q_u8", |
| "vld4_u16", |
| "vld4q_u16", |
| "vld4_u32", |
| "vld4q_u32", |
| "vld4_p8", |
| "vld4q_p8", |
| "vld4_p16", |
| "vld4q_p16", |
| "vmax_f16", |
| "vmaxq_f16", |
| "vmax_f32", |
| "vmaxq_f32", |
| "vmax_s8", |
| "vmaxq_s8", |
| "vmax_s16", |
| "vmaxq_s16", |
| "vmax_s32", |
| "vmaxq_s32", |
| "vmax_u8", |
| "vmaxq_u8", |
| "vmax_u16", |
| "vmaxq_u16", |
| "vmax_u32", |
| "vmaxq_u32", |
| "vmaxnm_f16", |
| "vmaxnmq_f16", |
| "vmaxnm_f32", |
| "vmaxnmq_f32", |
| "vmin_f16", |
| "vminq_f16", |
| "vmin_f32", |
| "vminq_f32", |
| "vmin_s8", |
| "vminq_s8", |
| "vmin_s16", |
| "vminq_s16", |
| "vmin_s32", |
| "vminq_s32", |
| "vmin_u8", |
| "vminq_u8", |
| "vmin_u16", |
| "vminq_u16", |
| "vmin_u32", |
| "vminq_u32", |
| "vminnm_f16", |
| "vminnmq_f16", |
| "vminnm_f32", |
| "vminnmq_f32", |
| "vmla_f32", |
| "vmlaq_f32", |
| "vmla_lane_f32", |
| "vmla_laneq_f32", |
| "vmlaq_lane_f32", |
| "vmlaq_laneq_f32", |
| "vmla_lane_s16", |
| "vmla_lane_u16", |
| "vmla_laneq_s16", |
| "vmla_laneq_u16", |
| "vmlaq_lane_s16", |
| "vmlaq_lane_u16", |
| "vmlaq_laneq_s16", |
| "vmlaq_laneq_u16", |
| "vmla_lane_s32", |
| "vmla_lane_u32", |
| "vmla_laneq_s32", |
| "vmla_laneq_u32", |
| "vmlaq_lane_s32", |
| "vmlaq_lane_u32", |
| "vmlaq_laneq_s32", |
| "vmlaq_laneq_u32", |
| "vmla_n_f32", |
| "vmlaq_n_f32", |
| "vmla_n_s16", |
| "vmlaq_n_s16", |
| "vmla_n_u16", |
| "vmlaq_n_u16", |
| "vmla_n_s32", |
| "vmlaq_n_s32", |
| "vmla_n_u32", |
| "vmlaq_n_u32", |
| "vmla_s8", |
| "vmlaq_s8", |
| "vmla_s16", |
| "vmlaq_s16", |
| "vmla_s32", |
| "vmlaq_s32", |
| "vmla_u8", |
| "vmlaq_u8", |
| "vmla_u16", |
| "vmlaq_u16", |
| "vmla_u32", |
| "vmlaq_u32", |
| "vmlal_lane_s16", |
| "vmlal_laneq_s16", |
| "vmlal_lane_s32", |
| "vmlal_laneq_s32", |
| "vmlal_lane_u16", |
| "vmlal_laneq_u16", |
| "vmlal_lane_u32", |
| "vmlal_laneq_u32", |
| "vmlal_n_s16", |
| "vmlal_n_s32", |
| "vmlal_n_u16", |
| "vmlal_n_u32", |
| "vmlal_s8", |
| "vmlal_s16", |
| "vmlal_s32", |
| "vmlal_u8", |
| "vmlal_u16", |
| "vmlal_u32", |
| "vmls_f32", |
| "vmlsq_f32", |
| "vmls_lane_f32", |
| "vmls_laneq_f32", |
| "vmlsq_lane_f32", |
| "vmlsq_laneq_f32", |
| "vmls_lane_s16", |
| "vmls_lane_u16", |
| "vmls_laneq_s16", |
| "vmls_laneq_u16", |
| "vmlsq_lane_s16", |
| "vmlsq_lane_u16", |
| "vmlsq_laneq_s16", |
| "vmlsq_laneq_u16", |
| "vmls_lane_s32", |
| "vmls_lane_u32", |
| "vmls_laneq_s32", |
| "vmls_laneq_u32", |
| "vmlsq_lane_s32", |
| "vmlsq_lane_u32", |
| "vmlsq_laneq_s32", |
| "vmlsq_laneq_u32", |
| "vmls_n_f32", |
| "vmlsq_n_f32", |
| "vmls_n_s16", |
| "vmlsq_n_s16", |
| "vmls_n_u16", |
| "vmlsq_n_u16", |
| "vmls_n_s32", |
| "vmlsq_n_s32", |
| "vmls_n_u32", |
| "vmlsq_n_u32", |
| "vmls_s8", |
| "vmlsq_s8", |
| "vmls_s16", |
| "vmlsq_s16", |
| "vmls_s32", |
| "vmlsq_s32", |
| "vmls_u8", |
| "vmlsq_u8", |
| "vmls_u16", |
| "vmlsq_u16", |
| "vmls_u32", |
| "vmlsq_u32", |
| "vmlsl_lane_s16", |
| "vmlsl_laneq_s16", |
| "vmlsl_lane_s32", |
| "vmlsl_laneq_s32", |
| "vmlsl_lane_u16", |
| "vmlsl_laneq_u16", |
| "vmlsl_lane_u32", |
| "vmlsl_laneq_u32", |
| "vmlsl_n_s16", |
| "vmlsl_n_s32", |
| "vmlsl_n_u16", |
| "vmlsl_n_u32", |
| "vmlsl_s8", |
| "vmlsl_s16", |
| "vmlsl_s32", |
| "vmlsl_u8", |
| "vmlsl_u16", |
| "vmlsl_u32", |
| "vmmlaq_s32", |
| "vmmlaq_u32", |
| "vmov_n_f16", |
| "vmovq_n_f16", |
| "vmul_f16", |
| "vmulq_f16", |
| "vmul_lane_f16", |
| "vmulq_lane_f16", |
| "vmul_lane_f32", |
| "vmul_laneq_f32", |
| "vmulq_lane_f32", |
| "vmulq_laneq_f32", |
| "vmul_lane_s16", |
| "vmulq_lane_s16", |
| "vmul_lane_s32", |
| "vmulq_lane_s32", |
| "vmul_lane_u16", |
| "vmulq_lane_u16", |
| "vmul_lane_u32", |
| "vmulq_lane_u32", |
| "vmul_laneq_s16", |
| "vmulq_laneq_s16", |
| "vmul_laneq_s32", |
| "vmulq_laneq_s32", |
| "vmul_laneq_u16", |
| "vmulq_laneq_u16", |
| "vmul_laneq_u32", |
| "vmulq_laneq_u32", |
| "vmul_n_f16", |
| "vmulq_n_f16", |
| "vmul_n_f32", |
| "vmulq_n_f32", |
| "vmul_n_s16", |
| "vmulq_n_s16", |
| "vmul_n_s32", |
| "vmulq_n_s32", |
| "vmul_n_u16", |
| "vmulq_n_u16", |
| "vmul_n_u32", |
| "vmulq_n_u32", |
| "vmul_p8", |
| "vmulq_p8", |
| "vmull_lane_s16", |
| "vmull_laneq_s16", |
| "vmull_lane_s32", |
| "vmull_laneq_s32", |
| "vmull_lane_u16", |
| "vmull_laneq_u16", |
| "vmull_lane_u32", |
| "vmull_laneq_u32", |
| "vmull_n_s16", |
| "vmull_n_s32", |
| "vmull_n_u16", |
| "vmull_n_u32", |
| "vmull_p8", |
| "vmull_s16", |
| "vmull_s32", |
| "vmull_s8", |
| "vmull_u8", |
| "vmull_u16", |
| "vmull_u32", |
| "vneg_f16", |
| "vnegq_f16", |
| "vneg_f32", |
| "vnegq_f32", |
| "vneg_s8", |
| "vnegq_s8", |
| "vneg_s16", |
| "vnegq_s16", |
| "vneg_s32", |
| "vnegq_s32", |
| "vpadal_s8", |
| "vpadalq_s8", |
| "vpadal_s16", |
| "vpadalq_s16", |
| "vpadal_s32", |
| "vpadalq_s32", |
| "vpadal_u8", |
| "vpadalq_u8", |
| "vpadal_u16", |
| "vpadalq_u16", |
| "vpadal_u32", |
| "vpadalq_u32", |
| "vpadd_f16", |
| "vpadd_f32", |
| "vpadd_s8", |
| "vpadd_s16", |
| "vpadd_s32", |
| "vpadd_u8", |
| "vpadd_u8", |
| "vpadd_u16", |
| "vpadd_u16", |
| "vpadd_u32", |
| "vpadd_u32", |
| "vpaddl_s8", |
| "vpaddlq_s8", |
| "vpaddl_s16", |
| "vpaddlq_s16", |
| "vpaddl_s32", |
| "vpaddlq_s32", |
| "vpaddl_u8", |
| "vpaddlq_u8", |
| "vpaddl_u16", |
| "vpaddlq_u16", |
| "vpaddl_u32", |
| "vpaddlq_u32", |
| "vpmax_f32", |
| "vpmax_s8", |
| "vpmax_s16", |
| "vpmax_s32", |
| "vpmax_u8", |
| "vpmax_u16", |
| "vpmax_u32", |
| "vpmin_f32", |
| "vpmin_s8", |
| "vpmin_s16", |
| "vpmin_s32", |
| "vpmin_u8", |
| "vpmin_u16", |
| "vpmin_u32", |
| "vqabs_s8", |
| "vqabsq_s8", |
| "vqabs_s16", |
| "vqabsq_s16", |
| "vqabs_s32", |
| "vqabsq_s32", |
| "vqadd_s64", |
| "vqaddq_s64", |
| "vqadd_u64", |
| "vqaddq_u64", |
| "vqdmlal_lane_s16", |
| "vqdmlal_lane_s32", |
| "vqdmlal_n_s16", |
| "vqdmlal_n_s32", |
| "vqdmlal_s16", |
| "vqdmlal_s32", |
| "vqdmlsl_lane_s16", |
| "vqdmlsl_lane_s32", |
| "vqdmlsl_n_s16", |
| "vqdmlsl_n_s32", |
| "vqdmlsl_s16", |
| "vqdmlsl_s32", |
| "vqdmulh_laneq_s16", |
| "vqdmulhq_laneq_s16", |
| "vqdmulh_laneq_s32", |
| "vqdmulhq_laneq_s32", |
| "vqdmulh_n_s16", |
| "vqdmulhq_n_s16", |
| "vqdmulh_n_s32", |
| "vqdmulhq_n_s32", |
| "vqdmulh_s16", |
| "vqdmulhq_s16", |
| "vqdmulh_s32", |
| "vqdmulhq_s32", |
| "vqdmull_lane_s16", |
| "vqdmull_lane_s32", |
| "vqdmull_n_s16", |
| "vqdmull_n_s32", |
| "vqdmull_s16", |
| "vqdmull_s32", |
| "vqmovn_s16", |
| "vqmovn_s32", |
| "vqmovn_s64", |
| "vqmovn_u16", |
| "vqmovn_u32", |
| "vqmovn_u64", |
| "vqmovun_s16", |
| "vqmovun_s32", |
| "vqmovun_s64", |
| "vqneg_s8", |
| "vqnegq_s8", |
| "vqneg_s16", |
| "vqnegq_s16", |
| "vqneg_s32", |
| "vqnegq_s32", |
| "vqrdmulh_lane_s16", |
| "vqrdmulh_lane_s32", |
| "vqrdmulh_laneq_s16", |
| "vqrdmulh_laneq_s32", |
| "vqrdmulhq_lane_s16", |
| "vqrdmulhq_lane_s32", |
| "vqrdmulhq_laneq_s16", |
| "vqrdmulhq_laneq_s32", |
| "vqrdmulh_n_s16", |
| "vqrdmulhq_n_s16", |
| "vqrdmulh_n_s32", |
| "vqrdmulhq_n_s32", |
| "vqrdmulh_s16", |
| "vqrdmulhq_s16", |
| "vqrdmulh_s32", |
| "vqrdmulhq_s32", |
| "vqrshl_s8", |
| "vqrshlq_s8", |
| "vqrshl_s16", |
| "vqrshlq_s16", |
| "vqrshl_s32", |
| "vqrshlq_s32", |
| "vqrshl_s64", |
| "vqrshlq_s64", |
| "vqrshl_u8", |
| "vqrshlq_u8", |
| "vqrshl_u16", |
| "vqrshlq_u16", |
| "vqrshl_u32", |
| "vqrshlq_u32", |
| "vqrshl_u64", |
| "vqrshlq_u64", |
| "vqrshrn_n_s16", |
| "vqrshrn_n_s32", |
| "vqrshrn_n_s64", |
| "vqrshrn_n_s16", |
| "vqrshrn_n_s32", |
| "vqrshrn_n_s64", |
| "vqrshrn_n_u16", |
| "vqrshrn_n_u32", |
| "vqrshrn_n_u64", |
| "vqrshrn_n_u16", |
| "vqrshrn_n_u32", |
| "vqrshrn_n_u64", |
| "vqrshrun_n_s16", |
| "vqrshrun_n_s32", |
| "vqrshrun_n_s64", |
| "vqrshrun_n_s16", |
| "vqrshrun_n_s32", |
| "vqrshrun_n_s64", |
| "vqshl_n_s8", |
| "vqshlq_n_s8", |
| "vqshl_n_s16", |
| "vqshlq_n_s16", |
| "vqshl_n_s32", |
| "vqshlq_n_s32", |
| "vqshl_n_s64", |
| "vqshlq_n_s64", |
| "vqshl_n_u8", |
| "vqshlq_n_u8", |
| "vqshl_n_u16", |
| "vqshlq_n_u16", |
| "vqshl_n_u32", |
| "vqshlq_n_u32", |
| "vqshl_n_u64", |
| "vqshlq_n_u64", |
| "vqshl_s8", |
| "vqshlq_s8", |
| "vqshl_s16", |
| "vqshlq_s16", |
| "vqshl_s32", |
| "vqshlq_s32", |
| "vqshl_s64", |
| "vqshlq_s64", |
| "vqshl_u8", |
| "vqshlq_u8", |
| "vqshl_u16", |
| "vqshlq_u16", |
| "vqshl_u32", |
| "vqshlq_u32", |
| "vqshl_u64", |
| "vqshlq_u64", |
| "vqshlu_n_s8", |
| "vqshluq_n_s8", |
| "vqshlu_n_s16", |
| "vqshluq_n_s16", |
| "vqshlu_n_s32", |
| "vqshluq_n_s32", |
| "vqshlu_n_s64", |
| "vqshluq_n_s64", |
| "vqshlu_n_s8", |
| "vqshluq_n_s8", |
| "vqshlu_n_s16", |
| "vqshluq_n_s16", |
| "vqshlu_n_s32", |
| "vqshluq_n_s32", |
| "vqshlu_n_s64", |
| "vqshluq_n_s64", |
| "vqshrn_n_s16", |
| "vqshrn_n_s32", |
| "vqshrn_n_s64", |
| "vqshrn_n_s16", |
| "vqshrn_n_s32", |
| "vqshrn_n_s64", |
| "vqshrn_n_u16", |
| "vqshrn_n_u32", |
| "vqshrn_n_u64", |
| "vqshrn_n_u16", |
| "vqshrn_n_u32", |
| "vqshrn_n_u64", |
| "vqshrun_n_s16", |
| "vqshrun_n_s32", |
| "vqshrun_n_s64", |
| "vqshrun_n_s16", |
| "vqshrun_n_s32", |
| "vqshrun_n_s64", |
| "vqsub_s64", |
| "vqsubq_s64", |
| "vqsub_u64", |
| "vqsubq_u64", |
| "vraddhn_high_s16", |
| "vraddhn_high_s32", |
| "vraddhn_high_s64", |
| "vraddhn_high_u16", |
| "vraddhn_high_u32", |
| "vraddhn_high_u64", |
| "vraddhn_s16", |
| "vraddhn_s32", |
| "vraddhn_s64", |
| "vraddhn_u16", |
| "vraddhn_u16", |
| "vraddhn_u32", |
| "vraddhn_u32", |
| "vraddhn_u64", |
| "vraddhn_u64", |
| "vrecpe_f16", |
| "vrecpeq_f16", |
| "vrecpe_f32", |
| "vrecpeq_f32", |
| "vrecpe_u32", |
| "vrecpeq_u32", |
| "vrecps_f16", |
| "vrecpsq_f16", |
| "vrecps_f32", |
| "vrecpsq_f32", |
| "vreinterpret_f32_f16", |
| "vreinterpret_f32_f16", |
| "vreinterpret_s8_f16", |
| "vreinterpret_s8_f16", |
| "vreinterpret_s16_f16", |
| "vreinterpret_s16_f16", |
| "vreinterpret_s32_f16", |
| "vreinterpret_s32_f16", |
| "vreinterpret_s64_f16", |
| "vreinterpret_s64_f16", |
| "vreinterpret_u8_f16", |
| "vreinterpret_u8_f16", |
| "vreinterpret_u16_f16", |
| "vreinterpret_u16_f16", |
| "vreinterpret_u32_f16", |
| "vreinterpret_u32_f16", |
| "vreinterpret_u64_f16", |
| "vreinterpret_u64_f16", |
| "vreinterpret_p8_f16", |
| "vreinterpret_p8_f16", |
| "vreinterpret_p16_f16", |
| "vreinterpret_p16_f16", |
| "vreinterpretq_f32_f16", |
| "vreinterpretq_f32_f16", |
| "vreinterpretq_s8_f16", |
| "vreinterpretq_s8_f16", |
| "vreinterpretq_s16_f16", |
| "vreinterpretq_s16_f16", |
| "vreinterpretq_s32_f16", |
| "vreinterpretq_s32_f16", |
| "vreinterpretq_s64_f16", |
| "vreinterpretq_s64_f16", |
| "vreinterpretq_u8_f16", |
| "vreinterpretq_u8_f16", |
| "vreinterpretq_u16_f16", |
| "vreinterpretq_u16_f16", |
| "vreinterpretq_u32_f16", |
| "vreinterpretq_u32_f16", |
| "vreinterpretq_u64_f16", |
| "vreinterpretq_u64_f16", |
| "vreinterpretq_p8_f16", |
| "vreinterpretq_p8_f16", |
| "vreinterpretq_p16_f16", |
| "vreinterpretq_p16_f16", |
| "vreinterpret_f16_f32", |
| "vreinterpret_f16_f32", |
| "vreinterpretq_f16_f32", |
| "vreinterpretq_f16_f32", |
| "vreinterpret_f16_s8", |
| "vreinterpret_f16_s8", |
| "vreinterpretq_f16_s8", |
| "vreinterpretq_f16_s8", |
| "vreinterpret_f16_s16", |
| "vreinterpret_f16_s16", |
| "vreinterpretq_f16_s16", |
| "vreinterpretq_f16_s16", |
| "vreinterpret_f16_s32", |
| "vreinterpret_f16_s32", |
| "vreinterpretq_f16_s32", |
| "vreinterpretq_f16_s32", |
| "vreinterpret_f16_s64", |
| "vreinterpret_f16_s64", |
| "vreinterpretq_f16_s64", |
| "vreinterpretq_f16_s64", |
| "vreinterpret_f16_u8", |
| "vreinterpret_f16_u8", |
| "vreinterpretq_f16_u8", |
| "vreinterpretq_f16_u8", |
| "vreinterpret_f16_u16", |
| "vreinterpret_f16_u16", |
| "vreinterpretq_f16_u16", |
| "vreinterpretq_f16_u16", |
| "vreinterpret_f16_u32", |
| "vreinterpret_f16_u32", |
| "vreinterpretq_f16_u32", |
| "vreinterpretq_f16_u32", |
| "vreinterpret_f16_u64", |
| "vreinterpret_f16_u64", |
| "vreinterpretq_f16_u64", |
| "vreinterpretq_f16_u64", |
| "vreinterpret_f16_p8", |
| "vreinterpret_f16_p8", |
| "vreinterpretq_f16_p8", |
| "vreinterpretq_f16_p8", |
| "vreinterpret_f16_p16", |
| "vreinterpret_f16_p16", |
| "vreinterpretq_f16_p16", |
| "vreinterpretq_f16_p16", |
| "vreinterpretq_f16_p128", |
| "vreinterpretq_f16_p128", |
| "vreinterpret_p64_f16", |
| "vreinterpret_p64_f16", |
| "vreinterpretq_p128_f16", |
| "vreinterpretq_p128_f16", |
| "vreinterpretq_p64_f16", |
| "vreinterpretq_p64_f16", |
| "vreinterpret_f16_p64", |
| "vreinterpret_f16_p64", |
| "vreinterpretq_f16_p64", |
| "vreinterpretq_f16_p64", |
| "vreinterpretq_f32_p128", |
| "vreinterpretq_f32_p128", |
| "vreinterpret_s8_f32", |
| "vreinterpret_s8_f32", |
| "vreinterpret_s16_f32", |
| "vreinterpret_s16_f32", |
| "vreinterpret_s32_f32", |
| "vreinterpret_s32_f32", |
| "vreinterpret_s64_f32", |
| "vreinterpret_s64_f32", |
| "vreinterpret_u8_f32", |
| "vreinterpret_u8_f32", |
| "vreinterpret_u16_f32", |
| "vreinterpret_u16_f32", |
| "vreinterpret_u32_f32", |
| "vreinterpret_u32_f32", |
| "vreinterpret_u64_f32", |
| "vreinterpret_u64_f32", |
| "vreinterpret_p8_f32", |
| "vreinterpret_p8_f32", |
| "vreinterpret_p16_f32", |
| "vreinterpret_p16_f32", |
| "vreinterpretq_p128_f32", |
| "vreinterpretq_p128_f32", |
| "vreinterpretq_s8_f32", |
| "vreinterpretq_s8_f32", |
| "vreinterpretq_s16_f32", |
| "vreinterpretq_s16_f32", |
| "vreinterpretq_s32_f32", |
| "vreinterpretq_s32_f32", |
| "vreinterpretq_s64_f32", |
| "vreinterpretq_s64_f32", |
| "vreinterpretq_u8_f32", |
| "vreinterpretq_u8_f32", |
| "vreinterpretq_u16_f32", |
| "vreinterpretq_u16_f32", |
| "vreinterpretq_u32_f32", |
| "vreinterpretq_u32_f32", |
| "vreinterpretq_u64_f32", |
| "vreinterpretq_u64_f32", |
| "vreinterpretq_p8_f32", |
| "vreinterpretq_p8_f32", |
| "vreinterpretq_p16_f32", |
| "vreinterpretq_p16_f32", |
| "vreinterpret_f32_s8", |
| "vreinterpret_f32_s8", |
| "vreinterpret_s16_s8", |
| "vreinterpret_s16_s8", |
| "vreinterpret_s32_s8", |
| "vreinterpret_s32_s8", |
| "vreinterpret_s64_s8", |
| "vreinterpret_s64_s8", |
| "vreinterpret_u8_s8", |
| "vreinterpret_u8_s8", |
| "vreinterpret_u16_s8", |
| "vreinterpret_u16_s8", |
| "vreinterpret_u32_s8", |
| "vreinterpret_u32_s8", |
| "vreinterpret_u64_s8", |
| "vreinterpret_u64_s8", |
| "vreinterpret_p8_s8", |
| "vreinterpret_p8_s8", |
| "vreinterpret_p16_s8", |
| "vreinterpret_p16_s8", |
| "vreinterpretq_f32_s8", |
| "vreinterpretq_f32_s8", |
| "vreinterpretq_s16_s8", |
| "vreinterpretq_s16_s8", |
| "vreinterpretq_s32_s8", |
| "vreinterpretq_s32_s8", |
| "vreinterpretq_s64_s8", |
| "vreinterpretq_s64_s8", |
| "vreinterpretq_u8_s8", |
| "vreinterpretq_u8_s8", |
| "vreinterpretq_u16_s8", |
| "vreinterpretq_u16_s8", |
| "vreinterpretq_u32_s8", |
| "vreinterpretq_u32_s8", |
| "vreinterpretq_u64_s8", |
| "vreinterpretq_u64_s8", |
| "vreinterpretq_p8_s8", |
| "vreinterpretq_p8_s8", |
| "vreinterpretq_p16_s8", |
| "vreinterpretq_p16_s8", |
| "vreinterpret_f32_s16", |
| "vreinterpret_f32_s16", |
| "vreinterpret_s8_s16", |
| "vreinterpret_s8_s16", |
| "vreinterpret_s32_s16", |
| "vreinterpret_s32_s16", |
| "vreinterpret_s64_s16", |
| "vreinterpret_s64_s16", |
| "vreinterpret_u8_s16", |
| "vreinterpret_u8_s16", |
| "vreinterpret_u16_s16", |
| "vreinterpret_u16_s16", |
| "vreinterpret_u32_s16", |
| "vreinterpret_u32_s16", |
| "vreinterpret_u64_s16", |
| "vreinterpret_u64_s16", |
| "vreinterpret_p8_s16", |
| "vreinterpret_p8_s16", |
| "vreinterpret_p16_s16", |
| "vreinterpret_p16_s16", |
| "vreinterpretq_f32_s16", |
| "vreinterpretq_f32_s16", |
| "vreinterpretq_s8_s16", |
| "vreinterpretq_s8_s16", |
| "vreinterpretq_s32_s16", |
| "vreinterpretq_s32_s16", |
| "vreinterpretq_s64_s16", |
| "vreinterpretq_s64_s16", |
| "vreinterpretq_u8_s16", |
| "vreinterpretq_u8_s16", |
| "vreinterpretq_u16_s16", |
| "vreinterpretq_u16_s16", |
| "vreinterpretq_u32_s16", |
| "vreinterpretq_u32_s16", |
| "vreinterpretq_u64_s16", |
| "vreinterpretq_u64_s16", |
| "vreinterpretq_p8_s16", |
| "vreinterpretq_p8_s16", |
| "vreinterpretq_p16_s16", |
| "vreinterpretq_p16_s16", |
| "vreinterpret_f32_s32", |
| "vreinterpret_f32_s32", |
| "vreinterpret_s8_s32", |
| "vreinterpret_s8_s32", |
| "vreinterpret_s16_s32", |
| "vreinterpret_s16_s32", |
| "vreinterpret_s64_s32", |
| "vreinterpret_s64_s32", |
| "vreinterpret_u8_s32", |
| "vreinterpret_u8_s32", |
| "vreinterpret_u16_s32", |
| "vreinterpret_u16_s32", |
| "vreinterpret_u32_s32", |
| "vreinterpret_u32_s32", |
| "vreinterpret_u64_s32", |
| "vreinterpret_u64_s32", |
| "vreinterpret_p8_s32", |
| "vreinterpret_p8_s32", |
| "vreinterpret_p16_s32", |
| "vreinterpret_p16_s32", |
| "vreinterpretq_f32_s32", |
| "vreinterpretq_f32_s32", |
| "vreinterpretq_s8_s32", |
| "vreinterpretq_s8_s32", |
| "vreinterpretq_s16_s32", |
| "vreinterpretq_s16_s32", |
| "vreinterpretq_s64_s32", |
| "vreinterpretq_s64_s32", |
| "vreinterpretq_u8_s32", |
| "vreinterpretq_u8_s32", |
| "vreinterpretq_u16_s32", |
| "vreinterpretq_u16_s32", |
| "vreinterpretq_u32_s32", |
| "vreinterpretq_u32_s32", |
| "vreinterpretq_u64_s32", |
| "vreinterpretq_u64_s32", |
| "vreinterpretq_p8_s32", |
| "vreinterpretq_p8_s32", |
| "vreinterpretq_p16_s32", |
| "vreinterpretq_p16_s32", |
| "vreinterpret_f32_s64", |
| "vreinterpret_f32_s64", |
| "vreinterpret_s8_s64", |
| "vreinterpret_s8_s64", |
| "vreinterpret_s16_s64", |
| "vreinterpret_s16_s64", |
| "vreinterpret_s32_s64", |
| "vreinterpret_s32_s64", |
| "vreinterpret_u8_s64", |
| "vreinterpret_u8_s64", |
| "vreinterpret_u16_s64", |
| "vreinterpret_u16_s64", |
| "vreinterpret_u32_s64", |
| "vreinterpret_u32_s64", |
| "vreinterpret_u64_s64", |
| "vreinterpret_p8_s64", |
| "vreinterpret_p8_s64", |
| "vreinterpret_p16_s64", |
| "vreinterpret_p16_s64", |
| "vreinterpretq_f32_s64", |
| "vreinterpretq_f32_s64", |
| "vreinterpretq_s8_s64", |
| "vreinterpretq_s8_s64", |
| "vreinterpretq_s16_s64", |
| "vreinterpretq_s16_s64", |
| "vreinterpretq_s32_s64", |
| "vreinterpretq_s32_s64", |
| "vreinterpretq_u8_s64", |
| "vreinterpretq_u8_s64", |
| "vreinterpretq_u16_s64", |
| "vreinterpretq_u16_s64", |
| "vreinterpretq_u32_s64", |
| "vreinterpretq_u32_s64", |
| "vreinterpretq_u64_s64", |
| "vreinterpretq_u64_s64", |
| "vreinterpretq_p8_s64", |
| "vreinterpretq_p8_s64", |
| "vreinterpretq_p16_s64", |
| "vreinterpretq_p16_s64", |
| "vreinterpret_f32_u8", |
| "vreinterpret_f32_u8", |
| "vreinterpret_s8_u8", |
| "vreinterpret_s8_u8", |
| "vreinterpret_s16_u8", |
| "vreinterpret_s16_u8", |
| "vreinterpret_s32_u8", |
| "vreinterpret_s32_u8", |
| "vreinterpret_s64_u8", |
| "vreinterpret_s64_u8", |
| "vreinterpret_u16_u8", |
| "vreinterpret_u16_u8", |
| "vreinterpret_u32_u8", |
| "vreinterpret_u32_u8", |
| "vreinterpret_u64_u8", |
| "vreinterpret_u64_u8", |
| "vreinterpret_p8_u8", |
| "vreinterpret_p8_u8", |
| "vreinterpret_p16_u8", |
| "vreinterpret_p16_u8", |
| "vreinterpretq_f32_u8", |
| "vreinterpretq_f32_u8", |
| "vreinterpretq_s8_u8", |
| "vreinterpretq_s8_u8", |
| "vreinterpretq_s16_u8", |
| "vreinterpretq_s16_u8", |
| "vreinterpretq_s32_u8", |
| "vreinterpretq_s32_u8", |
| "vreinterpretq_s64_u8", |
| "vreinterpretq_s64_u8", |
| "vreinterpretq_u16_u8", |
| "vreinterpretq_u16_u8", |
| "vreinterpretq_u32_u8", |
| "vreinterpretq_u32_u8", |
| "vreinterpretq_u64_u8", |
| "vreinterpretq_u64_u8", |
| "vreinterpretq_p8_u8", |
| "vreinterpretq_p8_u8", |
| "vreinterpretq_p16_u8", |
| "vreinterpretq_p16_u8", |
| "vreinterpret_f32_u16", |
| "vreinterpret_f32_u16", |
| "vreinterpret_s8_u16", |
| "vreinterpret_s8_u16", |
| "vreinterpret_s16_u16", |
| "vreinterpret_s16_u16", |
| "vreinterpret_s32_u16", |
| "vreinterpret_s32_u16", |
| "vreinterpret_s64_u16", |
| "vreinterpret_s64_u16", |
| "vreinterpret_u8_u16", |
| "vreinterpret_u8_u16", |
| "vreinterpret_u32_u16", |
| "vreinterpret_u32_u16", |
| "vreinterpret_u64_u16", |
| "vreinterpret_u64_u16", |
| "vreinterpret_p8_u16", |
| "vreinterpret_p8_u16", |
| "vreinterpret_p16_u16", |
| "vreinterpret_p16_u16", |
| "vreinterpretq_f32_u16", |
| "vreinterpretq_f32_u16", |
| "vreinterpretq_s8_u16", |
| "vreinterpretq_s8_u16", |
| "vreinterpretq_s16_u16", |
| "vreinterpretq_s16_u16", |
| "vreinterpretq_s32_u16", |
| "vreinterpretq_s32_u16", |
| "vreinterpretq_s64_u16", |
| "vreinterpretq_s64_u16", |
| "vreinterpretq_u8_u16", |
| "vreinterpretq_u8_u16", |
| "vreinterpretq_u32_u16", |
| "vreinterpretq_u32_u16", |
| "vreinterpretq_u64_u16", |
| "vreinterpretq_u64_u16", |
| "vreinterpretq_p8_u16", |
| "vreinterpretq_p8_u16", |
| "vreinterpretq_p16_u16", |
| "vreinterpretq_p16_u16", |
| "vreinterpret_f32_u32", |
| "vreinterpret_f32_u32", |
| "vreinterpret_s8_u32", |
| "vreinterpret_s8_u32", |
| "vreinterpret_s16_u32", |
| "vreinterpret_s16_u32", |
| "vreinterpret_s32_u32", |
| "vreinterpret_s32_u32", |
| "vreinterpret_s64_u32", |
| "vreinterpret_s64_u32", |
| "vreinterpret_u8_u32", |
| "vreinterpret_u8_u32", |
| "vreinterpret_u16_u32", |
| "vreinterpret_u16_u32", |
| "vreinterpret_u64_u32", |
| "vreinterpret_u64_u32", |
| "vreinterpret_p8_u32", |
| "vreinterpret_p8_u32", |
| "vreinterpret_p16_u32", |
| "vreinterpret_p16_u32", |
| "vreinterpretq_f32_u32", |
| "vreinterpretq_f32_u32", |
| "vreinterpretq_s8_u32", |
| "vreinterpretq_s8_u32", |
| "vreinterpretq_s16_u32", |
| "vreinterpretq_s16_u32", |
| "vreinterpretq_s32_u32", |
| "vreinterpretq_s32_u32", |
| "vreinterpretq_s64_u32", |
| "vreinterpretq_s64_u32", |
| "vreinterpretq_u8_u32", |
| "vreinterpretq_u8_u32", |
| "vreinterpretq_u16_u32", |
| "vreinterpretq_u16_u32", |
| "vreinterpretq_u64_u32", |
| "vreinterpretq_u64_u32", |
| "vreinterpretq_p8_u32", |
| "vreinterpretq_p8_u32", |
| "vreinterpretq_p16_u32", |
| "vreinterpretq_p16_u32", |
| "vreinterpret_f32_u64", |
| "vreinterpret_f32_u64", |
| "vreinterpret_s8_u64", |
| "vreinterpret_s8_u64", |
| "vreinterpret_s16_u64", |
| "vreinterpret_s16_u64", |
| "vreinterpret_s32_u64", |
| "vreinterpret_s32_u64", |
| "vreinterpret_s64_u64", |
| "vreinterpret_u8_u64", |
| "vreinterpret_u8_u64", |
| "vreinterpret_u16_u64", |
| "vreinterpret_u16_u64", |
| "vreinterpret_u32_u64", |
| "vreinterpret_u32_u64", |
| "vreinterpret_p8_u64", |
| "vreinterpret_p8_u64", |
| "vreinterpret_p16_u64", |
| "vreinterpret_p16_u64", |
| "vreinterpretq_f32_u64", |
| "vreinterpretq_f32_u64", |
| "vreinterpretq_s8_u64", |
| "vreinterpretq_s8_u64", |
| "vreinterpretq_s16_u64", |
| "vreinterpretq_s16_u64", |
| "vreinterpretq_s32_u64", |
| "vreinterpretq_s32_u64", |
| "vreinterpretq_s64_u64", |
| "vreinterpretq_s64_u64", |
| "vreinterpretq_u8_u64", |
| "vreinterpretq_u8_u64", |
| "vreinterpretq_u16_u64", |
| "vreinterpretq_u16_u64", |
| "vreinterpretq_u32_u64", |
| "vreinterpretq_u32_u64", |
| "vreinterpretq_p8_u64", |
| "vreinterpretq_p8_u64", |
| "vreinterpretq_p16_u64", |
| "vreinterpretq_p16_u64", |
| "vreinterpret_f32_p8", |
| "vreinterpret_f32_p8", |
| "vreinterpret_s8_p8", |
| "vreinterpret_s8_p8", |
| "vreinterpret_s16_p8", |
| "vreinterpret_s16_p8", |
| "vreinterpret_s32_p8", |
| "vreinterpret_s32_p8", |
| "vreinterpret_s64_p8", |
| "vreinterpret_s64_p8", |
| "vreinterpret_u8_p8", |
| "vreinterpret_u8_p8", |
| "vreinterpret_u16_p8", |
| "vreinterpret_u16_p8", |
| "vreinterpret_u32_p8", |
| "vreinterpret_u32_p8", |
| "vreinterpret_u64_p8", |
| "vreinterpret_u64_p8", |
| "vreinterpret_p16_p8", |
| "vreinterpret_p16_p8", |
| "vreinterpretq_f32_p8", |
| "vreinterpretq_f32_p8", |
| "vreinterpretq_s8_p8", |
| "vreinterpretq_s8_p8", |
| "vreinterpretq_s16_p8", |
| "vreinterpretq_s16_p8", |
| "vreinterpretq_s32_p8", |
| "vreinterpretq_s32_p8", |
| "vreinterpretq_s64_p8", |
| "vreinterpretq_s64_p8", |
| "vreinterpretq_u8_p8", |
| "vreinterpretq_u8_p8", |
| "vreinterpretq_u16_p8", |
| "vreinterpretq_u16_p8", |
| "vreinterpretq_u32_p8", |
| "vreinterpretq_u32_p8", |
| "vreinterpretq_u64_p8", |
| "vreinterpretq_u64_p8", |
| "vreinterpretq_p16_p8", |
| "vreinterpretq_p16_p8", |
| "vreinterpret_f32_p16", |
| "vreinterpret_f32_p16", |
| "vreinterpret_s8_p16", |
| "vreinterpret_s8_p16", |
| "vreinterpret_s16_p16", |
| "vreinterpret_s16_p16", |
| "vreinterpret_s32_p16", |
| "vreinterpret_s32_p16", |
| "vreinterpret_s64_p16", |
| "vreinterpret_s64_p16", |
| "vreinterpret_u8_p16", |
| "vreinterpret_u8_p16", |
| "vreinterpret_u16_p16", |
| "vreinterpret_u16_p16", |
| "vreinterpret_u32_p16", |
| "vreinterpret_u32_p16", |
| "vreinterpret_u64_p16", |
| "vreinterpret_u64_p16", |
| "vreinterpret_p8_p16", |
| "vreinterpret_p8_p16", |
| "vreinterpretq_f32_p16", |
| "vreinterpretq_f32_p16", |
| "vreinterpretq_s8_p16", |
| "vreinterpretq_s8_p16", |
| "vreinterpretq_s16_p16", |
| "vreinterpretq_s16_p16", |
| "vreinterpretq_s32_p16", |
| "vreinterpretq_s32_p16", |
| "vreinterpretq_s64_p16", |
| "vreinterpretq_s64_p16", |
| "vreinterpretq_u8_p16", |
| "vreinterpretq_u8_p16", |
| "vreinterpretq_u16_p16", |
| "vreinterpretq_u16_p16", |
| "vreinterpretq_u32_p16", |
| "vreinterpretq_u32_p16", |
| "vreinterpretq_u64_p16", |
| "vreinterpretq_u64_p16", |
| "vreinterpretq_p8_p16", |
| "vreinterpretq_p8_p16", |
| "vreinterpretq_s8_p128", |
| "vreinterpretq_s8_p128", |
| "vreinterpretq_s16_p128", |
| "vreinterpretq_s16_p128", |
| "vreinterpretq_s32_p128", |
| "vreinterpretq_s32_p128", |
| "vreinterpretq_s64_p128", |
| "vreinterpretq_s64_p128", |
| "vreinterpretq_u8_p128", |
| "vreinterpretq_u8_p128", |
| "vreinterpretq_u16_p128", |
| "vreinterpretq_u16_p128", |
| "vreinterpretq_u32_p128", |
| "vreinterpretq_u32_p128", |
| "vreinterpretq_u64_p128", |
| "vreinterpretq_u64_p128", |
| "vreinterpretq_p8_p128", |
| "vreinterpretq_p8_p128", |
| "vreinterpretq_p16_p128", |
| "vreinterpretq_p16_p128", |
| "vreinterpretq_p64_p128", |
| "vreinterpretq_p64_p128", |
| "vreinterpret_p64_s8", |
| "vreinterpret_p64_s8", |
| "vreinterpretq_p128_s8", |
| "vreinterpretq_p128_s8", |
| "vreinterpretq_p64_s8", |
| "vreinterpretq_p64_s8", |
| "vreinterpret_p64_s16", |
| "vreinterpret_p64_s16", |
| "vreinterpretq_p128_s16", |
| "vreinterpretq_p128_s16", |
| "vreinterpretq_p64_s16", |
| "vreinterpretq_p64_s16", |
| "vreinterpret_p64_s32", |
| "vreinterpret_p64_s32", |
| "vreinterpretq_p128_s32", |
| "vreinterpretq_p128_s32", |
| "vreinterpretq_p64_s32", |
| "vreinterpretq_p64_s32", |
| "vreinterpretq_p128_s64", |
| "vreinterpretq_p128_s64", |
| "vreinterpret_p64_u8", |
| "vreinterpret_p64_u8", |
| "vreinterpretq_p128_u8", |
| "vreinterpretq_p128_u8", |
| "vreinterpretq_p64_u8", |
| "vreinterpretq_p64_u8", |
| "vreinterpret_p64_u16", |
| "vreinterpret_p64_u16", |
| "vreinterpretq_p128_u16", |
| "vreinterpretq_p128_u16", |
| "vreinterpretq_p64_u16", |
| "vreinterpretq_p64_u16", |
| "vreinterpret_p64_u32", |
| "vreinterpret_p64_u32", |
| "vreinterpretq_p128_u32", |
| "vreinterpretq_p128_u32", |
| "vreinterpretq_p64_u32", |
| "vreinterpretq_p64_u32", |
| "vreinterpretq_p128_u64", |
| "vreinterpretq_p128_u64", |
| "vreinterpret_p64_p8", |
| "vreinterpret_p64_p8", |
| "vreinterpretq_p128_p8", |
| "vreinterpretq_p128_p8", |
| "vreinterpretq_p64_p8", |
| "vreinterpretq_p64_p8", |
| "vreinterpret_p64_p16", |
| "vreinterpret_p64_p16", |
| "vreinterpretq_p128_p16", |
| "vreinterpretq_p128_p16", |
| "vreinterpretq_p64_p16", |
| "vreinterpretq_p64_p16", |
| "vreinterpret_s8_p64", |
| "vreinterpret_s8_p64", |
| "vreinterpret_s16_p64", |
| "vreinterpret_s16_p64", |
| "vreinterpret_s32_p64", |
| "vreinterpret_s32_p64", |
| "vreinterpret_u8_p64", |
| "vreinterpret_u8_p64", |
| "vreinterpret_u16_p64", |
| "vreinterpret_u16_p64", |
| "vreinterpret_u32_p64", |
| "vreinterpret_u32_p64", |
| "vreinterpret_p8_p64", |
| "vreinterpret_p8_p64", |
| "vreinterpret_p16_p64", |
| "vreinterpret_p16_p64", |
| "vreinterpretq_p128_p64", |
| "vreinterpretq_p128_p64", |
| "vreinterpretq_s8_p64", |
| "vreinterpretq_s8_p64", |
| "vreinterpretq_s16_p64", |
| "vreinterpretq_s16_p64", |
| "vreinterpretq_s32_p64", |
| "vreinterpretq_s32_p64", |
| "vreinterpretq_u8_p64", |
| "vreinterpretq_u8_p64", |
| "vreinterpretq_u16_p64", |
| "vreinterpretq_u16_p64", |
| "vreinterpretq_u32_p64", |
| "vreinterpretq_u32_p64", |
| "vreinterpretq_p8_p64", |
| "vreinterpretq_p8_p64", |
| "vreinterpretq_p16_p64", |
| "vreinterpretq_p16_p64", |
| "vrev64_f16", |
| "vrev64q_f16", |
| "vrndn_f16", |
| "vrndnq_f16", |
| "vrndn_f32", |
| "vrndnq_f32", |
| "vrshl_s8", |
| "vrshlq_s8", |
| "vrshl_s16", |
| "vrshlq_s16", |
| "vrshl_s32", |
| "vrshlq_s32", |
| "vrshl_s64", |
| "vrshlq_s64", |
| "vrshl_u8", |
| "vrshlq_u8", |
| "vrshl_u16", |
| "vrshlq_u16", |
| "vrshl_u32", |
| "vrshlq_u32", |
| "vrshl_u64", |
| "vrshlq_u64", |
| "vrshr_n_s8", |
| "vrshrq_n_s8", |
| "vrshr_n_s16", |
| "vrshrq_n_s16", |
| "vrshr_n_s32", |
| "vrshrq_n_s32", |
| "vrshr_n_s64", |
| "vrshrq_n_s64", |
| "vrshr_n_u8", |
| "vrshrq_n_u8", |
| "vrshr_n_u16", |
| "vrshrq_n_u16", |
| "vrshr_n_u32", |
| "vrshrq_n_u32", |
| "vrshr_n_u64", |
| "vrshrq_n_u64", |
| "vrshrn_n_s16", |
| "vrshrn_n_s32", |
| "vrshrn_n_s64", |
| "vrshrn_n_s16", |
| "vrshrn_n_s32", |
| "vrshrn_n_s64", |
| "vrshrn_n_u16", |
| "vrshrn_n_u32", |
| "vrshrn_n_u64", |
| "vrsqrte_f16", |
| "vrsqrteq_f16", |
| "vrsqrteq_f32", |
| "vrsqrte_u32", |
| "vrsqrteq_u32", |
| "vrsqrts_f16", |
| "vrsqrtsq_f16", |
| "vrsqrts_f32", |
| "vrsqrtsq_f32", |
| "vrsra_n_s8", |
| "vrsraq_n_s8", |
| "vrsra_n_s16", |
| "vrsraq_n_s16", |
| "vrsra_n_s32", |
| "vrsraq_n_s32", |
| "vrsra_n_s64", |
| "vrsraq_n_s64", |
| "vrsra_n_u8", |
| "vrsraq_n_u8", |
| "vrsra_n_u16", |
| "vrsraq_n_u16", |
| "vrsra_n_u32", |
| "vrsraq_n_u32", |
| "vrsra_n_u64", |
| "vrsraq_n_u64", |
| "vrsubhn_s16", |
| "vrsubhn_s32", |
| "vrsubhn_s64", |
| "vrsubhn_u16", |
| "vrsubhn_u16", |
| "vrsubhn_u32", |
| "vrsubhn_u32", |
| "vrsubhn_u64", |
| "vrsubhn_u64", |
| "vset_lane_f16", |
| "vsetq_lane_f16", |
| "vset_lane_f32", |
| "vsetq_lane_f32", |
| "vset_lane_s8", |
| "vsetq_lane_s8", |
| "vset_lane_s16", |
| "vsetq_lane_s16", |
| "vset_lane_s32", |
| "vsetq_lane_s32", |
| "vsetq_lane_s64", |
| "vset_lane_u8", |
| "vsetq_lane_u8", |
| "vset_lane_u16", |
| "vsetq_lane_u16", |
| "vset_lane_u32", |
| "vsetq_lane_u32", |
| "vsetq_lane_u64", |
| "vset_lane_p8", |
| "vsetq_lane_p8", |
| "vset_lane_p16", |
| "vsetq_lane_p16", |
| "vset_lane_p64", |
| "vset_lane_s64", |
| "vset_lane_u64", |
| "vsetq_lane_p64", |
| "vsha1cq_u32", |
| "vsha1h_u32", |
| "vsha1mq_u32", |
| "vsha1pq_u32", |
| "vsha1su0q_u32", |
| "vsha1su1q_u32", |
| "vsha256h2q_u32", |
| "vsha256hq_u32", |
| "vsha256su0q_u32", |
| "vsha256su1q_u32", |
| "vshl_n_s8", |
| "vshlq_n_s8", |
| "vshl_n_s16", |
| "vshlq_n_s16", |
| "vshl_n_s32", |
| "vshlq_n_s32", |
| "vshl_n_s64", |
| "vshlq_n_s64", |
| "vshl_n_u8", |
| "vshlq_n_u8", |
| "vshl_n_u16", |
| "vshlq_n_u16", |
| "vshl_n_u32", |
| "vshlq_n_u32", |
| "vshl_n_u64", |
| "vshlq_n_u64", |
| "vshl_s8", |
| "vshlq_s8", |
| "vshl_s16", |
| "vshlq_s16", |
| "vshl_s32", |
| "vshlq_s32", |
| "vshl_s64", |
| "vshlq_s64", |
| "vshl_u8", |
| "vshlq_u8", |
| "vshl_u16", |
| "vshlq_u16", |
| "vshl_u32", |
| "vshlq_u32", |
| "vshl_u64", |
| "vshlq_u64", |
| "vshll_n_s16", |
| "vshll_n_s32", |
| "vshll_n_s8", |
| "vshll_n_u16", |
| "vshll_n_u32", |
| "vshll_n_u8", |
| "vshr_n_s8", |
| "vshrq_n_s8", |
| "vshr_n_s16", |
| "vshrq_n_s16", |
| "vshr_n_s32", |
| "vshrq_n_s32", |
| "vshr_n_s64", |
| "vshrq_n_s64", |
| "vshr_n_u8", |
| "vshrq_n_u8", |
| "vshr_n_u16", |
| "vshrq_n_u16", |
| "vshr_n_u32", |
| "vshrq_n_u32", |
| "vshr_n_u64", |
| "vshrq_n_u64", |
| "vshrn_n_s16", |
| "vshrn_n_s32", |
| "vshrn_n_s64", |
| "vshrn_n_u16", |
| "vshrn_n_u32", |
| "vshrn_n_u64", |
| "vsra_n_s8", |
| "vsraq_n_s8", |
| "vsra_n_s16", |
| "vsraq_n_s16", |
| "vsra_n_s32", |
| "vsraq_n_s32", |
| "vsra_n_s64", |
| "vsraq_n_s64", |
| "vsra_n_u8", |
| "vsraq_n_u8", |
| "vsra_n_u16", |
| "vsraq_n_u16", |
| "vsra_n_u32", |
| "vsraq_n_u32", |
| "vsra_n_u64", |
| "vsraq_n_u64", |
| "vst1_f16", |
| "vst1q_f16", |
| "vst1_f16_x2", |
| "vst1q_f16_x2", |
| "vst1_f16_x2", |
| "vst1q_f16_x2", |
| "vst1_f16_x3", |
| "vst1q_f16_x3", |
| "vst1_f16_x3", |
| "vst1q_f16_x3", |
| "vst1_f16_x4", |
| "vst1q_f16_x4", |
| "vst1_f16_x4", |
| "vst1q_f16_x4", |
| "vst1_f32_x2", |
| "vst1q_f32_x2", |
| "vst1_f32_x2", |
| "vst1q_f32_x2", |
| "vst1_f32_x3", |
| "vst1q_f32_x3", |
| "vst1_f32_x4", |
| "vst1q_f32_x4", |
| "vst1_f32_x4", |
| "vst1q_f32_x4", |
| "vst1_lane_f16", |
| "vst1q_lane_f16", |
| "vst1_lane_f32", |
| "vst1q_lane_f32", |
| "vst1_lane_s8", |
| "vst1q_lane_s8", |
| "vst1_lane_s16", |
| "vst1q_lane_s16", |
| "vst1_lane_s32", |
| "vst1q_lane_s32", |
| "vst1q_lane_s64", |
| "vst1_lane_u8", |
| "vst1q_lane_u8", |
| "vst1_lane_u16", |
| "vst1q_lane_u16", |
| "vst1_lane_u32", |
| "vst1q_lane_u32", |
| "vst1q_lane_u64", |
| "vst1_lane_p8", |
| "vst1q_lane_p8", |
| "vst1_lane_p16", |
| "vst1q_lane_p16", |
| "vst1_lane_p64", |
| "vst1_lane_s64", |
| "vst1_lane_u64", |
| "vst1_p64_x2", |
| "vst1_p64_x3", |
| "vst1_p64_x4", |
| "vst1q_p64_x2", |
| "vst1q_p64_x3", |
| "vst1q_p64_x4", |
| "vst1_s8_x2", |
| "vst1q_s8_x2", |
| "vst1_s16_x2", |
| "vst1q_s16_x2", |
| "vst1_s32_x2", |
| "vst1q_s32_x2", |
| "vst1_s64_x2", |
| "vst1q_s64_x2", |
| "vst1_s8_x2", |
| "vst1q_s8_x2", |
| "vst1_s16_x2", |
| "vst1q_s16_x2", |
| "vst1_s32_x2", |
| "vst1q_s32_x2", |
| "vst1_s64_x2", |
| "vst1q_s64_x2", |
| "vst1_s8_x3", |
| "vst1q_s8_x3", |
| "vst1_s16_x3", |
| "vst1q_s16_x3", |
| "vst1_s32_x3", |
| "vst1q_s32_x3", |
| "vst1_s64_x3", |
| "vst1q_s64_x3", |
| "vst1_s8_x3", |
| "vst1q_s8_x3", |
| "vst1_s16_x3", |
| "vst1q_s16_x3", |
| "vst1_s32_x3", |
| "vst1q_s32_x3", |
| "vst1_s64_x3", |
| "vst1q_s64_x3", |
| "vst1_s8_x4", |
| "vst1q_s8_x4", |
| "vst1_s16_x4", |
| "vst1q_s16_x4", |
| "vst1_s32_x4", |
| "vst1q_s32_x4", |
| "vst1_s64_x4", |
| "vst1q_s64_x4", |
| "vst1_s8_x4", |
| "vst1q_s8_x4", |
| "vst1_s16_x4", |
| "vst1q_s16_x4", |
| "vst1_s32_x4", |
| "vst1q_s32_x4", |
| "vst1_s64_x4", |
| "vst1q_s64_x4", |
| "vst1_u8_x2", |
| "vst1_u8_x3", |
| "vst1_u8_x4", |
| "vst1q_u8_x2", |
| "vst1q_u8_x3", |
| "vst1q_u8_x4", |
| "vst1_u16_x2", |
| "vst1_u16_x3", |
| "vst1_u16_x4", |
| "vst1q_u16_x2", |
| "vst1q_u16_x3", |
| "vst1q_u16_x4", |
| "vst1_u32_x2", |
| "vst1_u32_x3", |
| "vst1_u32_x4", |
| "vst1q_u32_x2", |
| "vst1q_u32_x3", |
| "vst1q_u32_x4", |
| "vst1_u64_x2", |
| "vst1_u64_x3", |
| "vst1_u64_x4", |
| "vst1q_u64_x2", |
| "vst1q_u64_x3", |
| "vst1q_u64_x4", |
| "vst1_p8_x2", |
| "vst1_p8_x3", |
| "vst1_p8_x4", |
| "vst1q_p8_x2", |
| "vst1q_p8_x3", |
| "vst1q_p8_x4", |
| "vst1_p16_x2", |
| "vst1_p16_x3", |
| "vst1_p16_x4", |
| "vst1q_p16_x2", |
| "vst1q_p16_x3", |
| "vst1q_p16_x4", |
| "vst1q_lane_p64", |
| "vst2_f16", |
| "vst2q_f16", |
| "vst2_f16", |
| "vst2q_f16", |
| "vst2_f32", |
| "vst2q_f32", |
| "vst2_s8", |
| "vst2q_s8", |
| "vst2_s16", |
| "vst2q_s16", |
| "vst2_s32", |
| "vst2q_s32", |
| "vst2_f32", |
| "vst2q_f32", |
| "vst2_s8", |
| "vst2q_s8", |
| "vst2_s16", |
| "vst2q_s16", |
| "vst2_s32", |
| "vst2q_s32", |
| "vst2_lane_f16", |
| "vst2q_lane_f16", |
| "vst2_lane_f16", |
| "vst2q_lane_f16", |
| "vst2_lane_f32", |
| "vst2q_lane_f32", |
| "vst2_lane_s8", |
| "vst2_lane_s16", |
| "vst2q_lane_s16", |
| "vst2_lane_s32", |
| "vst2q_lane_s32", |
| "vst2_lane_f32", |
| "vst2q_lane_f32", |
| "vst2_lane_s8", |
| "vst2_lane_s16", |
| "vst2q_lane_s16", |
| "vst2_lane_s32", |
| "vst2q_lane_s32", |
| "vst2_lane_u8", |
| "vst2_lane_u16", |
| "vst2q_lane_u16", |
| "vst2_lane_u32", |
| "vst2q_lane_u32", |
| "vst2_lane_p8", |
| "vst2_lane_p16", |
| "vst2q_lane_p16", |
| "vst2_p64", |
| "vst2_s64", |
| "vst2_s64", |
| "vst2_u64", |
| "vst2_u8", |
| "vst2q_u8", |
| "vst2_u16", |
| "vst2q_u16", |
| "vst2_u32", |
| "vst2q_u32", |
| "vst2_p8", |
| "vst2q_p8", |
| "vst2_p16", |
| "vst2q_p16", |
| "vst3_f16", |
| "vst3q_f16", |
| "vst3_f16", |
| "vst3q_f16", |
| "vst3_f32", |
| "vst3q_f32", |
| "vst3_s8", |
| "vst3q_s8", |
| "vst3_s16", |
| "vst3q_s16", |
| "vst3_s32", |
| "vst3q_s32", |
| "vst3_f32", |
| "vst3q_f32", |
| "vst3_s8", |
| "vst3q_s8", |
| "vst3_s16", |
| "vst3q_s16", |
| "vst3_s32", |
| "vst3q_s32", |
| "vst3_lane_f16", |
| "vst3q_lane_f16", |
| "vst3_lane_f16", |
| "vst3q_lane_f16", |
| "vst3_lane_f32", |
| "vst3q_lane_f32", |
| "vst3_lane_s8", |
| "vst3_lane_s16", |
| "vst3q_lane_s16", |
| "vst3_lane_s32", |
| "vst3q_lane_s32", |
| "vst3_lane_f32", |
| "vst3q_lane_f32", |
| "vst3_lane_s8", |
| "vst3_lane_s16", |
| "vst3q_lane_s16", |
| "vst3_lane_s32", |
| "vst3q_lane_s32", |
| "vst3_lane_u8", |
| "vst3_lane_u16", |
| "vst3q_lane_u16", |
| "vst3_lane_u32", |
| "vst3q_lane_u32", |
| "vst3_lane_p8", |
| "vst3_lane_p16", |
| "vst3q_lane_p16", |
| "vst3_p64", |
| "vst3_s64", |
| "vst3_s64", |
| "vst3_u64", |
| "vst3_u8", |
| "vst3q_u8", |
| "vst3_u16", |
| "vst3q_u16", |
| "vst3_u32", |
| "vst3q_u32", |
| "vst3_p8", |
| "vst3q_p8", |
| "vst3_p16", |
| "vst3q_p16", |
| "vst4_f16", |
| "vst4q_f16", |
| "vst4_f16", |
| "vst4q_f16", |
| "vst4_f32", |
| "vst4q_f32", |
| "vst4_s8", |
| "vst4q_s8", |
| "vst4_s16", |
| "vst4q_s16", |
| "vst4_s32", |
| "vst4q_s32", |
| "vst4_f32", |
| "vst4q_f32", |
| "vst4_s8", |
| "vst4q_s8", |
| "vst4_s16", |
| "vst4q_s16", |
| "vst4_s32", |
| "vst4q_s32", |
| "vst4_lane_f16", |
| "vst4q_lane_f16", |
| "vst4_lane_f16", |
| "vst4q_lane_f16", |
| "vst4_lane_f32", |
| "vst4q_lane_f32", |
| "vst4_lane_s8", |
| "vst4_lane_s16", |
| "vst4q_lane_s16", |
| "vst4_lane_s32", |
| "vst4q_lane_s32", |
| "vst4_lane_f32", |
| "vst4q_lane_f32", |
| "vst4_lane_s8", |
| "vst4_lane_s16", |
| "vst4q_lane_s16", |
| "vst4_lane_s32", |
| "vst4q_lane_s32", |
| "vst4_lane_u8", |
| "vst4_lane_u16", |
| "vst4q_lane_u16", |
| "vst4_lane_u32", |
| "vst4q_lane_u32", |
| "vst4_lane_p8", |
| "vst4_lane_p16", |
| "vst4q_lane_p16", |
| "vst4_p64", |
| "vst4_s64", |
| "vst4_s64", |
| "vst4_u64", |
| "vst4_u8", |
| "vst4q_u8", |
| "vst4_u16", |
| "vst4q_u16", |
| "vst4_u32", |
| "vst4q_u32", |
| "vst4_p8", |
| "vst4q_p8", |
| "vst4_p16", |
| "vst4q_p16", |
| "vsub_f16", |
| "vsubq_f16", |
| "vsub_s64", |
| "vsubq_s64", |
| "vsub_u64", |
| "vsubq_u64", |
| "vsubhn_high_s16", |
| "vsubhn_high_s32", |
| "vsubhn_high_s64", |
| "vsubhn_high_u16", |
| "vsubhn_high_u32", |
| "vsubhn_high_u64", |
| "vsubhn_s16", |
| "vsubhn_s32", |
| "vsubhn_s64", |
| "vsubhn_u16", |
| "vsubhn_u32", |
| "vsubhn_u64", |
| "vsubl_s8", |
| "vsubl_s16", |
| "vsubl_s32", |
| "vsubl_u8", |
| "vsubl_u16", |
| "vsubl_u32", |
| "vsubw_s8", |
| "vsubw_s16", |
| "vsubw_s32", |
| "vsubw_u8", |
| "vsubw_u16", |
| "vsubw_u32", |
| "vsudot_lane_s32", |
| "vsudot_lane_s32", |
| "vsudotq_lane_s32", |
| "vsudotq_lane_s32", |
| "vsudot_laneq_s32", |
| "vsudotq_laneq_s32", |
| "vtrn_f16", |
| "vtrnq_f16", |
| "vtrn_f32", |
| "vtrn_s32", |
| "vtrn_u32", |
| "vtrnq_f32", |
| "vtrn_s8", |
| "vtrnq_s8", |
| "vtrn_s16", |
| "vtrnq_s16", |
| "vtrnq_s32", |
| "vtrn_u8", |
| "vtrnq_u8", |
| "vtrn_u16", |
| "vtrnq_u16", |
| "vtrnq_u32", |
| "vtrn_p8", |
| "vtrnq_p8", |
| "vtrn_p16", |
| "vtrnq_p16", |
| "vtst_s8", |
| "vtstq_s8", |
| "vtst_s16", |
| "vtstq_s16", |
| "vtst_s32", |
| "vtstq_s32", |
| "vtst_p8", |
| "vtstq_p8", |
| "vtst_p16", |
| "vtstq_p16", |
| "vtst_u8", |
| "vtstq_u8", |
| "vtst_u16", |
| "vtstq_u16", |
| "vtst_u32", |
| "vtstq_u32", |
| "vusdot_lane_s32", |
| "vusdot_lane_s32", |
| "vusdotq_lane_s32", |
| "vusdotq_lane_s32", |
| "vusdot_laneq_s32", |
| "vusdot_laneq_s32", |
| "vusdotq_laneq_s32", |
| "vusdotq_laneq_s32", |
| "vusdot_s32", |
| "vusdotq_s32", |
| "vusmmlaq_s32", |
| "vuzp_f16", |
| "vuzpq_f16", |
| "vuzp_f32", |
| "vuzp_s32", |
| "vuzp_u32", |
| "vuzpq_f32", |
| "vuzp_s8", |
| "vuzpq_s8", |
| "vuzp_s16", |
| "vuzpq_s16", |
| "vuzpq_s32", |
| "vuzp_u8", |
| "vuzpq_u8", |
| "vuzp_u16", |
| "vuzpq_u16", |
| "vuzpq_u32", |
| "vuzp_p8", |
| "vuzpq_p8", |
| "vuzp_p16", |
| "vuzpq_p16", |
| "vzip_f16", |
| "vzipq_f16", |
| "vzip_f32", |
| "vzip_s32", |
| "vzip_u32", |
| "vzip_s8", |
| "vzip_s16", |
| "vzip_u8", |
| "vzip_u16", |
| "vzip_p8", |
| "vzip_p16", |
| "vzipq_f32", |
| "vzipq_s8", |
| "vzipq_s16", |
| "vzipq_s32", |
| "vzipq_u8", |
| "vzipq_u16", |
| "vzipq_u32", |
| "vzipq_p8", |
| "vzipq_p16", |
| "__rndr", |
| "__rndrrs", |
| "vcopy_laneq_f64", |
| "vcopy_laneq_f64", |
| "vcopy_laneq_s64", |
| "vcopy_laneq_s64", |
| "vcopy_laneq_u64", |
| "vcopy_laneq_u64", |
| "vcopy_laneq_p64", |
| "vcopy_laneq_p64", |
| "vget_high_f64", |
| "vget_high_f64", |
| "vget_high_p64", |
| "vget_high_p64", |
| "vget_low_f64", |
| "vget_low_f64", |
| "vget_low_p64", |
| "vget_low_p64", |
| "vgetq_lane_f64", |
| "vgetq_lane_f64", |
| "vaddl_high_s16", |
| "vaddl_high_s16", |
| "vaddl_high_s32", |
| "vaddl_high_s32", |
| "vaddl_high_s8", |
| "vaddl_high_s8", |
| "vaddl_high_u16", |
| "vaddl_high_u16", |
| "vaddl_high_u32", |
| "vaddl_high_u32", |
| "vaddl_high_u8", |
| "vaddl_high_u8", |
| "vget_high_f32", |
| "vget_high_f32", |
| "vget_high_p16", |
| "vget_high_p16", |
| "vget_high_p8", |
| "vget_high_p8", |
| "vget_high_s16", |
| "vget_high_s16", |
| "vget_high_s32", |
| "vget_high_s32", |
| "vget_high_s8", |
| "vget_high_s8", |
| "vget_high_u16", |
| "vget_high_u16", |
| "vget_high_u32", |
| "vget_high_u32", |
| "vget_high_u8", |
| "vget_high_u8", |
| "vget_high_s64", |
| "vget_high_s64", |
| "vget_high_u64", |
| "vget_high_u64", |
| "vget_lane_f32", |
| "vget_lane_f32", |
| "vget_lane_p16", |
| "vget_lane_p16", |
| "vget_lane_p8", |
| "vget_lane_p8", |
| "vget_lane_s16", |
| "vget_lane_s16", |
| "vget_lane_s32", |
| "vget_lane_s32", |
| "vget_lane_s8", |
| "vget_lane_s8", |
| "vget_lane_u16", |
| "vget_lane_u16", |
| "vget_lane_u32", |
| "vget_lane_u32", |
| "vget_lane_u8", |
| "vget_lane_u8", |
| "vgetq_lane_f32", |
| "vgetq_lane_f32", |
| "vgetq_lane_p16", |
| "vgetq_lane_p16", |
| "vgetq_lane_p64", |
| "vgetq_lane_p64", |
| "vgetq_lane_p8", |
| "vgetq_lane_p8", |
| "vgetq_lane_s16", |
| "vgetq_lane_s16", |
| "vgetq_lane_s32", |
| "vgetq_lane_s32", |
| "vgetq_lane_s64", |
| "vgetq_lane_s64", |
| "vgetq_lane_s8", |
| "vgetq_lane_s8", |
| "vgetq_lane_u16", |
| "vgetq_lane_u16", |
| "vgetq_lane_u32", |
| "vgetq_lane_u32", |
| "vgetq_lane_u8", |
| "vgetq_lane_u8", |
| "vget_lane_p64", |
| "vget_lane_s64", |
| "vget_lane_u64", |
| "vget_low_f32", |
| "vget_low_f32", |
| "vget_low_p16", |
| "vget_low_p16", |
| "vget_low_p8", |
| "vget_low_p8", |
| "vget_low_s16", |
| "vget_low_s16", |
| "vget_low_s32", |
| "vget_low_s32", |
| "vget_low_s8", |
| "vget_low_s8", |
| "vget_low_u16", |
| "vget_low_u16", |
| "vget_low_u32", |
| "vget_low_u32", |
| "vget_low_u8", |
| "vget_low_u8", |
| "vget_low_s64", |
| "vget_low_s64", |
| "vget_low_u64", |
| "vget_low_u64", |
| "vaddw_high_s16", |
| "vaddw_high_s32", |
| "vaddw_high_s8", |
| "vaddw_high_u16", |
| "vaddw_high_u32", |
| "vaddw_high_u8", |
| "vgetq_lane_u64", |
| ]; |
